@williamthorsen/nmr 0.38.0 → 0.40.0

package/dist/esm/vitest-source-resolution.d.ts

@@ -1,10 +1,10 @@
 import type { Plugin } from 'vite';
 /**
- * Builds the plugin that resolves a package's `source` export condition, for a package whose files sit outside
+ * Builds the plugin that resolves a package's `source` export condition, for a package whose files are outside
  * every `node_modules`.
  *
  * The condition cannot be emitted as a `resolve.conditions` entry instead: Vitest turns the server environment's
- * conditions into `--conditions` flags on the worker process, where Node applies them to every package it
+ * conditions into `--conditions` flags on the worker process, where Node applies them to every package that it
  * resolves natively. Node refuses to strip types from a file under `node_modules`, so a dependency declaring a
  * TypeScript `source` entry fails to load as soon as the condition reaches that far.
  *
@@ -22,16 +22,16 @@ export interface SourceResolutionContext {
     packageDirs?: Map<string, string | undefined>;
 }
 /**
- * Resolves a bare specifier to the file that its package's `source` condition names, or nothing where the condition
- * does not reach it.
+ * Resolves a bare specifier to the file that its package's `source` condition names, or to nothing when the
+ * condition does not reach it.
  *
- * Answers a bare specifier naming a package whose real directory sits outside every `node_modules`. Every other
- * specifier returns nothing -- such as a relative or absolute path, a virtual module, a builtin, or a package under
- * `node_modules` -- so Vite resolves the specifier through its own conditions. Throws where the condition reaches no
- * file, because falling through to the build output is the staleness that resolving from source exists to prevent,
- * and nothing in a run reports it.
+ * Answers a bare specifier naming a package whose real directory is outside every `node_modules`. Returns nothing
+ * for every other specifier -- such as a relative or absolute path, a virtual module, a builtin, or a package under
+ * `node_modules` -- so Vite resolves the specifier through its own conditions. Throws when the condition does not
+ * reach any file, because falling through to the build output is the staleness that resolving from source exists
+ * to prevent, and nothing in a run reports it.
  *
- * A query or hash suffix is split off before the `exports` lookup and re-appended to the resolved path, as Vite
- * does, so `pkg/icon.svg?raw` matches the `./icon.svg` entry and still reaches the plugin that reads the suffix.
+ * Because a query or hash suffix is split off before the `exports` lookup and re-appended to the resolved path, as
+ * Vite does, `pkg/icon.svg?raw` matches the `./icon.svg` entry and still reaches the plugin that reads the suffix.
  */
 export declare function resolveSourceTarget(specifier: string, importer: string | undefined, context: SourceResolutionContext): string | undefined;

package/dist/esm/vitest-source-resolution.js

@@ -24,44 +24,44 @@ export function createSourceResolutionPlugin() {
 export function resolveSourceTarget(specifier, importer, context) {
     if (importer === undefined)
         return undefined;
-    const parsed = parseSpecifier(specifier);
-    if (!parsed)
+    const parsedSpecifier = parseSpecifier(specifier);
+    if (!parsedSpecifier)
         return undefined;
-    const packageDir = findPackageDir(parsed.name, path.dirname(importer), context.packageDirs);
+    const packageDir = findPackageDir(parsedSpecifier.name, path.dirname(importer), context.packageDirs);
     if (packageDir === undefined || isInsideNodeModules(packageDir))
         return undefined;
     const manifest = readManifest(packageDir, context.manifests);
     if (!isObject(manifest))
         return undefined;
-    const matched = matchSubpath(manifest['exports'], parsed.subpath);
-    if (!matched)
+    const matchedSubpath = matchSubpath(manifest['exports'], parsedSpecifier.subpath);
+    if (!matchedSubpath)
         return undefined;
     const environmentCondition = context.environmentName === 'client' ? CLIENT_CONDITION : SERVER_CONDITION;
     const conditions = new Set([environmentCondition, ...SHARED_CONDITIONS]);
-    const selected = selectTarget(matched.value, conditions);
-    if (!selected?.usedSource)
+    const selectedTarget = selectTarget(matchedSubpath.value, conditions);
+    if (!selectedTarget?.didUseSource)
         return undefined;
-    const wildcard = matched.wildcard;
-    const declared = wildcard === undefined ? selected.target : selected.target.replaceAll('*', () => wildcard);
-    if (!declared.startsWith('./'))
+    const wildcard = matchedSubpath.wildcard;
+    const declaredTarget = wildcard === undefined ? selectedTarget.target : selectedTarget.target.replaceAll('*', () => wildcard);
+    if (!declaredTarget.startsWith('./'))
         return undefined;
-    const declaredPath = path.resolve(packageDir, declared);
+    const declaredPath = path.resolve(packageDir, declaredTarget);
     const target = findTargetFile(declaredPath);
     if (target === undefined) {
-        throw new UserError(formatMissingTarget(parsed.name, parsed.subpath, declared, declaredPath));
+        throw new UserError(formatMissingTarget(parsedSpecifier.name, parsedSpecifier.subpath, declaredTarget, declaredPath));
     }
-    return `${target}${parsed.postfix}`;
+    return `${target}${parsedSpecifier.postfix}`;
 }
 function findPackageDir(name, fromDir, cache) {
     const key = `${fromDir}\0${name}`;
     if (cache?.has(key))
         return cache.get(key);
-    let found = findSelfReferenceDir(name, fromDir);
+    let foundDir = findSelfReferenceDir(name, fromDir);
     let dir = fromDir;
-    while (found === undefined) {
+    while (foundDir === undefined) {
         const candidate = path.join(dir, NODE_MODULES, name);
         if (existsSync(path.join(candidate, 'package.json'))) {
-            found = realpathSync(candidate);
+            foundDir = realpathSync(candidate);
             break;
         }
         const parent = path.dirname(dir);
@@ -69,16 +69,18 @@ function findPackageDir(name, fromDir, cache) {
             break;
         dir = parent;
     }
-    cache?.set(key, found);
-    return found;
+    cache?.set(key, foundDir);
+    return foundDir;
 }
 function findSelfReferenceDir(name, fromDir) {
     let dir = fromDir;
     for (;;) {
         const file = path.join(dir, 'package.json');
         if (existsSync(file)) {
-            const parsed = parsePackageJson(readFileSync(file, 'utf8'), file);
-            return isObject(parsed) && parsed['name'] === name && parsed['exports'] !== undefined ? dir : undefined;
+            const parsedManifest = parsePackageJson(readFileSync(file, 'utf8'), file);
+            return isObject(parsedManifest) && parsedManifest['name'] === name && parsedManifest['exports'] !== undefined
+                ? dir
+                : undefined;
         }
         const parent = path.dirname(dir);
         if (parent === dir)
@@ -110,11 +112,11 @@ function findTargetFile(declaredPath) {
     }
     return undefined;
 }
-function formatMissingTarget(name, subpath, declared, target) {
+function formatMissingTarget(name, subpath, declaredTarget, target) {
     return [
-        `Package "${name}" declares a \`source\` export for "${subpath}" at "${declared}", which reaches no file.`,
+        `Package "${name}" declares a \`source\` export for "${subpath}" at "${declaredTarget}", which does not reach any file.`,
         `Looked for ${target}, the same path under each of ${TARGET_EXTENSIONS.join(', ')}, and an index under it.`,
-        'Point the condition at a file that exists, or remove it so the package resolves through its other conditions.',
+        'Point the condition at a file that exists, or remove it so that the package resolves through its other conditions.',
     ].join(' ');
 }
 function isFile(candidate) {
@@ -129,10 +131,10 @@ function matchSubpath(exportsValue, subpath) {
     if (!isObject(exportsValue) || Object.keys(exportsValue).every((key) => !key.startsWith('.'))) {
         return subpath === '.' ? { value: exportsValue } : undefined;
     }
-    const exact = exportsValue[subpath];
-    if (exact !== undefined)
-        return { value: exact };
-    let best;
+    const exactValue = exportsValue[subpath];
+    if (exactValue !== undefined)
+        return { value: exactValue };
+    let bestMatch;
     for (const [key, value] of Object.entries(exportsValue)) {
         const star = key.indexOf('*');
         if (star === -1)
@@ -143,21 +145,21 @@ function matchSubpath(exportsValue, subpath) {
             continue;
         if (subpath.length < base.length + suffix.length)
             continue;
-        if (best !== undefined && best.base.length >= base.length)
+        if (bestMatch !== undefined && bestMatch.base.length >= base.length)
             continue;
-        best = { base, value, wildcard: subpath.slice(base.length, subpath.length - suffix.length) };
+        bestMatch = { base, value, wildcard: subpath.slice(base.length, subpath.length - suffix.length) };
     }
-    return best && { value: best.value, wildcard: best.wildcard };
+    return bestMatch && { value: bestMatch.value, wildcard: bestMatch.wildcard };
 }
 function parseSpecifier(specifier) {
     if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('\0'))
         return undefined;
     const suffixIndex = findSuffixIndex(specifier);
-    const bare = suffixIndex === -1 ? specifier : specifier.slice(0, suffixIndex);
-    if (bare.includes(':') || isBuiltin(bare))
+    const bareSpecifier = suffixIndex === -1 ? specifier : specifier.slice(0, suffixIndex);
+    if (bareSpecifier.includes(':') || isBuiltin(bareSpecifier))
         return undefined;
-    const segments = bare.split('/');
-    const nameLength = bare.startsWith('@') ? 2 : 1;
+    const segments = bareSpecifier.split('/');
+    const nameLength = bareSpecifier.startsWith('@') ? 2 : 1;
     if (segments.length < nameLength || segments.includes(''))
         return undefined;
     const rest = segments.slice(nameLength);
@@ -171,18 +173,18 @@ function readManifest(packageDir, cache) {
     if (cache?.has(packageDir))
         return cache.get(packageDir);
     const file = path.join(packageDir, 'package.json');
-    const parsed = parsePackageJson(readFileSync(file, 'utf8'), file);
-    cache?.set(packageDir, parsed);
-    return parsed;
+    const parsedManifest = parsePackageJson(readFileSync(file, 'utf8'), file);
+    cache?.set(packageDir, parsedManifest);
+    return parsedManifest;
 }
 function selectTarget(value, conditions) {
     if (typeof value === 'string')
-        return { target: value, usedSource: false };
+        return { target: value, didUseSource: false };
     if (Array.isArray(value)) {
         for (const entry of value) {
-            const selected = selectTarget(entry, conditions);
-            if (selected)
-                return selected;
+            const selectedTarget = selectTarget(entry, conditions);
+            if (selectedTarget)
+                return selectedTarget;
         }
         return undefined;
     }
@@ -190,16 +192,16 @@ function selectTarget(value, conditions) {
         return undefined;
     const source = value[SOURCE_CONDITION];
     if (source !== undefined) {
-        const selected = selectTarget(source, conditions);
-        if (selected)
-            return { target: selected.target, usedSource: true };
+        const selectedTarget = selectTarget(source, conditions);
+        if (selectedTarget)
+            return { target: selectedTarget.target, didUseSource: true };
     }
     for (const [key, entry] of Object.entries(value)) {
         if (key === SOURCE_CONDITION || !conditions.has(key))
             continue;
-        const selected = selectTarget(entry, conditions);
-        if (selected)
-            return selected;
+        const selectedTarget = selectTarget(entry, conditions);
+        if (selectedTarget)
+            return selectedTarget;
     }
     return undefined;
 }

package/dist/esm/vitest.d.ts

@@ -3,8 +3,8 @@ import type { InlineConfig, ProjectConfig } from 'vitest/node';
 import { type TierName } from './tiers.js';
 export type { TierName } from './tiers.js';
 /**
- * Test options Vitest honours only at the root of a `projects` config. Derived from Vitest's own types rather than
- * hand-listed, so an option that changes scope in a later release changes scope here too.
+ * Test options that Vitest honours only at the root of a `projects` config. Derived from Vitest's own types, so an
+ * option that changes scope in a later release changes scope here too.
  */
 export type RootTestOptions = Omit<InlineConfig, keyof ProjectConfig>;
 /** Root-scoped overrides: Vite-level options plus the test options that survive at the root. */
@@ -16,7 +16,7 @@ export interface VitestConfigOptions {
      * Merged into the root config, which every project inherits because each declares `extends: true`.
      *
      * `resolve` is per-environment. Vitest resolves a test's own imports through the server environment, so a
-     * condition meant for them goes under `ssr`; a top-level `resolve.conditions` entry reaches the client
+     * condition meant for them goes under `ssr`; a top-level `resolve.conditions` entry applies to the client
      * environment, which only browser-mode tests resolve through.
      */
     root?: RootOverrides;
@@ -29,41 +29,42 @@ export interface VitestConfigOptions {
      */
     tiers?: Partial<Record<TierName, ProjectConfig>>;
     /**
-     * Directory basenames kept out of every project's collection, additive to the ones the shared config always
-     * prunes. Each name is matched at any depth, and every layer's entries are concatenated rather than the last
-     * winning, matching the config's rule for arrays.
+     * Directory basenames kept out of every project's collection, additive to the ones that the shared config always
+     * prunes and to the paths that git ignores. Each name is matched at any depth, and every layer's entries are
+     * concatenated rather than the last winning, matching the config's rule for arrays.
      *
      * The same array declares the scope of nmr's exported test-file conventions check, so the sweep and the
      * collection glob cannot drift. Excluding a directory from the sweep alone leaves a test file that runs and
-     * reports nothing; excluding it from collection alone leaves a report a consumer cannot act on. A repo wanting
+     * reports nothing; excluding it from collection alone leaves a report that a consumer cannot act on. A repo wanting
      * a glob rather than a directory name has the `project` seam's own `exclude`.
      */
     testCollectionExclude?: readonly string[];
     /**
-     * Loads nmr's git-isolation setup file into every project, ahead of any the layers supply. Defaults to `true`.
-     * Turn it off only where a suite is meant to read the developer's own git configuration.
+     * Loads nmr's git-isolation setup file into every project, ahead of any that the layers supply. Defaults to `true`.
+     * Turn it off only when a suite is meant to read the developer's own git configuration.
      */
-    isolateGit?: boolean;
+    shouldIsolateGit?: boolean;
     /**
-     * Resolves a package whose files sit outside every `node_modules` through its `source` export condition, so a
-     * suite runs without a prior build. Defaults to `true`. A package declaring no such condition is unaffected,
-     * and so is every package under `node_modules`, which Node resolves and which the condition never reaches.
+     * Resolves a package whose files are outside every `node_modules` through its `source` export condition, so a
+     * suite runs without a prior build. Defaults to `true`. A package that does not declare a `source` condition is
+     * unaffected, and so is every package under `node_modules`, which Node resolves and to which the condition never
+     * applies.
      */
-    resolveFromSource?: boolean;
+    shouldResolveFromSource?: boolean;
     /**
-     * Resolves a specifier through the `paths` a `tsconfig.json` declares, so a test reaches an alias the way `tsc`
-     * does. Defaults to `false`, matching Vite, and requires Vite 8.
+     * Resolves a test's aliased specifier through the `paths` that a `tsconfig.json` declares, the way `tsc` does.
+     * Defaults to `false`, matching Vite, and requires Vite 8.
      *
-     * Not a default, because both directions are safe to leave to the consumer: omitting it fails loudly with an
-     * unresolved import, while turning it on for a repo that declares `paths` for `tsc` alone changes which module a
-     * specifier reaches with nothing in the run reporting it. A repo declaring no `paths` is unaffected either way.
+     * Without it, an alias fails loudly as an unresolved import. With it, a repo that declares `paths` for `tsc` alone
+     * changes which module a specifier reaches, and nothing in the run reports the change. A repo that does not declare
+     * `paths` is unaffected either way.
      */
     tsconfigPaths?: boolean;
 }
 export interface RootVitestConfigOptions extends VitestConfigOptions {
     /**
-     * An absolute path to the monorepo root, which must hold `pnpm-workspace.yaml`. A root config sits at that
-     * directory by construction, so this is `import.meta.dirname`. Stated rather than searched for: resolving it
+     * An absolute path to the monorepo root, which must contain `pnpm-workspace.yaml`. A root config is in that
+     * directory by construction, so this is `import.meta.dirname`. Stated rather than searched for: Resolving it
      * from the working directory would make the config describe whichever monorepo the run happened to start in.
      */
     monorepoRoot: string;
@@ -75,18 +76,18 @@ type RootConfigLayers = [...(VitestConfigOptions | undefined)[], RootVitestConfi
  * projects. Select them at run time with `--project`, which unions when repeated and accepts negation.
  *
  * Layers fold left to right, later winning and arrays composing, so a config file shares settings by passing a
- * layer ahead of its own. Merging two of this function's *outputs* is not the way: both declare the same four
+ * layer ahead of its own. Merging two of this function's *outputs* is not the way: Both declare the same four
  * project names, which Vitest rejects at startup.
  *
- * An `undefined` layer is skipped, so `defineVitestConfig(shared, isCI ? ciLayer : undefined)` composes.
+ * An `undefined` layer is skipped, which lets `defineVitestConfig(shared, isCI ? ciLayer : undefined)` compose.
  */
 export declare function defineVitestConfig(...layers: (VitestConfigOptions | undefined)[]): ViteUserConfig;
 /**
  * Builds the shared Vitest config for repo-root tests. Excludes every workspace package from all projects, and
- * reports no coverage of its own — packages cover their own sources.
+ * does not report any coverage of its own; packages cover their own sources.
  *
- * `monorepoRoot` rides on the last layer, which is the config file's own: a shared layer describes settings, not
+ * `monorepoRoot` is set on the last layer, which is the config file's own: A shared layer describes settings, not
  * which repo they belong to, and only the root config's `import.meta.dirname` states this one. The guard below
- * still catches the JavaScript config that types never reach.
+ * still catches the JavaScript config that type checking never covers.
  */
 export declare function defineRootVitestConfig(...layers: RootConfigLayers): ViteUserConfig;

package/dist/esm/vitest.js

@@ -1,21 +1,43 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { defaultExclude, mergeConfig } from 'vitest/config';
+import { listGitIgnoredPaths } from "./git-ignored-paths.js";
 import { isObject } from "./helpers/type-guards.js";
 import { ALL_TEST_PATTERNS, buildTierPatterns, TEST_COLLECTION_EXCLUDE, TIER_NAMES } from "./tiers.js";
 import { createSourceResolutionPlugin } from "./vitest-source-resolution.js";
 import { getWorkspacePackageDirs } from "./workspace.js";
 const [RESIDUAL_TIER, ...NAMED_TIERS] = TIER_NAMES;
 const TIERED_PATTERNS = NAMED_TIERS.flatMap(buildTierPatterns);
-const TIER_TIMEOUT = 30_000;
+const TIER_TIMEOUT_MS = 30_000;
 const GIT_ISOLATION_SETUP_FILE = resolveGitIsolationSetupFile();
 const CLIENT_CONDITIONS = ['module', 'browser', 'development|production'];
 const SERVER_CONDITIONS = ['module', 'node', 'development|production'];
 const COVERAGE_EXCLUDE = ['**/__{fixtures,mocks,tests}__/**', '**/index.ts', '**/*.d.ts'];
 const PACKAGE_COVERAGE_INCLUDE = ['**/src/**/*.{ts,tsx}'];
-const MISSING_MONOREPO_ROOT = 'defineRootVitestConfig requires `monorepoRoot`, an absolute path to the directory holding pnpm-workspace.yaml. Pass `import.meta.dirname` in the last options layer, from the root config.';
+const GLOB_SYNTAX_PATTERN = /[!()*+?@[\]{}]/g;
+const RECOGNIZED_OPTIONS = {
+    project: true,
+    root: true,
+    shouldIsolateGit: true,
+    shouldResolveFromSource: true,
+    testCollectionExclude: true,
+    tiers: true,
+    tsconfigPaths: true,
+};
+const RECOGNIZED_ROOT_OPTIONS = {
+    ...RECOGNIZED_OPTIONS,
+    monorepoRoot: true,
+};
+const RECOGNIZED_OPTION_KEYS = Object.keys(RECOGNIZED_OPTIONS);
+const RECOGNIZED_ROOT_OPTION_KEYS = Object.keys(RECOGNIZED_ROOT_OPTIONS);
+const RETIRED_OPTION_KEYS = new Map([
+    ['isolateGit', 'shouldIsolateGit'],
+    ['resolveFromSource', 'shouldResolveFromSource'],
+]);
+const MISSING_MONOREPO_ROOT = 'defineRootVitestConfig requires `monorepoRoot`, an absolute path to the directory that contains pnpm-workspace.yaml. Pass `import.meta.dirname` in the last options layer, from the root config.';
 export function defineVitestConfig(...layers) {
-    return buildConfig(layers, { coverageInclude: PACKAGE_COVERAGE_INCLUDE });
+    assertOptionKeys(layers, RECOGNIZED_OPTION_KEYS);
+    return buildConfig(layers, { coverageInclude: PACKAGE_COVERAGE_INCLUDE, ignoredPathsRoot: process.cwd() });
 }
 export function defineRootVitestConfig(...layers) {
     const lastLayer = layers.at(-1);
@@ -23,13 +45,15 @@ export function defineRootVitestConfig(...layers) {
     if (typeof monorepoRoot !== 'string' || !path.isAbsolute(monorepoRoot)) {
         throw new TypeError(MISSING_MONOREPO_ROOT);
     }
+    assertOptionKeys(layers, RECOGNIZED_ROOT_OPTION_KEYS);
     return buildConfig(layers, {
         coverageInclude: [],
+        ignoredPathsRoot: monorepoRoot,
         projectExclude: getWorkspaceExcludePatterns(monorepoRoot),
         projectRoot: monorepoRoot,
     });
 }
-function buildConfig(declaredLayers, { coverageInclude, projectExclude = [], projectRoot }) {
+function buildConfig(declaredLayers, { coverageInclude, ignoredPathsRoot, projectExclude = [], projectRoot }) {
     const layers = declaredLayers.filter((layer) => layer !== undefined);
     assertKnownTiers(layers);
     const resolve = {
@@ -37,7 +61,7 @@ function buildConfig(declaredLayers, { coverageInclude, projectExclude = [], pro
         ...(resolveFlag(layers, 'tsconfigPaths', false) && { tsconfigPaths: true }),
     };
     const config = {
-        ...(resolveFlag(layers, 'resolveFromSource', true) && { plugins: [createSourceResolutionPlugin()] }),
+        ...(resolveFlag(layers, 'shouldResolveFromSource', true) && { plugins: [createSourceResolutionPlugin()] }),
         resolve,
         ssr: { resolve: { conditions: SERVER_CONDITIONS } },
         test: {
@@ -48,31 +72,31 @@ function buildConfig(declaredLayers, { coverageInclude, projectExclude = [], pro
                 provider: 'v8',
             },
             passWithNoTests: true,
-            projects: buildProjects(layers, projectExclude, projectRoot),
+            projects: buildProjects(layers, projectExclude, projectRoot, ignoredPathsRoot),
             silent: 'passed-only',
             watch: false,
         },
     };
-    let merged = config;
+    let mergedConfig = config;
     for (const { root } of layers) {
         if (root)
-            merged = mergeConfig(merged, root);
+            mergedConfig = mergeConfig(mergedConfig, root);
     }
-    return merged;
+    return mergedConfig;
 }
-function buildProjects(layers, extraExclude, projectRoot) {
+function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
     const projectTiers = [
         { exclude: TIERED_PATTERNS, include: ALL_TEST_PATTERNS, name: RESIDUAL_TIER },
         ...NAMED_TIERS.map((tier) => ({
             exclude: [],
             include: buildTierPatterns(tier),
             name: tier,
-            timeout: TIER_TIMEOUT,
+            timeoutMs: TIER_TIMEOUT_MS,
         })),
     ];
-    const collectionExclude = buildCollectionExclude(layers);
-    const isolateGit = resolveFlag(layers, 'isolateGit', true);
-    return projectTiers.map(({ exclude, include, name, timeout }) => {
+    const collectionExclude = buildCollectionExclude(layers, ignoredPathsRoot);
+    const shouldIsolateGit = resolveFlag(layers, 'shouldIsolateGit', true);
+    return projectTiers.map(({ exclude, include, name, timeoutMs }) => {
         const project = {
             extends: true,
             ...(projectRoot !== undefined && { root: projectRoot }),
@@ -80,51 +104,84 @@ function buildProjects(layers, extraExclude, projectRoot) {
                 exclude: [...collectionExclude, ...exclude, ...extraExclude],
                 include,
                 name,
-                ...(isolateGit && { setupFiles: [GIT_ISOLATION_SETUP_FILE] }),
-                ...(timeout !== undefined && { hookTimeout: timeout, testTimeout: timeout }),
+                ...(shouldIsolateGit && { setupFiles: [GIT_ISOLATION_SETUP_FILE] }),
+                ...(timeoutMs !== undefined && { hookTimeout: timeoutMs, testTimeout: timeoutMs }),
             },
         };
-        let merged = project;
+        let mergedProject = project;
         for (const layer of layers) {
-            merged = applyLayer(merged, layer, name);
+            mergedProject = applyLayer(mergedProject, layer, name);
         }
-        return merged;
+        return mergedProject;
     });
 }
 function applyLayer(project, layer, tier) {
     const withProject = layer.project ? mergeConfig(project, { test: layer.project }) : project;
-    const targeted = layer.tiers?.[tier];
-    return targeted ? mergeConfig(withProject, { test: targeted }) : withProject;
+    const targetedOverrides = layer.tiers?.[tier];
+    return targetedOverrides ? mergeConfig(withProject, { test: targetedOverrides }) : withProject;
 }
 function assertKnownTiers(layers) {
-    const known = TIER_NAMES;
+    const knownTiers = TIER_NAMES;
     for (const { tiers } of layers) {
         const declaredTiers = Object.keys(tiers ?? {});
         for (const name of declaredTiers) {
-            if (!known.includes(name)) {
+            if (!knownTiers.includes(name)) {
                 throw new TypeError(`Unknown tier "${name}" in \`tiers\`. Valid tiers: ${TIER_NAMES.join(', ')}.`);
             }
         }
     }
 }
-function buildCollectionExclude(layers) {
-    const declared = layers.flatMap((layer) => layer.testCollectionExclude ?? []);
-    const globs = [...TEST_COLLECTION_EXCLUDE, ...declared].map((dir) => `**/${dir}/**`);
-    return [...new Set([...defaultExclude, ...globs])];
+function assertNoRetiredOptions(layer) {
+    for (const key of Object.keys(layer)) {
+        const replacement = RETIRED_OPTION_KEYS.get(key);
+        if (replacement !== undefined) {
+            throw new TypeError(`Invalid Vitest config: \`${key}\` was renamed to \`${replacement}\`.`);
+        }
+    }
+}
+function assertOptionKeys(layers, lastLayerKeys) {
+    const lastIndex = layers.length - 1;
+    layers.forEach((layer, index) => {
+        if (layer === undefined)
+            return;
+        assertNoRetiredOptions(layer);
+        const recognizedKeys = index === lastIndex ? lastLayerKeys : RECOGNIZED_OPTION_KEYS;
+        const unrecognizedKeys = Object.keys(layer).filter((key) => !recognizedKeys.includes(key));
+        if (unrecognizedKeys.length === 0)
+            return;
+        throw new TypeError(`Invalid Vitest config: unrecognized ${unrecognizedKeys.length === 1 ? 'option' : 'options'} ` +
+            `${formatOptionKeys(unrecognizedKeys)}. Recognized: ${formatOptionKeys(recognizedKeys)}.`);
+    });
+}
+function buildCollectionExclude(layers, ignoredPathsRoot) {
+    const declaredDirs = layers.flatMap((layer) => layer.testCollectionExclude ?? []);
+    const globs = [...TEST_COLLECTION_EXCLUDE, ...declaredDirs].map((dir) => `**/${dir}/**`);
+    const ignoredGlobs = listGitIgnoredPaths(ignoredPathsRoot).map(buildIgnoredPathGlob);
+    return [...new Set([...defaultExclude, ...globs, ...ignoredGlobs])];
+}
+function buildIgnoredPathGlob(ignoredPath) {
+    const escapedPath = ignoredPath.replaceAll(GLOB_SYNTAX_PATTERN, String.raw `\$&`);
+    return escapedPath.endsWith('/') ? `${escapedPath}**` : escapedPath;
+}
+function formatOptionKeys(keys) {
+    return keys
+        .toSorted()
+        .map((key) => `\`${key}\``)
+        .join(', ');
 }
 function getWorkspaceExcludePatterns(monorepoRoot) {
     return getWorkspacePackageDirs(monorepoRoot)
         .map((dir) => `${path.relative(monorepoRoot, dir).split(path.sep).join('/')}/**`)
         .toSorted();
 }
-function resolveFlag(layers, name, fallback) {
-    let resolved = fallback;
+function resolveFlag(layers, name, isOnByDefault) {
+    let resolvedFlag = isOnByDefault;
     for (const layer of layers) {
-        const declared = layer[name];
-        if (declared !== undefined)
-            resolved = declared;
+        const declaredFlag = layer[name];
+        if (declaredFlag !== undefined)
+            resolvedFlag = declaredFlag;
     }
-    return resolved;
+    return resolvedFlag;
 }
 function resolveGitIsolationSetupFile() {
     const thisFile = fileURLToPath(import.meta.url);

package/dist/esm/workspace.d.ts

@@ -1,31 +1,15 @@
-/** Reports whether a directory is the monorepo root, which the workspace manifest's presence marks. */
-export declare function isMonorepoRoot(dir: string): boolean;
+export type { EmptyWorkspaceCause, WorkspaceResolution } from '@williamthorsen/nmr-core/workspace';
+export { isMonorepoRoot, readWorkspaceOverrides, readWorkspacePackageNames, resolveWorkspace, } from '@williamthorsen/nmr-core/workspace';
 /**
  * Finds the monorepo root by walking up from `startDir` to find `pnpm-workspace.yaml`.
- * Throws if no workspace root is found.
+ * Throws if it does not find a workspace root in `startDir` or any of its parent directories.
  */
 export declare function findMonorepoRoot(startDir?: string): string;
 /**
  * Reads the workspace patterns from `pnpm-workspace.yaml` and resolves them to absolute package
- * directories, applying pnpm's pattern semantics — including `!`-prefixed exclusions.
+ * directories, applying pnpm's pattern semantics, including `!`-prefixed exclusions.
  *
- * Returns an empty array when the manifest declares no usable `packages` list, and throws when
- * `monorepoRoot` holds no manifest at all — the caller named a directory that is not a monorepo root.
+ * Returns an empty array when the manifest does not declare a usable `packages` list, and throws when
+ * `monorepoRoot` does not contain a manifest at all.
  */
 export declare function getWorkspacePackageDirs(monorepoRoot: string): string[];
-/**
- * Reads the `overrides` block from the monorepo root's `pnpm-workspace.yaml`, the site pnpm reads an override
- * from.
- *
- * Returns nothing when the manifest or the block is missing, and drops an entry whose value is not a string.
- */
-export declare function readWorkspaceOverrides(monorepoRoot: string): Record<string, string> | undefined;
-/**
- * Reads the manifest `name` each of the given package directories declares, which is what a `-F` pattern
- * matches.
- *
- * A directory whose manifest is missing, unparseable, or nameless contributes nothing. The sweep runs for a
- * diagnostic's sake, so one malformed manifest elsewhere in the workspace must not replace the diagnostic the
- * reader asked for with a failure of its own.
- */
-export declare function readWorkspacePackageNames(packageDirs: readonly string[]): string[];