test-inventory 0.6.1 → 0.8.0

package/dist/config-runs.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
 import picomatch from 'picomatch';
 import { globSync } from 'tinyglobby';
@@ -8,6 +8,17 @@ import { VITEST_BENCHMARK_INCLUDE, VITEST_INCLUDE, VITEST_TYPECHECK_INCLUDE, vit
 const PLAYWRIGHT_TEST_MATCH = '**/*.@(spec|test).?(c|m)[jt]s?(x)';
 /** A file Vitest takes as a project config, by name. */
 const VITEST_CONFIG = /^(vitest|vite)(\..*)?\.config\./;
+/** Jest's default `testMatch` before 30.0, and from 30.0, which also matches `.mjs`, `.cjs`, `.mts` and `.cts`. */
+const JEST_TEST_MATCH = {
+    29: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[tj]s?(x)'],
+    30: ['**/__tests__/**/*.?([mc])[jt]s?(x)', '**/?(*.)+(spec|test).?([mc])[jt]s?(x)'],
+};
+/** The extensions a file a Jest `projects` glob matches needs to be read as a config. */
+const JEST_CONFIG_EXTENSIONS = ['.js', '.ts', '.mjs', '.mts', '.cjs', '.cts', '.json'];
+/** Jest's default `moduleFileExtensions` before 30.0; 30.0 adds `mts` and `cts`. */
+const JEST_EXTENSIONS = ['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'json', 'node'];
+/** Presets that leave Jest's choice of test files as it is, so the scan needs nothing from them. */
+const NEUTRAL_PRESETS = /^(ts-jest(\/.*)?|jest-puppeteer)$/;
 /** Vitest 3's workspace files, which list its projects in place of `test.projects`. */
 const VITEST_WORKSPACES = ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs', 'json'].map((extension) => `vitest.workspace.${extension}`);
 const NO_DEFAULTS = {
@@ -101,6 +112,8 @@ export class ConfigRuns {
     projects = new Map();
     ignoreRules = new Map();
     folderStates = new Map();
+    /** The project Jest runs with when no config is found up to the root. */
+    jestDefaults = null;
     /** The Vitest configs whose projects are being found, with their names, to stop at one whose projects name itself. */
     expanding = new Map();
     constructor(configs, framework, version, findsFiles) {
@@ -119,7 +132,9 @@ export class ConfigRuns {
         return { ...placement, tags: this.configTags(placement.config) };
     }
     place(file) {
-        const around = this.configs.around(file);
+        // Jest started at the root reads the config there only, and the others through its `projects`.
+        const rootConfig = this.framework === 'jest' ? this.configs.inFolder(this.configs.root) : null;
+        const around = this.framework !== 'jest' ? this.configs.around(file) : rootConfig ? [rootConfig] : [];
         for (const config of around) {
             const running = this.projectsOf(config).flatMap((project) => {
                 const runs = project.runs?.(file);
@@ -137,6 +152,12 @@ export class ConfigRuns {
             return { config: unknown.config, settings: unknown.settings, runs: null, projects: null };
         }
         const nearest = around.at(-1) ?? null;
+        if (nearest === null && this.framework === 'jest') {
+            // Jest then reads a package.json above the root, taken to have no `jest` key: its defaults apply from the root.
+            this.jestDefaults ??= this.jestProject(this.noConfig(), emptySettings(), this.configs.root, emptySettings());
+            const runs = this.jestDefaults.runs;
+            return { config: null, settings: null, runs: runs(file), projects: null };
+        }
         return {
             config: nearest,
             settings: nearest?.settings ?? null,
@@ -189,7 +210,12 @@ export class ConfigRuns {
     projectsOf(config) {
         let projects = this.projects.get(config);
         if (!projects) {
-            projects = this.framework === 'playwright' ? this.playwrightProjects(config) : this.vitestProjects(config);
+            if (this.framework === 'playwright')
+                projects = this.playwrightProjects(config);
+            else if (this.framework === 'jest')
+                projects = this.jestProjects(config);
+            else
+                projects = this.vitestProjects(config);
             this.projects.set(config, projects);
         }
         return projects;
@@ -429,10 +455,196 @@ export class ConfigRuns {
         }
         return rules;
     }
+    /** A config for the defaults of a runner started where no config is found. */
+    noConfig() {
+        const file = path.join(this.configs.root, 'package.json');
+        return { file, record: { relativeFilePath: 'package.json', extends: [] }, settings: emptySettings() };
+    }
+    /**
+     * Jest's projects: the config itself, or the entries of its `projects`. A path or glob there names a folder, whose
+     * config is the one Jest finds from it, or a config file; an object is a project whose `rootDir` defaults to the
+     * config's folder. The config's own test files then count only when an entry names its folder.
+     */
+    jestProjects(config) {
+        const folder = path.dirname(config.file);
+        const list = settingAt(config.settings, ['projects']);
+        const isEmpty = list?.kind === 'list' && list.items.length === 0;
+        if (list === null || isUnset(list) || isEmpty) {
+            return [this.jestProject(config, config.settings, folder, config.settings)];
+        }
+        if (list.kind !== 'list')
+            return [this.unknownProject(config, unknownAt(list), 'projects')];
+        const rootDir = jestRootDir(config.settings, folder);
+        if (typeof rootDir !== 'string')
+            return [this.unknownProject(config, rootDir, 'rootDir')];
+        return list.items.flatMap((item) => {
+            if (item.kind === 'object')
+                return [this.jestProject(config, item, folder, config.settings)];
+            if (item.kind !== 'value' || typeof item.value !== 'string') {
+                return [this.unknownProject(config, unknownAt(item), 'projects')];
+            }
+            const entry = replaceRootDir(rootDir, item.value);
+            // Jest globs from where it is started, with `\` as a separator on Windows, and keeps an entry that matches nothing
+            // as a path.
+            const pattern = posix(path.isAbsolute(entry) ? path.relative(this.configs.root, entry) : entry);
+            const matches = picomatch.scan(pattern).isGlob
+                ? globSync(pattern, { cwd: this.configs.root, absolute: true, onlyFiles: false, expandDirectories: false })
+                : [];
+            // Jest leaves out a matched file it can't require, such as a README.
+            const requirable = matches.filter((match) => statSync(match).isDirectory() || JEST_CONFIG_EXTENSIONS.some((extension) => match.endsWith(extension)));
+            const targets = matches.length > 0 ? requirable : [path.resolve(this.configs.root, entry)];
+            // Jest fails on an entry that names nothing, so it adds no project here.
+            return targets.sort().flatMap((target) => {
+                if (!existsSync(target))
+                    return [];
+                const isFile = statSync(target).isFile();
+                const nested = isFile ? this.configs.at(target) : this.configs.projectConfig(target);
+                if (!nested || nested === config)
+                    return [this.jestProject(config, config.settings, folder, config.settings)];
+                return [this.jestProject(nested, nested.settings, path.dirname(nested.file), config.settings)];
+            });
+        });
+    }
+    /**
+     * The files a Jest project runs, as Jest's SearchSource picks them: under one of `roots`, with an extension in
+     * `moduleFileExtensions`, not left out by `modulePathIgnorePatterns`, matching `testMatch` or `testRegex`, and not
+     * `testPathIgnorePatterns`. Paths and patterns are matched with `/`, and `<rootDir>` stands for `rootDir`. `global`
+     * is the config Jest is started with, whose `testTimeout` applies to every project in Jest 29.
+     */
+    jestProject(config, written, folder, global) {
+        const rootDir = jestRootDir(written, folder);
+        if (typeof rootDir !== 'string')
+            return this.unknownProject(config, rootDir, 'rootDir');
+        const settings = this.withPreset(config, written, rootDir);
+        const isJest30 = this.version === null || this.version[0] >= 30;
+        const lists = {};
+        const defaults = [
+            ['roots', ['<rootDir>']],
+            ['testMatch', isJest30 ? JEST_TEST_MATCH[30] : JEST_TEST_MATCH[29]],
+            ['testRegex', []],
+            ['testPathIgnorePatterns', ['/node_modules/']],
+            ['modulePathIgnorePatterns', []],
+            ['moduleFileExtensions', isJest30 ? [...JEST_EXTENSIONS, 'mts', 'cts'] : JEST_EXTENSIONS],
+        ];
+        for (const [key, fallback] of defaults) {
+            const setting = settingAt(settings, [key]);
+            const found = isJestSet(setting) ? patterns(setting, key === 'testRegex') : fallback;
+            // A list of paths left out only takes files away, so the entries the scan can read are still a good guess.
+            if (!Array.isArray(found) && key.endsWith('IgnorePatterns')) {
+                this.configs.reportUnknown(found, key, 'the scan may list test files that Jest leaves out');
+                const items = setting?.kind === 'list' ? setting.items : [];
+                lists[key] = items.flatMap((item) => item.kind === 'value' && typeof item.value === 'string' ? [item.value] : []);
+                continue;
+            }
+            if (!Array.isArray(found))
+                return this.unknownProject(config, found, key);
+            lists[key] = found;
+        }
+        const testRegex = lists.testRegex.map((item) => typeof item === 'string' ? regExp(item, '') : item);
+        const invalid = lists.testRegex.find((_, index) => testRegex[index] === null);
+        const testMatchSetting = settingAt(settings, ['testMatch']);
+        let refusal = null;
+        if (invalid !== undefined) {
+            refusal = `The config's testRegex '${String(invalid)}' is not a regular expression, so Jest fails to start.`;
+        }
+        else if (testRegex.length > 0 && isJestSet(testMatchSetting)) {
+            refusal = 'The config sets both testMatch and testRegex, which Jest refuses, so it runs no tests.';
+        }
+        const roots = lists.roots
+            .map((item) => replaceRootDir(rootDir, item))
+            .map((root) => path.resolve(rootDir, root));
+        const escaped = posix(rootDir).replaceAll(/([!()*?[\\\]{}])/g, '\\$1');
+        const testMatch = testRegex.length > 0 ? [] : lists.testMatch.map((glob) => posix(replaceRootDir(escaped, glob)));
+        const isTestMatch = jestGlobs(testMatch);
+        // A pattern is a regular expression, in which Jest replaces every `<rootDir>`; escapes stay as written.
+        const joined = (key) => {
+            const items = lists[key].map((item) => item.replaceAll('<rootDir>', posix(rootDir)));
+            if (items.length === 0)
+                return null;
+            const expression = regExp(items.join('|'), '');
+            refusal ??= expression ? null : `The config's ${key} is not a regular expression, so Jest fails to start.`;
+            return expression;
+        };
+        const ignored = joined('testPathIgnorePatterns');
+        const moduleIgnored = joined('modulePathIgnorePatterns');
+        if (refusal)
+            this.configs.reportConfig(config, refusal);
+        const extensions = new Set(lists.moduleFileExtensions);
+        const preset = settingAt(written, ['preset']);
+        const isPackage = preset?.kind === 'value' && typeof preset.value === 'string' && !isLocalPreset(preset.value);
+        if (isPackage && !NEUTRAL_PRESETS.test(String(preset.value))) {
+            const message = `The config's preset '${preset.value}' is a package the scan doesn't read, and it may set which files are tests; the scan takes Jest's defaults for what the config doesn't set.`;
+            if (testMatchSetting === null && testRegex.length === 0)
+                this.configs.reportConfig(config, message);
+        }
+        const displayName = settingAt(settings, ['displayName']);
+        const named = displayName?.kind === 'object' ? settingAt(displayName, ['name']) : displayName;
+        const name = named?.kind === 'value' && typeof named.value === 'string' ? named.value : '';
+        const about = {
+            name,
+            testDir: rootDir,
+            dependencies: [],
+            settings,
+            root: rootDir,
+            container: null,
+            config,
+            grep: null,
+            grepRoot: rootDir,
+            runsByDefault: true,
+            defaults: {
+                // A project's own testTimeout counts from Jest 30; before, only the config Jest is started with sets it.
+                timeout: (isJest30 ? settingAt(settings, ['testTimeout']) : null) ?? settingAt(global, ['testTimeout']),
+                retry: null,
+                repeatEach: null,
+                repeats: null,
+                parallel: null,
+                tags: null,
+            },
+        };
+        return {
+            config,
+            settings,
+            about,
+            unknown: null,
+            runs: (file) => {
+                const unix = posix(file);
+                if (refusal || !extensions.has(path.extname(file).slice(1)))
+                    return false;
+                if (!roots.some((root) => isInside(root, file)) || moduleIgnored?.test(unix))
+                    return false;
+                if (testMatch.length > 0 && !isTestMatch(unix))
+                    return false;
+                if (ignored?.test(unix))
+                    return false;
+                return testRegex.length === 0 || testRegex.some((expression) => matches(expression, unix))
+                    ? 'test'
+                    : false;
+            },
+        };
+    }
     /**
      * The projects of a Vitest config, the one the runner starts with or, in Vitest 5, a config another lists, whose name
      * then goes around the names of its projects.
      */
+    /**
+     * A project's settings over those of its `preset` when that is a local file, as `'../../jest.preset.js'`, which Jest
+     * finds from `rootDir`: the project's own settings win, as Jest merges them. A preset that is a package isn't read.
+     */
+    withPreset(config, settings, rootDir) {
+        const preset = settingAt(settings, ['preset']);
+        if (preset?.kind !== 'value' || typeof preset.value !== 'string' || !isLocalPreset(preset.value))
+            return settings;
+        const target = path.resolve(rootDir, replaceRootDir(rootDir, preset.value));
+        const file = ['', '.js', '.json', '.cjs'].map((extension) => target + extension).find(isFileAt);
+        if (!file) {
+            this.configs.reportConfig(config, `The config's preset '${preset.value}' doesn't exist, so Jest fails to start.`);
+            return settings;
+        }
+        const base = this.configs.at(file).settings;
+        if (base.kind !== 'object' || settings.kind !== 'object')
+            return settings;
+        return { ...settings, keys: new Map([...base.keys, ...settings.keys]) };
+    }
     vitestProjects(config, container = null) {
         const folder = path.dirname(config.file);
         const list = settingAt(config.settings, ['test', 'projects']);
@@ -945,3 +1157,51 @@ function agreedTags(projects) {
     const text = JSON.stringify(first ?? null);
     return first && others.every((tags) => JSON.stringify(tags) === text) ? first : null;
 }
+/**
+ * Jest's `rootDir`: the config's folder, or the folder the config sets, from its folder, where an inline project's
+ * `<rootDir>` is the config's folder too; unknown when it can't tell.
+ */
+function jestRootDir(settings, folder) {
+    const setting = settingAt(settings, ['rootDir']);
+    if (setting === null || isUnset(setting))
+        return folder;
+    return setting.kind === 'value' && typeof setting.value === 'string'
+        ? path.resolve(folder, replaceRootDir(folder, setting.value))
+        : unknownAt(setting);
+}
+/** Jest's `replaceRootDirInPath`: `<rootDir>` at the start of a path stands for the project's `rootDir`. */
+function replaceRootDir(rootDir, item) {
+    return item.startsWith('<rootDir>') ? path.join(rootDir, item.slice('<rootDir>'.length)) : item;
+}
+/**
+ * Jest's `globsToMatcher`: a path matches a glob that isn't negated and no negated glob leaves it out, or, when every
+ * glob is negated, none leaves it out. Globs match the absolute path, dot files too.
+ */
+function jestGlobs(globs) {
+    const matchers = globs.map((glob) => {
+        const isMatch = picomatch(glob, { dot: true }, true);
+        return { isMatch, negated: isMatch.state.negated || Boolean(isMatch.state.negatedExtglob) };
+    });
+    return (file) => {
+        let kept;
+        for (const { isMatch, negated } of matchers) {
+            const matched = isMatch(file);
+            if (!matched && negated)
+                kept = false;
+            else if (matched && !negated)
+                kept = true;
+        }
+        return matchers.every(({ negated }) => negated) ? kept !== false : kept === true;
+    };
+}
+/** Whether a Jest setting is given: `null` and `undefined` leave Jest's default, as a `testMatch: null` beside `testRegex`. */
+function isJestSet(setting) {
+    return setting !== null && !isUnset(setting) && !(setting.kind === 'value' && setting.value === null);
+}
+/** A Jest preset written as a path, which Jest reads from the project, rather than a package's name. */
+function isLocalPreset(preset) {
+    return /^(\.{1,2}\/|\/|<rootDir>)/.test(preset);
+}
+function isFileAt(file) {
+    return existsSync(file) && statSync(file).isFile();
+}

package/dist/config.d.ts

@@ -59,7 +59,8 @@ 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;
@@ -83,8 +84,24 @@ 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 config the runner reads in a way the scan doesn't follow, or refuses. */
+    reportConfig(config: ConfigFile, message: string): void;
     /** 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

@@ -5,7 +5,7 @@ import { childNodes, isFunctionNode, propertyKey, propertyName, returnValues, un
 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 { atLeast, problem } from "./frameworks/common.js";
 import { parseFile } from "./parse.js";
 import { snippet } from "./source.js";
 import { isKey, isScopeNode, Values } from "./values.js";
@@ -14,6 +14,7 @@ import { VITEST_INCLUDE, VITEST_TYPECHECK_INCLUDE, vitestExclude } from "./vites
 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}`),
 };
 /** Methods that change the object or list they are called on. */
 const CHANGING_METHODS = new Set([
@@ -266,7 +267,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,7 +278,7 @@ 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;
         }
         for (const statement of program.body) {
             const source = starReexport(statement);
@@ -287,6 +288,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 +360,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 +415,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);
@@ -483,10 +513,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 +550,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 +567,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 +583,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,6 +639,7 @@ 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;
@@ -661,17 +708,78 @@ export class Configs {
         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 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) ? jestKey(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 +795,19 @@ export class Configs {
             const message = `The config could not be read: ${readFailure(error)}, ${none}`;
             return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
         }
+        if (file.endsWith('.json')) {
+            let value;
+            try {
+                value = JSON.parse(code);
+            }
+            catch (error) {
+                const message = `The config could not be parsed: ${error.message}, ${none}`;
+                return unreadable(fileDiagnostic('config-value-unknown', relativeFilePath, message));
+            }
+            // Jest reads a package.json without a `jest` key as an empty config.
+            const settings = path.basename(file) === 'package.json' ? jestKeyOf(value) : value;
+            return { file, record: { relativeFilePath, extends: [] }, settings: fromValue(settings ?? {}) };
+        }
         const parsed = parseFile(relativeFilePath, code);
         if (parsed.error) {
             const { message, start, end } = parsed.error;
@@ -712,3 +833,28 @@ export class Configs {
         return { file, record: { relativeFilePath, extends: config.followed }, settings };
     }
 }
+/** The `jest` key of a package.json; undefined when it has none, or can't be read. */
+function jestKey(file) {
+    try {
+        return jestKeyOf(JSON.parse(readFileSync(file, 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The `jest` key of a parsed package.json; undefined for a value Jest reads as no config, as `false` or `""` are. */
+function jestKeyOf(packageJson) {
+    const key = packageJson?.jest;
+    if (!key)
+        return undefined;
+    return key;
+}
+/** A JSON text's value; null when it isn't JSON. */
+function attemptJson(text) {
+    try {
+        return { json: JSON.parse(text) };
+    }
+    catch {
+        return null;
+    }
+}