test-inventory 0.6.1 → 0.8.0

package/dist/extract.js

@@ -1,5 +1,5 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyName, returnValues, unwrap, } from "./ast.js";
-import { exportName } from "./frameworks/bindings.js";
+import { commonJsExport, exportName } from "./frameworks/bindings.js";
 import { problem, readCount } from "./frameworks/common.js";
 import { snippet, splitLines } from "./source.js";
 import { isScopeNode } from "./values.js";
@@ -11,6 +11,11 @@ const MAX_DEPTH = 16;
  * of six levels are a million.
  */
 const MAX_CALLS = 10_000;
+/**
+ * How many loop passes and describe cases `expandCases` walks one by one in a file, far more than real suites expand;
+ * past it, loops and describe tables are one record, so that a long loop over test data can't use up the walk.
+ */
+const MAX_EXPANDED = 1000;
 /** Whether a function is called where it is written, so that its tests are registered there. */
 function calledWhereWritten(call, written) {
     return (call.scope === written.scope &&
@@ -20,6 +25,70 @@ function calledWhereWritten(call, written) {
         !call.inBody);
 }
 const LOOP_METHODS = new Set(['forEach', 'map']);
+/**
+ * Whether a statement leaves on every path through it, with `return` or `throw`, or with `break` or `continue` aimed
+ * at a loop or label outside it, so that what follows it in its block doesn't run. `labels` are those declared inside.
+ */
+function alwaysLeaves(statement, labels = new Set()) {
+    switch (statement.type) {
+        case 'ReturnStatement':
+        case 'ThrowStatement':
+            return true;
+        case 'BreakStatement':
+        case 'ContinueStatement':
+            return statement.label === null || !labels.has(statement.label.name);
+        case 'BlockStatement':
+            return statement.body.some((item) => alwaysLeaves(item, labels));
+        case 'IfStatement':
+            return (statement.alternate !== null &&
+                alwaysLeaves(statement.consequent, labels) &&
+                alwaysLeaves(statement.alternate, labels));
+        case 'LabeledStatement':
+            return alwaysLeaves(statement.body, new Set([...labels, statement.label.name]));
+        case 'TryStatement':
+            return ((statement.finalizer !== null && alwaysLeaves(statement.finalizer, labels)) ||
+                (alwaysLeaves(statement.block, labels) &&
+                    (statement.handler === null || alwaysLeaves(statement.handler.body, labels))));
+        default:
+            // A loop or switch takes the `break` and `continue` inside it, and may run its body not at all.
+            return false;
+    }
+}
+/**
+ * The names a condition reads, as in `side === 'buy'` or `!strategy.enabled`; null when it has a function, which the
+ * scan doesn't look into.
+ */
+function referencedNames(node) {
+    if (isFunctionNode(node))
+        return null;
+    if (node.type === 'Identifier')
+        return [node.name];
+    const parts = node.type === 'MemberExpression' && !node.computed ? [node.object] : childNodes(node);
+    const names = [];
+    for (const part of parts) {
+        const found = referencedNames(part);
+        if (!found)
+            return null;
+        names.push(...found);
+    }
+    return names;
+}
+/**
+ * Whether a loop body can end a pass before its end or stop the loop, with `break`, `continue`, `return` or `throw`,
+ * so that a test in it may not be registered on every pass. Functions inside run later, and don't count.
+ */
+function leavesEarly(body) {
+    if (body.type === 'FunctionDeclaration' || isFunctionNode(body))
+        return false;
+    switch (body.type) {
+        case 'BreakStatement':
+        case 'ContinueStatement':
+        case 'ReturnStatement':
+        case 'ThrowStatement':
+            return true;
+    }
+    return childNodes(body).some(leavesEarly);
+}
 /**
  * What `test.describe.configure()` sets on the describe or file it is called in: the last mode, timeout and retries
  * win, locks add up.
@@ -119,13 +188,17 @@ class Walker {
     callStack = [];
     /** Helper calls walked in the file so far, up to MAX_CALLS. */
     callsWalked = 0;
+    /** Loop passes and describe cases walked one by one so far, up to MAX_EXPANDED. */
+    expandedPasses = 0;
     /** Problems already reported, since a function walked at several calls finds the same ones each time. */
     reported = new Set();
     /** What the functions named in calls such as `onNode(22)('title', fn)` return, by the declaration of each name. */
     returns = new Map();
     /** For each file's program, the scopes around each function in it. */
     scopeChains = new Map();
-    constructor(main, openModule) {
+    options;
+    constructor(main, openModule, options) {
+        this.options = options;
         this.main = main;
         this.frame = main;
         this.openModule = openModule;
@@ -155,6 +228,11 @@ class Walker {
             testContext: null,
             guards: [],
             isInLoop: false,
+            loops: [],
+            loopConditions: [],
+            caseIndex: null,
+            isExpanding: false,
+            expandedAt: null,
             isInCondition: false,
             isInFunction: false,
             helper: null,
@@ -216,6 +294,13 @@ class Walker {
                     break;
                 const condition = this.text(node.test);
                 this.visit(node.test, context);
+                const known = this.known(node.test, context);
+                if (known) {
+                    const taken = known.value ? node.consequent : node.alternate;
+                    if (taken)
+                        this.visit(taken, context);
+                    return;
+                }
                 this.visit(node.consequent, this.guarded(context, condition));
                 if (node.alternate)
                     this.visit(node.alternate, this.guarded(context, `!(${condition})`));
@@ -224,6 +309,11 @@ class Walker {
             case 'ConditionalExpression': {
                 const condition = this.text(node.test);
                 this.visit(node.test, context);
+                const known = this.known(node.test, context);
+                if (known) {
+                    this.visit(known.value ? node.consequent : node.alternate, context);
+                    return;
+                }
                 this.visit(node.consequent, this.guarded(context, condition));
                 this.visit(node.alternate, this.guarded(context, `!(${condition})`));
                 return;
@@ -232,6 +322,18 @@ class Walker {
                 const left = this.text(node.left);
                 const guard = node.operator === '&&' ? left : node.operator === '||' ? `!(${left})` : `(${left}) == null`;
                 this.visit(node.left, context);
+                const known = this.known(node.left, context);
+                if (known) {
+                    const { value } = known;
+                    const right = node.operator === '&&'
+                        ? Boolean(value)
+                        : node.operator === '||'
+                            ? !value
+                            : value === null || value === undefined;
+                    if (right)
+                        this.visit(node.right, context);
+                    return;
+                }
                 this.visit(node.right, this.guarded(context, guard));
                 return;
             }
@@ -255,12 +357,30 @@ class Walker {
                 }
                 return;
             }
-            case 'ForStatement':
+            case 'BlockStatement':
+                this.visitStatements(node.body, context);
+                return;
             case 'ForInStatement':
-            case 'ForOfStatement':
+            case 'ForOfStatement': {
+                const leaves = leavesEarly(node.body);
+                const values = leaves ? null : this.loopValues(node);
+                const expands = values ? this.expands(node, values, context) : 'no';
+                if (values && expands === 'yes') {
+                    this.expandLoop(node, values, context);
+                    return;
+                }
+                // For `for...in`, the keys are what `Object.keys()` lists.
+                const listed = node.type === 'ForOfStatement' && !leaves ? node.right : null;
+                const count = values?.length ?? (listed ? this.frame.values.lengthOf(listed, this.scopes.slice(0, -1)) : null);
+                this.walkUnexpanded(node, expands === 'limit', () => {
+                    this.visitChildren(node, this.inLoop(context, count));
+                });
+                return;
+            }
+            case 'ForStatement':
             case 'WhileStatement':
             case 'DoWhileStatement':
-                this.visitChildren(node, { ...context, isInLoop: true });
+                this.visitChildren(node, this.inLoop(context, null));
                 return;
             case 'FunctionDeclaration':
             case 'FunctionExpression':
@@ -297,6 +417,47 @@ class Walker {
         return ((fn.type === 'FunctionDeclaration' && fn.id !== null) ||
             (parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier' && parent.init === fn));
     }
+    /**
+     * With `expandCases`, the value of a condition outside test and hook bodies when the scan can work it out, as with
+     * the values of a case or pass; null otherwise, and then both branches are walked under the condition.
+     */
+    known(test, context) {
+        if (!this.options.expandCases || context.test || context.hookScope)
+            return null;
+        // Only the values of the case, pass or helper call decide: a constant of the module may be changed in ways the scan
+        // doesn't see, and taking a branch away would drop a test the runner registers.
+        const names = referencedNames(test);
+        if (!names?.every((name) => this.frame.values.isBound(name, this.scopes)))
+            return null;
+        const resolved = this.frame.values.resolve(test, this.scopes);
+        return resolved.ok ? { value: resolved.value } : null;
+    }
+    /**
+     * Walks the statements of a block. After an `if` whose branch always leaves the function or loop, as in
+     * `if (!strategy.enabled) return;`, what follows runs only when that branch isn't taken, so it is under the opposite
+     * condition; a branch taken for certain, or both branches leaving, ends the walk. A branch that leaves on only some
+     * of its paths leaves what follows as it is.
+     */
+    visitStatements(statements, context) {
+        let current = context;
+        for (const statement of statements) {
+            this.visit(statement, current);
+            if (statement.type !== 'IfStatement' || isImportMetaVitest(statement.test))
+                continue;
+            const thenLeaves = alwaysLeaves(statement.consequent);
+            const elseLeaves = statement.alternate !== null && alwaysLeaves(statement.alternate);
+            if (!thenLeaves && !elseLeaves)
+                continue;
+            const known = this.known(statement.test, current);
+            const taken = known && (known.value ? thenLeaves : elseLeaves);
+            if (taken || (thenLeaves && elseLeaves))
+                return;
+            if (known)
+                continue;
+            const condition = this.text(statement.test);
+            current = this.guarded(current, thenLeaves ? `!(${condition})` : condition);
+        }
+    }
     placement(context) {
         return {
             scope: context.scope,
@@ -327,15 +488,110 @@ class Walker {
     text(node) {
         return snippet(this.frame.parsed.source.slice(node.start, node.end));
     }
+    /** `pass` is the pass of an expanded loop, and where the loop starts. */
+    inLoop(context, passes, pass = null) {
+        return {
+            ...context,
+            isInLoop: true,
+            loops: [...context.loops, passes],
+            loopConditions: [...context.loopConditions, context.isInCondition || pass !== null],
+            caseIndex: pass?.index ?? context.caseIndex,
+            isExpanding: context.isExpanding || pass !== null,
+            expandedAt: this.expandedAt(context, pass?.at ?? null),
+        };
+    }
+    /**
+     * Where what an expansion registers is ordered: the outermost expansion in the scanned file. In a helper walked at a
+     * call, the call already orders what it registers, and the helper may be in another file.
+     */
+    expandedAt(context, at) {
+        return context.expandedAt ?? (context.registeredBy === null ? at : null);
+    }
+    /**
+     * Whether to walk a loop or describe table once per value: with `expandCases`, outside test and hook bodies, which
+     * the runner walks once for each test, for a loop that declares its variable with `let` or `const`. An expansion
+     * outside any other starts only while the file has expanded fewer than MAX_EXPANDED passes and cases, so that a long
+     * loop over test data can't use up the walk; inside one, loops expand up to ten times that, so that an expansion
+     * is whole. `limit` means the limit is why it doesn't.
+     */
+    expands(loop, values, context) {
+        if (!this.options.expandCases || context.test || context.hookScope)
+            return 'no';
+        // Vitest runs describe callbacks after the loop, when a `var` holds its last value.
+        if (loop && !(loop.left.type === 'VariableDeclaration' && loop.left.kind !== 'var'))
+            return 'no';
+        const limit = context.isExpanding ? 10 * MAX_EXPANDED : MAX_EXPANDED;
+        if (this.expandedPasses + values.length > limit)
+            return 'limit';
+        this.expandedPasses += values.length;
+        return 'yes';
+    }
+    /**
+     * Walks a loop as one record, and says why it isn't expanded when it was asked to be and registers tests or
+     * describes.
+     */
+    walkUnexpanded(node, limited, walk) {
+        const before = this.tests.length + this.suites.length;
+        walk();
+        if (!limited || this.tests.length + this.suites.length === before)
+            return;
+        this.report(problem('cases-not-expanded', node, `The passes of the loop are listed as one record, since expanding it would take the file past ${MAX_EXPANDED.toLocaleString('en-US')} loop passes and describe cases.`));
+    }
+    /**
+     * Walks the body of `for...of` or `for...in` once per value, with the loop variable bound to it, as the runner runs
+     * it; false when the loop doesn't declare its variable, as in `for (symbol of SYMBOLS)`.
+     */
+    expandLoop(loop, values, context) {
+        const declarator = loop.left.declarations[0];
+        this.visit(loop.right, context);
+        for (const [index, value] of values.entries()) {
+            this.frame.values.withLoopValue(declarator, declarator.id, { ok: true, value }, loop.body, this.scopes, () => {
+                this.visit(loop.body, this.inLoop(context, 1, { index, at: loop.start }));
+            });
+        }
+        return true;
+    }
+    /**
+     * What `for...of` or `for...in` goes over, when the scan can work it out: an array's elements, or the keys of any
+     * value, as `for...in` takes them; null when the value is unknown or `for...of` can't go over it.
+     */
+    loopValues(loop) {
+        // The loop's own scope declares the loop variable, which the value it goes over can't refer to.
+        const resolved = this.frame.values.resolve(loop.right, this.scopes.slice(0, -1));
+        if (!resolved.ok)
+            return null;
+        if (loop.type === 'ForInStatement')
+            return Object.keys(Object(resolved.value ?? {}));
+        return Array.isArray(resolved.value) ? resolved.value : null;
+    }
     /** `symbols.forEach((symbol) => test(...))` declares its tests in a loop. */
     loopCall(call, context) {
         const callee = unwrap(call.callee);
         if (callee.type !== 'MemberExpression' || !LOOP_METHODS.has(propertyName(callee) ?? ''))
             return false;
         this.visit(call.callee, context);
+        const resolved = this.frame.values.resolve(callee.object, this.scopes);
+        const list = resolved.ok && Array.isArray(resolved.value) ? resolved.value : null;
         for (const arg of call.arguments) {
             if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
-                this.visitCallback(arg, { ...context, isInLoop: true });
+                const leaves = leavesEarly(arg.body);
+                const values = leaves ? null : list;
+                const expands = values ? this.expands(null, values, context) : 'no';
+                if (values && expands === 'yes') {
+                    // The callback gets each element, its index and the array.
+                    for (const [index, value] of values.entries()) {
+                        const args = [value, index, values].map((item) => ({ ok: true, value: item }));
+                        this.frame.values.withArguments(arg, args, this.scopes, () => {
+                            this.visitCallback(arg, this.inLoop(context, 1, { index, at: call.start }));
+                        });
+                    }
+                }
+                else {
+                    const count = values?.length ?? (leaves ? null : this.frame.values.lengthOf(callee.object, this.scopes));
+                    this.walkUnexpanded(call, expands === 'limit', () => {
+                        this.visitCallback(arg, this.inLoop(context, count));
+                    });
+                }
             }
             else {
                 this.visit(arg, context);
@@ -441,9 +697,11 @@ class Walker {
                 context.test?.problems.push(...api.problems.map((item) => this.here(item)));
                 return true;
             case 'invalid': {
-                const afterLoad = context.test !== null || context.hookScope !== null || context.helper !== null;
+                // Code that runs after the file loads, or only when a condition holds, can't be sure to stop it loading.
+                const afterLoad = context.test !== null || context.hookScope !== null || context.helper !== null || context.isInCondition;
                 this.report(afterLoad ? { ...api.problem, afterLoad } : api.problem);
-                return api.declaration ? this.handle(call, api.declaration, context) : true;
+                // Under a condition, the call either never runs or fails the file, so it declares nothing either way.
+                return api.declaration && !context.isInCondition ? this.handle(call, api.declaration, context) : true;
             }
             case 'other':
                 return false;
@@ -542,11 +800,10 @@ class Walker {
     }
     /** The function a name imported from a local module stands for, in the file that writes it; null otherwise. */
     importedFunction(name, scopes, from = this.frame) {
-        const declaration = from.values.declarationOf(name, scopes);
         const source = from.values.importSource(name, scopes);
         if (source === null)
             return null;
-        const imported = declaration?.type === 'ImportSpecifier' ? exportName(declaration.imported) : 'default';
+        const imported = from.values.importedName(name, scopes);
         const frame = this.openFrom(from, source);
         return frame ? this.exportedFunction(frame, imported, new Set(), 0) : null;
     }
@@ -570,14 +827,18 @@ class Walker {
             return null;
         searched.add(key);
         const { program } = frame.parsed;
-        const local = (localName) => {
-            const fn = this.functionIn(frame, localName, [program]);
-            return fn ? { fn, frame } : null;
-        };
         const from = (source, exported) => {
             const module = this.openFrom(frame, source);
             return module ? this.exportedFunction(module, exported, searched, depth + 1) : null;
         };
+        const local = (localName) => {
+            const fn = this.functionIn(frame, localName, [program]);
+            if (fn)
+                return { fn, frame };
+            // A name the module imports and exports again, as `import helper from './a'; export { helper }`.
+            const source = frame.values.importSource(localName, [program]);
+            return source === null ? null : from(source, frame.values.importedName(localName, [program]));
+        };
         for (const statement of program.body) {
             if (statement.type === 'ExportDefaultDeclaration' && name === 'default') {
                 const declaration = statement.declaration;
@@ -606,7 +867,12 @@ class Walker {
                 return statement.source ? from(statement.source.value, localName) : local(localName);
             }
         }
-        return null;
+        // A CommonJS module: `module.exports = { registerSettlement }` or `exports.registerSettlement = function () {}`.
+        const commonJs = commonJsExport(program, name);
+        const value = commonJs ? unwrap(commonJs) : null;
+        if (value?.type === 'Identifier')
+            return local(value.name);
+        return isFunctionNode(value) ? { fn: value, frame } : null;
     }
     /**
      * Walks a function at one of its calls from the file or a describe, as the runner runs it there: with the scopes
@@ -695,6 +961,18 @@ class Walker {
      * called instead.
      */
     runSetting(call, api, context) {
+        if (api.fileWide) {
+            for (const item of api.problems)
+                this.report(item);
+            // Called by a function or while tests run, it changes only the tests that run after it.
+            if (context.declaredIn !== null || context.test || context.hookScope)
+                return;
+            const { settings, problems } = this.guardedRun(call, api.settings, api.argument, context.guards);
+            for (const item of problems)
+                this.report(item);
+            mergeRun(this.fileScope.details.run, settings);
+            return;
+        }
         if (context.declaredIn !== null && !context.test) {
             for (const item of api.problems)
                 this.report(item);
@@ -733,11 +1011,18 @@ class Walker {
                 conditions: own.map((condition) => joinConditions([...guards, ...(condition === null ? [] : [condition])])),
             };
         }
-        if (settings.timeout !== undefined && guard !== null) {
-            const message = `Option timeout: ${argument} is set only when ${guard}; it is not applied.`;
+        const unapplied = (key) => {
+            const message = `Option ${key}: ${argument} is set only when ${guard}; it is not applied.`;
             problems.push(problem('unresolved-option', call, message, snippet(this.text(call))));
+        };
+        if (settings.timeout !== undefined && guard !== null) {
+            unapplied('timeout');
             delete settings.timeout;
         }
+        if (settings.retry !== undefined && guard !== null) {
+            unapplied('retry');
+            delete settings.retry;
+        }
         return { settings, problems };
     }
     /** Run settings a helper sets when a test body or a `beforeEach` calls it, under the conditions around the call. */
@@ -925,6 +1210,46 @@ class Walker {
     declareTest(call, declaration, context) {
         if (context.quiet || this.nested(call, context))
             return;
+        for (const item of this.cases(declaration, call, context))
+            this.declareCase(call, item, context);
+    }
+    /**
+     * With `expandCases`, a declaration for each case of its table, with the case's title and the arguments its callback
+     * gets; otherwise, or when the scan can't give each case its title, the declaration alone, with a problem that says
+     * why.
+     */
+    cases(declaration, call, context) {
+        const single = (reason) => {
+            if (reason === null)
+                return [{ declaration, index: null, args: null }];
+            const item = problem('cases-not-expanded', call, `The cases of the table are listed as one record, since ${reason}.`);
+            return [{ declaration: { ...declaration, problems: [...declaration.problems, item] }, index: null, args: null }];
+        };
+        if (!this.options.expandCases || !declaration.isParameterized || declaration.caseCount === null)
+            return single(null);
+        if (!declaration.cases)
+            return single("the scan can't work out every value in it");
+        const title = declaration.title;
+        if (!title || title.isDynamic)
+            return single("the scan can't work out the title");
+        const titles = declaration.cases.map((item) => item.title);
+        if (titles.some((text) => text === null)) {
+            return single("the title shows a value the scan doesn't format the way the runner does");
+        }
+        if (declaration.kind === 'describe' && this.expands(null, declaration.cases, context) === 'limit') {
+            return single(`expanding it would take the file past ${MAX_EXPANDED.toLocaleString('en-US')} loop passes and describe cases`);
+        }
+        return declaration.cases.map((item, index) => ({
+            declaration: {
+                ...declaration,
+                title: { text: titles[index], withoutTags: titles[index], isDynamic: false },
+                caseCount: 1,
+            },
+            index,
+            args: item.args.map((value) => ({ ok: true, value })),
+        }));
+    }
+    declareCase(call, { declaration, index, args }, context) {
         const statement = this.statement(call);
         const empty = emptyTitle(declaration, call);
         const test = {
@@ -935,12 +1260,16 @@ class Walker {
             declaredAt: this.declaredAt(call),
             frame: this.frame,
             registeredBy: context.registeredBy,
-            order: (context.registeredBy ?? call).start,
+            order: context.expandedAt ?? context.registeredBy?.start ?? call.start,
             states: [...declaration.states],
             annotations: [...declaration.details.annotations],
             isInLoop: context.isInLoop,
+            // A condition inside a loop decides on each pass whether the test is registered.
+            passes: context.loops,
+            loops: context.loops.map((passes, index) => context.isInCondition && !context.loopConditions[index] ? null : passes),
             isInCondition: context.isInCondition,
             isInFunction: context.isInFunction,
+            caseIndex: index ?? context.caseIndex,
             comments: this.commentsAbove(statement.start),
             run: {},
             expectCount: 0,
@@ -958,21 +1287,34 @@ class Walker {
         if (body) {
             if (!declaration.fn)
                 this.walkedAtCall.add(body);
-            this.visitCallback(body, {
-                ...context,
-                test,
-                hookScope: null,
-                hookName: null,
-                stepDepth: 0,
-                testContext: declaration.testContext,
-                guards: [],
-                helper: null,
+            this.withCase(body, args, () => {
+                this.visitCallback(body, {
+                    ...context,
+                    test,
+                    hookScope: null,
+                    hookName: null,
+                    stepDepth: 0,
+                    testContext: declaration.testContext,
+                    guards: [],
+                    helper: null,
+                });
             });
         }
     }
+    /** Runs `walk` with a case's arguments bound to the parameters of its callback, as the runner calls it. */
+    withCase(fn, args, walk) {
+        if (args)
+            this.frame.values.withArguments(fn, args, this.scopes, walk);
+        else
+            walk();
+    }
     declareSuite(call, declaration, context) {
         if (context.quiet || this.nested(call, context))
             return;
+        for (const item of this.cases(declaration, call, context))
+            this.declareSuiteCase(call, item, context);
+    }
+    declareSuiteCase(call, { declaration, index, args }, context) {
         for (const item of [...declaration.problems, ...emptyTitle(declaration, call)])
             this.report(item);
         const scope = {
@@ -997,26 +1339,34 @@ class Walker {
             declaredAt: this.declaredAt(call),
             frame: this.frame,
             registeredBy: context.registeredBy,
-            order: (context.registeredBy ?? call).start,
+            order: context.expandedAt ?? context.registeredBy?.start ?? call.start,
             cuts: [],
             isInCondition: context.isInCondition,
             isInFunction: context.isInFunction,
+            caseIndex: index ?? context.caseIndex,
         };
         scope.suite = suite;
         this.suites.push(suite);
         this.cut(context.scope, call);
         this.suiteFrames.set(suite, this.frame);
-        if (declaration.fn) {
-            this.visitCallback(declaration.fn, {
-                ...context,
-                scope,
-                test: null,
-                hookScope: null,
-                hookName: null,
-                stepDepth: 0,
-                testContext: null,
-                guards: [],
-                helper: null,
+        const { fn } = declaration;
+        if (fn) {
+            this.withCase(fn, args, () => {
+                this.visitCallback(fn, {
+                    ...context,
+                    scope,
+                    test: null,
+                    hookScope: null,
+                    hookName: null,
+                    stepDepth: 0,
+                    testContext: null,
+                    guards: [],
+                    helper: null,
+                    // The pass of a loop around the describe is the describe's, not that of each test in it.
+                    caseIndex: null,
+                    isExpanding: context.isExpanding || index !== null,
+                    expandedAt: this.expandedAt(context, index === null ? null : call.start),
+                });
             });
         }
     }
@@ -1051,6 +1401,6 @@ class Walker {
     }
 }
 /** Walks the scanned file; `openModule` reads the modules of imported helpers that the file calls. */
-export function extract(main, openModule) {
-    return new Walker(main, openModule).run();
+export function extract(main, openModule, options = { expandCases: false, version: null }) {
+    return new Walker(main, openModule, options).run();
 }

package/dist/files.js

@@ -82,8 +82,9 @@ export async function findFiles(root, patterns, ignore, framework, platform = pr
         const absolutePath = path.resolve(root, match);
         const realPath = realpathSync(absolutePath);
         const linked = realPath !== path.join(realRoot, match);
-        if (linked && framework === 'playwright') {
-            diagnostics.push(fileDiagnostic('symlink-ignored', match, 'The file is reached through a symbolic link, which Playwright does not follow.'));
+        if (linked && framework !== 'vitest') {
+            const name = framework === 'jest' ? 'Jest' : 'Playwright';
+            diagnostics.push(fileDiagnostic('symlink-ignored', match, `The file is reached through a symbolic link, which ${name} does not follow.`));
             continue;
         }
         candidates.push({ absolutePath, relativeFilePath: match, realPath, linked });

package/dist/filter.js

@@ -75,6 +75,7 @@ const TEST_KEYS = Object.keys({
     isBenchmark: true,
     isParameterized: true,
     caseCount: true,
+    caseIndex: true,
     isInLoop: true,
     isInCondition: true,
     isInFunction: true,

package/dist/framework-version.d.ts

@@ -1,4 +1,6 @@
 import type { Framework } from './types.ts';
+/** Each framework's name in messages. */
+export declare const FRAMEWORK_NAMES: Record<Framework, string>;
 /** Oldest supported version of each framework. */
 export declare const OLDEST: Record<Framework, [number, number]>;
 /** Where the framework version came from. */
@@ -11,6 +13,15 @@ export interface DetectedVersion {
 }
 /**
  * The framework version from the installed package, then a lockfile, then package.json, each looked for in the root
- * and the folders above it. A version range, as in `^4.0.0`, is used only when nothing else is found.
+ * and the folders above it. A version range, as in `^4.0.0`, is used only when nothing else is found. When none of
+ * those has the framework, as in a monorepo whose root leaves it to a package such as `code/`, the shallowest package
+ * below the root that declares it and holds one of the scanned `files` is read the same way, from its own folder up.
  */
-export declare function detectFrameworkVersion(root: string, framework: Framework): DetectedVersion | null;
+export declare function detectFrameworkVersion(root: string, framework: Framework, files: readonly string[]): DetectedVersion | null;
+/**
+ * The runner a project uses, for a scan without `framework`: the one whose package a package.json in the root or a
+ * folder below it, outside `ignore`, lists, or whose config is there. Only when none is found there do the package.json files above the
+ * root count, as a monorepo may declare its runner once at its top. Throws an `OptionsError` when the project uses
+ * none of them or several, naming what it found.
+ */
+export declare function detectFramework(root: string, ignore: readonly string[]): Framework;