uql-orm 0.3.0 → 0.3.2

package/dist/browser/uql-browser.min.js

@@ -1477,7 +1477,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);
     }
@@ -1488,13 +1506,24 @@ 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
@@ -2861,14 +2890,24 @@ const PLUGINS = [
     Immutable,
     AsymmetricMatcher
 ];
-function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
     const MAX_LENGTH = maxLength ?? 1e4;
     let result;
+    // Convert string selector to filter function
+    const filterFn = typeof filterNode === "string" ? createNodeFilterFromSelector(filterNode) : filterNode;
+    const plugins = filterFn ? [
+        ReactTestComponent,
+        ReactElement,
+        createDOMElementFilter(filterFn),
+        DOMCollection,
+        Immutable,
+        AsymmetricMatcher
+    ] : PLUGINS;
     try {
         result = format$1(object, {
             maxDepth,
             escapeString: false,
-            plugins: PLUGINS,
+            plugins,
             ...options
         });
     } catch  {
@@ -2876,16 +2915,36 @@ function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
             callToJSON: false,
             maxDepth,
             escapeString: false,
-            plugins: PLUGINS,
+            plugins,
             ...options
         });
     }
     // Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
     return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
         maxLength,
+        filterNode,
         ...options
     }) : result;
 }
+function createNodeFilterFromSelector(selector) {
+    const ELEMENT_NODE = 1;
+    const COMMENT_NODE = 8;
+    return (node)=>{
+        // Filter out comments
+        if (node.nodeType === COMMENT_NODE) {
+            return false;
+        }
+        // Filter out elements matching the selector
+        if (node.nodeType === ELEMENT_NODE && node.matches) {
+            try {
+                return !node.matches(selector);
+            } catch  {
+                return true;
+            }
+        }
+        return true;
+    };
+}
 const formatRegExp = /%[sdjifoOc%]/g;
 function baseFormat(args, options = {}) {
     const formatArg = (item, inspecOptions)=>{
@@ -2944,6 +3003,9 @@ function baseFormat(args, options = {}) {
                     if (typeof value === "bigint") {
                         return `${value.toString()}n`;
                     }
+                    if (typeof value === "symbol") {
+                        return "NaN";
+                    }
                     return Number(value).toString();
                 }
             case "%i":
@@ -2984,7 +3046,7 @@ function baseFormat(args, options = {}) {
     });
     for(let x = args[i]; i < len; x = args[++i]){
         if (x === null || typeof x !== "object") {
-            str += ` ${x}`;
+            str += ` ${typeof x === "symbol" ? x.toString() : x}`;
         } else {
             str += ` ${formatArg(x)}`;
         }
@@ -3030,6 +3092,31 @@ function assertTypes(value, name, types) {
         throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
     }
 }
+function filterOutComments(s) {
+    const result = [];
+    let commentState = "none";
+    for(let i = 0; i < s.length; ++i){
+        if (commentState === "singleline") {
+            if (s[i] === "\n") {
+                commentState = "none";
+            }
+        } else if (commentState === "multiline") {
+            if (s[i - 1] === "*" && s[i] === "/") {
+                commentState = "none";
+            }
+        } else if (commentState === "none") {
+            if (s[i] === "/" && s[i + 1] === "/") {
+                commentState = "singleline";
+            } else if (s[i] === "/" && s[i + 1] === "*") {
+                commentState = "multiline";
+                i += 2;
+            } else {
+                result.push(s[i]);
+            }
+        }
+    }
+    return result.join("");
+}
 function toArray(array) {
     if (array === null || array === undefined) {
         array = [];
@@ -3077,6 +3164,23 @@ function isNegativeNaN(val) {
     const isNegative = u32[1] >>> 31 === 1;
     return isNegative;
 }
+function ordinal(i) {
+    const j = i % 10;
+    const k = i % 100;
+    if (j === 1 && k !== 11) {
+        return `${i}st`;
+    }
+    if (j === 2 && k !== 12) {
+        return `${i}nd`;
+    }
+    if (j === 3 && k !== 13) {
+        return `${i}rd`;
+    }
+    return `${i}th`;
+}
+function unique(array) {
+    return Array.from(new Set(array));
+}
 
 const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
 function getSafeTimers() {
@@ -3200,6 +3304,8 @@ for(let i = 0; i < chars.length; i++){
 }
 const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
 const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const NOW_LENGTH = Date.now().toString().length;
+const REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
 function extractLocation(urlLike) {
     // Fail-fast but return locations like "(native)"
     if (!urlLike.includes(":")) {
@@ -3228,6 +3334,9 @@ function extractLocation(urlLike) {
         const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
         url = url.slice(isWindows ? 5 : 4);
     }
+    if (url.includes("vitest=")) {
+        url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
+    }
     return [
         url,
         parts[2] || undefined,
@@ -3324,7 +3433,7 @@ function parseSingleV8Stack(raw) {
     // normalize Windows path (\ -> /)
     file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
     if (method) {
-        method = method.replace(/__vite_ssr_import_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+        method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
     }
     return {
         method,
@@ -3334,19 +3443,29 @@ function parseSingleV8Stack(raw) {
     };
 }
 
-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 () {
@@ -3359,8 +3478,11 @@ 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;
 }
 function findTestFileStackTrace(testFilePath, error) {
@@ -3373,6 +3495,23 @@ function findTestFileStackTrace(testFilePath, error) {
         }
     }
 }
+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 createTaskName(names, separator = " > ") {
     return names.filter((name)=>name !== undefined).join(separator);
 }
@@ -3385,6 +3524,21 @@ class PendingError extends Error {
         this.taskId = task.id;
     }
 }
+class FixtureDependencyError extends Error {
+    constructor(...args){
+        super(...args), this.name = "FixtureDependencyError";
+    }
+}
+class FixtureAccessError extends Error {
+    constructor(...args){
+        super(...args), this.name = "FixtureAccessError";
+    }
+}
+class FixtureParseError extends Error {
+    constructor(...args){
+        super(...args), this.name = "FixtureParseError";
+    }
+}
 // use WeakMap here to make the Test and Suite object serializable
 const fnMap = new WeakMap();
 const testFixtureMap = new WeakMap();
@@ -3395,7 +3549,7 @@ function setFn(key, fn) {
 function setTestFixture(key, fixture) {
     testFixtureMap.set(key, fixture);
 }
-function getTestFixture(key) {
+function getTestFixtures(key) {
     return testFixtureMap.get(key);
 }
 function setHooks(key, hooks) {
@@ -3404,179 +3558,312 @@ function setHooks(key, hooks) {
 function getHooks(key) {
     return hooksMap.get(key);
 }
-function mergeScopedFixtures(testFixtures, scopedFixtures) {
-    const scopedFixturesMap = scopedFixtures.reduce((map, fixture)=>{
-        map[fixture.prop] = fixture;
-        return map;
-    }, {});
-    const newFixtures = {};
-    testFixtures.forEach((fixture)=>{
-        const useFixture = scopedFixturesMap[fixture.prop] || {
-            ...fixture
-        };
-        newFixtures[useFixture.prop] = useFixture;
-    });
-    for(const fixtureKep in newFixtures){
-        var _fixture$deps;
-        const fixture = newFixtures[fixtureKep];
-        // if the fixture was define before the scope, then its dep
-        // will reference the original fixture instead of the scope
-        fixture.deps = (_fixture$deps = fixture.deps) === null || _fixture$deps === void 0 ? void 0 : _fixture$deps.map((dep)=>newFixtures[dep.prop]);
-    }
-    return Object.values(newFixtures);
-}
-function mergeContextFixtures(fixtures, context, runner) {
-    const fixtureOptionKeys = [
-        "auto",
-        "injected",
-        "scope"
-    ];
-    const fixtureArray = Object.entries(fixtures).map(([prop, value])=>{
-        const fixtureItem = {
-            value
+class TestFixtures {
+    static{
+        this._definitions = [];
+    }
+    static{
+        this._builtinFixtures = [
+            "task",
+            "signal",
+            "onTestFailed",
+            "onTestFinished",
+            "skip",
+            "annotate"
+        ];
+    }
+    static{
+        this._fixtureOptionKeys = [
+            "auto",
+            "injected",
+            "scope"
+        ];
+    }
+    static{
+        this._fixtureScopes = [
+            "test",
+            "file",
+            "worker"
+        ];
+    }
+    static{
+        this._workerContextSuite = {
+            type: "worker"
         };
-        if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key)=>fixtureOptionKeys.includes(key))) {
-            var _runner$injectValue;
-            // fixture with options
-            Object.assign(fixtureItem, value[1]);
-            const userValue = value[0];
-            fixtureItem.value = fixtureItem.injected ? ((_runner$injectValue = runner.injectValue) === null || _runner$injectValue === void 0 ? void 0 : _runner$injectValue.call(runner, prop)) ?? userValue : userValue;
+    }
+    static clearDefinitions() {
+        TestFixtures._definitions.length = 0;
+    }
+    static getWorkerContexts() {
+        return TestFixtures._definitions.map((f)=>f.getWorkerContext());
+    }
+    static getFileContexts(file) {
+        return TestFixtures._definitions.map((f)=>f.getFileContext(file));
+    }
+    constructor(registrations){
+        this._overrides = new WeakMap();
+        this._registrations = registrations ?? new Map();
+        this._suiteContexts = new WeakMap();
+        TestFixtures._definitions.push(this);
+    }
+    extend(runner, userFixtures) {
+        const { suite } = getCurrentSuite();
+        const isTopLevel = !suite || suite.file === suite;
+        const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel);
+        return new TestFixtures(registrations);
+    }
+    get(suite) {
+        let currentSuite = suite;
+        while(currentSuite){
+            const overrides = this._overrides.get(currentSuite);
+            // return the closest override
+            if (overrides) {
+                return overrides;
+            }
+            if (currentSuite === currentSuite.file) {
+                break;
+            }
+            currentSuite = currentSuite.suite || currentSuite.file;
         }
-        fixtureItem.scope = fixtureItem.scope || "test";
-        if (fixtureItem.scope === "worker" && !runner.getWorkerContext) {
-            fixtureItem.scope = "file";
+        return this._registrations;
+    }
+    override(runner, userFixtures) {
+        const { suite: currentSuite, file } = getCurrentSuite();
+        const suite = currentSuite || file;
+        const isTopLevel = !currentSuite || currentSuite.file === currentSuite;
+        // Create a copy of the closest parent's registrations to avoid modifying them
+        // For chained calls, this.get(suite) returns this suite's overrides; for first call, returns parent's
+        const suiteRegistrations = new Map(this.get(suite));
+        const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel, suiteRegistrations);
+        // If defined in top-level, just override all registrations
+        // We don't support overriding suite-level fixtures anyway (it will throw an error)
+        if (isTopLevel) {
+            this._registrations = registrations;
+        } else {
+            this._overrides.set(suite, registrations);
         }
-        fixtureItem.prop = prop;
-        fixtureItem.isFn = typeof fixtureItem.value === "function";
-        return fixtureItem;
-    });
-    if (Array.isArray(context.fixtures)) {
-        context.fixtures = context.fixtures.concat(fixtureArray);
-    } else {
-        context.fixtures = fixtureArray;
-    }
-    // Update dependencies of fixture functions
-    fixtureArray.forEach((fixture)=>{
-        if (fixture.isFn) {
-            const usedProps = getUsedProps(fixture.value);
-            if (usedProps.length) {
-                fixture.deps = context.fixtures.filter(({ prop })=>prop !== fixture.prop && usedProps.includes(prop));
+    }
+    getFileContext(file) {
+        if (!this._suiteContexts.has(file)) {
+            this._suiteContexts.set(file, Object.create(null));
+        }
+        return this._suiteContexts.get(file);
+    }
+    getWorkerContext() {
+        if (!this._suiteContexts.has(TestFixtures._workerContextSuite)) {
+            this._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));
+        }
+        return this._suiteContexts.get(TestFixtures._workerContextSuite);
+    }
+    parseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
+        const errors = [];
+        Object.entries(userFixtures).forEach(([name, fn])=>{
+            let options;
+            let value;
+            let _options;
+            if (Array.isArray(fn) && fn.length >= 2 && isObject(fn[1]) && Object.keys(fn[1]).some((key)=>TestFixtures._fixtureOptionKeys.includes(key))) {
+                _options = fn[1];
+                options = {
+                    auto: _options.auto ?? false,
+                    scope: _options.scope ?? "test",
+                    injected: _options.injected ?? false
+                };
+                value = options.injected ? runner.injectValue?.(name) ?? fn[0] : fn[0];
+            } else {
+                value = fn;
             }
-            // test can access anything, so we ignore it
-            if (fixture.scope !== "test") {
-                var _fixture$deps2;
-                (_fixture$deps2 = fixture.deps) === null || _fixture$deps2 === void 0 ? void 0 : _fixture$deps2.forEach((dep)=>{
-                    if (!dep.isFn) {
-                        // non fn fixtures are always resolved and available to anyone
-                        return;
-                    }
-                    // worker scope can only import from worker scope
-                    if (fixture.scope === "worker" && dep.scope === "worker") {
-                        return;
-                    }
-                    // file scope an import from file and worker scopes
-                    if (fixture.scope === "file" && dep.scope !== "test") {
-                        return;
-                    }
-                    throw new SyntaxError(`cannot use the ${dep.scope} fixture "${dep.prop}" inside the ${fixture.scope} fixture "${fixture.prop}"`);
-                });
+            const parent = registrations.get(name);
+            if (parent && options) {
+                if (parent.scope !== options.scope) {
+                    errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered with a "${options.scope}" scope.`));
+                }
+                if (parent.auto !== options.auto) {
+                    errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered as { auto: ${options.auto} }.`));
+                }
+            } else if (parent) {
+                options = {
+                    auto: parent.auto,
+                    scope: parent.scope,
+                    injected: parent.injected
+                };
+            } else if (!options) {
+                options = {
+                    auto: false,
+                    injected: false,
+                    scope: "test"
+                };
+            }
+            if (options.scope && !TestFixtures._fixtureScopes.includes(options.scope)) {
+                errors.push(new FixtureDependencyError(`The "${name}" fixture has unknown scope "${options.scope}".`));
+            }
+            if (!supportNonTest && options.scope !== "test") {
+                errors.push(new FixtureDependencyError(`The "${name}" fixture cannot be defined with a ${options.scope} scope${!_options?.scope && parent?.scope ? " (inherited from the base fixture)" : ""} inside the describe block. Define it at the top level of the file instead.`));
+            }
+            const deps = isFixtureFunction(value) ? getUsedProps(value) : new Set();
+            const item = {
+                name,
+                value,
+                auto: options.auto ?? false,
+                injected: options.injected ?? false,
+                scope: options.scope ?? "test",
+                deps,
+                parent
+            };
+            registrations.set(name, item);
+            if (item.scope === "worker" && (runner.pool === "vmThreads" || runner.pool === "vmForks")) {
+                item.scope = "file";
+            }
+        });
+        // validate fixture dependency scopes
+        for (const fixture of registrations.values()){
+            for (const depName of fixture.deps){
+                if (TestFixtures._builtinFixtures.includes(depName)) {
+                    continue;
+                }
+                const dep = registrations.get(depName);
+                if (!dep) {
+                    errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on unknown fixture "${depName}".`));
+                    continue;
+                }
+                if (depName === fixture.name && !fixture.parent) {
+                    errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on itself, but does not have a base implementation.`));
+                    continue;
+                }
+                if (TestFixtures._fixtureScopes.indexOf(fixture.scope) > TestFixtures._fixtureScopes.indexOf(dep.scope)) {
+                    errors.push(new FixtureDependencyError(`The ${fixture.scope} "${fixture.name}" fixture cannot depend on a ${dep.scope} fixture "${dep.name}".`));
+                    continue;
+                }
             }
         }
-    });
-    return context;
+        if (errors.length === 1) {
+            throw errors[0];
+        } else if (errors.length > 1) {
+            throw new AggregateError(errors, "Cannot resolve user fixtures. See errors for more information.");
+        }
+        return registrations;
+    }
 }
-const fixtureValueMaps = new Map();
-const cleanupFnArrayMap = new Map();
-function withFixtures(runner, fn, testContext) {
-    return (hookContext)=>{
-        const context = hookContext || testContext;
+const cleanupFnArrayMap = new WeakMap();
+const contextHasFixturesCache = new WeakMap();
+function withFixtures(fn, options) {
+    const collector = getCurrentSuite();
+    const suite = options?.suite || collector.suite || collector.file;
+    return async (hookContext)=>{
+        const context = hookContext || options?.context;
         if (!context) {
+            if (options?.suiteHook) {
+                validateSuiteHook(fn, options.suiteHook, options.stackTraceError);
+            }
             return fn({});
         }
-        const fixtures = getTestFixture(context);
-        if (!(fixtures === null || fixtures === void 0 ? void 0 : fixtures.length)) {
+        const fixtures = options?.fixtures || getTestFixtures(context);
+        if (!fixtures) {
             return fn(context);
         }
-        const usedProps = getUsedProps(fn);
-        const hasAutoFixture = fixtures.some(({ auto })=>auto);
-        if (!usedProps.length && !hasAutoFixture) {
+        const registrations = fixtures.get(suite);
+        if (!registrations.size) {
             return fn(context);
         }
-        if (!fixtureValueMaps.get(context)) {
-            fixtureValueMaps.set(context, new Map());
+        const usedFixtures = [];
+        const usedProps = getUsedProps(fn);
+        for (const fixture of registrations.values()){
+            if (fixture.auto || usedProps.has(fixture.name)) {
+                usedFixtures.push(fixture);
+            }
+        }
+        if (!usedFixtures.length) {
+            return fn(context);
         }
-        const fixtureValueMap = fixtureValueMaps.get(context);
         if (!cleanupFnArrayMap.has(context)) {
             cleanupFnArrayMap.set(context, []);
         }
         const cleanupFnArray = cleanupFnArrayMap.get(context);
-        const usedFixtures = fixtures.filter(({ prop, auto })=>auto || usedProps.includes(prop));
-        const pendingFixtures = resolveDeps(usedFixtures);
+        const pendingFixtures = resolveDeps(usedFixtures, registrations);
         if (!pendingFixtures.length) {
             return fn(context);
         }
-        async function resolveFixtures() {
-            for (const fixture of pendingFixtures){
+        // Check if suite-level hook is trying to access test-scoped fixtures
+        // Suite hooks (beforeAll/afterAll/aroundAll) can only access file/worker scoped fixtures
+        if (options?.suiteHook) {
+            const testScopedFixtures = pendingFixtures.filter((f)=>f.scope === "test");
+            if (testScopedFixtures.length > 0) {
+                const fixtureNames = testScopedFixtures.map((f)=>`"${f.name}"`).join(", ");
+                const alternativeHook = {
+                    aroundAll: "aroundEach",
+                    beforeAll: "beforeEach",
+                    afterAll: "afterEach"
+                };
+                const error = new FixtureDependencyError(`Test-scoped fixtures cannot be used inside ${options.suiteHook} hook. ` + `The following fixtures are test-scoped: ${fixtureNames}. ` + `Use { scope: 'file' } or { scope: 'worker' } fixtures instead, or move the logic to ${alternativeHook[options.suiteHook]} hook.`);
+                // Use stack trace from hook registration for better error location
+                if (options.stackTraceError?.stack) {
+                    error.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, "");
+                }
+                throw error;
+            }
+        }
+        if (!contextHasFixturesCache.has(context)) {
+            contextHasFixturesCache.set(context, new WeakSet());
+        }
+        const cachedFixtures = contextHasFixturesCache.get(context);
+        for (const fixture of pendingFixtures){
+            if (fixture.scope === "test") {
                 // fixture could be already initialized during "before" hook
-                if (fixtureValueMap.has(fixture)) {
+                // we can't check "fixture.name" in context because context may
+                // access the parent fixture ({ a: ({ a }) => {} })
+                if (cachedFixtures.has(fixture)) {
                     continue;
                 }
-                const resolvedValue = await resolveFixtureValue(runner, fixture, context, cleanupFnArray);
-                context[fixture.prop] = resolvedValue;
-                fixtureValueMap.set(fixture, resolvedValue);
-                if (fixture.scope === "test") {
-                    cleanupFnArray.unshift(()=>{
-                        fixtureValueMap.delete(fixture);
-                    });
-                }
+                cachedFixtures.add(fixture);
+                const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+                context[fixture.name] = resolvedValue;
+                cleanupFnArray.push(()=>{
+                    cachedFixtures.delete(fixture);
+                });
+            } else {
+                const resolvedValue = await resolveScopeFixtureValue(fixtures, suite, fixture);
+                context[fixture.name] = resolvedValue;
             }
         }
-        return resolveFixtures().then(()=>fn(context));
+        return fn(context);
     };
 }
-const globalFixturePromise = new WeakMap();
-function resolveFixtureValue(runner, fixture, context, cleanupFnArray) {
-    var _runner$getWorkerCont;
-    const fileContext = getFileContext(context.task.file);
-    const workerContext = (_runner$getWorkerCont = runner.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner);
-    if (!fixture.isFn) {
-        var _fixture$prop;
-        fileContext[_fixture$prop = fixture.prop] ?? (fileContext[_fixture$prop] = fixture.value);
-        if (workerContext) {
-            var _fixture$prop2;
-            workerContext[_fixture$prop2 = fixture.prop] ?? (workerContext[_fixture$prop2] = fixture.value);
-        }
+function isFixtureFunction(value) {
+    return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+    if (!isFixtureFunction(fixture.value)) {
         return fixture.value;
     }
-    if (fixture.scope === "test") {
-        return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
-    }
-    // in case the test runs in parallel
-    if (globalFixturePromise.has(fixture)) {
-        return globalFixturePromise.get(fixture);
+    return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
+}
+const scopedFixturePromiseCache = new WeakMap();
+async function resolveScopeFixtureValue(fixtures, suite, fixture) {
+    const workerContext = fixtures.getWorkerContext();
+    const fileContext = fixtures.getFileContext(suite.file);
+    const fixtureContext = fixture.scope === "worker" ? workerContext : fileContext;
+    if (!isFixtureFunction(fixture.value)) {
+        fixtureContext[fixture.name] = fixture.value;
+        return fixture.value;
     }
-    let fixtureContext;
-    if (fixture.scope === "worker") {
-        if (!workerContext) {
-            throw new TypeError("[@vitest/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.");
-        }
-        fixtureContext = workerContext;
-    } else {
-        fixtureContext = fileContext;
+    if (fixture.name in fixtureContext) {
+        return fixtureContext[fixture.name];
     }
-    if (fixture.prop in fixtureContext) {
-        return fixtureContext[fixture.prop];
+    if (scopedFixturePromiseCache.has(fixture)) {
+        return scopedFixturePromiseCache.get(fixture);
     }
     if (!cleanupFnArrayMap.has(fixtureContext)) {
         cleanupFnArrayMap.set(fixtureContext, []);
     }
     const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
-    const promise = resolveFixtureFunction(fixture.value, fixtureContext, cleanupFnFileArray).then((value)=>{
-        fixtureContext[fixture.prop] = value;
-        globalFixturePromise.delete(fixture);
+    const promise = resolveFixtureFunction(fixture.value, fixture.scope === "file" ? {
+        ...workerContext,
+        ...fileContext
+    } : fixtureContext, cleanupFnFileArray).then((value)=>{
+        fixtureContext[fixture.name] = value;
+        scopedFixturePromiseCache.delete(fixture);
         return value;
     });
-    globalFixturePromise.set(fixture, promise);
+    scopedFixturePromiseCache.set(fixture, promise);
     return promise;
 }
 async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
@@ -3607,29 +3894,66 @@ async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
     });
     return useFnArgPromise;
 }
-function resolveDeps(fixtures, depSet = new Set(), pendingFixtures = []) {
-    fixtures.forEach((fixture)=>{
+function resolveDeps(usedFixtures, registrations, depSet = new Set(), pendingFixtures = []) {
+    usedFixtures.forEach((fixture)=>{
         if (pendingFixtures.includes(fixture)) {
             return;
         }
-        if (!fixture.isFn || !fixture.deps) {
+        if (!isFixtureFunction(fixture.value) || !fixture.deps) {
             pendingFixtures.push(fixture);
             return;
         }
         if (depSet.has(fixture)) {
-            throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[
-                ...depSet
-            ].reverse().map((d)=>d.prop).join(" <- ")}`);
+            if (fixture.parent) {
+                fixture = fixture.parent;
+            } else {
+                throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[
+                    ...depSet
+                ].reverse().map((d)=>d.name).join(" <- ")}`);
+            }
         }
         depSet.add(fixture);
-        resolveDeps(fixture.deps, depSet, pendingFixtures);
+        resolveDeps([
+            ...fixture.deps
+        ].map((n)=>n === fixture.name ? fixture.parent : registrations.get(n)).filter((n)=>!!n), registrations, depSet, pendingFixtures);
         pendingFixtures.push(fixture);
         depSet.clear();
     });
     return pendingFixtures;
 }
-function getUsedProps(fn) {
-    let fnString = filterOutComments(fn.toString());
+function validateSuiteHook(fn, hook, suiteError) {
+    const usedProps = getUsedProps(fn, {
+        sourceError: suiteError,
+        suiteHook: hook
+    });
+    if (usedProps.size) {
+        const error = new FixtureAccessError(`The ${hook} hook uses fixtures "${[
+            ...usedProps
+        ].join("\", \"")}", but has no access to context. ` + `Did you forget to call it as "test.${hook}()" instead of "${hook}()"?\n` + `If you used internal "suite" task as the first argument previously, access it in the second argument instead. ` + `See https://vitest.dev/guide/test-context#suite-level-hooks`);
+        if (suiteError) {
+            error.stack = suiteError.stack?.replace(suiteError.message, error.message);
+        }
+        throw error;
+    }
+}
+const kPropsSymbol = Symbol("$vitest:fixture-props");
+const kPropNamesSymbol = Symbol("$vitest:fixture-prop-names");
+function configureProps(fn, options) {
+    Object.defineProperty(fn, kPropsSymbol, {
+        value: options,
+        enumerable: false
+    });
+}
+function memoProps(fn, props) {
+    fn[kPropNamesSymbol] = props;
+    return props;
+}
+function getUsedProps(fn, { sourceError, suiteHook } = {}) {
+    if (kPropNamesSymbol in fn) {
+        return fn[kPropNamesSymbol];
+    }
+    const { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};
+    let fnString = filterOutComments(implementation.toString());
     // match lowered async function and strip it off
     // example code on esbuild-try https://esbuild.github.io/try/#YgAwLjI0LjAALS1zdXBwb3J0ZWQ6YXN5bmMtYXdhaXQ9ZmFsc2UAZQBlbnRyeS50cwBjb25zdCBvID0gewogIGYxOiBhc3luYyAoKSA9PiB7fSwKICBmMjogYXN5bmMgKGEpID0+IHt9LAogIGYzOiBhc3luYyAoYSwgYikgPT4ge30sCiAgZjQ6IGFzeW5jIGZ1bmN0aW9uKGEpIHt9LAogIGY1OiBhc3luYyBmdW5jdGlvbiBmZihhKSB7fSwKICBhc3luYyBmNihhKSB7fSwKCiAgZzE6IGFzeW5jICgpID0+IHt9LAogIGcyOiBhc3luYyAoeyBhIH0pID0+IHt9LAogIGczOiBhc3luYyAoeyBhIH0sIGIpID0+IHt9LAogIGc0OiBhc3luYyBmdW5jdGlvbiAoeyBhIH0pIHt9LAogIGc1OiBhc3luYyBmdW5jdGlvbiBnZyh7IGEgfSkge30sCiAgYXN5bmMgZzYoeyBhIH0pIHt9LAoKICBoMTogYXN5bmMgKCkgPT4ge30sCiAgLy8gY29tbWVudCBiZXR3ZWVuCiAgaDI6IGFzeW5jIChhKSA9PiB7fSwKfQ
     //   __async(this, null, function*
@@ -3640,56 +3964,37 @@ function getUsedProps(fn) {
     }
     const match = fnString.match(/[^(]*\(([^)]*)/);
     if (!match) {
-        return [];
+        return memoProps(fn, new Set());
     }
     const args = splitByComma(match[1]);
     if (!args.length) {
-        return [];
+        return memoProps(fn, new Set());
     }
-    let first = args[0];
-    if ("__VITEST_FIXTURE_INDEX__" in fn) {
-        first = args[fn.__VITEST_FIXTURE_INDEX__];
-        if (!first) {
-            return [];
-        }
+    const fixturesArgument = args[fixturesIndex];
+    if (!fixturesArgument) {
+        return memoProps(fn, new Set());
     }
-    if (!(first[0] === "{" && first.endsWith("}"))) {
-        throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+    if (!(fixturesArgument[0] === "{" && fixturesArgument.endsWith("}"))) {
+        const ordinalArgument = ordinal(fixturesIndex + 1);
+        const error = new FixtureParseError(`The ${ordinalArgument} argument inside a fixture must use object destructuring pattern, e.g. ({ task } => {}). ` + `Instead, received "${fixturesArgument}".` + `${suiteHook ? ` If you used internal "suite" task as the ${ordinalArgument} argument previously, access it in the ${ordinal(fixturesIndex + 2)} argument instead.` : ""}`);
+        if (sourceError) {
+            error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+        }
+        throw error;
     }
-    const _first = first.slice(1, -1).replace(/\s/g, "");
+    const _first = fixturesArgument.slice(1, -1).replace(/\s/g, "");
     const props = splitByComma(_first).map((prop)=>{
         return prop.replace(/:.*|=.*/g, "");
     });
     const last = props.at(-1);
     if (last && last.startsWith("...")) {
-        throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
-    }
-    return props;
-}
-function filterOutComments(s) {
-    const result = [];
-    let commentState = "none";
-    for(let i = 0; i < s.length; ++i){
-        if (commentState === "singleline") {
-            if (s[i] === "\n") {
-                commentState = "none";
-            }
-        } else if (commentState === "multiline") {
-            if (s[i - 1] === "*" && s[i] === "/") {
-                commentState = "none";
-            }
-        } else if (commentState === "none") {
-            if (s[i] === "/" && s[i + 1] === "/") {
-                commentState = "singleline";
-            } else if (s[i] === "/" && s[i + 1] === "*") {
-                commentState = "multiline";
-                i += 2;
-            } else {
-                result.push(s[i]);
-            }
+        const error = new FixtureParseError(`Rest parameters are not supported in fixtures, received "${last}".`);
+        if (sourceError) {
+            error.stack = sourceError.stack?.replace(sourceError.message, error.message);
         }
+        throw error;
     }
-    return result.join("");
+    return memoProps(fn, new Set(props));
 }
 function splitByComma(s) {
     const result = [];
@@ -3719,6 +4024,8 @@ function getDefaultHookTimeout() {
 }
 const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
 const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+const AROUND_TIMEOUT_KEY = Symbol.for("VITEST_AROUND_TIMEOUT");
+const AROUND_STACK_TRACE_KEY = Symbol.for("VITEST_AROUND_STACK_TRACE");
 /**
 * 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.
@@ -3740,7 +4047,8 @@ const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
         "function"
     ]);
     const stackTraceError = new Error("STACK_TRACE_ERROR");
-    return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(fn, timeout, true, stackTraceError), {
+    const context = getChainableContext(this);
+    return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(withSuiteFixtures("beforeAll", fn, context, stackTraceError), timeout, true, stackTraceError), {
         [CLEANUP_TIMEOUT_KEY]: timeout,
         [CLEANUP_STACK_TRACE_KEY]: stackTraceError
     }));
@@ -3765,7 +4073,9 @@ const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
     assertTypes(fn, "\"afterAll\" callback", [
         "function"
     ]);
-    return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
+    const context = getChainableContext(this);
+    const stackTraceError = new Error("STACK_TRACE_ERROR");
+    return getCurrentSuite().on("afterAll", withTimeout(withSuiteFixtures("afterAll", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));
 }
 /**
 * Registers a callback function to be executed before each test within the current suite.
@@ -3788,8 +4098,13 @@ const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
         "function"
     ]);
     const stackTraceError = new Error("STACK_TRACE_ERROR");
-    const runner = getRunner();
-    return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+    const wrapper = (context, suite)=>{
+        const fixtureResolver = withFixtures(fn, {
+            suite
+        });
+        return fixtureResolver(context);
+    };
+    return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
         [CLEANUP_TIMEOUT_KEY]: timeout,
         [CLEANUP_STACK_TRACE_KEY]: stackTraceError
     }));
@@ -3814,8 +4129,118 @@ const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
     assertTypes(fn, "\"afterEach\" callback", [
         "function"
     ]);
-    const runner = getRunner();
-    return getCurrentSuite().on("afterEach", withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+    const wrapper = (context, suite)=>{
+        const fixtureResolver = withFixtures(fn, {
+            suite
+        });
+        return fixtureResolver(context);
+    };
+    return getCurrentSuite().on("afterEach", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+}
+/**
+* Registers a callback function that wraps around all tests within the current suite.
+* The callback receives a `runSuite` function that must be called to run the suite's tests.
+* This hook is useful for scenarios where you need to wrap an entire suite in a context
+* (e.g., starting a server, opening a database connection that all tests share).
+*
+* **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the 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 aroundAll to wrap suite in a tracing span
+* aroundAll(async (runSuite) => {
+*   await tracer.trace('test-suite', runSuite);
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundAll with fixtures
+* aroundAll(async (runSuite, { db }) => {
+*   await db.transaction(() => runSuite());
+* });
+* ```
+*/ function aroundAll(fn, timeout) {
+    assertTypes(fn, "\"aroundAll\" callback", [
+        "function"
+    ]);
+    const stackTraceError = new Error("STACK_TRACE_ERROR");
+    const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+    const context = getChainableContext(this);
+    return getCurrentSuite().on("aroundAll", Object.assign(withSuiteFixtures("aroundAll", fn, context, stackTraceError, 1), {
+        [AROUND_TIMEOUT_KEY]: resolvedTimeout,
+        [AROUND_STACK_TRACE_KEY]: stackTraceError
+    }));
+}
+/**
+* Registers a callback function that wraps around each test within the current suite.
+* The callback receives a `runTest` function that must be called to run the test.
+* This hook is useful for scenarios where you need to wrap tests in a context (e.g., database transactions).
+*
+* **Note:** When multiple `aroundEach` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the test. Must call `runTest()` to run the test.
+* @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 aroundEach to wrap tests in a database transaction
+* aroundEach(async (runTest) => {
+*   await database.transaction(() => runTest());
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundEach with fixtures
+* aroundEach(async (runTest, { db }) => {
+*   await db.transaction(() => runTest());
+* });
+* ```
+*/ function aroundEach(fn, timeout) {
+    assertTypes(fn, "\"aroundEach\" callback", [
+        "function"
+    ]);
+    const stackTraceError = new Error("STACK_TRACE_ERROR");
+    const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+    const wrapper = (runTest, context, suite)=>{
+        const innerFn = (ctx)=>fn(runTest, ctx, suite);
+        configureProps(innerFn, {
+            index: 1,
+            original: fn
+        });
+        const fixtureResolver = withFixtures(innerFn, {
+            suite
+        });
+        return fixtureResolver(context);
+    };
+    return getCurrentSuite().on("aroundEach", Object.assign(wrapper, {
+        [AROUND_TIMEOUT_KEY]: resolvedTimeout,
+        [AROUND_STACK_TRACE_KEY]: stackTraceError
+    }));
+}
+function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex = 0) {
+    return (...args)=>{
+        const suite = args.at(-1);
+        const prefix = args.slice(0, -1);
+        const wrapper = (ctx)=>fn(...prefix, ctx, suite);
+        configureProps(wrapper, {
+            index: contextIndex,
+            original: fn
+        });
+        const fixtures = context?.getFixtures();
+        const fileContext = fixtures?.getFileContext(suite.file);
+        const fixtured = withFixtures(wrapper, {
+            suiteHook,
+            fixtures,
+            context: fileContext,
+            stackTraceError
+        });
+        return fixtured();
+    };
 }
 /**
 * Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
@@ -3959,9 +4384,12 @@ function createSuiteHooks() {
         beforeAll: [],
         afterAll: [],
         beforeEach: [],
-        afterEach: []
+        afterEach: [],
+        aroundEach: [],
+        aroundAll: []
     };
 }
+const POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
 function parseArguments(optionsOrFn, timeoutOrTest) {
     if (timeoutOrTest != null && typeof timeoutOrTest === "object") {
         throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
@@ -3990,23 +4418,59 @@ function parseArguments(optionsOrFn, timeoutOrTest) {
     };
 }
 // implementations
-function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions, parentCollectorFixtures) {
+function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions) {
     const tasks = [];
     let suite;
     initSuite();
     const task = function(name = "", options = {}) {
-        var _collectorContext$cur, _collectorContext$cur2, _collectorContext$cur3;
-        const timeout = (options === null || options === void 0 ? void 0 : options.timeout) ?? runner.config.testTimeout;
-        const currentSuite = (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.suite;
+        const currentSuite = collectorContext.currentSuite?.suite;
+        const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+        const parentTags = parentTask?.tags || [];
+        const testTags = unique([
+            ...parentTags,
+            ...toArray(options.tags)
+        ]);
+        const tagsOptions = testTags.map((tag)=>{
+            const tagDefinition = runner.config.tags?.find((t)=>t.name === tag);
+            if (!tagDefinition && runner.config.strictTags) {
+                throw createNoTagsError(runner.config.tags, tag);
+            }
+            return tagDefinition;
+        }).filter((r)=>r != null).sort((tag1, tag2)=>(tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag)=>{
+            const { name, description, priority, meta, ...options } = tag;
+            Object.assign(acc, options);
+            if (meta) {
+                acc.meta = Object.assign(acc.meta ?? Object.create(null), meta);
+            }
+            return acc;
+        }, {});
+        const testOwnMeta = options.meta;
+        options = {
+            ...tagsOptions,
+            ...options
+        };
+        const timeout = options.timeout ?? runner.config.testTimeout;
+        const parentMeta = currentSuite?.meta;
+        const tagMeta = tagsOptions.meta;
+        const testMeta = Object.create(null);
+        if (tagMeta) {
+            Object.assign(testMeta, tagMeta);
+        }
+        if (parentMeta) {
+            Object.assign(testMeta, parentMeta);
+        }
+        if (testOwnMeta) {
+            Object.assign(testMeta, testOwnMeta);
+        }
         const task = {
             id: "",
             name,
             fullName: createTaskName([
-                (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur2 = collectorContext.currentSuite) === null || _collectorContext$cur2 === void 0 || (_collectorContext$cur2 = _collectorContext$cur2.file) === null || _collectorContext$cur2 === void 0 ? void 0 : _collectorContext$cur2.fullName),
+                currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName,
                 name
             ]),
             fullTestName: createTaskName([
-                currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName,
+                currentSuite?.fullTestName,
                 name
             ]),
             suite: currentSuite,
@@ -4014,14 +4478,15 @@ function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions,
             fails: options.fails,
             context: undefined,
             type: "test",
-            file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur3 = collectorContext.currentSuite) === null || _collectorContext$cur3 === void 0 ? void 0 : _collectorContext$cur3.file),
+            file: currentSuite?.file ?? collectorContext.currentSuite?.file,
             timeout,
             retry: options.retry ?? runner.config.retry,
             repeats: options.repeats,
             mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
-            meta: options.meta ?? Object.create(null),
+            meta: testMeta,
             annotations: [],
-            artifacts: []
+            artifacts: [],
+            tags: testTags
         };
         const handler = options.handler;
         if (task.mode === "run" && !handler) {
@@ -4030,21 +4495,22 @@ function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions,
         if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
             task.concurrent = true;
         }
-        task.shuffle = suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle;
+        task.shuffle = suiteOptions?.shuffle;
         const context = createTestContext(task, runner);
         // create test context
         Object.defineProperty(task, "context", {
             value: context,
             enumerable: false
         });
-        setTestFixture(context, options.fixtures);
-        // custom can be called from any place, let's assume the limit is 15 stacks
+        setTestFixture(context, options.fixtures ?? new TestFixtures());
         const limit = Error.stackTraceLimit;
-        Error.stackTraceLimit = 15;
+        Error.stackTraceLimit = 10;
         const stackTraceError = new Error("STACK_TRACE_ERROR");
         Error.stackTraceLimit = limit;
         if (handler) {
-            setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(runner, handler, context), task), timeout, false, stackTraceError, (_, error)=>abortIfTimeout([
+            setFn(task, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, {
+                context
+            }), task), task.context.signal), timeout, false, stackTraceError, (_, error)=>abortIfTimeout([
                     context
                 ], error)));
         }
@@ -4068,8 +4534,14 @@ function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions,
             options = Object.assign({}, suiteOptions, options);
         }
         // inherit concurrent / sequential from suite
-        options.concurrent = this.concurrent || !this.sequential && (options === null || options === void 0 ? void 0 : options.concurrent);
-        options.sequential = this.sequential || !this.concurrent && (options === null || options === void 0 ? void 0 : options.sequential);
+        const concurrent = this.concurrent ?? (!this.sequential && options?.concurrent);
+        if (options.concurrent != null && concurrent != null) {
+            options.concurrent = concurrent;
+        }
+        const sequential = this.sequential ?? (!this.concurrent && options?.sequential);
+        if (options.sequential != null && sequential != null) {
+            options.sequential = sequential;
+        }
         const test = task(formatName(name), {
             ...this,
             ...options,
@@ -4077,7 +4549,6 @@ function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions,
         });
         test.type = "test";
     });
-    let collectorFixtures = parentCollectorFixtures;
     const collector = {
         type: "collector",
         name,
@@ -4085,54 +4556,50 @@ function createSuiteCollector(name, factory = ()=>{}, mode, each, suiteOptions,
         suite,
         options: suiteOptions,
         test,
+        file: suite.file,
         tasks,
         collect,
         task,
         clear,
-        on: addHook,
-        fixtures () {
-            return collectorFixtures;
-        },
-        scoped (fixtures) {
-            const parsed = mergeContextFixtures(fixtures, {
-                fixtures: collectorFixtures
-            }, runner);
-            if (parsed.fixtures) {
-                collectorFixtures = parsed.fixtures;
-            }
-        }
+        on: addHook
     };
     function addHook(name, ...fn) {
         getHooks(suite)[name].push(...fn);
     }
     function initSuite(includeLocation) {
-        var _collectorContext$cur4, _collectorContext$cur5, _collectorContext$cur6;
         if (typeof suiteOptions === "number") {
             suiteOptions = {
                 timeout: suiteOptions
             };
         }
-        const currentSuite = (_collectorContext$cur4 = collectorContext.currentSuite) === null || _collectorContext$cur4 === void 0 ? void 0 : _collectorContext$cur4.suite;
+        const currentSuite = collectorContext.currentSuite?.suite;
+        const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+        const suiteTags = toArray(suiteOptions?.tags);
+        validateTags(runner.config, suiteTags);
         suite = {
             id: "",
             type: "suite",
             name,
             fullName: createTaskName([
-                (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur5 = collectorContext.currentSuite) === null || _collectorContext$cur5 === void 0 || (_collectorContext$cur5 = _collectorContext$cur5.file) === null || _collectorContext$cur5 === void 0 ? void 0 : _collectorContext$cur5.fullName),
+                currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName,
                 name
             ]),
             fullTestName: createTaskName([
-                currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName,
+                currentSuite?.fullTestName,
                 name
             ]),
             suite: currentSuite,
             mode,
             each,
-            file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur6 = collectorContext.currentSuite) === null || _collectorContext$cur6 === void 0 ? void 0 : _collectorContext$cur6.file),
-            shuffle: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle,
+            file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+            shuffle: suiteOptions?.shuffle,
             tasks: [],
-            meta: Object.create(null),
-            concurrent: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.concurrent
+            meta: suiteOptions?.meta ?? Object.create(null),
+            concurrent: suiteOptions?.concurrent,
+            tags: unique([
+                ...parentTask?.tags || [],
+                ...suiteTags
+            ])
         };
         setHooks(suite, createSuiteHooks());
     }
@@ -4173,31 +4640,43 @@ function withAwaitAsyncAssertions(fn, task) {
 }
 function createSuite() {
     function suiteFn(name, factoryOrOptions, optionsOrFactory) {
-        var _currentSuite$options;
-        let mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
         const currentSuite = collectorContext.currentSuite || defaultSuite;
         let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
-        if (mode === "run" && !factory) {
-            mode = "todo";
-        }
         const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
         const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+        const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};
         // inherit options from current suite
         options = {
-            ...currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.options,
-            ...options,
-            shuffle: this.shuffle ?? options.shuffle ?? (currentSuite === null || currentSuite === void 0 || (_currentSuite$options = currentSuite.options) === null || _currentSuite$options === void 0 ? void 0 : _currentSuite$options.shuffle) ?? (void 0 )
+            ...parentOptions,
+            ...options
         };
+        const shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;
+        if (shuffle != null) {
+            options.shuffle = shuffle;
+        }
+        let mode = this.only ?? options.only ? "only" : this.skip ?? options.skip ? "skip" : this.todo ?? options.todo ? "todo" : "run";
+        // passed as test(name), assume it's a "todo"
+        if (mode === "run" && !factory) {
+            mode = "todo";
+        }
         // inherit concurrent / sequential from suite
         const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
         const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
-        options.concurrent = isConcurrent && !isSequential;
-        options.sequential = isSequential && !isConcurrent;
-        return createSuiteCollector(formatName(name), factory, mode, this.each, options, currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fixtures());
+        if (isConcurrent != null) {
+            options.concurrent = isConcurrent && !isSequential;
+        }
+        if (isSequential != null) {
+            options.sequential = isSequential && !isConcurrent;
+        }
+        if (parentMeta) {
+            options.meta = Object.assign(Object.create(null), parentMeta, options.meta);
+        }
+        return createSuiteCollector(formatName(name), factory, mode, this.each, options);
     }
     suiteFn.each = function(cases, ...args) {
-        const suite = this.withContext();
-        this.setContext("each", true);
+        const context = getChainableContext(this);
+        const suite = context.withContext();
+        context.setContext("each", true);
         if (Array.isArray(cases) && args.length) {
             cases = formatTemplateString(cases, args);
         }
@@ -4224,7 +4703,7 @@ function createSuite() {
                     }
                 }
             });
-            this.setContext("each", undefined);
+            context.setContext("each", undefined);
         };
     };
     suiteFn.for = function(cases, ...args) {
@@ -4250,11 +4729,12 @@ function createSuite() {
         "todo"
     ], suiteFn);
 }
-function createTaskCollector(fn, context) {
+function createTaskCollector(fn) {
     const taskFn = fn;
     taskFn.each = function(cases, ...args) {
-        const test = this.withContext();
-        this.setContext("each", true);
+        const context = getChainableContext(this);
+        const test = context.withContext();
+        context.setContext("each", true);
         if (Array.isArray(cases) && args.length) {
             cases = formatTemplateString(cases, args);
         }
@@ -4281,11 +4761,12 @@ function createTaskCollector(fn, context) {
                     }
                 }
             });
-            this.setContext("each", undefined);
+            context.setContext("each", undefined);
         };
     };
     taskFn.for = function(cases, ...args) {
-        const test = this.withContext();
+        const context = getChainableContext(this);
+        const test = context.withContext();
         if (Array.isArray(cases) && args.length) {
             cases = formatTemplateString(cases, args);
         }
@@ -4296,8 +4777,10 @@ function createTaskCollector(fn, context) {
                 // monkey-patch handler to allow parsing fixture
                 const handlerWrapper = handler ? (ctx)=>handler(item, ctx) : undefined;
                 if (handlerWrapper) {
-                    handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
-                    handlerWrapper.toString = ()=>handler.toString();
+                    configureProps(handlerWrapper, {
+                        index: 1,
+                        original: handler
+                    });
                 }
                 test(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
             });
@@ -4309,29 +4792,110 @@ function createTaskCollector(fn, context) {
     taskFn.runIf = function(condition) {
         return condition ? this : this.skip;
     };
-    taskFn.scoped = function(fixtures) {
-        const collector = getCurrentSuite();
-        collector.scoped(fixtures);
-    };
-    taskFn.extend = function(fixtures) {
-        const _context = mergeContextFixtures(fixtures, context || {}, runner);
-        const originalWrapper = fn;
-        return createTest(function(name, optionsOrFn, optionsOrTest) {
-            const collector = getCurrentSuite();
-            const scopedFixtures = collector.fixtures();
-            const context = {
-                ...this
+    /**
+	* Parse builder pattern arguments into a fixtures object.
+	* Handles both builder pattern (name, options?, value) and object syntax.
+	*/ function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
+        // Object syntax: just return as-is
+        if (typeof fixturesOrName !== "string") {
+            return fixturesOrName;
+        }
+        const fixtureName = fixturesOrName;
+        let fixtureOptions;
+        let fixtureValue;
+        if (maybeFn !== undefined) {
+            // (name, options, value) or (name, options, fn)
+            fixtureOptions = optionsOrFn;
+            fixtureValue = maybeFn;
+        } else {
+            // (name, value) or (name, fn)
+            // Check if optionsOrFn looks like fixture options (has scope or auto)
+            if (optionsOrFn !== null && typeof optionsOrFn === "object" && !Array.isArray(optionsOrFn) && ("scope" in optionsOrFn || "auto" in optionsOrFn)) {
+                // (name, options) with no value - treat as empty object fixture
+                fixtureOptions = optionsOrFn;
+                fixtureValue = {};
+            } else {
+                // (name, value) or (name, fn)
+                fixtureOptions = undefined;
+                fixtureValue = optionsOrFn;
+            }
+        }
+        // Function value: wrap with onCleanup pattern
+        if (typeof fixtureValue === "function") {
+            const builderFn = fixtureValue;
+            // Wrap builder pattern function (returns value) to use() pattern
+            const fixture = async (ctx, use)=>{
+                let cleanup;
+                const onCleanup = (fn)=>{
+                    if (cleanup !== undefined) {
+                        throw new Error(`onCleanup can only be called once per fixture. ` + `Define separate fixtures if you need multiple cleanup functions.`);
+                    }
+                    cleanup = fn;
+                };
+                const value = await builderFn(ctx, {
+                    onCleanup
+                });
+                await use(value);
+                if (cleanup) {
+                    await cleanup();
+                }
             };
-            if (scopedFixtures) {
-                context.fixtures = mergeScopedFixtures(context.fixtures || [], scopedFixtures);
+            configureProps(fixture, {
+                original: builderFn
+            });
+            if (fixtureOptions) {
+                return {
+                    [fixtureName]: [
+                        fixture,
+                        fixtureOptions
+                    ]
+                };
             }
-            originalWrapper.call(context, formatName(name), optionsOrFn, optionsOrTest);
-        }, _context);
+            return {
+                [fixtureName]: fixture
+            };
+        }
+        // Non-function value: use directly
+        if (fixtureOptions) {
+            return {
+                [fixtureName]: [
+                    fixtureValue,
+                    fixtureOptions
+                ]
+            };
+        }
+        return {
+            [fixtureName]: fixtureValue
+        };
+    }
+    taskFn.override = function(fixturesOrName, optionsOrFn, maybeFn) {
+        const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+        getChainableContext(this).getFixtures().override(runner, userFixtures);
+        return this;
+    };
+    taskFn.scoped = function(fixtures) {
+        console.warn(`test.scoped() is deprecated and will be removed in future versions. Please use test.override() instead.`);
+        return this.override(fixtures);
     };
+    taskFn.extend = function(fixturesOrName, optionsOrFn, maybeFn) {
+        const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+        const fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);
+        const _test = createTest(function(name, optionsOrFn, optionsOrTest) {
+            fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+        });
+        getChainableContext(_test).mergeContext({
+            fixtures
+        });
+        return _test;
+    };
+    taskFn.describe = suite;
+    taskFn.suite = suite;
     taskFn.beforeEach = beforeEach;
     taskFn.afterEach = afterEach;
     taskFn.beforeAll = beforeAll;
     taskFn.afterAll = afterAll;
+    taskFn.aroundEach = aroundEach;
+    taskFn.aroundAll = aroundAll;
     const _test = createChainable([
         "concurrent",
         "sequential",
@@ -4339,14 +4903,13 @@ function createTaskCollector(fn, context) {
         "only",
         "todo",
         "fails"
-    ], taskFn);
-    if (context) {
-        _test.mergeContext(context);
-    }
+    ], taskFn, {
+        fixtures: new TestFixtures()
+    });
     return _test;
 }
-function createTest(fn, context) {
-    return createTaskCollector(fn, context);
+function createTest(fn) {
+    return createTaskCollector(fn);
 }
 function formatName(name) {
     return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
@@ -4380,7 +4943,7 @@ function formatTitle(template, items, idx) {
             const arrayElement = isArrayKey ? objectAttr(items, key) : undefined;
             const value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;
             return objDisplay(value, {
-                truncate: void 0 
+                truncate: runner?.config?.chaiConfig?.truncateThreshold
             });
         });
     }
@@ -4425,13 +4988,12 @@ function formatTemplateString(cases, args) {
     }
     return res;
 }
-const now$2 = Date.now;
+const now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const collectorContext = {
     currentSuite: null
 };
 function collectTask(task) {
-    var _collectorContext$cur;
-    (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.tasks.push(task);
+    collectorContext.currentSuite?.tasks.push(task);
 }
 async function runWithSuite(suite, fn) {
     const prev = collectorContext.currentSuite;
@@ -4451,16 +5013,15 @@ function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
         runner._currentTaskStartTime = startTime;
         runner._currentTaskTimeout = timeout;
         return new Promise((resolve_, reject_)=>{
-            var _timer$unref;
             const timer = setTimeout(()=>{
                 clearTimeout(timer);
                 rejectTimeoutError();
             }, timeout);
             // `unref` might not exist in browser
-            (_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
+            timer.unref?.();
             function rejectTimeoutError() {
                 const error = makeTimeoutError(isHook, timeout, stackTraceError);
-                onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
+                onTimeout?.(args, error);
                 reject_(error);
             }
             function resolve(result) {
@@ -4499,6 +5060,23 @@ function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
         });
     };
 }
+function withCancel(fn, signal) {
+    return function runWithCancel(...args) {
+        return new Promise((resolve, reject)=>{
+            signal.addEventListener("abort", ()=>reject(signal.reason));
+            try {
+                const result = fn(...args);
+                if (typeof result === "object" && result != null && typeof result.then === "function") {
+                    result.then(resolve, reject);
+                } else {
+                    resolve(result);
+                }
+            } catch (error) {
+                reject(error);
+            }
+        });
+    };
+}
 const abortControllers = new WeakMap();
 function abortIfTimeout([context], error) {
     if (context) {
@@ -4507,10 +5085,9 @@ function abortIfTimeout([context], error) {
 }
 function abortContextSignal(context, error) {
     const abortController = abortControllers.get(context);
-    abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
+    abortController?.abort(error);
 }
 function createTestContext(test, runner) {
-    var _runner$extendTaskCon;
     const context = function() {
         throw new Error("done() callback is deprecated, use promise instead");
     };
@@ -4526,9 +5103,9 @@ function createTestContext(test, runner) {
             // do nothing
             return undefined;
         }
-        test.result ?? (test.result = {
+        test.result ??= {
             state: "skip"
-        });
+        };
         test.result.pending = true;
         throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
     };
@@ -4559,31 +5136,23 @@ function createTestContext(test, runner) {
         }));
     };
     context.onTestFailed = (handler, timeout)=>{
-        test.onFailed || (test.onFailed = []);
+        test.onFailed ||= [];
         test.onFailed.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error)=>abortController.abort(error)));
     };
     context.onTestFinished = (handler, timeout)=>{
-        test.onFinished || (test.onFinished = []);
+        test.onFinished ||= [];
         test.onFinished.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error)=>abortController.abort(error)));
     };
-    return ((_runner$extendTaskCon = runner.extendTaskContext) === null || _runner$extendTaskCon === void 0 ? void 0 : _runner$extendTaskCon.call(runner, context)) || context;
+    return runner.extendTaskContext?.(context) || context;
 }
 function makeTimeoutError(isHook, timeout, stackTraceError) {
     const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.\nIf 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 error = new Error(message);
-    if (stackTraceError === null || stackTraceError === void 0 ? void 0 : stackTraceError.stack) {
+    if (stackTraceError?.stack) {
         error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
     }
     return error;
 }
-const fileContexts = new WeakMap();
-function getFileContext(file) {
-    const context = fileContexts.get(file);
-    if (!context) {
-        throw new Error(`Cannot find file context for ${file.name}`);
-    }
-    return context;
-}
 globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 getSafeTimers();
@@ -4592,7 +5161,6 @@ const eventsPacks = [];
 const pendingTasksUpdates = [];
 function sendTasksUpdate(runner) {
     if (packs.size) {
-        var _runner$onTaskUpdate;
         const taskPacks = Array.from(packs).map(([id, task])=>{
             return [
                 id,
@@ -4600,7 +5168,7 @@ function sendTasksUpdate(runner) {
                 task[1]
             ];
         });
-        const p = (_runner$onTaskUpdate = runner.onTaskUpdate) === null || _runner$onTaskUpdate === void 0 ? void 0 : _runner$onTaskUpdate.call(runner, taskPacks, eventsPacks);
+        const p = runner.onTaskUpdate?.(taskPacks, eventsPacks);
         if (p) {
             pendingTasksUpdates.push(p);
             // remove successful promise to not grow array indefnitely,
@@ -4625,12 +5193,13 @@ async function finishSendTasksUpdate(runner) {
 *
 * 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
@@ -4650,9 +5219,6 @@ async function finishSendTasksUpdate(runner) {
 * ```
 */ async function recordArtifact(task, artifact) {
     const runner = getRunner();
-    if (task.result && task.result.state !== "run") {
-        throw new Error(`Cannot record a test artifact outside of the test run. The test "${task.name}" finished running with the "${task.result.state}" state already.`);
-    }
     const stack = findTestFileStackTrace(task.file.filepath, new Error("STACK_TRACE").stack);
     if (stack) {
         artifact.location = {