@vitest/runner 0.28.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @vitest/runner
+
+Vitest mechanism to collect and run tasks.
+
+[GitHub](https://github.com/vitest-dev/vitest) | [Documentation](https://vitest.dev/advanced/runner)

package/dist/chunk-tasks.js

@@ -0,0 +1,285 @@
+import { format, deepClone, stringify, getOwnProperties, getType, toArray } from '@vitest/utils';
+
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c of suite.tasks) {
+    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
+      tasksGroup.push(c);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c];
+    }
+  }
+  if (tasksGroup.length > 0)
+    tasksGroups.push(tasksGroup);
+  return tasksGroups;
+}
+
+function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
+  const suiteIsOnly = parentIsOnly || suite.mode === "only";
+  suite.tasks.forEach((t) => {
+    const includeTask = suiteIsOnly || t.mode === "only";
+    if (onlyMode) {
+      if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
+        if (t.mode === "only") {
+          checkAllowOnly(t, allowOnly);
+          t.mode = "run";
+        }
+      } else if (t.mode === "run" && !includeTask) {
+        t.mode = "skip";
+      } else if (t.mode === "only") {
+        checkAllowOnly(t, allowOnly);
+        t.mode = "run";
+      }
+    }
+    if (t.type === "test") {
+      if (namePattern && !getTaskFullName(t).match(namePattern))
+        t.mode = "skip";
+    } else if (t.type === "suite") {
+      if (t.mode === "skip")
+        skipAllTasks(t);
+      else
+        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
+    }
+  });
+  if (suite.mode === "run") {
+    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run"))
+      suite.mode = "skip";
+  }
+}
+function getTaskFullName(task) {
+  return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
+}
+function someTasksAreOnly(suite) {
+  return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
+}
+function skipAllTasks(suite) {
+  suite.tasks.forEach((t) => {
+    if (t.mode === "run") {
+      t.mode = "skip";
+      if (t.type === "suite")
+        skipAllTasks(t);
+    }
+  });
+}
+function checkAllowOnly(task, allowOnly) {
+  if (allowOnly)
+    return;
+  const error = new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error");
+  task.result = {
+    state: "fail",
+    error,
+    errors: [error]
+  };
+}
+function generateHash(str) {
+  let hash = 0;
+  if (str.length === 0)
+    return `${hash}`;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `${hash}`;
+}
+function calculateSuiteHash(parent) {
+  parent.tasks.forEach((t, idx) => {
+    t.id = `${parent.id}_${idx}`;
+    if (t.type === "suite")
+      calculateSuiteHash(t);
+  });
+}
+
+function createChainable(keys, fn) {
+  function create(context) {
+    const chain2 = function(...args) {
+      return fn.apply(context, args);
+    };
+    Object.assign(chain2, fn);
+    chain2.withContext = () => chain2.bind(context);
+    for (const key of keys) {
+      Object.defineProperty(chain2, key, {
+        get() {
+          return create({ ...context, [key]: true });
+        }
+      });
+    }
+    return chain2;
+  }
+  const chain = create({});
+  chain.fn = fn;
+  return chain;
+}
+
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+const isImmutable = (v) => v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+  if (err instanceof Error)
+    return `<unserializable>: ${err.message}`;
+  if (typeof err === "string")
+    return `<unserializable>: ${err}`;
+  return "<unserializable>";
+}
+function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
+  if (!val || typeof val === "string")
+    return val;
+  if (typeof val === "function")
+    return `Function<${val.name || "anonymous"}>`;
+  if (typeof val === "symbol")
+    return val.toString();
+  if (typeof val !== "object")
+    return val;
+  if (isImmutable(val))
+    return serializeError(val.toJSON(), seen);
+  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction")
+    return "Promise";
+  if (typeof Element !== "undefined" && val instanceof Element)
+    return val.tagName;
+  if (typeof val.asymmetricMatch === "function")
+    return `${val.toString()} ${format(val.sample)}`;
+  if (seen.has(val))
+    return seen.get(val);
+  if (Array.isArray(val)) {
+    const clone = new Array(val.length);
+    seen.set(val, clone);
+    val.forEach((e, i) => {
+      try {
+        clone[i] = serializeError(e, seen);
+      } catch (err) {
+        clone[i] = getUnserializableMessage(err);
+      }
+    });
+    return clone;
+  } else {
+    const clone = /* @__PURE__ */ Object.create(null);
+    seen.set(val, clone);
+    let obj = val;
+    while (obj && obj !== OBJECT_PROTO) {
+      Object.getOwnPropertyNames(obj).forEach((key) => {
+        if (key in clone)
+          return;
+        try {
+          clone[key] = serializeError(val[key], seen);
+        } catch (err) {
+          delete clone[key];
+          clone[key] = getUnserializableMessage(err);
+        }
+      });
+      obj = Object.getPrototypeOf(obj);
+    }
+    return clone;
+  }
+}
+function normalizeErrorMessage(message) {
+  return message.replace(/__vite_ssr_import_\d+__\./g, "");
+}
+function processError(err, options = {}) {
+  if (!err || typeof err !== "object")
+    return err;
+  if (err.stack)
+    err.stackStr = String(err.stack);
+  if (err.name)
+    err.nameStr = String(err.name);
+  const clonedActual = deepClone(err.actual);
+  const clonedExpected = deepClone(err.expected);
+  const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(clonedActual, clonedExpected);
+  err.actual = replacedActual;
+  err.expected = replacedExpected;
+  const maxDiffSize = options.outputDiffMaxSize ?? 1e4;
+  if (typeof err.expected !== "string")
+    err.expected = stringify(err.expected, 10, { maxLength: maxDiffSize });
+  if (typeof err.actual !== "string")
+    err.actual = stringify(err.actual, 10, { maxLength: maxDiffSize });
+  try {
+    if (typeof err.message === "string")
+      err.message = normalizeErrorMessage(err.message);
+    if (typeof err.cause === "object" && typeof err.cause.message === "string")
+      err.cause.message = normalizeErrorMessage(err.cause.message);
+  } catch {
+  }
+  try {
+    return serializeError(err);
+  } catch (e) {
+    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}
+Inner error message: ${err == null ? void 0 : err.message}`));
+  }
+}
+function isAsymmetricMatcher(data) {
+  const type = getType(data);
+  return type === "Object" && typeof data.asymmetricMatch === "function";
+}
+function isReplaceable(obj1, obj2) {
+  const obj1Type = getType(obj1);
+  const obj2Type = getType(obj2);
+  return obj1Type === obj2Type && obj1Type === "Object";
+}
+function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
+  if (!isReplaceable(actual, expected))
+    return { replacedActual: actual, replacedExpected: expected };
+  if (actualReplaced.has(actual) || expectedReplaced.has(expected))
+    return { replacedActual: actual, replacedExpected: expected };
+  actualReplaced.add(actual);
+  expectedReplaced.add(expected);
+  getOwnProperties(expected).forEach((key) => {
+    const expectedValue = expected[key];
+    const actualValue = actual[key];
+    if (isAsymmetricMatcher(expectedValue)) {
+      if (expectedValue.asymmetricMatch(actualValue))
+        actual[key] = expectedValue;
+    } else if (isAsymmetricMatcher(actualValue)) {
+      if (actualValue.asymmetricMatch(expectedValue))
+        expected[key] = actualValue;
+    } else if (isReplaceable(actualValue, expectedValue)) {
+      const replaced = replaceAsymmetricMatcher(
+        actualValue,
+        expectedValue,
+        actualReplaced,
+        expectedReplaced
+      );
+      actual[key] = replaced.replacedActual;
+      expected[key] = replaced.replacedExpected;
+    }
+  });
+  return {
+    replacedActual: actual,
+    replacedExpected: expected
+  };
+}
+
+function isAtomTest(s) {
+  return s.type === "test" || s.type === "custom";
+}
+function getTests(suite) {
+  return toArray(suite).flatMap((s) => isAtomTest(s) ? [s] : s.tasks.flatMap((c) => isAtomTest(c) ? [c] : getTests(c)));
+}
+function getTasks(tasks = []) {
+  return toArray(tasks).flatMap((s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]);
+}
+function getSuites(suite) {
+  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+  return toArray(suite).some((s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c)));
+}
+function hasFailed(suite) {
+  return toArray(suite).some((s) => {
+    var _a;
+    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+  });
+}
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
+    current = current.suite || current.file;
+    if (current == null ? void 0 : current.name)
+      names.unshift(current.name);
+  }
+  return names;
+}
+
+export { calculateSuiteHash as a, partitionSuiteChildren as b, createChainable as c, hasFailed as d, getTests as e, getTasks as f, generateHash as g, hasTests as h, interpretTaskModes as i, getSuites as j, getNames as k, serializeError as l, processError as p, replaceAsymmetricMatcher as r, someTasksAreOnly as s };

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { V as VitestRunner } from './runner-93cc9c0d.js';
+export { V as VitestRunner, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-93cc9c0d.js';
+import { T as Task, F as File, S as SuiteAPI, a as TestAPI, b as SuiteCollector, c as SuiteHooks, H as HookListener, d as TestContext, e as Suite, f as HookCleanupCallback, O as OnTestFailedHandler, g as Test } from './tasks-e1fc71d1.js';
+export { D as DoneCallback, F as File, f as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, p as RuntimeContext, q as SequenceHooks, e as Suite, S as SuiteAPI, b as SuiteCollector, o as SuiteFactory, c as SuiteHooks, T as Task, i as TaskBase, j as TaskCustom, k as TaskResult, l as TaskResultPack, h as TaskState, g as Test, a as TestAPI, d as TestContext, m as TestFunction, n as TestOptions } from './tasks-e1fc71d1.js';
+import { Awaitable } from '@vitest/utils';
+
+declare function updateTask(task: Task, runner: VitestRunner): void;
+declare function startTests(paths: string[], runner: VitestRunner): Promise<File[]>;
+
+declare const suite: SuiteAPI<{}>;
+declare const test: TestAPI<{}>;
+declare const describe: SuiteAPI<{}>;
+declare const it: TestAPI<{}>;
+declare function getCurrentSuite<ExtraContext = {}>(): SuiteCollector<ExtraContext>;
+
+declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number) => void;
+declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number) => void;
+declare const beforeEach: <ExtraContext = {}>(fn: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>, timeout?: number) => void;
+declare const afterEach: <ExtraContext = {}>(fn: HookListener<[TestContext & ExtraContext, Suite], void>, timeout?: number) => void;
+declare const onTestFailed: (fn: OnTestFailedHandler) => void;
+
+declare function setFn(key: Test, fn: (() => Awaitable<void>)): void;
+declare function getFn<Task = Test>(key: Task): (() => Awaitable<void>);
+
+export { afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };

package/dist/index.js

@@ -0,0 +1,610 @@
+import limit from 'p-limit';
+import { getSafeTimers, format, isObject, objDisplay, objectAttr, noop, toArray, shuffle } from '@vitest/utils';
+import { c as createChainable, g as generateHash, p as processError, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, b as partitionSuiteChildren, h as hasTests, d as hasFailed } from './chunk-tasks.js';
+import { relative } from 'pathe';
+
+const fnMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+  fnMap.set(key, fn);
+}
+function getFn(key) {
+  return fnMap.get(key);
+}
+function setHooks(key, hooks) {
+  hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+  return hooksMap.get(key);
+}
+
+const collectorContext = {
+  tasks: [],
+  currentSuite: null
+};
+function collectTask(task) {
+  var _a;
+  (_a = collectorContext.currentSuite) == null ? void 0 : _a.tasks.push(task);
+}
+async function runWithSuite(suite, fn) {
+  const prev = collectorContext.currentSuite;
+  collectorContext.currentSuite = suite;
+  await fn();
+  collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false) {
+  if (timeout <= 0 || timeout === Infinity)
+    return fn;
+  const { setTimeout, clearTimeout } = getSafeTimers();
+  return (...args) => {
+    return Promise.race([fn(...args), new Promise((resolve, reject) => {
+      var _a;
+      const timer = setTimeout(() => {
+        clearTimeout(timer);
+        reject(new Error(makeTimeoutMsg(isHook, timeout)));
+      }, timeout);
+      (_a = timer.unref) == null ? void 0 : _a.call(timer);
+    })]);
+  };
+}
+function createTestContext(test, runner) {
+  var _a;
+  const context = function() {
+    throw new Error("done() callback is deprecated, use promise instead");
+  };
+  context.meta = test;
+  context.onTestFailed = (fn) => {
+    test.onFailed || (test.onFailed = []);
+    test.onFailed.push(fn);
+  };
+  return ((_a = runner.extendTestContext) == null ? void 0 : _a.call(runner, context)) || context;
+}
+function makeTimeoutMsg(isHook, timeout) {
+  return `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
+If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
+}
+
+const suite = createSuite();
+const test = createTest(
+  function(name, fn, options) {
+    getCurrentSuite().test.fn.call(this, name, fn, options);
+  }
+);
+const describe = suite;
+const it = test;
+let runner;
+let defaultSuite;
+function getDefaultSuite() {
+  return defaultSuite;
+}
+function getRunner() {
+  return runner;
+}
+function clearCollectorContext(currentRunner) {
+  if (!defaultSuite)
+    defaultSuite = currentRunner.config.sequence.shuffle ? suite.shuffle("") : suite("");
+  runner = currentRunner;
+  collectorContext.tasks.length = 0;
+  defaultSuite.clear();
+  collectorContext.currentSuite = defaultSuite;
+}
+function getCurrentSuite() {
+  return collectorContext.currentSuite || defaultSuite;
+}
+function createSuiteHooks() {
+  return {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+}
+function createSuiteCollector(name, factory = () => {
+}, mode, concurrent, shuffle, suiteOptions) {
+  const tasks = [];
+  const factoryQueue = [];
+  let suite2;
+  initSuite();
+  const test2 = createTest(function(name2, fn = noop, options = suiteOptions) {
+    const mode2 = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+    if (typeof options === "number")
+      options = { timeout: options };
+    const test3 = {
+      id: "",
+      type: "test",
+      name: name2,
+      mode: mode2,
+      suite: void 0,
+      fails: this.fails,
+      retry: options == null ? void 0 : options.retry
+    };
+    if (this.concurrent || concurrent)
+      test3.concurrent = true;
+    if (shuffle)
+      test3.shuffle = true;
+    const context = createTestContext(test3, runner);
+    Object.defineProperty(test3, "context", {
+      value: context,
+      enumerable: false
+    });
+    setFn(test3, withTimeout(
+      () => fn(context),
+      (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
+    ));
+    tasks.push(test3);
+  });
+  const custom = function(name2 = "") {
+    const self = this || {};
+    const task = {
+      id: "",
+      name: name2,
+      type: "custom",
+      mode: self.only ? "only" : self.skip ? "skip" : self.todo ? "todo" : "run"
+    };
+    tasks.push(task);
+    return task;
+  };
+  const collector = {
+    type: "collector",
+    name,
+    mode,
+    test: test2,
+    tasks,
+    collect,
+    custom,
+    clear,
+    on: addHook
+  };
+  function addHook(name2, ...fn) {
+    getHooks(suite2)[name2].push(...fn);
+  }
+  function initSuite() {
+    suite2 = {
+      id: "",
+      type: "suite",
+      name,
+      mode,
+      shuffle,
+      tasks: []
+    };
+    setHooks(suite2, createSuiteHooks());
+  }
+  function clear() {
+    tasks.length = 0;
+    factoryQueue.length = 0;
+    initSuite();
+  }
+  async function collect(file) {
+    factoryQueue.length = 0;
+    if (factory)
+      await runWithSuite(collector, () => factory(test2));
+    const allChildren = [];
+    for (const i of [...factoryQueue, ...tasks])
+      allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+    suite2.file = file;
+    suite2.tasks = allChildren;
+    allChildren.forEach((task) => {
+      task.suite = suite2;
+      if (file)
+        task.file = file;
+    });
+    return suite2;
+  }
+  collectTask(collector);
+  return collector;
+}
+function createSuite() {
+  function suiteFn(name, factory, options) {
+    const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+    return createSuiteCollector(name, factory, mode, this.concurrent, this.shuffle, options);
+  }
+  suiteFn.each = function(cases, ...args) {
+    const suite2 = this.withContext();
+    if (Array.isArray(cases) && args.length)
+      cases = formatTemplateString(cases, args);
+    return (name, fn, options) => {
+      const arrayOnlyCases = cases.every(Array.isArray);
+      cases.forEach((i, idx) => {
+        const items = Array.isArray(i) ? i : [i];
+        arrayOnlyCases ? suite2(formatTitle(name, items, idx), () => fn(...items), options) : suite2(formatTitle(name, items, idx), () => fn(i), options);
+      });
+    };
+  };
+  suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
+  suiteFn.runIf = (condition) => condition ? suite : suite.skip;
+  return createChainable(
+    ["concurrent", "shuffle", "skip", "only", "todo"],
+    suiteFn
+  );
+}
+function createTest(fn) {
+  const testFn = fn;
+  testFn.each = function(cases, ...args) {
+    const test2 = this.withContext();
+    if (Array.isArray(cases) && args.length)
+      cases = formatTemplateString(cases, args);
+    return (name, fn2, options) => {
+      const arrayOnlyCases = cases.every(Array.isArray);
+      cases.forEach((i, idx) => {
+        const items = Array.isArray(i) ? i : [i];
+        arrayOnlyCases ? test2(formatTitle(name, items, idx), () => fn2(...items), options) : test2(formatTitle(name, items, idx), () => fn2(i), options);
+      });
+    };
+  };
+  testFn.skipIf = (condition) => condition ? test.skip : test;
+  testFn.runIf = (condition) => condition ? test : test.skip;
+  return createChainable(
+    ["concurrent", "skip", "only", "todo", "fails"],
+    testFn
+  );
+}
+function formatTitle(template, items, idx) {
+  if (template.includes("%#")) {
+    template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/__vitest_escaped_%__/g, "%%");
+  }
+  const count = template.split("%").length - 1;
+  let formatted = format(template, ...items.slice(0, count));
+  if (isObject(items[0])) {
+    formatted = formatted.replace(
+      /\$([$\w_.]+)/g,
+      (_, key) => objDisplay(objectAttr(items[0], key))
+    );
+  }
+  return formatted;
+}
+function formatTemplateString(cases, args) {
+  const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i) => i.split("|"))[0];
+  const res = [];
+  for (let i = 0; i < Math.floor(args.length / header.length); i++) {
+    const oneCase = {};
+    for (let j = 0; j < header.length; j++)
+      oneCase[header[j]] = args[i * header.length + j];
+    res.push(oneCase);
+  }
+  return res;
+}
+
+async function runSetupFiles(config, runner) {
+  const files = toArray(config.setupFiles);
+  await Promise.all(
+    files.map(async (fsPath) => {
+      await runner.importFile(fsPath, "setup");
+    })
+  );
+}
+
+const now$1 = Date.now;
+async function collectTests(paths, runner) {
+  const files = [];
+  const config = runner.config;
+  for (const filepath of paths) {
+    const path = relative(config.root, filepath);
+    const file = {
+      id: generateHash(path),
+      name: path,
+      type: "suite",
+      mode: "run",
+      filepath,
+      tasks: [],
+      projectName: config.name
+    };
+    clearCollectorContext(runner);
+    try {
+      const setupStart = now$1();
+      await runSetupFiles(config, runner);
+      const collectStart = now$1();
+      file.setupDuration = collectStart - setupStart;
+      await runner.importFile(filepath, "collect");
+      const defaultTasks = await getDefaultSuite().collect(file);
+      setHooks(file, getHooks(defaultTasks));
+      for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
+        if (c.type === "test") {
+          file.tasks.push(c);
+        } else if (c.type === "custom") {
+          file.tasks.push(c);
+        } else if (c.type === "suite") {
+          file.tasks.push(c);
+        } else if (c.type === "collector") {
+          const suite = await c.collect(file);
+          if (suite.name || suite.tasks.length)
+            file.tasks.push(suite);
+        }
+      }
+      file.collectDuration = now$1() - collectStart;
+    } catch (e) {
+      const error = processError(e);
+      file.result = {
+        state: "fail",
+        error,
+        errors: [error]
+      };
+    }
+    calculateSuiteHash(file);
+    const hasOnlyTasks = someTasksAreOnly(file);
+    interpretTaskModes(file, config.testNamePattern, hasOnlyTasks, false, config.allowOnly);
+    files.push(file);
+  }
+  return files;
+}
+
+let _test;
+function setCurrentTest(test) {
+  _test = test;
+}
+function getCurrentTest() {
+  return _test;
+}
+
+const now = Date.now;
+function updateSuiteHookState(suite, name, state, runner) {
+  var _a;
+  if (!suite.result)
+    suite.result = { state: "run" };
+  if (!((_a = suite.result) == null ? void 0 : _a.hooks))
+    suite.result.hooks = {};
+  const suiteHooks = suite.result.hooks;
+  if (suiteHooks) {
+    suiteHooks[name] = state;
+    updateTask(suite, runner);
+  }
+}
+function getSuiteHooks(suite, name, sequence) {
+  const hooks = getHooks(suite)[name];
+  if (sequence === "stack" && (name === "afterAll" || name === "afterEach"))
+    return hooks.slice().reverse();
+  return hooks;
+}
+async function callSuiteHook(suite, currentTask, name, runner, args) {
+  const sequence = runner.config.sequence.hooks;
+  const callbacks = [];
+  if (name === "beforeEach" && suite.suite) {
+    callbacks.push(
+      ...await callSuiteHook(suite.suite, currentTask, name, runner, args)
+    );
+  }
+  updateSuiteHookState(currentTask, name, "run", runner);
+  const hooks = getSuiteHooks(suite, name, sequence);
+  if (sequence === "parallel") {
+    callbacks.push(...await Promise.all(hooks.map((fn) => fn(...args))));
+  } else {
+    for (const hook of hooks)
+      callbacks.push(await hook(...args));
+  }
+  updateSuiteHookState(currentTask, name, "pass", runner);
+  if (name === "afterEach" && suite.suite) {
+    callbacks.push(
+      ...await callSuiteHook(suite.suite, currentTask, name, runner, args)
+    );
+  }
+  return callbacks;
+}
+const packs = /* @__PURE__ */ new Map();
+let updateTimer;
+let previousUpdate;
+function updateTask(task, runner) {
+  packs.set(task.id, task.result);
+  const { clearTimeout, setTimeout } = getSafeTimers();
+  clearTimeout(updateTimer);
+  updateTimer = setTimeout(() => {
+    previousUpdate = sendTasksUpdate(runner);
+  }, 10);
+}
+async function sendTasksUpdate(runner) {
+  var _a;
+  const { clearTimeout } = getSafeTimers();
+  clearTimeout(updateTimer);
+  await previousUpdate;
+  if (packs.size) {
+    const p = (_a = runner.onTaskUpdate) == null ? void 0 : _a.call(runner, Array.from(packs));
+    packs.clear();
+    return p;
+  }
+}
+const callCleanupHooks = async (cleanups) => {
+  await Promise.all(cleanups.map(async (fn) => {
+    if (typeof fn !== "function")
+      return;
+    await fn();
+  }));
+};
+async function runTest(test, runner) {
+  var _a, _b, _c, _d, _e, _f;
+  await ((_a = runner.onBeforeRunTest) == null ? void 0 : _a.call(runner, test));
+  if (test.mode !== "run")
+    return;
+  if (((_b = test.result) == null ? void 0 : _b.state) === "fail") {
+    updateTask(test, runner);
+    return;
+  }
+  const start = now();
+  test.result = {
+    state: "run",
+    startTime: start
+  };
+  updateTask(test, runner);
+  setCurrentTest(test);
+  const retry = test.retry || 1;
+  for (let retryCount = 0; retryCount < retry; retryCount++) {
+    let beforeEachCleanups = [];
+    try {
+      await ((_c = runner.onBeforeTryTest) == null ? void 0 : _c.call(runner, test, retryCount));
+      beforeEachCleanups = await callSuiteHook(test.suite, test, "beforeEach", runner, [test.context, test.suite]);
+      test.result.retryCount = retryCount;
+      if (runner.runTest) {
+        await runner.runTest(test);
+      } else {
+        const fn = getFn(test);
+        if (!fn)
+          throw new Error("Test function is not found. Did you add it using `setFn`?");
+        await fn();
+      }
+      await ((_d = runner.onAfterTryTest) == null ? void 0 : _d.call(runner, test, retryCount));
+      test.result.state = "pass";
+    } catch (e) {
+      const error = processError(e);
+      test.result.state = "fail";
+      test.result.error = error;
+      test.result.errors = [error];
+    }
+    try {
+      await callSuiteHook(test.suite, test, "afterEach", runner, [test.context, test.suite]);
+      await callCleanupHooks(beforeEachCleanups);
+    } catch (e) {
+      const error = processError(e);
+      test.result.state = "fail";
+      test.result.error = error;
+      test.result.errors = [error];
+    }
+    if (test.result.state === "pass")
+      break;
+    updateTask(test, runner);
+  }
+  if (test.result.state === "fail")
+    await Promise.all(((_e = test.onFailed) == null ? void 0 : _e.map((fn) => fn(test.result))) || []);
+  if (test.fails) {
+    if (test.result.state === "pass") {
+      const error = processError(new Error("Expect test to fail"));
+      test.result.state = "fail";
+      test.result.error = error;
+      test.result.errors = [error];
+    } else {
+      test.result.state = "pass";
+      test.result.error = void 0;
+      test.result.errors = void 0;
+    }
+  }
+  setCurrentTest(void 0);
+  test.result.duration = now() - start;
+  await ((_f = runner.onAfterRunTest) == null ? void 0 : _f.call(runner, test));
+  updateTask(test, runner);
+}
+function markTasksAsSkipped(suite, runner) {
+  suite.tasks.forEach((t) => {
+    t.mode = "skip";
+    t.result = { ...t.result, state: "skip" };
+    updateTask(t, runner);
+    if (t.type === "suite")
+      markTasksAsSkipped(t, runner);
+  });
+}
+async function runSuite(suite, runner) {
+  var _a, _b, _c;
+  await ((_a = runner.onBeforeRunSuite) == null ? void 0 : _a.call(runner, suite));
+  if (((_b = suite.result) == null ? void 0 : _b.state) === "fail") {
+    markTasksAsSkipped(suite, runner);
+    updateTask(suite, runner);
+    return;
+  }
+  const start = now();
+  suite.result = {
+    state: "run",
+    startTime: start
+  };
+  updateTask(suite, runner);
+  if (suite.mode === "skip") {
+    suite.result.state = "skip";
+  } else if (suite.mode === "todo") {
+    suite.result.state = "todo";
+  } else {
+    try {
+      const beforeAllCleanups = await callSuiteHook(suite, suite, "beforeAll", runner, [suite]);
+      if (runner.runSuite) {
+        await runner.runSuite(suite);
+      } else {
+        for (let tasksGroup of partitionSuiteChildren(suite)) {
+          if (tasksGroup[0].concurrent === true) {
+            const mutex = limit(runner.config.maxConcurrency);
+            await Promise.all(tasksGroup.map((c) => mutex(() => runSuiteChild(c, runner))));
+          } else {
+            const { sequence } = runner.config;
+            if (sequence.shuffle || suite.shuffle) {
+              const suites = tasksGroup.filter((group) => group.type === "suite");
+              const tests = tasksGroup.filter((group) => group.type === "test");
+              const groups = shuffle([suites, tests], sequence.seed);
+              tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+            }
+            for (const c of tasksGroup)
+              await runSuiteChild(c, runner);
+          }
+        }
+      }
+      await callSuiteHook(suite, suite, "afterAll", runner, [suite]);
+      await callCleanupHooks(beforeAllCleanups);
+    } catch (e) {
+      const error = processError(e);
+      suite.result.state = "fail";
+      suite.result.error = error;
+      suite.result.errors = [error];
+    }
+  }
+  suite.result.duration = now() - start;
+  if (suite.mode === "run") {
+    if (!hasTests(suite)) {
+      suite.result.state = "fail";
+      if (!suite.result.error) {
+        const error = processError(new Error(`No test found in suite ${suite.name}`));
+        suite.result.error = error;
+        suite.result.errors = [error];
+      }
+    } else if (hasFailed(suite)) {
+      suite.result.state = "fail";
+    } else {
+      suite.result.state = "pass";
+    }
+  }
+  await ((_c = runner.onAfterRunSuite) == null ? void 0 : _c.call(runner, suite));
+  updateTask(suite, runner);
+}
+async function runSuiteChild(c, runner) {
+  if (c.type === "test")
+    return runTest(c, runner);
+  else if (c.type === "suite")
+    return runSuite(c, runner);
+}
+async function runFiles(files, runner) {
+  var _a, _b;
+  for (const file of files) {
+    if (!file.tasks.length && !runner.config.passWithNoTests) {
+      if (!((_b = (_a = file.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.length)) {
+        const error = processError(new Error(`No test suite found in file ${file.filepath}`));
+        file.result = {
+          state: "fail",
+          error,
+          errors: [error]
+        };
+      }
+    }
+    await runSuite(file, runner);
+  }
+}
+async function startTests(paths, runner) {
+  var _a, _b, _c, _d;
+  await ((_a = runner.onBeforeCollect) == null ? void 0 : _a.call(runner, paths));
+  const files = await collectTests(paths, runner);
+  (_b = runner.onCollected) == null ? void 0 : _b.call(runner, files);
+  await ((_c = runner.onBeforeRun) == null ? void 0 : _c.call(runner, files));
+  await runFiles(files, runner);
+  await ((_d = runner.onAfterRun) == null ? void 0 : _d.call(runner, files));
+  await sendTasksUpdate(runner);
+  return files;
+}
+
+const getDefaultHookTimeout = () => getRunner().config.hookTimeout;
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+const onTestFailed = createTestHook("onTestFailed", (test, handler) => {
+  test.onFailed || (test.onFailed = []);
+  test.onFailed.push(handler);
+});
+function createTestHook(name, handler) {
+  return (fn) => {
+    const current = getCurrentTest();
+    if (!current)
+      throw new Error(`Hook ${name}() can only be called inside a test`);
+    handler(current, fn);
+  };
+}
+
+export { afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };

package/dist/runner-93cc9c0d.d.ts

@@ -0,0 +1,93 @@
+import { q as SequenceHooks, F as File, g as Test, e as Suite, k as TaskResult, d as TestContext } from './tasks-e1fc71d1.js';
+
+interface VitestRunnerConfig {
+    root: string;
+    setupFiles: string[] | string;
+    name: string;
+    passWithNoTests: boolean;
+    testNamePattern?: RegExp;
+    allowOnly?: boolean;
+    sequence: {
+        shuffle?: boolean;
+        seed?: number;
+        hooks: SequenceHooks;
+    };
+    maxConcurrency: number;
+    testTimeout: number;
+    hookTimeout: number;
+}
+type VitestRunnerImportSource = 'collect' | 'setup';
+interface VitestRunnerConstructor {
+    new (config: VitestRunnerConfig): VitestRunner;
+}
+interface VitestRunner {
+    /**
+     * First thing that's getting called before actually collecting and running tests.
+     */
+    onBeforeCollect?(paths: string[]): unknown;
+    /**
+     * Called after collecting tests and before "onBeforeRun".
+     */
+    onCollected?(files: File[]): unknown;
+    /**
+     * Called before running a single test. Doesn't have "result" yet.
+     */
+    onBeforeRunTest?(test: Test): unknown;
+    /**
+     * Called before actually running the test function. Already has "result" with "state" and "startTime".
+     */
+    onBeforeTryTest?(test: Test, retryCount: number): unknown;
+    /**
+     * Called after result and state are set.
+     */
+    onAfterRunTest?(test: Test): unknown;
+    /**
+     * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
+     */
+    onAfterTryTest?(test: Test, retryCount: number): unknown;
+    /**
+     * Called before running a single suite. Doesn't have "result" yet.
+     */
+    onBeforeRunSuite?(suite: Suite): unknown;
+    /**
+     * Called after running a single suite. Has state and result.
+     */
+    onAfterRunSuite?(suite: Suite): unknown;
+    /**
+     * If defined, will be called instead of usual Vitest suite partition and handling.
+     * "before" and "after" hooks will not be ignored.
+     */
+    runSuite?(suite: Suite): Promise<void>;
+    /**
+     * If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
+     * "before" and "after" hooks will not be ignored.
+     */
+    runTest?(test: Test): Promise<void>;
+    /**
+     * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
+     */
+    onTaskUpdate?(task: [string, TaskResult | undefined][]): Promise<void>;
+    /**
+     * Called before running all tests in collected paths.
+     */
+    onBeforeRun?(files: File[]): unknown;
+    /**
+     * Called right after running all tests in collected paths.
+     */
+    onAfterRun?(files: File[]): unknown;
+    /**
+     * Called when new context for a test is defined. Useful, if you want to add custom properties to the context.
+     * If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
+     */
+    extendTestContext?(context: TestContext): TestContext;
+    /**
+     * Called, when files are imported. Can be called in two situations: when collecting tests and when importing setup files.
+     */
+    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    /**
+     * Publically available configuration.
+     */
+    config: VitestRunnerConfig;
+}
+
+export { VitestRunner as V, VitestRunnerConfig as a, VitestRunnerImportSource as b, VitestRunnerConstructor as c };

package/dist/tasks-e1fc71d1.d.ts

@@ -0,0 +1,195 @@
+import { Awaitable } from '@vitest/utils';
+
+type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
+    (...args: Args): R;
+} & {
+    [x in T]: ChainableFunction<T, Args, R, E>;
+} & {
+    fn: (this: Record<T, boolean | undefined>, ...args: Args) => R;
+} & E;
+declare function createChainable<T extends string, Args extends any[], R = any, E = {}>(keys: T[], fn: (this: Record<T, boolean | undefined>, ...args: Args) => R): ChainableFunction<T, Args, R, E>;
+
+interface ParsedStack {
+    method: string;
+    file: string;
+    line: number;
+    column: number;
+}
+interface ErrorWithDiff extends Error {
+    name: string;
+    nameStr?: string;
+    stack?: string;
+    stackStr?: string;
+    stacks?: ParsedStack[];
+    showDiff?: boolean;
+    actual?: any;
+    expected?: any;
+    operator?: string;
+    type?: string;
+    frame?: string;
+}
+declare function serializeError(val: any, seen?: WeakMap<object, any>): any;
+interface ProcessErrorOptions {
+    outputDiffMaxSize?: number;
+}
+declare function processError(err: any, options?: ProcessErrorOptions): any;
+declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<object>, expectedReplaced?: WeakSet<object>): {
+    replacedActual: any;
+    replacedExpected: any;
+};
+
+type RunMode = 'run' | 'skip' | 'only' | 'todo';
+type TaskState = RunMode | 'pass' | 'fail';
+interface TaskBase {
+    id: string;
+    name: string;
+    mode: RunMode;
+    concurrent?: boolean;
+    shuffle?: boolean;
+    suite?: Suite;
+    file?: File;
+    result?: TaskResult;
+    retry?: number;
+    meta?: any;
+}
+interface TaskCustom extends TaskBase {
+    type: 'custom';
+}
+interface TaskResult {
+    state: TaskState;
+    duration?: number;
+    startTime?: number;
+    heap?: number;
+    /**
+     * @deprecated Use "errors" instead
+     */
+    error?: ErrorWithDiff;
+    errors?: ErrorWithDiff[];
+    htmlError?: string;
+    hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
+    retryCount?: number;
+}
+type TaskResultPack = [id: string, result: TaskResult | undefined];
+interface Suite extends TaskBase {
+    type: 'suite';
+    tasks: Task[];
+    filepath?: string;
+    projectName?: string;
+}
+interface File extends Suite {
+    filepath: string;
+    collectDuration?: number;
+    setupDuration?: number;
+}
+interface Test<ExtraContext = {}> extends TaskBase {
+    type: 'test';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+    context: TestContext & ExtraContext;
+    onFailed?: OnTestFailedHandler[];
+}
+type Task = Test | Suite | TaskCustom | File;
+type DoneCallback = (error?: any) => void;
+type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
+type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
+    1: [T[0]];
+    2: [T[0], T[1]];
+    3: [T[0], T[1], T[2]];
+    4: [T[0], T[1], T[2], T[3]];
+    5: [T[0], T[1], T[2], T[3], T[4]];
+    6: [T[0], T[1], T[2], T[3], T[4], T[5]];
+    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6]];
+    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7]];
+    9: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8]];
+    10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]];
+    fallback: Array<T extends ReadonlyArray<infer U> ? U : any>;
+}[T extends Readonly<[any]> ? 1 : T extends Readonly<[any, any]> ? 2 : T extends Readonly<[any, any, any]> ? 3 : T extends Readonly<[any, any, any, any]> ? 4 : T extends Readonly<[any, any, any, any, any]> ? 5 : T extends Readonly<[any, any, any, any, any, any]> ? 6 : T extends Readonly<[any, any, any, any, any, any, any]> ? 7 : T extends Readonly<[any, any, any, any, any, any, any, any]> ? 8 : T extends Readonly<[any, any, any, any, any, any, any, any, any]> ? 9 : T extends Readonly<[any, any, any, any, any, any, any, any, any, any]> ? 10 : 'fallback'];
+interface SuiteEachFunction {
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>) => void;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>) => void;
+    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>) => void;
+}
+interface TestEachFunction {
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions) => void;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>, options?: number | TestOptions) => void;
+    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>, options?: number | TestOptions) => void;
+    (...args: [TemplateStringsArray, ...any]): (name: string, fn: (...args: any[]) => Awaitable<void>, options?: number | TestOptions) => void;
+}
+type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
+    name: string,
+    fn?: TestFunction<ExtraContext>,
+    options?: number | TestOptions
+], void, {
+    each: TestEachFunction;
+    <T extends ExtraContext>(name: string, fn?: TestFunction<T>, options?: number | TestOptions): void;
+}>;
+interface TestOptions {
+    /**
+     * Test timeout.
+     */
+    timeout?: number;
+    /**
+     * Times to retry the test if fails. Useful for making flaky tests more stable.
+     * When retries is up, the last test error will be thrown.
+     *
+     * @default 1
+     */
+    retry?: number;
+}
+type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
+    each: TestEachFunction;
+    skipIf(condition: any): ChainableTestAPI<ExtraContext>;
+    runIf(condition: any): ChainableTestAPI<ExtraContext>;
+};
+type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
+    name: string,
+    factory?: SuiteFactory<ExtraContext>,
+    options?: number | TestOptions
+], SuiteCollector<ExtraContext>, {
+    each: TestEachFunction;
+    <T extends ExtraContext>(name: string, factory?: SuiteFactory<T>): SuiteCollector<T>;
+}>;
+type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
+    each: SuiteEachFunction;
+    skipIf(condition: any): ChainableSuiteAPI<ExtraContext>;
+    runIf(condition: any): ChainableSuiteAPI<ExtraContext>;
+};
+type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
+type HookCleanupCallback = (() => Awaitable<unknown>) | void;
+interface SuiteHooks<ExtraContext = {}> {
+    beforeAll: HookListener<[Suite | File], HookCleanupCallback>[];
+    afterAll: HookListener<[Suite | File]>[];
+    beforeEach: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>[];
+    afterEach: HookListener<[TestContext & ExtraContext, Suite]>[];
+}
+interface SuiteCollector<ExtraContext = {}> {
+    readonly name: string;
+    readonly mode: RunMode;
+    type: 'collector';
+    test: TestAPI<ExtraContext>;
+    tasks: (Suite | TaskCustom | Test | SuiteCollector<ExtraContext>)[];
+    custom: (name: string) => TaskCustom;
+    collect: (file?: File) => Promise<Suite>;
+    clear: () => void;
+    on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
+}
+type SuiteFactory<ExtraContext = {}> = (test: (name: string, fn: TestFunction<ExtraContext>) => void) => Awaitable<void>;
+interface RuntimeContext {
+    tasks: (SuiteCollector | Test)[];
+    currentSuite: SuiteCollector | null;
+}
+interface TestContext {
+    /**
+     * Metadata of the current test
+     */
+    meta: Readonly<Test>;
+    /**
+     * Extract hooks on test failed
+     */
+    onTestFailed: (fn: OnTestFailedHandler) => void;
+}
+type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
+type SequenceHooks = 'stack' | 'list' | 'parallel';
+
+export { ChainableFunction as C, DoneCallback as D, ErrorWithDiff as E, File as F, HookListener as H, OnTestFailedHandler as O, ParsedStack as P, RunMode as R, SuiteAPI as S, Task as T, TestAPI as a, SuiteCollector as b, SuiteHooks as c, TestContext as d, Suite as e, HookCleanupCallback as f, Test as g, TaskState as h, TaskBase as i, TaskCustom as j, TaskResult as k, TaskResultPack as l, TestFunction as m, TestOptions as n, SuiteFactory as o, RuntimeContext as p, SequenceHooks as q, createChainable as r, serializeError as s, processError as t, replaceAsymmetricMatcher as u };

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export { D as DoneCallback, F as File, f as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, p as RuntimeContext, q as SequenceHooks, e as Suite, S as SuiteAPI, b as SuiteCollector, o as SuiteFactory, c as SuiteHooks, T as Task, i as TaskBase, j as TaskCustom, k as TaskResult, l as TaskResultPack, h as TaskState, g as Test, a as TestAPI, d as TestContext, m as TestFunction, n as TestOptions } from './tasks-e1fc71d1.js';
+export { V as VitestRunner, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-93cc9c0d.js';
+import '@vitest/utils';

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/utils.d.ts

@@ -0,0 +1,25 @@
+import { e as Suite, T as Task, g as Test, j as TaskCustom } from './tasks-e1fc71d1.js';
+export { C as ChainableFunction, E as ErrorWithDiff, P as ParsedStack, r as createChainable, t as processError, u as replaceAsymmetricMatcher, s as serializeError } from './tasks-e1fc71d1.js';
+import { Arrayable } from '@vitest/utils';
+
+/**
+ * If any tasks been marked as `only`, mark all other tasks as `skip`.
+ */
+declare function interpretTaskModes(suite: Suite, namePattern?: string | RegExp, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
+declare function someTasksAreOnly(suite: Suite): boolean;
+declare function generateHash(str: string): string;
+declare function calculateSuiteHash(parent: Suite): void;
+
+/**
+ * Partition in tasks groups by consecutive concurrent
+ */
+declare function partitionSuiteChildren(suite: Suite): Task[][];
+
+declare function getTests(suite: Arrayable<Task>): (Test | TaskCustom)[];
+declare function getTasks(tasks?: Arrayable<Task>): Task[];
+declare function getSuites(suite: Arrayable<Task>): Suite[];
+declare function hasTests(suite: Arrayable<Suite>): boolean;
+declare function hasFailed(suite: Arrayable<Task>): boolean;
+declare function getNames(task: Task): string[];
+
+export { calculateSuiteHash, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, partitionSuiteChildren, someTasksAreOnly };

package/dist/utils.js

@@ -0,0 +1,2 @@
+export { a as calculateSuiteHash, c as createChainable, g as generateHash, k as getNames, j as getSuites, f as getTasks, e as getTests, d as hasFailed, h as hasTests, i as interpretTaskModes, b as partitionSuiteChildren, p as processError, r as replaceAsymmetricMatcher, l as serializeError, s as someTasksAreOnly } from './chunk-tasks.js';
+import '@vitest/utils';

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@vitest/runner",
+  "type": "module",
+  "version": "0.28.0",
+  "description": "Vitest test runner",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/runner"
+  },
+  "sideEffects": true,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "*.d.ts"
+  ],
+  "dependencies": {
+    "p-limit": "^4.0.0",
+    "pathe": "^1.1.0",
+    "@vitest/utils": "0.28.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch"
+  }
+}

package/types.d.ts

@@ -0,0 +1 @@
+export * from './dist/types.js'

package/utils.d.ts

@@ -0,0 +1 @@
+export * from './dist/utils.js'