@vitest/runner 4.0.9 → 4.0.11

package/dist/{hooks.d-C0RE9A6t.d.ts → tasks.d-r9p5YKu0.d.ts}

@@ -14,6 +14,122 @@ interface FixtureItem extends FixtureOptions {
 	deps?: FixtureItem[];
 }
 
+/**
+* Registers a callback function to be executed once before all tests within the current suite.
+* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+*
+* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeAll to set up a database connection
+* beforeAll(async () => {
+*   await database.connect();
+* });
+* ```
+*/
+declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
+/**
+* Registers a callback function to be executed once after all tests within the current suite have completed.
+* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+*
+* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterAll to close a database connection
+* afterAll(async () => {
+*   await database.disconnect();
+* });
+* ```
+*/
+declare function afterAll(fn: AfterAllListener, timeout?: number): void;
+/**
+* Registers a callback function to be executed before each test within the current suite.
+* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+*
+* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeEach to reset a database state
+* beforeEach(async () => {
+*   await database.reset();
+* });
+* ```
+*/
+declare function beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): void;
+/**
+* Registers a callback function to be executed after each test within the current suite has completed.
+* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+*
+* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterEach to delete temporary files created during a test
+* afterEach(async () => {
+*   await fileSystem.deleteTempFiles();
+* });
+* ```
+*/
+declare function afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): void;
+/**
+* Registers a callback function to be executed when a test fails within the current suite.
+* This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
+*
+* **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @throws {Error} Throws an error if the function is not called within a test.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using onTestFailed to log failure details
+* onTestFailed(({ errors }) => {
+*   console.log(`Test failed: ${test.name}`, errors);
+* });
+* ```
+*/
+declare const onTestFailed: TaskHook<OnTestFailedHandler>;
+/**
+* Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
+* This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
+*
+* This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
+*
+* **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.
+*
+* @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @throws {Error} Throws an error if the function is not called within a test.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using onTestFinished for cleanup
+* const db = await connectToDatabase();
+* onTestFinished(async () => {
+*   await db.disconnect();
+* });
+* ```
+*/
+declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
+
 type ChainableFunction<
 	T extends string,
 	F extends (...args: any) => any,
@@ -178,9 +294,10 @@ interface ImportDuration {
 type TaskResultPack = [id: string, result: TaskResult | undefined, meta: TaskMeta];
 interface TaskEventData {
 	annotation?: TestAnnotation | undefined;
+	artifact?: TestArtifact | undefined;
 }
 type TaskEventPack = [id: string, event: TaskUpdateEvent, data: TaskEventData | undefined];
-type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation";
+type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation" | "test-artifact";
 interface Suite extends TaskBase {
 	type: "suite";
 	/**
@@ -232,22 +349,12 @@ interface Test<ExtraContext = object> extends TaskPopulated {
 	* An array of custom annotations.
 	*/
 	annotations: TestAnnotation[];
-}
-interface TestAttachment {
-	contentType?: string;
-	path?: string;
-	body?: string | Uint8Array;
-}
-interface TestAnnotationLocation {
-	line: number;
-	column: number;
-	file: string;
-}
-interface TestAnnotation {
-	message: string;
-	type: string;
-	location?: TestAnnotationLocation;
-	attachment?: TestAttachment;
+	/**
+	* An array of artifacts produced by the test.
+	*
+	* @experimental
+	*/
+	artifacts: TestArtifact[];
 }
 type Task = Test | Suite | File;
 type TestFunction<ExtraContext = object> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
@@ -518,122 +625,148 @@ interface TaskHook<HookListener> {
 }
 type SequenceHooks = "stack" | "list" | "parallel";
 type SequenceSetupFiles = "list" | "parallel";
-
 /**
-* Registers a callback function to be executed once before all tests within the current suite.
-* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
-*
-* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+* Represents a file or data attachment associated with a test artifact.
 *
-* @param {Function} fn - The callback function to be executed before all tests.
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using beforeAll to set up a database connection
-* beforeAll(async () => {
-*   await database.connect();
-* });
-* ```
+* Attachments can be either file-based (via `path`) or inline content (via `body`).
+* The `contentType` helps consumers understand how to interpret the attachment data.
 */
-declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
+interface TestAttachment {
+	/** MIME type of the attachment (e.g., 'image/png', 'text/plain') */
+	contentType?: string;
+	/** File system path to the attachment */
+	path?: string;
+	/** Inline attachment content as a string or raw binary data */
+	body?: string | Uint8Array;
+}
 /**
-* Registers a callback function to be executed once after all tests within the current suite have completed.
-* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
-*
-* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+* Source code location information for a test artifact.
 *
-* @param {Function} fn - The callback function to be executed after all tests.
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using afterAll to close a database connection
-* afterAll(async () => {
-*   await database.disconnect();
-* });
-* ```
+* Indicates where in the source code the artifact originated from.
 */
-declare function afterAll(fn: AfterAllListener, timeout?: number): void;
+interface TestArtifactLocation {
+	/** Line number in the source file (1-indexed) */
+	line: number;
+	/** Column number in the line (1-indexed) */
+	column: number;
+	/** Path to the source file */
+	file: string;
+}
 /**
-* Registers a callback function to be executed before each test within the current suite.
-* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+* @experimental
 *
-* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+* Base interface for all test artifacts.
 *
-* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using beforeEach to reset a database state
-* beforeEach(async () => {
-*   await database.reset();
-* });
-* ```
+* Extend this interface when creating custom test artifacts. Vitest automatically manages the `attachments` array and injects the `location` property to indicate where the artifact was created in your test code.
 */
-declare function beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): void;
+interface TestArtifactBase {
+	/** File or data attachments associated with this artifact */
+	attachments?: TestAttachment[];
+	/** Source location where this artifact was created */
+	location?: TestArtifactLocation;
+}
 /**
-* Registers a callback function to be executed after each test within the current suite has completed.
-* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
-*
-* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+* @deprecated Use {@linkcode TestArtifactLocation} instead.
 *
-* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using afterEach to delete temporary files created during a test
-* afterEach(async () => {
-*   await fileSystem.deleteTempFiles();
-* });
-* ```
+* Kept for backwards compatibility.
 */
-declare function afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): void;
+type TestAnnotationLocation = TestArtifactLocation;
+interface TestAnnotation {
+	message: string;
+	type: string;
+	location?: TestArtifactLocation;
+	attachment?: TestAttachment;
+}
 /**
-* Registers a callback function to be executed when a test fails within the current suite.
-* This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
-*
-* **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+* @experimental
 *
-* @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @throws {Error} Throws an error if the function is not called within a test.
-* @returns {void}
-* @example
-* ```ts
-* // Example of using onTestFailed to log failure details
-* onTestFailed(({ errors }) => {
-*   console.log(`Test failed: ${test.name}`, errors);
-* });
-* ```
+* Artifact type for test annotations.
 */
-declare const onTestFailed: TaskHook<OnTestFailedHandler>;
+interface TestAnnotationArtifact extends TestArtifactBase {
+	type: "internal:annotation";
+	annotation: TestAnnotation;
+}
 /**
-* Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
-* This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
+* @experimental
+* @advanced
 *
-* This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
+* Registry for custom test artifact types.
 *
-* **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+* Augment this interface to register custom artifact types that your tests can produce.
 *
-* **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.
+* Each custom artifact should extend {@linkcode TestArtifactBase} and include a unique `type` discriminator property.
+*
+* @remarks
+* - Use a `Symbol` as the **registry key** to guarantee uniqueness
+* - The `type` property should follow the pattern `'package-name:artifact-name'`, `'internal:'` is a reserved prefix
+* - Use `attachments` to include files or data; extend {@linkcode TestAttachment} for custom metadata
+* - `location` property is automatically injected to indicate where the artifact was created
 *
-* @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
-* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
-* @throws {Error} Throws an error if the function is not called within a test.
-* @returns {void}
 * @example
-* ```ts
-* // Example of using onTestFinished for cleanup
-* const db = await connectToDatabase();
-* onTestFinished(async () => {
-*   await db.disconnect();
-* });
+*  ```ts
+* // Define custom attachment type for generated PDF
+* interface PDFAttachment extends TestAttachment {
+*   contentType: 'application/pdf'
+*   body: Uint8Array
+*   pageCount: number
+*   fileSize: number
+* }
+*
+* interface PDFGenerationArtifact extends TestArtifactBase {
+*   type: 'my-plugin:pdf-generation'
+*   templateName: string
+*   isValid: boolean
+*   attachments: [PDFAttachment]
+* }
+*
+* // Use a symbol to guarantee key uniqueness
+* const pdfKey = Symbol('pdf-generation')
+*
+* declare module 'vitest' {
+*   interface TestArtifactRegistry {
+*     [pdfKey]: PDFGenerationArtifact
+*   }
+* }
+*
+* // Custom assertion for PDF generation
+* async function toGenerateValidPDF(
+*   this: MatcherState,
+*   actual: PDFTemplate,
+*   data: Record<string, unknown>
+* ): AsyncExpectationResult {
+*   const pdfBuffer = await actual.render(data)
+*   const validation = await validatePDF(pdfBuffer)
+*
+*   await recordArtifact(this.task, {
+*     type: 'my-plugin:pdf-generation',
+*     templateName: actual.name,
+*     isValid: validation.success,
+*     attachments: [{
+*       contentType: 'application/pdf',
+*       body: pdfBuffer,
+*       pageCount: validation.pageCount,
+*       fileSize: pdfBuffer.byteLength
+*     }]
+*   })
+*
+*   return {
+*     pass: validation.success,
+*     message: () => validation.success
+*       ? `Generated valid PDF with ${validation.pageCount} pages`
+*       : `Invalid PDF: ${validation.error}`
+*   }
+* }
 * ```
 */
-declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
+interface TestArtifactRegistry {}
+/**
+* @experimental
+*
+* Union type of all test artifacts, including built-in and custom registered artifacts.
+*
+* This type automatically includes all artifacts registered via {@link TestArtifactRegistry}.
+*/
+type TestArtifact = TestAnnotationArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
 
-export { createChainable as X, afterAll as g, afterEach as h, beforeAll as i, beforeEach as j, onTestFinished as k, onTestFailed as o };
-export type { AfterAllListener as A, BeforeAllListener as B, TaskEventPack as C, TaskHook as D, TaskMeta as E, File as F, TaskPopulated as G, TaskResult as H, ImportDuration as I, TaskResultPack as J, TaskState as K, TestAnnotation as L, TestAnnotationLocation as M, TestAttachment as N, OnTestFailedHandler as O, TestContext as P, TestFunction as Q, RunMode as R, Suite as S, Test as T, TestOptions as U, Use as V, ChainableFunction as W, SuiteHooks as a, TaskUpdateEvent as b, Task as c, TestAPI as d, SuiteAPI as e, SuiteCollector as f, AfterEachListener as l, BeforeEachListener as m, Fixture as n, FixtureFn as p, FixtureOptions as q, Fixtures as r, InferFixturesTypes as s, OnTestFinishedHandler as t, RuntimeContext as u, SequenceHooks as v, SequenceSetupFiles as w, SuiteFactory as x, TaskBase as y, TaskCustomOptions as z };
+export { createChainable as c, afterAll as i, afterEach as j, beforeAll as k, beforeEach as l, onTestFinished as m, onTestFailed as o };
+export type { TestOptions as $, AfterAllListener as A, BeforeAllListener as B, ChainableFunction as C, TaskBase as D, TaskCustomOptions as E, File as F, TaskEventPack as G, TaskHook as H, ImportDuration as I, TaskMeta as J, TaskPopulated as K, TaskResult as L, TaskResultPack as M, TaskState as N, OnTestFailedHandler as O, TestAnnotation as P, TestAnnotationArtifact as Q, RunMode as R, Suite as S, Task as T, TestAnnotationLocation as U, TestArtifactBase as V, TestArtifactLocation as W, TestArtifactRegistry as X, TestAttachment as Y, TestContext as Z, TestFunction as _, Test as a, Use as a0, TestArtifact as b, SuiteHooks as d, TaskUpdateEvent as e, TestAPI as f, SuiteAPI as g, SuiteCollector as h, AfterEachListener as n, BeforeEachListener as p, Fixture as q, FixtureFn as r, FixtureOptions as s, Fixtures as t, InferFixturesTypes as u, OnTestFinishedHandler as v, RuntimeContext as w, SequenceHooks as x, SequenceSetupFiles as y, SuiteFactory as z };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { DiffOptions } from '@vitest/utils/diff';
-import { F as File, T as Test, S as Suite, J as TaskResultPack, C as TaskEventPack, L as TestAnnotation, P as TestContext, I as ImportDuration, v as SequenceHooks, w as SequenceSetupFiles } from './hooks.d-C0RE9A6t.js';
-export { A as AfterAllListener, l as AfterEachListener, B as BeforeAllListener, m as BeforeEachListener, n as Fixture, p as FixtureFn, q as FixtureOptions, r as Fixtures, s as InferFixturesTypes, O as OnTestFailedHandler, t as OnTestFinishedHandler, R as RunMode, u as RuntimeContext, e as SuiteAPI, f as SuiteCollector, x as SuiteFactory, a as SuiteHooks, c as Task, y as TaskBase, z as TaskCustomOptions, D as TaskHook, E as TaskMeta, G as TaskPopulated, H as TaskResult, K as TaskState, b as TaskUpdateEvent, d as TestAPI, M as TestAnnotationLocation, N as TestAttachment, Q as TestFunction, U as TestOptions, V as Use } from './hooks.d-C0RE9A6t.js';
+import { F as File, a as Test, S as Suite, M as TaskResultPack, G as TaskEventPack, P as TestAnnotation, b as TestArtifact, Z as TestContext, I as ImportDuration, x as SequenceHooks, y as SequenceSetupFiles } from './tasks.d-r9p5YKu0.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, u as InferFixturesTypes, O as OnTestFailedHandler, v as OnTestFinishedHandler, R as RunMode, w as RuntimeContext, g as SuiteAPI, h as SuiteCollector, z as SuiteFactory, d as SuiteHooks, T as Task, D as TaskBase, E as TaskCustomOptions, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, N as TaskState, e as TaskUpdateEvent, f as TestAPI, Q as TestAnnotationArtifact, U as TestAnnotationLocation, V as TestArtifactBase, W as TestArtifactLocation, X as TestArtifactRegistry, Y as TestAttachment, _ as TestFunction, $ as TestOptions, a0 as Use } from './tasks.d-r9p5YKu0.js';
 import '@vitest/utils';
 
 /**
@@ -122,6 +122,12 @@ interface VitestRunner {
 	*/
 	onTestAnnotate?: (test: Test, annotation: TestAnnotation) => Promise<TestAnnotation>;
 	/**
+	* @experimental
+	*
+	* Called when artifacts are recorded on tests via the `recordArtifact` utility.
+	*/
+	onTestArtifactRecord?: <Artifact extends TestArtifact>(test: Test, artifact: Artifact) => Promise<Artifact>;
+	/**
 	* Called before running all tests in collected paths.
 	*/
 	onBeforeRunFiles?: (files: File[]) => unknown;
@@ -161,11 +167,13 @@ interface VitestRunner {
 	*/
 	getWorkerContext?: () => Record<string, unknown>;
 	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
+	trace?<T>(name: string, cb: () => T): T;
+	trace?<T>(name: string, attributes: Record<string, any>, cb: () => T): T;
 	/** @private */
 	_currentTaskStartTime?: number;
 	/** @private */
 	_currentTaskTimeout?: number;
 }
 
-export { File, ImportDuration, SequenceHooks, SequenceSetupFiles, Suite, TaskEventPack, TaskResultPack, Test, TestAnnotation, TestContext };
+export { File, ImportDuration, SequenceHooks, SequenceSetupFiles, Suite, TaskEventPack, TaskResultPack, Test, TestAnnotation, TestArtifact, TestContext };
 export type { CancelReason, FileSpecification, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, F as File, c as Task, T as Test } from './hooks.d-C0RE9A6t.js';
-export { W as ChainableFunction, X as createChainable } from './hooks.d-C0RE9A6t.js';
+import { S as Suite, F as File, T as Task, a as Test } from './tasks.d-r9p5YKu0.js';
+export { C as ChainableFunction, c as createChainable } from './tasks.d-r9p5YKu0.js';
 import { ParsedStack, Arrayable } from '@vitest/utils';
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "4.0.9",
+  "version": "4.0.11",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^2.0.3",
-    "@vitest/utils": "4.0.9"
+    "@vitest/utils": "4.0.11"
   },
   "scripts": {
     "build": "premove dist && rollup -c",