@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/@vitest/mocker/redirect.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import nodeModule from 'node:module';
+import module$1 from 'node:module';
 import { d as dirname, j as join, b as basename, r as resolve, e as extname } from './chunk-pathe.M-eThtNZ.js';
 
 const { existsSync, readdirSync, statSync } = fs;
@@ -42,7 +42,7 @@ function findMockRedirect(root, mockPath, external) {
   return existsSync(fullPath) ? fullPath : null;
 }
 const builtins = new Set([
-  ...nodeModule.builtinModules,
+  ...module$1.builtinModules,
   "assert/strict",
   "diagnostics_channel",
   "dns/promises",
@@ -67,8 +67,8 @@ const prefixedBuiltins = new Set([
 const NODE_BUILTIN_NAMESPACE = "node:";
 function isNodeBuiltin(id) {
   // Added in v18.6.0
-  if (nodeModule.isBuiltin) {
-    return nodeModule.isBuiltin(id);
+  if (module$1.isBuiltin) {
+    return module$1.isBuiltin(id);
   }
   if (prefixedBuiltins.has(id)) {
     return true;

package/dist/@vitest/mocker/register.d.ts

@@ -1,7 +1,7 @@
-import { M as ModuleMockerInterceptor, a as ModuleMockerCompilerHints, b as ModuleMocker } from './mocker.d-TnKRhz7N.js';
+import { M as ModuleMockerInterceptor, a as ModuleMockerCompilerHints, b as ModuleMocker } from './mocker.d-QEntlm6J.js';
 import '../spy/index.js';
-import './types.d-B8CCKmHt.js';
-import './index.d-C-sLYZi-.js';
+import './types.d-BjI5eAwu.js';
+import './index.d-B41z0AuW.js';
 
 declare function registerModuleMocker(interceptor: (accessor: string) => ModuleMockerInterceptor): ModuleMockerCompilerHints;
 declare function registerNativeFactoryResolver(mocker: ModuleMocker): void;

package/dist/@vitest/mocker/register.js

@@ -1,5 +1,6 @@
 import { createMockInstance } from '../spy/index.js';
 import { M as ModuleMocker, r as rpc, c as createCompilerHints, h as hot } from './chunk-mocker.js';
+import './chunk-helpers.js';
 import './index.js';
 import './chunk-registry.js';
 import './chunk-pathe.M-eThtNZ.js';

package/dist/@vitest/mocker/transforms.d.ts

@@ -0,0 +1,6 @@
+export { c as createManualModuleSource, h as hoistMocks } from './hoistMocks.d-w2ILr1dG.js';
+export { automockModule } from './automock.js';
+declare function initSyntaxLexers(): Promise<void>;
+declare function collectModuleExports(filename: string, code: string, format: "module" | "commonjs", exports?: string[]): string[];
+
+export { collectModuleExports, initSyntaxLexers };

package/dist/@vitest/mocker/transforms.js

@@ -0,0 +1,8 @@
+export { c as createManualModuleSource } from './chunk-utils.js';
+export { a as automockModule, c as collectModuleExports, i as initSyntaxLexers } from './chunk-automock.js';
+export { h as hoistMocks } from './chunk-hoistMocks.js';
+import 'node:fs';
+import 'node:url';
+import 'node:module';
+import 'node:path';
+import './chunk-helpers.js';

package/dist/@vitest/mocker/{types.d-B8CCKmHt.d.ts → types.d-BjI5eAwu.d.ts}

@@ -65,15 +65,15 @@ interface RedirectedModuleSerialized {
 	raw: string;
 	redirect: string;
 }
-declare class ManualMockedModule {
+declare class ManualMockedModule<T = any> {
 	raw: string;
 	id: string;
 	url: string;
-	factory: () => any;
-	cache: Record<string | symbol, any> | undefined;
+	factory: () => T;
+	cache: T | undefined;
 	readonly type = "manual";
-	constructor(raw: string, id: string, url: string, factory: () => any);
-	resolve(): Promise<Record<string | symbol, any>>;
+	constructor(raw: string, id: string, url: string, factory: () => T);
+	resolve(): T;
 	static fromJSON(data: ManualMockedModuleSerialized, factory: () => any): ManualMockedModule;
 	toJSON(): ManualMockedModuleSerialized;
 }
@@ -102,6 +102,22 @@ interface ServerIdResolution {
 	url: string;
 	optimized: boolean;
 }
+interface ModuleMockContext {
+	/**
+	* When mocking with a factory, this refers to the module that imported the mock.
+	*/
+	callstack: null | string[];
+}
+interface TestModuleMocker {
+	queueMock(id: string, importer: string, factoryOrOptions?: ModuleMockFactory | ModuleMockOptions): void;
+	queueUnmock(id: string, importer: string): void;
+	importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
+	importMock(rawId: string, importer: string): Promise<any>;
+	mockObject(object: Record<string | symbol, any>, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	mockObject(object: Record<string | symbol, any>, mockExports: Record<string | symbol, any> | undefined, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	getMockContext(): ModuleMockContext;
+	reset(): void;
+}
 
-export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, AutospiedModule as f, ManualMockedModule as g };
-export type { ServerMockResolution as S, MockedModule as a, ModuleMockOptions as b, ModuleMockFactoryWithHelper as c, MockedModuleType as d, ServerIdResolution as e, AutomockedModuleSerialized as h, AutospiedModuleSerialized as i, ManualMockedModuleSerialized as j, MockedModuleSerialized as k, RedirectedModuleSerialized as l, ModuleMockFactory as m };
+export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, AutospiedModule as h, ManualMockedModule as j };
+export type { ServerMockResolution as S, TestModuleMocker as T, MockedModule as a, ModuleMockOptions as b, ModuleMockFactoryWithHelper as c, MockedModuleType as d, ModuleMockContext as e, ServerIdResolution as f, AutomockedModuleSerialized as g, AutospiedModuleSerialized as i, ManualMockedModuleSerialized as k, MockedModuleSerialized as l, ModuleMockFactory as m, RedirectedModuleSerialized as n };

package/dist/@vitest/pretty-format/index.d.ts

@@ -103,6 +103,15 @@ type Plugins = Array<Plugin>;
 * LICENSE file in the root directory of this source tree.
 */
 
+declare function createDOMElementFilter(filterNode?: (node: any) => boolean): NewPlugin;
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
 declare const DEFAULT_OPTIONS: Options;
 /**
 * Returns a presentation string of your `val` object
@@ -110,6 +119,7 @@ declare const DEFAULT_OPTIONS: Options;
 * @param options Custom settings
 */
 declare function format(val: unknown, options?: OptionsReceived): string;
+
 declare const plugins: {
 	AsymmetricMatcher: NewPlugin;
 	DOMCollection: NewPlugin;
@@ -120,5 +130,5 @@ declare const plugins: {
 	Error: NewPlugin;
 };
 
-export { DEFAULT_OPTIONS, format, plugins };
+export { DEFAULT_OPTIONS, createDOMElementFilter, format, plugins };
 export type { Colors, CompareKeys, Config, NewPlugin, OldPlugin, Options, OptionsReceived, Plugin, Plugins, PrettyFormatOptions, Printer, Refs, Theme };

package/dist/@vitest/pretty-format/index.js

@@ -295,7 +295,25 @@ function nodeIsComment(node) {
 function nodeIsFragment(node) {
   return node.nodeType === FRAGMENT_NODE;
 }
-const serialize$3 = (node, config, indentation, depth, refs, printer) => {
+function filterChildren(children, filterNode) {
+  // Filter out text nodes that only contain whitespace to prevent empty lines
+  // This is done regardless of whether a filterNode is provided
+  let filtered = children.filter((node) => {
+    // Filter out text nodes that are only whitespace
+    if (node.nodeType === TEXT_NODE) {
+      const text = node.data || "";
+      // Keep text nodes that have non-whitespace content
+      return text.trim().length > 0;
+    }
+    return true;
+  });
+  // Apply additional user-provided filter if specified
+  if (filterNode) {
+    filtered = filtered.filter(filterNode);
+  }
+  return filtered;
+}
+function serializeDOM(node, config, indentation, depth, refs, printer, filterNode) {
   if (nodeIsText(node)) {
     return printText(node.data, config);
   }
@@ -306,11 +324,22 @@ const serialize$3 = (node, config, indentation, depth, refs, printer) => {
   if (++depth > config.maxDepth) {
     return printElementAsLeaf(type, config);
   }
+  const children = Array.prototype.slice.call(node.childNodes || node.children);
+  const shadowChildren = nodeIsFragment(node) || !node.shadowRoot ? [] : Array.prototype.slice.call(node.shadowRoot.children);
+  const resolvedChildren = filterNode ? filterChildren(children, filterNode) : children;
+  const resolvedShadowChildren = filterNode ? filterChildren(shadowChildren, filterNode) : shadowChildren;
   return printElement(type, printProps(nodeIsFragment(node) ? [] : Array.from(node.attributes, (attr) => attr.name).sort(), nodeIsFragment(node) ? {} : [...node.attributes].reduce((props, attribute) => {
     props[attribute.name] = attribute.value;
     return props;
-  }, {}), config, indentation + config.indent, depth, refs, printer), (nodeIsFragment(node) || !node.shadowRoot ? "" : printShadowRoot(Array.prototype.slice.call(node.shadowRoot.children), config, indentation + config.indent, depth, refs, printer)) + printChildren(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
-};
+  }, {}), config, indentation + config.indent, depth, refs, printer), (resolvedShadowChildren.length > 0 ? printShadowRoot(resolvedShadowChildren, config, indentation + config.indent, depth, refs, printer) : "") + printChildren(resolvedChildren, config, indentation + config.indent, depth, refs, printer), config, indentation);
+}
+const serialize$3 = (node, config, indentation, depth, refs, printer) => serializeDOM(node, config, indentation, depth, refs, printer);
+function createDOMElementFilter(filterNode) {
+  return {
+    test: test$3,
+    serialize: (node, config, indentation, depth, refs, printer) => serializeDOM(node, config, indentation, depth, refs, printer, filterNode)
+  };
+}
 const plugin$3 = {
   serialize: serialize$3,
   test: test$3
@@ -1019,4 +1048,4 @@ const plugins = {
   Error: ErrorPlugin
 };
 
-export { DEFAULT_OPTIONS, format, plugins };
+export { DEFAULT_OPTIONS, createDOMElementFilter, format, plugins };

package/dist/@vitest/runner/chunk-tasks.js

@@ -3,19 +3,29 @@ import { parseSingleStack } from '../utils/source-map.js';
 import { relative } from '../../vendor/pathe.mjs';
 import { toArray } from '../utils/helpers.js';
 
-function createChainable(keys, fn) {
+const kChainableContext = Symbol("kChainableContext");
+function getChainableContext(chainable) {
+  return chainable?.[kChainableContext];
+}
+function createChainable(keys, fn, context) {
   function create(context) {
     const chain = function(...args) {
       return fn.apply(context, args);
     };
     Object.assign(chain, fn);
-    chain.withContext = () => chain.bind(context);
-    chain.setContext = (key, value) => {
-      context[key] = value;
-    };
-    chain.mergeContext = (ctx) => {
-      Object.assign(context, ctx);
-    };
+    Object.defineProperty(chain, kChainableContext, {
+      value: {
+        withContext: () => chain.bind(context),
+        getFixtures: () => context.fixtures,
+        setContext: (key, value) => {
+          context[key] = value;
+        },
+        mergeContext: (ctx) => {
+          Object.assign(context, ctx);
+        }
+      },
+      enumerable: false
+    });
     for (const key of keys) {
       Object.defineProperty(chain, key, { get() {
         return create({
@@ -26,15 +36,18 @@ function createChainable(keys, fn) {
     }
     return chain;
   }
-  const chain = create({});
-  chain.fn = fn;
+  const chain = create(context ?? {});
+  Object.defineProperty(chain, "fn", {
+    value: fn,
+    enumerable: false
+  });
   return chain;
 }
 
 /**
 * If any tasks been marked as `only`, mark all other tasks as `skip`.
 */
-function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIsOnly, allowOnly) {
+function interpretTaskModes(file, namePattern, testLocations, testIds, testTagsFilter, onlyMode, parentIsOnly, allowOnly) {
   const matchedLocations = [];
   const traverseSuite = (suite, parentIsOnly, parentMatchedWithLocation) => {
     const suiteIsOnly = parentIsOnly || suite.mode === "only";
@@ -60,10 +73,10 @@ function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIs
       }
       let hasLocationMatch = parentMatchedWithLocation;
       // Match test location against provided locations, only run if present
-      // in `testLocations`. Note: if `includeTaskLocations` is not enabled,
+      // in `testLocations`. Note: if `includeTaskLocation` is not enabled,
       // all test will be skipped.
       if (testLocations !== undefined && testLocations.length !== 0) {
-        if (t.location && (testLocations === null || testLocations === void 0 ? void 0 : testLocations.includes(t.location.line))) {
+        if (t.location && testLocations?.includes(t.location.line)) {
           t.mode = "run";
           matchedLocations.push(t.location.line);
           hasLocationMatch = true;
@@ -77,6 +90,12 @@ function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIs
         if (namePattern && !getTaskFullName(t).match(namePattern)) {
           t.mode = "skip";
         }
+        if (testIds && !testIds.includes(t.id)) {
+          t.mode = "skip";
+        }
+        if (testTagsFilter && !testTagsFilter(t.tags || [])) {
+          t.mode = "skip";
+        }
       } else if (t.type === "suite") {
         if (t.mode === "skip") {
           skipAllTasks(t);
@@ -95,7 +114,7 @@ function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIs
     }
   };
   traverseSuite(file, parentIsOnly, false);
-  const nonMatching = testLocations === null || testLocations === void 0 ? void 0 : testLocations.filter((loc) => !matchedLocations.includes(loc));
+  const nonMatching = testLocations?.filter((loc) => !matchedLocations.includes(loc));
   if (nonMatching && nonMatching.length !== 0) {
     const message = nonMatching.length === 1 ? `line ${nonMatching[0]}` : `lines ${nonMatching.join(", ")}`;
     if (file.result === undefined) {
@@ -230,28 +249,45 @@ function limitConcurrency(concurrency = Infinity) {
       tail = head && tail;
     }
   };
-  return (func, ...args) => {
-    // Create a promise chain that:
-    //  1. Waits for its turn in the task queue (if necessary).
-    //  2. Runs the task.
-    //  3. Allows the next pending task (if any) to run.
+  const acquire = () => {
+    let released = false;
+    const release = () => {
+      if (!released) {
+        released = true;
+        finish();
+      }
+    };
+    if (count++ < concurrency) {
+      return release;
+    }
     return new Promise((resolve) => {
-      if (count++ < concurrency) {
-        // No need to queue if fewer than maxConcurrency tasks are running.
-        resolve();
-      } else if (tail) {
+      if (tail) {
         // There are pending tasks, so append to the queue.
-        tail = tail[1] = [resolve];
+        tail = tail[1] = [() => resolve(release)];
       } else {
         // No other pending tasks, initialize the queue with a new tail and head.
-        head = tail = [resolve];
+        head = tail = [() => resolve(release)];
+      }
+    });
+  };
+  const limiterFn = (func, ...args) => {
+    function run(release) {
+      try {
+        const result = func(...args);
+        if (result instanceof Promise) {
+          return result.finally(release);
+        }
+        release();
+        return Promise.resolve(result);
+      } catch (error) {
+        release();
+        return Promise.reject(error);
       }
-    }).then(() => {
-      // Running func here ensures that even a non-thenable result or an
-      // immediately thrown error gets wrapped into a Promise.
-      return func(...args);
-    }).finally(finish);
+    }
+    const release = acquire();
+    return release instanceof Promise ? release.then(run) : run(release);
   };
+  return Object.assign(limiterFn, { acquire });
 }
 
 /**
@@ -274,6 +310,241 @@ function partitionSuiteChildren(suite) {
   return tasksGroups;
 }
 
+function validateTags(config, tags) {
+  if (!config.strictTags) {
+    return;
+  }
+  const availableTags = new Set(config.tags.map((tag) => tag.name));
+  for (const tag of tags) {
+    if (!availableTags.has(tag)) {
+      throw createNoTagsError(config.tags, tag);
+    }
+  }
+}
+function createNoTagsError(availableTags, tag, prefix = "tag") {
+  if (!availableTags.length) {
+    throw new Error(`The Vitest config does't define any "tags", cannot apply "${tag}" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);
+  }
+  throw new Error(`The ${prefix} "${tag}" is not defined in the configuration. Available tags are:\n${availableTags.map((t) => `- ${t.name}${t.description ? `: ${t.description}` : ""}`).join("\n")}`);
+}
+function createTagsFilter(tagsExpr, availableTags) {
+  const matchers = tagsExpr.map((expr) => parseTagsExpression(expr, availableTags));
+  return (testTags) => {
+    return matchers.every((matcher) => matcher(testTags));
+  };
+}
+function parseTagsExpression(expr, availableTags) {
+  const tokens = tokenize(expr);
+  const stream = new TokenStream(tokens, expr);
+  const ast = parseOrExpression(stream, availableTags);
+  if (stream.peek().type !== "EOF") {
+    throw new Error(`Invalid tags expression: unexpected "${formatToken(stream.peek())}" in "${expr}"`);
+  }
+  return (tags) => evaluateNode(ast, tags);
+}
+function formatToken(token) {
+  switch (token.type) {
+    case "TAG": return token.value;
+    default: return formatTokenType(token.type);
+  }
+}
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    if (expr[i] === " " || expr[i] === "  ") {
+      i++;
+      continue;
+    }
+    if (expr[i] === "(") {
+      tokens.push({ type: "LPAREN" });
+      i++;
+      continue;
+    }
+    if (expr[i] === ")") {
+      tokens.push({ type: "RPAREN" });
+      i++;
+      continue;
+    }
+    if (expr[i] === "!") {
+      tokens.push({ type: "NOT" });
+      i++;
+      continue;
+    }
+    if (expr.slice(i, i + 2) === "&&") {
+      tokens.push({ type: "AND" });
+      i += 2;
+      continue;
+    }
+    if (expr.slice(i, i + 2) === "||") {
+      tokens.push({ type: "OR" });
+      i += 2;
+      continue;
+    }
+    if (/^and(?:\s|\)|$)/i.test(expr.slice(i))) {
+      tokens.push({ type: "AND" });
+      i += 3;
+      continue;
+    }
+    if (/^or(?:\s|\)|$)/i.test(expr.slice(i))) {
+      tokens.push({ type: "OR" });
+      i += 2;
+      continue;
+    }
+    if (/^not\s/i.test(expr.slice(i))) {
+      tokens.push({ type: "NOT" });
+      i += 3;
+      continue;
+    }
+    let tag = "";
+    while (i < expr.length && expr[i] !== " " && expr[i] !== "  " && expr[i] !== "(" && expr[i] !== ")" && expr[i] !== "!" && expr[i] !== "&" && expr[i] !== "|") {
+      const remaining = expr.slice(i);
+      // Only treat and/or/not as operators if we're at the start of a tag (after whitespace)
+      // This allows tags like "demand", "editor", "cannot" to work correctly
+      if (tag === "" && (/^and(?:\s|\)|$)/i.test(remaining) || /^or(?:\s|\)|$)/i.test(remaining) || /^not\s/i.test(remaining))) {
+        break;
+      }
+      tag += expr[i];
+      i++;
+    }
+    if (tag) {
+      tokens.push({
+        type: "TAG",
+        value: tag
+      });
+    }
+  }
+  tokens.push({ type: "EOF" });
+  return tokens;
+}
+class TokenStream {
+  pos = 0;
+  constructor(tokens, expr) {
+    this.tokens = tokens;
+    this.expr = expr;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    return this.tokens[this.pos++];
+  }
+  expect(type) {
+    const token = this.next();
+    if (token.type !== type) {
+      if (type === "RPAREN" && token.type === "EOF") {
+        throw new Error(`Invalid tags expression: missing closing ")" in "${this.expr}"`);
+      }
+      throw new Error(`Invalid tags expression: expected "${formatTokenType(type)}" but got "${formatToken(token)}" in "${this.expr}"`);
+    }
+    return token;
+  }
+  unexpectedToken() {
+    const token = this.peek();
+    if (token.type === "EOF") {
+      throw new Error(`Invalid tags expression: unexpected end of expression in "${this.expr}"`);
+    }
+    throw new Error(`Invalid tags expression: unexpected "${formatToken(token)}" in "${this.expr}"`);
+  }
+}
+function formatTokenType(type) {
+  switch (type) {
+    case "TAG": return "tag";
+    case "AND": return "and";
+    case "OR": return "or";
+    case "NOT": return "not";
+    case "LPAREN": return "(";
+    case "RPAREN": return ")";
+    case "EOF": return "end of expression";
+  }
+}
+function parseOrExpression(stream, availableTags) {
+  let left = parseAndExpression(stream, availableTags);
+  while (stream.peek().type === "OR") {
+    stream.next();
+    const right = parseAndExpression(stream, availableTags);
+    left = {
+      type: "or",
+      left,
+      right
+    };
+  }
+  return left;
+}
+function parseAndExpression(stream, availableTags) {
+  let left = parseUnaryExpression(stream, availableTags);
+  while (stream.peek().type === "AND") {
+    stream.next();
+    const right = parseUnaryExpression(stream, availableTags);
+    left = {
+      type: "and",
+      left,
+      right
+    };
+  }
+  return left;
+}
+function parseUnaryExpression(stream, availableTags) {
+  if (stream.peek().type === "NOT") {
+    stream.next();
+    const operand = parseUnaryExpression(stream, availableTags);
+    return {
+      type: "not",
+      operand
+    };
+  }
+  return parsePrimaryExpression(stream, availableTags);
+}
+function parsePrimaryExpression(stream, availableTags) {
+  const token = stream.peek();
+  if (token.type === "LPAREN") {
+    stream.next();
+    const expr = parseOrExpression(stream, availableTags);
+    stream.expect("RPAREN");
+    return expr;
+  }
+  if (token.type === "TAG") {
+    stream.next();
+    const tagValue = token.value;
+    const pattern = resolveTagPattern(tagValue, availableTags);
+    return {
+      type: "tag",
+      value: tagValue,
+      pattern
+    };
+  }
+  stream.unexpectedToken();
+}
+function createWildcardRegex(pattern) {
+  return new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+}
+function resolveTagPattern(tagPattern, availableTags) {
+  if (tagPattern.includes("*")) {
+    const regex = createWildcardRegex(tagPattern);
+    const hasMatch = availableTags.some((tag) => regex.test(tag.name));
+    if (!hasMatch) {
+      throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+    }
+    return regex;
+  }
+  if (!availableTags.length || !availableTags.some((tag) => tag.name === tagPattern)) {
+    throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+  }
+  return null;
+}
+function evaluateNode(node, tags) {
+  switch (node.type) {
+    case "tag":
+      if (node.pattern) {
+        return tags.some((tag) => node.pattern.test(tag));
+      }
+      return tags.includes(node.value);
+    case "not": return !evaluateNode(node.operand, tags);
+    case "and": return evaluateNode(node.left, tags) && evaluateNode(node.right, tags);
+    case "or": return evaluateNode(node.left, tags) || evaluateNode(node.right, tags);
+  }
+}
+
 function isTestCase(s) {
   return s.type === "test";
 }
@@ -308,17 +579,14 @@ function hasTests(suite) {
   return toArray(suite).some((s) => s.tasks.some((c) => isTestCase(c) || hasTests(c)));
 }
 function hasFailed(suite) {
-  return toArray(suite).some((s) => {
-    var _s$result;
-    return ((_s$result = s.result) === null || _s$result === void 0 ? void 0 : _s$result.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
-  });
+  return toArray(suite).some((s) => s.result?.state === "fail" || s.type === "suite" && hasFailed(s.tasks));
 }
 function getNames(task) {
   const names = [task.name];
   let current = task;
-  while (current === null || current === void 0 ? void 0 : current.suite) {
+  while (current?.suite) {
     current = current.suite;
-    if (current === null || current === void 0 ? void 0 : current.name) {
+    if (current?.name) {
       names.unshift(current.name);
     }
   }
@@ -337,4 +605,4 @@ function createTaskName(names, separator = " > ") {
   return names.filter((name) => name !== undefined).join(separator);
 }
 
-export { calculateSuiteHash as a, createFileTask as b, createChainable as c, generateHash as d, createTaskName as e, findTestFileStackTrace as f, generateFileHash as g, getFullName as h, interpretTaskModes as i, getNames as j, getSuites as k, limitConcurrency as l, getTasks as m, getTestName as n, getTests as o, partitionSuiteChildren as p, hasFailed as q, hasTests as r, someTasksAreOnly as s, isTestCase as t };
+export { createChainable as a, createFileTask as b, calculateSuiteHash as c, createTagsFilter as d, createTaskName as e, findTestFileStackTrace as f, generateFileHash as g, generateHash as h, getFullName as i, getNames as j, getSuites as k, getTasks as l, getTestName as m, getTests as n, hasFailed as o, hasTests as p, interpretTaskModes as q, isTestCase as r, limitConcurrency as s, partitionSuiteChildren as t, someTasksAreOnly as u, validateTags as v, getChainableContext as w, createNoTagsError as x };

package/dist/@vitest/runner/index.d.ts

@@ -1,8 +1,6 @@
-import { b as TestArtifact, a as Test, S as Suite, d as SuiteHooks, F as File, e as TaskUpdateEvent, T as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-C7UxawJ9.js';
-export { A as AfterAllListener, n as AfterEachListener, B as BeforeAllListener, p as BeforeEachListener, q as Fixture, r as FixtureFn, s as FixtureOptions, t as Fixtures, I as ImportDuration, u as InferFixturesTypes, O as OnTestFailedHandler, v as OnTestFinishedHandler, R as RunMode, w as RuntimeContext, x as SequenceHooks, y as SequenceSetupFiles, z as SuiteFactory, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, V as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, Z as TestContext, _ as TestFunction, $ as TestOptions, a0 as Use, a1 as VisualRegressionArtifact, i as afterAll, j as afterEach, k as beforeAll, l as beforeEach, o as onTestFailed, m as onTestFinished } from './tasks.d-C7UxawJ9.js';
+import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-D2GKpdwQ.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, y as SuiteFactory, z as SuiteOptions, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource, a8 as afterAll, a9 as afterEach, aa as aroundAll, ab as aroundEach, ac as beforeAll, ad as beforeEach, ae as onTestFailed, af as onTestFinished } from './tasks.d-D2GKpdwQ.js';
 import { Awaitable } from '../utils/index.js';
-import { FileSpecification, VitestRunner } from './types.js';
-export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
 import '../utils/diff.js';
 
 /**
@@ -15,12 +13,13 @@ import '../utils/diff.js';
 *
 * Vitest automatically injects the source location where the artifact was created and manages any attachments you include.
 *
+* **Note:** artifacts must be recorded before the task is reported. Any artifacts recorded after that will not be included in the task.
+*
 * @param task - The test task context, typically accessed via `this.task` in custom matchers or `context.task` in tests
 * @param artifact - The artifact to record. Must extend {@linkcode TestArtifactBase}
 *
 * @returns A promise that resolves to the recorded artifact with location injected
 *
-* @throws {Error} If called after the test has finished running
 * @throws {Error} If the test runner doesn't support artifacts
 *
 * @example
@@ -173,7 +172,7 @@ declare const describe: SuiteAPI;
 */
 declare const it: TestAPI;
 declare function getCurrentSuite<ExtraContext = object>(): SuiteCollector<ExtraContext>;
-declare function createTaskCollector(fn: (...args: any[]) => any, context?: Record<string, unknown>): TestAPI;
+declare function createTaskCollector(fn: (...args: any[]) => any): TestAPI;
 
 declare function getCurrentTest<T extends Test | undefined>(): T;