test-inventory 0.7.0 → 0.9.0

package/dist/config.d.ts

@@ -39,6 +39,8 @@ export interface ObjectSetting {
     kind: 'object';
     keys: Map<string, Setting>;
     rest: Unknown | null;
+    /** Where the object is written; absent for one the scan builds, as by merging two. */
+    where?: Site;
 }
 /** The source text of a setting the scan can't work out; null for one of a config it couldn't read at all. */
 export declare function unknownText(setting: Unknown): string | null;
@@ -59,11 +61,13 @@ export interface ConfigFile {
 /** Finds and reads the configs of one scan, and collects what it can't work out in them as diagnostics. */
 export declare class Configs {
     readonly diagnostics: Diagnostic[];
-    private readonly root;
+    /** The project root, where the runner is taken to be started. */
+    readonly root: string;
     private readonly framework;
     private readonly readerFor;
     private readonly inFolders;
     private readonly files;
+    private mocha;
     private readonly used;
     private readonly reported;
     private readonly version;
@@ -83,8 +87,45 @@ export declare class Configs {
     records(projectsOf: (config: ConfigFile) => ProjectRecord[] | null): ConfigRecord[];
     /** Reports a setting the scan reads but can't work out, once; `key` names it, and `effect` says what the scan does. */
     reportUnknown(setting: Unknown, key: string, effect: string): void;
+    /**
+     * Reports, once, a setting the runner mishandles, where it is written, or on its config when the scan built it from
+     * several places; `key` names it.
+     */
+    reportSetting(setting: ObjectSetting, config: ConfigFile, key: string, message: string): void;
+    private reportAt;
+    /** Reports, once, a config the runner reads in a way the scan doesn't follow, or refuses. */
+    reportConfig(config: ConfigFile, message: string): void;
+    /**
+     * The config Mocha runs with, started in the root: the first `.mocharc` file from the root up, joined with the `mocha`
+     * key of the nearest package.json. Null without either.
+     */
+    mochaConfig(): ConfigFile | null;
+    /**
+     * The config the jasmine command reads, started in the root: the first of `spec/support/jasmine.mjs` (from Jasmine
+     * 5), `.json` and `.js` there; null without one.
+     */
+    jasmineConfig(): ConfigFile | null;
+    /**
+     * The config `cypress run` or `wdio` reads, started in the root without a config named: the first of its config
+     * files there; null without one.
+     */
+    rootConfig(): ConfigFile | null;
     /** The config the runner started in a folder would use; null when the folder has none. */
     inFolder(folder: string): ConfigFile | null;
+    /** Config file names, in the order the runner looks for them; Jest reads `.cts` from 30.0 and `.mts` from 30.4. */
+    private names;
+    /**
+     * The config Jest takes in a folder: a `jest.config` file, else the `package.json` with a `jest` key, which from 30.0
+     * may be the path to the config. A `package.json` without one is a config only in the root, as Jest started there
+     * reads it; below the root it is a package, whose tests the root's config runs. Jest refuses to start with more than
+     * one config in the folder, which is reported.
+     */
+    private jestConfigIn;
+    /**
+     * The config Jest finds for a folder its `projects` names: from the folder up to the root, the first `jest.config`
+     * file or `package.json`, which Jest reads there also without a `jest` key.
+     */
+    projectConfig(folder: string): ConfigFile | null;
     private read;
 }
 export {};

package/dist/config.js

@@ -4,16 +4,28 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { childNodes, isFunctionNode, propertyKey, propertyName, returnValues, unwrap, } from "./ast.js";
 import { fileDiagnostic, toDiagnostic } from "./diagnostics.js";
 import { readFailure } from "./files.js";
-import { exportName, moduleExportsValue, ownExport, parseModule, requiredModule, starReexport, } from "./frameworks/bindings.js";
-import { problem } from "./frameworks/common.js";
+import { folders } from "./framework-version.js";
+import { commonJsExport, exportName, moduleExportsValue, ownExport, parseModule, requiredModule, starReexport, } from "./frameworks/bindings.js";
+import { atLeast, problem } from "./frameworks/common.js";
 import { parseFile } from "./parse.js";
 import { snippet } from "./source.js";
 import { isKey, isScopeNode, Values } from "./values.js";
 import { VITEST_INCLUDE, VITEST_TYPECHECK_INCLUDE, vitestExclude } from "./vitest-defaults.js";
+import { readToml, TomlError } from "./toml.js";
+import { readYaml, YamlError } from "./yaml.js";
 /** Config file names in the order each runner looks for them in a folder. */
 const CONFIG_FILES = {
     playwright: ['.ts', '.js', '.mts', '.mjs', '.cts', '.cjs'].map((extension) => `playwright.config${extension}`),
     vitest: ['vitest.config', 'vite.config'].flatMap((name) => ['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'].map((extension) => name + extension)),
+    jest: ['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts', '.json'].map((extension) => `jest.config${extension}`),
+    mocha: ['.cjs', '.js', '.mjs', '.yaml', '.yml', '.jsonc', '.json'].map((extension) => `.mocharc${extension}`),
+    // From the root, which the jasmine command runs in; `.mjs` from Jasmine 5.
+    jasmine: ['.mjs', '.json', '.js'].map((extension) => `spec/support/jasmine${extension}`),
+    cypress: ['.ts', '.js', '.mjs', '.cjs', '.mts', '.cts'].map((extension) => `cypress.config${extension}`),
+    // The files `wdio run` takes without a config named, in its order.
+    webdriverio: ['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts'].map((extension) => `wdio.conf${extension}`),
+    node: [],
+    bun: ['bunfig.toml'],
 };
 /** Methods that change the object or list they are called on. */
 const CHANGING_METHODS = new Set([
@@ -266,7 +278,7 @@ class ConfigCode {
         const { program } = frame.parsed;
         const own = ownExport(program, name);
         if (own?.kind === 'default')
-            return this.evaluate(own.value, frame, [program]);
+            return this.config(own.value, frame, [program]);
         if (own) {
             const at = { frame, node: own.statement };
             const found = own.kind === 'specifier' && own.source !== null
@@ -277,8 +289,12 @@ class ConfigCode {
         if (name === 'default') {
             // `export *` passes on every name but the default.
             const commonJs = program.body.map(moduleExportsValue).find((value) => value !== null);
-            return commonJs ? this.evaluate(commonJs, frame, [program]) : null;
+            return commonJs ? this.config(commonJs, frame, [program]) : null;
         }
+        // A name a CommonJS module exports, as WebdriverIO's `exports.config = { ... }`.
+        const commonJs = commonJsExport(program, name);
+        if (commonJs)
+            return this.config(commonJs, frame, [program]);
         for (const statement of program.body) {
             const source = starReexport(statement);
             const found = source === null ? null : this.fromModule(frame, source, name, site);
@@ -287,6 +303,21 @@ class ConfigCode {
         }
         return null;
     }
+    /** A module's default export, which Jest calls when it is a function, and awaits. */
+    config(node, frame, scopes) {
+        if (this.framework !== 'jest')
+            return this.evaluate(node, frame, scopes);
+        let fn = unwrap(node);
+        let around = scopes;
+        if (fn.type === 'Identifier') {
+            const constant = frame.values.constantOf(fn.name, scopes);
+            if (constant)
+                [fn, around] = [unwrap(constant.init), constant.scopes];
+        }
+        return fn.type === 'FunctionDeclaration' || isFunctionNode(fn)
+            ? this.returned(fn, frame, around)
+            : this.evaluate(node, frame, scopes);
+    }
     /** Works out an expression; `scopes` are the scope nodes around it, outermost first. */
     evaluate(node, frame, scopes) {
         const expression = unwrap(node);
@@ -344,10 +375,11 @@ class ConfigCode {
             const setting = this.once(constant.init, site, () => this.evaluate(constant.init, frame, constant.scopes));
             return this.changed(setting, frame, declaration);
         }
-        if (declaration?.type !== 'ImportSpecifier' && declaration?.type !== 'ImportDefaultSpecifier')
-            return null;
-        const imported = declaration.type === 'ImportSpecifier' ? exportName(declaration.imported) : 'default';
+        // An import, or a local file loaded with `require()`, which reads as one.
         const source = frame.values.importSource(name, scopes);
+        const imported = frame.values.importedName(name, scopes);
+        if (source === null || imported === null)
+            return null;
         if (source === 'vitest/config' || source === 'vitest/node') {
             const defaults = this.vitestDefaults(imported, site);
             if (defaults)
@@ -398,6 +430,19 @@ class ConfigCode {
     }
     /** What a module an import names exports under a name; null when the module doesn't export it. */
     fromModule(frame, specifier, name, site) {
+        if (specifier.endsWith('.json')) {
+            // A JSON file, required or imported with `with { type: 'json' }`, is its value.
+            const module = frame.readModule(specifier);
+            if ('reason' in module)
+                return unknown(site);
+            const value = attemptJson(module.code);
+            if (value === null)
+                return unknown(site);
+            if (!this.followed.includes(module.relativeFilePath))
+                this.followed.push(module.relativeFilePath);
+            const setting = fromValue(value.json);
+            return name === 'default' ? setting : child(setting, name);
+        }
         const module = this.open(frame, specifier);
         if (!module)
             return unknown(site);
@@ -455,7 +500,7 @@ class ConfigCode {
             // A method or getter is a function, which the scan can't work out.
             object.keys.set(String(key.value), this.evaluate(property.value, frame, scopes));
         }
-        return object;
+        return { ...object, where: { frame, node } };
     }
     /**
      * `{ ...object, ...argument }`, also for an argument that picks between two objects, as in
@@ -483,10 +528,12 @@ class ConfigCode {
                 items.push(this.evaluate(element, frame, scopes));
                 continue;
             }
+            // A spread the scan can't work out is one unknown item, so the items it can are kept.
             const spreadList = this.evaluate(element.argument, frame, scopes);
-            if (spreadList.kind !== 'list')
-                return unknown({ frame, node: element });
-            items.push(...spreadList.items);
+            if (spreadList.kind === 'list')
+                items.push(...spreadList.items);
+            else
+                items.push(unknown({ frame, node: element }));
         }
         return { kind: 'list', items };
     }
@@ -518,6 +565,12 @@ class ConfigCode {
      */
     call(call, frame, scopes) {
         const site = { frame, node: call };
+        // `require('./jest.base.js')` of a local file, as CommonJS configs build on a shared one, is its default export.
+        const required = requiredModule(call);
+        const isGlobal = frame.values.declarationOf('require', scopes) === null;
+        if (required !== null && isGlobal && /^\.\.?\//.test(required)) {
+            return this.fromModule(frame, required, 'default', site) ?? unknown(site);
+        }
         const origin = this.origin(unwrap(call.callee), frame, scopes);
         const pathFunction = origin && PATH_FUNCTIONS[`${origin.source.replace(/^node:/, '')}.${origin.name}`];
         if (pathFunction) {
@@ -529,7 +582,15 @@ class ConfigCode {
         const name = isPackage && CONFIG_FUNCTIONS.has(origin.name) ? origin.name : null;
         const { arguments: given } = call;
         const needed = name === 'mergeConfig' ? 2 : 1;
-        if (name === null || given.length < needed || given.some((arg) => arg.type === 'SpreadElement')) {
+        // Jest exports defineConfig() and mergeConfig() from 30.3; neither takes a project.
+        const isJest = origin !== null &&
+            ['jest', 'jest-config'].includes(origin.source) &&
+            name !== 'defineProject' &&
+            atLeast(this.version, 30, 3);
+        if (name === null ||
+            (this.framework === 'jest' && !isJest) ||
+            given.length < needed ||
+            given.some((arg) => arg.type === 'SpreadElement')) {
             return unknown(site);
         }
         const args = given;
@@ -537,8 +598,8 @@ class ConfigCode {
             const [base, over] = args.map((arg) => this.evaluate(arg, frame, scopes));
             return mergeDeep(base, over);
         }
-        if (this.framework === 'vitest') {
-            // Vitest's defineConfig() and defineProject() return the config they are given, or the one a function returns.
+        if (this.framework !== 'playwright') {
+            // Vitest's and Jest's defineConfig() return the config they are given, or the one a function returns.
             return isFunctionNode(args[0]) ? this.returned(args[0], frame, scopes) : this.evaluate(args[0], frame, scopes);
         }
         // Playwright's defineConfig() merges the configs it is given, each over the ones before it.
@@ -593,11 +654,13 @@ class ConfigCode {
 /** Finds and reads the configs of one scan, and collects what it can't work out in them as diagnostics. */
 export class Configs {
     diagnostics = [];
+    /** The project root, where the runner is taken to be started. */
     root;
     framework;
     readerFor;
     inFolders = new Map();
     files = new Map();
+    mocha;
     used = new Set();
     reported = new Set();
     version;
@@ -649,29 +712,142 @@ export class Configs {
     }
     /** Reports a setting the scan reads but can't work out, once; `key` names it, and `effect` says what the scan does. */
     reportUnknown(setting, key, effect) {
-        if (setting.where === null)
+        const message = `The config's ${key} could not be worked out without running the config, so ${effect}.`;
+        this.reportAt(setting.where, key, message);
+    }
+    /**
+     * Reports, once, a setting the runner mishandles, where it is written, or on its config when the scan built it from
+     * several places; `key` names it.
+     */
+    reportSetting(setting, config, key, message) {
+        if (setting.where)
+            this.reportAt(setting.where, key, message);
+        else
+            this.reportConfig(config, message);
+    }
+    reportAt(where, key, message) {
+        if (where === null)
             return;
-        const { frame, node } = setting.where;
+        const { frame, node } = where;
         const id = `${frame.relativeFilePath}\0${node.start}\0${key}`;
         if (this.reported.has(id))
             return;
         this.reported.add(id);
-        const message = `The config's ${key} could not be worked out without running the config, so ${effect}.`;
         const code = snippet(frame.parsed.source.text.slice(node.start, node.end));
         const found = problem('config-value-unknown', node, message, code);
         this.diagnostics.push(toDiagnostic(found, frame.relativeFilePath, frame.parsed.source));
     }
+    /** Reports, once, a config the runner reads in a way the scan doesn't follow, or refuses. */
+    reportConfig(config, message) {
+        const id = `${config.record.relativeFilePath}\0${message}`;
+        if (this.reported.has(id))
+            return;
+        this.reported.add(id);
+        this.diagnostics.push(fileDiagnostic('config-value-unknown', config.record.relativeFilePath, message));
+    }
+    /**
+     * The config Mocha runs with, started in the root: the first `.mocharc` file from the root up, joined with the `mocha`
+     * key of the nearest package.json. Null without either.
+     */
+    mochaConfig() {
+        if (this.mocha !== undefined)
+            return this.mocha;
+        let rc = null;
+        let manifest = null;
+        for (const folder of folders(this.root)) {
+            const name = rc ? undefined : CONFIG_FILES.mocha.find((item) => existsSync(path.join(folder, item)));
+            if (name)
+                rc = this.at(path.join(folder, name));
+            if (manifest === null && existsSync(path.join(folder, 'package.json')))
+                manifest = path.join(folder, 'package.json');
+            if (rc && manifest)
+                break;
+        }
+        const key = manifest && manifestKey(manifest, 'mocha') !== undefined ? this.at(manifest) : null;
+        this.mocha = rc && key ? joinMochaConfigs(rc, key) : (rc ?? key);
+        return this.mocha;
+    }
+    /**
+     * The config the jasmine command reads, started in the root: the first of `spec/support/jasmine.mjs` (from Jasmine
+     * 5), `.json` and `.js` there; null without one.
+     */
+    jasmineConfig() {
+        const names = CONFIG_FILES.jasmine.filter((name) => !name.endsWith('.mjs') || atLeast(this.version, 5, 0));
+        const name = names.find((item) => existsSync(path.join(this.root, item)));
+        return name ? this.at(path.join(this.root, name)) : null;
+    }
+    /**
+     * The config `cypress run` or `wdio` reads, started in the root without a config named: the first of its config
+     * files there; null without one.
+     */
+    rootConfig() {
+        const name = CONFIG_FILES[this.framework].find((item) => existsSync(path.join(this.root, item)));
+        return name ? this.at(path.join(this.root, name)) : null;
+    }
     /** The config the runner started in a folder would use; null when the folder has none. */
     inFolder(folder) {
         let config = this.inFolders.get(folder);
         if (config === undefined) {
             // The runners take a config that exists, without checking that it is a file they can read.
-            const name = CONFIG_FILES[this.framework].find((item) => existsSync(path.join(folder, item)));
-            config = name ? this.at(path.join(folder, name)) : null;
+            if (this.framework === 'jest') {
+                config = this.jestConfigIn(folder);
+            }
+            else {
+                const name = this.names().find((item) => existsSync(path.join(folder, item)));
+                config = name ? this.at(path.join(folder, name)) : null;
+            }
             this.inFolders.set(folder, config);
         }
         return config;
     }
+    /** Config file names, in the order the runner looks for them; Jest reads `.cts` from 30.0 and `.mts` from 30.4. */
+    names() {
+        if (this.framework !== 'jest')
+            return CONFIG_FILES[this.framework];
+        return CONFIG_FILES.jest.filter((name) => (!name.endsWith('.cts') || atLeast(this.version, 30, 0)) &&
+            (!name.endsWith('.mts') || atLeast(this.version, 30, 4)));
+    }
+    /**
+     * The config Jest takes in a folder: a `jest.config` file, else the `package.json` with a `jest` key, which from 30.0
+     * may be the path to the config. A `package.json` without one is a config only in the root, as Jest started there
+     * reads it; below the root it is a package, whose tests the root's config runs. Jest refuses to start with more than
+     * one config in the folder, which is reported.
+     */
+    jestConfigIn(folder, anyManifest = false) {
+        const names = this.names().filter((item) => existsSync(path.join(folder, item)));
+        const manifest = path.join(folder, 'package.json');
+        const key = existsSync(manifest) ? manifestKey(manifest) : undefined;
+        const KEY = 'the jest key in package.json';
+        if (key !== undefined)
+            names.push(KEY);
+        if (names.length > 1) {
+            const listed = `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`;
+            const message = `Jest finds more than one config in this folder, ${listed}, and refuses to start; the scan reads ${names[0]}.`;
+            const relativeFilePath = this.relative(path.join(folder, names[0]));
+            if (!this.reported.has(`${relativeFilePath}\0${message}`)) {
+                this.reported.add(`${relativeFilePath}\0${message}`);
+                this.diagnostics.push(fileDiagnostic('config-value-unknown', relativeFilePath, message));
+            }
+        }
+        if (names.length > 0 && names[0] !== KEY)
+            return this.at(path.join(folder, names[0]));
+        if (typeof key === 'string' && atLeast(this.version, 30, 0))
+            return this.at(path.resolve(folder, key));
+        return key !== undefined || ((anyManifest || folder === this.root) && existsSync(manifest))
+            ? this.at(manifest)
+            : null;
+    }
+    /**
+     * The config Jest finds for a folder its `projects` names: from the folder up to the root, the first `jest.config`
+     * file or `package.json`, which Jest reads there also without a `jest` key.
+     */
+    projectConfig(folder) {
+        for (let current = folder;; current = path.dirname(current)) {
+            const config = this.jestConfigIn(current, true);
+            if (config || current === this.root || path.dirname(current) === current)
+                return config;
+        }
+    }
     read(file) {
         const relativeFilePath = path.relative(this.root, file).replaceAll('\\', '/');
         const unreadable = (diagnostic) => {
@@ -687,6 +863,26 @@ export class Configs {
             const message = `The config could not be read: ${readFailure(error)}, ${none}`;
             return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
         }
+        if (/\.(jsonc?|ya?ml|toml)$/.test(file)) {
+            let value;
+            try {
+                // Mocha reads `.mocharc.json` with comments too.
+                const comments = file.endsWith('.jsonc') || path.basename(file).startsWith('.mocharc');
+                value = /\.ya?ml$/.test(file)
+                    ? readYaml(code)
+                    : file.endsWith('.toml')
+                        ? readToml(code)
+                        : JSON.parse(comments ? withoutJsonComments(code) : code);
+            }
+            catch (error) {
+                const at = error instanceof YamlError || error instanceof TomlError ? ` on line ${error.line}` : '';
+                const message = `The config could not be parsed${at}: ${error.message}, ${none}`;
+                return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
+            }
+            // Jest reads a package.json without a `jest` key as an empty config, and Mocha one without a `mocha` key.
+            const settings = path.basename(file) === 'package.json' ? manifestKeyOf(value, this.framework) : value;
+            return { file, record: { relativeFilePath, extends: [] }, settings: fromValue(settings ?? {}) };
+        }
         const parsed = parseFile(relativeFilePath, code);
         if (parsed.error) {
             const { message, start, end } = parsed.error;
@@ -697,7 +893,9 @@ export class Configs {
         const config = new ConfigCode(frame, this.framework, this.root, this.version);
         let settings;
         try {
-            settings = config.exported(frame, 'default', { frame, node: parsed.program });
+            // WebdriverIO's config is the module's `config` export.
+            const name = this.framework === 'webdriverio' ? 'config' : 'default';
+            settings = config.exported(frame, name, { frame, node: parsed.program });
         }
         catch (error) {
             // The scan runs none of the project's code, so what fails here is its own and throws an Error.
@@ -706,9 +904,77 @@ export class Configs {
             return unreadable(fileDiagnostic('internal-error', relativeFilePath, message));
         }
         if (settings === null) {
-            const message = `The config has no default export the scan can find, ${none}`;
+            const message = `The config has no ${this.framework === 'webdriverio' ? '`config`' : 'default'} export the scan can find, ${none}`;
             return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
         }
         return { file, record: { relativeFilePath, extends: config.followed }, settings };
     }
 }
+/** The `jest` or `mocha` key of a package.json; undefined when it has none, or can't be read. */
+function manifestKey(file, framework = 'jest') {
+    try {
+        return manifestKeyOf(JSON.parse(readFileSync(file, 'utf8')), framework);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Mocha's options that take a list, which it joins across a `.mocharc` file and package.json. */
+const MOCHA_LISTS = new Set([
+    'extension',
+    'file',
+    'global',
+    'ignore',
+    'exclude',
+    'node-option',
+    'reporter-option',
+    'require',
+    'spec',
+    'watch-files',
+    'watch-ignore',
+]);
+/**
+ * A `.mocharc` file and the `mocha` key of a package.json as Mocha joins them: a list option is the file's items and
+ * then the package.json's, a single value counting as a list of one; for any other key the file's value wins (checked
+ * with Mocha 10.8.2, 11.7.5 and 12.0.3).
+ */
+function joinMochaConfigs(rc, key) {
+    const record = { ...rc.record, extends: [...rc.record.extends, key.record.relativeFilePath] };
+    if (rc.settings.kind !== 'object' || key.settings.kind !== 'object')
+        return { ...rc, record };
+    const keys = new Map([...key.settings.keys, ...rc.settings.keys]);
+    for (const name of MOCHA_LISTS) {
+        const [first, second] = [rc.settings.keys.get(name), key.settings.keys.get(name)];
+        if (!first || !second)
+            continue;
+        const items = (setting) => (setting.kind === 'list' ? setting.items : [setting]);
+        keys.set(name, { kind: 'list', items: [...items(first), ...items(second)] });
+    }
+    return { ...rc, record, settings: { kind: 'object', keys, rest: rc.settings.rest } };
+}
+/**
+ * The `jest` or `mocha` key of a parsed package.json, by the framework; undefined for a value the runner reads as no
+ * config, as `false` or `""` are.
+ */
+function manifestKeyOf(packageJson, framework = 'jest') {
+    const key = packageJson?.[framework === 'mocha' ? 'mocha' : 'jest'];
+    if (!key)
+        return undefined;
+    return key;
+}
+/**
+ * JSON text without `//` and `/* *\/` comments outside strings, as Mocha reads `.mocharc.jsonc`; a comment becomes
+ * spaces, so the parser's positions stay right.
+ */
+function withoutJsonComments(text) {
+    return text.replaceAll(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (match, string) => string ?? match.replaceAll(/[^\n]/g, ' '));
+}
+/** A JSON text's value; null when it isn't JSON. */
+function attemptJson(text) {
+    try {
+        return { json: JSON.parse(text) };
+    }
+    catch {
+        return null;
+    }
+}

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;