test-inventory 0.7.0 → 0.8.0

package/dist/dependency-hash.d.ts

@@ -3,7 +3,7 @@ import type { ConfigGap, RunsWith } from './config-dependencies.ts';
 import type { Extraction, Frame, PendingTest } from './extract.ts';
 import type { ModuleReader, ModuleSource, Problem, Span } from './model.ts';
 import { type ParsedFile } from './parse.ts';
-import { type SourceText } from './source.ts';
+import { SourceText } from './source.ts';
 import type { Framework } from './types.ts';
 import { Values } from './values.ts';
 /** A file whose code a test can run: the scanned file, a module it imports, or a data file such as JSON. */
@@ -96,6 +96,14 @@ interface Reach {
     asks: string[] | null;
     snapshots: SnapshotUse[];
 }
+/** What several reaches cover together, by file. */
+interface Merged {
+    files: string[];
+    /** Each file's hashes, sorted. */
+    byFile: Map<string, string[]>;
+    /** Each file's part of the text the dependency hash is taken of. */
+    parts: Map<string, string>;
+}
 /** A fixture one `extend()` call defines, and the fixtures it asks for; null when it takes them whole. */
 interface Fixture {
     unit: Unit;
@@ -145,11 +153,11 @@ export declare class DependencyGraph {
     /** The units a set of roots reaches, leaving out those `skip` reached, with their hashes by file. */
     reach(roots: Unit[], skip?: Reach[]): Reach;
     /**
-     * Everything a test's roots reach on top of `base`, the code its file runs when loaded, which all its tests share,
-     * with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
-     * followed.
+     * Everything a test's roots reach on top of `bases`, such as the code its file runs when loaded, which all its tests
+     * share, with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
+     * followed. `shared` is what the bases cover, put together once for the many tests that share them.
      */
-    dependencies(roots: Unit[], bases: Reach[], needs: FixtureNeeds, snapshots: (uses: SnapshotUse[]) => Unit[], report: (place: Place) => void): Dependencies;
+    dependencies(roots: Unit[], bases: Reach[], shared: Merged, needs: FixtureNeeds, snapshots: (uses: SnapshotUse[]) => Unit[], report: (place: Place) => void): Dependencies;
     private newModule;
     private newUnit;
     private hashOf;

package/dist/dependency-hash.js

@@ -5,8 +5,9 @@ import { exportName, parseModule } from "./frameworks/bindings.js";
 import { destructuredNames, problem, takesWhole } from "./frameworks/common.js";
 import { shortHash, hashNodes } from "./hash.js";
 import { parseFile } from "./parse.js";
-import { snippet } from "./source.js";
+import { snippet, SourceText } from "./source.js";
 import { bindingNames, isScopeNode, Values } from "./values.js";
+const NOTHING_MERGED = { files: [], byFile: new Map(), parts: new Map() };
 /** Statements that only declare something, unless code in them runs while they are evaluated. */
 const DECLARATIONS = new Set([
     'ImportDeclaration',
@@ -386,11 +387,11 @@ export class DependencyGraph {
         return { units, byFile, places, fixtures, asks, snapshots };
     }
     /**
-     * Everything a test's roots reach on top of `base`, the code its file runs when loaded, which all its tests share,
-     * with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
-     * followed.
+     * Everything a test's roots reach on top of `bases`, such as the code its file runs when loaded, which all its tests
+     * share, with the fixtures it needs of each test object reached: the hash, the files, and whether all of it could be
+     * followed. `shared` is what the bases cover, put together once for the many tests that share them.
      */
-    dependencies(roots, bases, needs, snapshots, report) {
+    dependencies(roots, bases, shared, needs, snapshots, report) {
         const reached = [...bases, this.reach(roots, bases)];
         // A fixture can ask for one an object it extends defines, or use another test object, so names are shared by
         // every test object reached, and each name and object is read once.
@@ -476,11 +477,13 @@ export class DependencyGraph {
             this.reported.add(key);
             report(place);
         }
-        const files = [...new Set(reached.flatMap((item) => [...item.byFile.keys()]))].sort();
+        const added = hashesByFile(reached.slice(bases.length));
+        const files = [...new Set([...shared.files, ...added.keys()])].sort();
         const parts = files.map((file) => {
-            return [file, reached.flatMap((item) => item.byFile.get(file) ?? []).sort()];
+            const own = added.get(file);
+            return own ? part(file, [...(shared.byFile.get(file) ?? []), ...own]) : shared.parts.get(file);
         });
-        return { hash: shortHash(JSON.stringify(parts)), files, isComplete: places.length === 0 };
+        return { hash: shortHash(`[${parts.join(',')}]`), files, isComplete: places.length === 0 };
     }
     newModule(relativeFilePath, parsed, text, values, readModule) {
         return {
@@ -632,7 +635,8 @@ export class DependencyGraph {
     }
     /** A place in a module the scan can't follow, as a unit that marks the tests that reach it. */
     placeUnit(module, at, message, isQuiet = false) {
-        const { source } = module.parsed;
+        // A JSON config, such as Jest's package.json, is taken by its text.
+        const source = module.parsed?.source ?? new SourceText(module.text);
         const unit = this.newUnit(module, [], new Map(), false);
         unit.edges = new Set();
         const text = snippet(source.slice(at.start, at.end)) || null;
@@ -665,7 +669,11 @@ export class DependencyGraph {
         if ('module' in gap) {
             const module = this.moduleOf(gap.module);
             // The path a setup key names, where the config writes it.
-            const at = gap.text === null ? null : literalIn(module.parsed.program, gap.text);
+            let at = null;
+            if (gap.text !== null && module.parsed)
+                at = literalIn(module.parsed.program, gap.text);
+            else if (gap.text !== null)
+                at = jsonStringIn(module.text, gap.text);
             return this.placeUnit(module, at ?? { start: 0, end: 0 }, gap.message, gap.isQuiet);
         }
         const module = this.newModule(gap.relativeFilePath, null, null, new Values(), null);
@@ -1300,6 +1308,33 @@ export class DependencyGraph {
         return edges;
     }
 }
+/** The hashes of several reaches by file, in the order the reaches come. */
+function hashesByFile(reaches) {
+    const byFile = new Map();
+    for (const item of reaches) {
+        for (const [file, hashes] of item.byFile)
+            byFile.set(file, [...(byFile.get(file) ?? []), ...hashes]);
+    }
+    return byFile;
+}
+/** A file and its hashes, sorted, as text: the hash is taken of these parts, in the order of the files. */
+function part(file, hashes) {
+    return JSON.stringify([file, hashes.sort()]);
+}
+/** What `merged` covers with what one more reach adds, the parts of the files it adds hashes to written again. */
+function combine(merged, reach) {
+    if (reach.byFile.size === 0)
+        return merged;
+    const byFile = new Map(merged.byFile);
+    const parts = new Map(merged.parts);
+    for (const [file, hashes] of reach.byFile) {
+        const all = [...(merged.byFile.get(file) ?? []), ...hashes];
+        parts.set(file, part(file, all));
+        byFile.set(file, all);
+    }
+    const files = [...new Set([...merged.files, ...reach.byFile.keys()])].sort();
+    return { files, byFile, parts };
+}
 /** Whether an identifier refers to a binding, rather than naming a property, a label or a member. */
 function isReference(key, parent) {
     switch (parent?.type) {
@@ -1360,6 +1395,12 @@ function literalIn(node, value) {
     }
     return null;
 }
+/** Where a JSON file writes a string, as `"./setup.js"`; null when it doesn't. */
+function jsonStringIn(text, value) {
+    const written = JSON.stringify(value);
+    const start = text.indexOf(written);
+    return start === -1 ? null : { start, end: start + written.length };
+}
 /**
  * The snapshot files the matchers of a test compare against, from the project root, at the runners' default places:
  * Vitest's `__snapshots__/<file>.snap`, paths given to `toMatchFileSnapshot()`, and browser screenshots in
@@ -1468,6 +1509,7 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
         ...runsWith.gaps.map((gap) => graph.gapUnit(gap)),
     ];
     const base = graph.reach([load, ...config]);
+    const baseMerged = combine(NOTHING_MERGED, base);
     // The describes around a test and the helper call that registers it are shared by the tests there, often thousands
     // for one helper call, so what they reach is walked once for all of them.
     const contexts = new Map();
@@ -1481,7 +1523,8 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
                 if (around.suite)
                     roots.push(...suiteUnit(around.suite));
             }
-            context = graph.reach(roots, [base]);
+            const reach = graph.reach(roots, [base]);
+            context = { reach, merged: combine(baseMerged, reach) };
             byCall.set(registeredBy, context);
         }
         return context;
@@ -1528,6 +1571,7 @@ export function fileDependencies(graph, main, extraction, types, report, runsWit
             needs.names.push(...scope.setupFixtures);
             needs.all ||= scope.takesAllFixtures;
         }
-        return graph.dependencies(roots, [base, contextOf(test.scope, test.registeredBy)], needs, snapshots, report);
+        const context = contextOf(test.scope, test.registeredBy);
+        return graph.dependencies(roots, [base, context.reach], context.merged, needs, snapshots, report);
     };
 }

package/dist/diagnostics.js

@@ -18,6 +18,7 @@ export const LEVELS = {
     'test-without-body': 'error',
     'describe-not-called': 'error',
     'async-describe': 'error',
+    'describe-throws': 'error',
     'nested-test': 'warning',
     'tag-without-at': 'error',
     'removed-api': 'error',
@@ -51,6 +52,7 @@ export const LEVELS = {
 export const REJECTS_FILE = {
     playwright: new Set(['test-without-body', 'tag-without-at', 'invalid-chain', 'duplicate-title']),
     vitest: new Set(['invalid-chain', 'removed-api', 'undefined-tag']),
+    jest: new Set(['invalid-chain', 'test-without-body', 'async-describe', 'describe-throws']),
 };
 export function toDiagnostic(problem, relativeFilePath, source, testId = null) {
     const position = problem.node && source ? source.position(problem.node.start) : null;

package/dist/extract.js

@@ -1,8 +1,7 @@
 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 { vitestCaseTitle } from "./case-titles.js";
 import { isScopeNode } from "./values.js";
 /** How many helpers deep a call is followed into the functions it calls, far more than real suites nest. */
 const MAX_DEPTH = 16;
@@ -363,14 +362,18 @@ class Walker {
                 return;
             case 'ForInStatement':
             case 'ForOfStatement': {
-                const values = leavesEarly(node.body) ? null : this.loopValues(node);
+                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, values?.length ?? null));
+                    this.visitChildren(node, this.inLoop(context, count));
                 });
                 return;
             }
@@ -571,7 +574,8 @@ class Walker {
         const list = resolved.ok && Array.isArray(resolved.value) ? resolved.value : null;
         for (const arg of call.arguments) {
             if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
-                const values = leavesEarly(arg.body) ? null : list;
+                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.
@@ -583,8 +587,9 @@ class Walker {
                     }
                 }
                 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, values?.length ?? null));
+                        this.visitCallback(arg, this.inLoop(context, count));
                     });
                 }
             }
@@ -692,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;
@@ -793,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;
     }
@@ -821,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;
@@ -857,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
@@ -946,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);
@@ -984,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. */
@@ -1198,9 +1232,9 @@ class Walker {
         const title = declaration.title;
         if (!title || title.isDynamic)
             return single("the scan can't work out the title");
-        const titles = declaration.cases.map((item, index) => vitestCaseTitle(title.text, item.items, index, this.options.version));
+        const titles = declaration.cases.map((item) => item.title);
         if (titles.some((text) => text === null)) {
-            return single("the title shows an array or object, which the scan doesn't format the way Vitest does");
+            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`);

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/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. */
@@ -16,3 +18,10 @@ export interface DetectedVersion {
  * 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, 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;

package/dist/framework-version.js

@@ -1,9 +1,12 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { globSync } from 'tinyglobby';
-const PACKAGES = { playwright: '@playwright/test', vitest: 'vitest' };
+import { OptionsError } from "./options.js";
+const PACKAGES = { playwright: '@playwright/test', vitest: 'vitest', jest: 'jest' };
+/** Each framework's name in messages. */
+export const FRAMEWORK_NAMES = { playwright: 'Playwright', vitest: 'Vitest', jest: 'Jest' };
 /** Oldest supported version of each framework. */
-export const OLDEST = { playwright: [1, 42], vitest: [3, 0] };
+export const OLDEST = { playwright: [1, 42], vitest: [3, 0], jest: [29, 0] };
 /** A file's text, or null when it is missing or can't be read. */
 function readText(file) {
     try {
@@ -108,3 +111,45 @@ function detectIn(root, all, name) {
     }
     return null;
 }
+/** Config file names of each runner. A Vite config alone doesn't count, as Vite apps without Vitest have one. */
+const CONFIG_NAMES = {
+    playwright: /^playwright\.config\.[cm]?[jt]s$/,
+    vitest: /^vitest\.config\.[cm]?[jt]s$/,
+    jest: /^jest\.config\.([cm]?[jt]s|json)$/,
+};
+/** Whether a package.json lists a runner, or for Jest has a `jest` key, its config. */
+function declares(manifest, framework) {
+    const json = readJson(manifest);
+    const fields = ['devDependencies', 'dependencies', 'peerDependencies', 'optionalDependencies'];
+    return (fields.some((field) => json?.[field]?.[PACKAGES[framework]] !== undefined) ||
+        (framework === 'jest' && json?.jest !== undefined));
+}
+/**
+ * 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 function detectFramework(root, ignore) {
+    const below = globSync(['**/package.json', '**/*.config.*'], {
+        cwd: root,
+        ignore: ['**/node_modules/**', '**/.git/**', ...ignore],
+    });
+    const manifests = below.filter((file) => path.basename(file) === 'package.json').map((file) => path.join(root, file));
+    const above = folders(root)
+        .slice(1)
+        .map((folder) => path.join(folder, 'package.json'));
+    const all = ['playwright', 'vitest', 'jest'];
+    let found = all.filter((framework) => below.some((file) => CONFIG_NAMES[framework].test(path.basename(file))) ||
+        manifests.some((manifest) => declares(manifest, framework)));
+    if (found.length === 0)
+        found = all.filter((framework) => above.some((manifest) => declares(manifest, framework)));
+    if (found.length === 1)
+        return found[0];
+    if (found.length === 0) {
+        throw new OptionsError('options.framework is needed: no package.json in the root, below it or above it lists @playwright/test, vitest or jest, and no config of theirs is in the root or below.');
+    }
+    const names = found.map((framework) => FRAMEWORK_NAMES[framework]);
+    const values = found.map((framework) => `"${framework}"`);
+    throw new OptionsError(`options.framework is needed, as the project uses ${names.slice(0, -1).join(', ')} and ${names.at(-1)}: scan it once with each of ${values.join(', ')}.`);
+}

package/dist/frameworks/bindings.d.ts

@@ -19,6 +19,8 @@ export interface TestObjects {
     returnsTestObject(name: string): boolean;
     /** Whether re-exporting `imported` from `source` exports a test object, or a function that returns one. */
     reexports(source: string, imported: string, exported: Exported): boolean;
+    /** What the test object the module exports as `name` stands for, as `it.skip` stands for `it` with `skip`. */
+    exportedStart?(name: string): unknown;
 }
 /**
  * The functions a module declares at its top level, by name, to tell whether one returns a test object: every value it
@@ -54,6 +56,13 @@ export declare function allDeclarators(program: Program): VariableDeclarator[];
 export declare function moduleImports(program: Program, isFramework: (source: string) => boolean): Map<string, ModuleImport>;
 /** The module of `require('module')`, or null for any other expression. */
 export declare function requiredModule(expression: Expression): string | null;
+/**
+ * What a CommonJS module exports under `name`: `exports.name = value`, `module.exports.name = value` or a key of
+ * `module.exports = { ... }`, and for `default`, `module.exports` itself; the last one written wins; null otherwise.
+ */
+export declare function commonJsExport(program: Program, name: string): Expression | null;
+/** The names a CommonJS module exports one by one, as `exports.name = value` and `module.exports.name = value` do. */
+export declare function commonJsNames(program: Program): string[];
 /** What `module.exports = value` assigns, the default export of a CommonJS module; null for any other statement. */
 export declare function moduleExportsValue(statement: Node): Expression | null;
 /** Applies `bind` to each declarator until no more names are bound, so declaration order doesn't matter. */
@@ -103,10 +112,15 @@ export declare function followModule(source: string, name: string, readModule: M
 interface Followed {
     exported: boolean;
     reason: string | null;
+    /** What the exported test object stands for, when the framework's test objects say. */
+    start?: unknown;
+    /** The module writes a function under the name, a helper that registers tests itself, which the walk follows. */
+    isHelper?: boolean;
 }
 /** Follows the import of `name` in a test file, with the diagnostic to report when it isn't a test object. */
 export declare function followImport(name: string, imported: ModuleImport, readModule: ModuleReader | null, file: FileContext, framework: Framework): {
     exported: boolean;
     problem: Problem | null;
+    start: unknown;
 };
 export {};

package/dist/frameworks/bindings.js

@@ -1,4 +1,4 @@
-import { childNodes, isFunctionNode, propertyName, returnValues, unwrap } from "../ast.js";
+import { childNodes, isFunctionNode, propertyKey, propertyName, returnValues, unwrap, } from "../ast.js";
 import { parseFile } from "../parse.js";
 import { snippet } from "../source.js";
 import { problem, text } from "./common.js";
@@ -125,6 +125,18 @@ export function moduleImports(program, isFramework) {
             imports.set(specifier.local.name, { source: statement.source.value, imported, node: specifier });
         }
     }
+    // `const { test } = require('./fixtures')` imports as `import { test } from './fixtures'` does.
+    for (const declarator of topLevelDeclarators(program)) {
+        const source = declarator.init ? requiredModule(declarator.init) : null;
+        if (source === null || !/^\.\.?\//.test(source) || declarator.id.type !== 'ObjectPattern')
+            continue;
+        for (const property of declarator.id.properties) {
+            const key = property.type === 'Property' ? propertyKey(property) : null;
+            if (key !== null && property.type === 'Property' && property.value.type === 'Identifier') {
+                imports.set(property.value.name, { source, imported: key, node: declarator });
+            }
+        }
+    }
     return imports;
 }
 /** The module of `require('module')`, or null for any other expression. */
@@ -135,6 +147,59 @@ export function requiredModule(expression) {
     const argument = node.arguments.at(0);
     return argument?.type === 'Literal' && typeof argument.value === 'string' ? argument.value : null;
 }
+/**
+ * What a CommonJS module exports under `name`: `exports.name = value`, `module.exports.name = value` or a key of
+ * `module.exports = { ... }`, and for `default`, `module.exports` itself; the last one written wins; null otherwise.
+ */
+export function commonJsExport(program, name) {
+    let found = null;
+    for (const statement of program.body) {
+        const whole = moduleExportsValue(statement);
+        if (whole) {
+            const object = unwrap(whole);
+            if (name === 'default')
+                found = whole;
+            else if (object.type === 'ObjectExpression') {
+                for (const property of object.properties) {
+                    if (property.type === 'Property' && propertyKey(property) === name)
+                        found = property.value;
+                }
+            }
+            continue;
+        }
+        if (statement.type !== 'ExpressionStatement')
+            continue;
+        const expression = unwrap(statement.expression);
+        if (expression.type !== 'AssignmentExpression' || expression.left.type !== 'MemberExpression')
+            continue;
+        if (propertyName(expression.left) !== name)
+            continue;
+        const target = unwrap(expression.left.object);
+        const isExports = target.type === 'Identifier' && target.name === 'exports';
+        const isModuleExports = target.type === 'MemberExpression' &&
+            target.object.type === 'Identifier' &&
+            target.object.name === 'module' &&
+            propertyName(target) === 'exports';
+        if (isExports || isModuleExports)
+            found = expression.right;
+    }
+    return found;
+}
+/** The names a CommonJS module exports one by one, as `exports.name = value` and `module.exports.name = value` do. */
+export function commonJsNames(program) {
+    const names = new Set();
+    for (const statement of program.body) {
+        if (statement.type !== 'ExpressionStatement')
+            continue;
+        const expression = unwrap(statement.expression);
+        if (expression.type !== 'AssignmentExpression' || expression.left.type !== 'MemberExpression')
+            continue;
+        const name = propertyName(expression.left);
+        if (name !== null && commonJsExport(program, name) === expression.right)
+            names.add(name);
+    }
+    return [...names];
+}
 /** What `module.exports = value` assigns, the default export of a CommonJS module; null for any other statement. */
 export function moduleExportsValue(statement) {
     if (statement.type !== 'ExpressionStatement')
@@ -187,6 +252,9 @@ export function exportsTestObject(program, name, objects, exported = 'test objec
         case 'specifier':
             return own.source === null ? local(own.local) : objects.reexports(own.source, own.local, exported);
     }
+    const commonJs = exported === 'test object' && name !== 'default' ? commonJsExport(program, name) : null;
+    if (commonJs)
+        return objects.isTestObject(commonJs);
     return program.body.some((statement) => {
         const source = starReexport(statement);
         return source !== null && objects.reexports(source, name, exported);
@@ -382,12 +450,21 @@ function followExports(module, name, framework, exported, within, followed) {
         return { exported: false, reason: 'could not be parsed' };
     const followFrom = (from, imported, kind) => followModule(from, imported, module.readModule, framework, kind, within, followed);
     const objects = framework.testObjects(program, (from, imported, kind = 'test object') => followFrom(from, imported, kind).exported);
-    if (exportsTestObject(program, name, objects, exported))
-        return { exported: true, reason: null };
+    if (exportsTestObject(program, name, objects, exported)) {
+        return { exported: true, reason: null, start: objects.exportedStart?.(name) };
+    }
+    // A function the module writes and exports is a helper that registers tests itself, which the walk follows.
+    if (exported === 'test object' && exportsFunction(program, name)) {
+        return { exported: false, reason: null, isHelper: true };
+    }
     const unrecognized = (kind) => `does not export ${kind === 'function' ? 'a function that returns a test object' : `a ${framework.name} test object`} that could be recognized`;
     const origin = importOrigin(program, name, framework.isSource, exported);
     if (origin) {
-        const end = followFrom(origin.source, origin.imported, origin.exported).reason ?? unrecognized(origin.exported);
+        const followed = followFrom(origin.source, origin.imported, origin.exported);
+        // A helper function re-exported, as `import helper from './a'; export { helper }`, is no broken test object.
+        if (followed.isHelper && origin.how === 're-exports')
+            return followed;
+        const end = followed.reason ?? unrecognized(origin.exported);
         return { exported: false, reason: `${origin.how} it from '${origin.source}', which ${end}` };
     }
     if (importsFrom(program, framework.isSource))
@@ -397,6 +474,22 @@ function followExports(module, name, framework, exported, within, followed) {
     const call = exported === 'test object' ? creatingCall(program, name, source) : null;
     return { exported: false, reason: call ? `builds it with ${call}, which is not followed` : null };
 }
+/** Whether a module writes the function it exports as `name`: declared, written in place, or held in a variable. */
+function exportsFunction(program, name) {
+    const own = ownExport(program, name);
+    if (own?.kind === 'function')
+        return true;
+    if (own?.kind === 'default') {
+        const value = unwrap(own.value);
+        return value.type === 'FunctionDeclaration' || isFunctionNode(value);
+    }
+    const local = own?.kind === 'variable' ? name : own?.kind === 'specifier' && own.source === null ? own.local : null;
+    if (local === null)
+        return false;
+    const declared = program.body.some((statement) => statement.type === 'FunctionDeclaration' && statement.id?.name === local);
+    const declarator = topLevelDeclarators(program).find((item) => item.id.type === 'Identifier' && item.id.name === local);
+    return declared || isFunctionNode(declarator?.init ? unwrap(declarator.init) : null);
+}
 /**
  * The call that creates what the module exports as `name`, a variable or its default export, as `defineBrokerTest()`;
  * null for other values.
@@ -412,9 +505,9 @@ function creatingCall(program, name, source) {
 }
 /** Follows the import of `name` in a test file, with the diagnostic to report when it isn't a test object. */
 export function followImport(name, imported, readModule, file, framework) {
-    const { exported, reason } = followModule(imported.source, imported.imported, readModule, framework);
+    const { exported, reason, start } = followModule(imported.source, imported.imported, readModule, framework);
     const problemFound = reason
         ? problem('unresolved-test-import', imported.node, `'${name}' is imported from '${imported.source}', which ${reason}; tests that use it are missing.`, snippet(text(file, imported.node)))
         : null;
-    return { exported, problem: problemFound };
+    return { exported, problem: problemFound, start };
 }