@williamthorsen/nmr 0.37.0 → 0.39.0

package/dist/esm/verdict.js

@@ -1,46 +1,63 @@
+import { STATUS_GLYPHS } from '@williamthorsen/nmr-core';
+import { NMR_GLYPHS } from "./glyphs.js";
 import { clampToBytes, TRUNCATION_MARK } from "./helpers/clampToBytes.js";
 import { formatDuration, formatSaving } from "./helpers/duration.js";
-export const VERDICT_LINE_LIMIT = 512;
-export function renderVerdict(verdict) {
-    const { icon, phrase } = describeOutcome(verdict);
+export const VERDICT_LINE_LIMIT_BYTES = 512;
+export function renderVerdict(verdict, style) {
+    const { marker, phrase } = describeOutcome(verdict, style);
     const detail = flattenDetail(verdict.detail ?? renderReplay(verdict) ?? '');
     const detailClause = detail === '' ? '' : ` — ${detail}`;
-    return clampToBytes(`${icon} ${verdict.scope}: ${verdict.command}: ${phrase}${detailClause}`, LINE_BUDGET_BYTES);
+    return clampToBytes(`${marker} ${verdict.scope}: ${verdict.command}: ${phrase}${detailClause}`, LINE_BUDGET_BYTES);
 }
 export function serializeVerdict(verdict) {
-    const rendered = JSON.stringify(verdict);
-    return isWithinBudget(rendered) ? rendered : renderWithinBudget(verdict);
+    const renderedLine = JSON.stringify(verdict);
+    return isWithinBudget(renderedLine) ? renderedLine : renderWithinBudget(verdict);
 }
-export function writeVerdict(verdict, stream, format) {
-    const line = format === 'json' ? serializeVerdict(verdict) : renderVerdict(verdict);
+export function writeVerdict(verdict, stream, format, style) {
+    const line = format === 'json' ? serializeVerdict(verdict) : renderVerdict(verdict, style);
     stream.write(`${line}\n`);
 }
 const NEWLINE_BYTES = 1;
-const LINE_BUDGET_BYTES = VERDICT_LINE_LIMIT - NEWLINE_BYTES;
+const LINE_BUDGET_BYTES = VERDICT_LINE_LIMIT_BYTES - NEWLINE_BYTES;
 const MIN_CUT_BYTES = Buffer.byteLength(TRUNCATION_MARK);
 const REPLAY_MARKER = 'replayed:';
-function describeOutcome(verdict) {
+function describeOutcome(verdict, style) {
+    const statuses = STATUS_GLYPHS[style];
     switch (verdict.outcome) {
         case 'passed':
-            return { icon: '✅', phrase: `passed in ${formatDuration(verdict.durationMs)}` };
+            return { marker: statuses.passed.text, phrase: `passed in ${formatDuration(verdict.durationMs)}` };
         case 'failed':
             return {
-                icon: '❌',
+                marker: statuses.failed.text,
                 phrase: `failed in ${formatDuration(verdict.durationMs)} (exit ${verdict.exitCode})`,
             };
         case 'recalled': {
             const saving = formatSaving(verdict.savedMs);
             const savingClause = saving === undefined ? '' : `, ${saving}`;
-            return { icon: '⏭️', phrase: `passed ${formatDuration(verdict.ageMs)} ago on this tree${savingClause}` };
-        }
-        case 'no-op':
             return {
-                icon: '⛔',
-                phrase: `skipped, the override is ${verdict.reason === 'empty-override' ? 'empty' : 'a no-op'}`,
+                marker: statuses.skipped.text,
+                phrase: `passed ${formatDuration(verdict.ageMs)} ago on this tree${savingClause}`,
             };
+        }
+        case 'no-op':
+            return { marker: NMR_GLYPHS[style].noop.text, phrase: `skipped, ${describeNoOpReason(verdict.reason)}` };
+        default: {
+            const unhandledVerdict = verdict;
+            throw new Error(`Unhandled verdict outcome: ${JSON.stringify(unhandledVerdict)}`);
+        }
+    }
+}
+function describeNoOpReason(reason) {
+    switch (reason) {
+        case 'empty-override':
+            return 'the override is empty';
+        case 'empty-workspace':
+            return 'the workspace declares no package';
+        case 'noop-override':
+            return 'the override is a no-op';
         default: {
-            const unhandled = verdict;
-            throw new Error(`Unhandled verdict outcome: ${JSON.stringify(unhandled)}`);
+            const unhandledReason = reason;
+            throw new Error(`Unhandled no-op reason: ${String(unhandledReason)}`);
         }
     }
 }
@@ -58,14 +75,16 @@ function renderReplay(verdict) {
 function flattenDetail(detail) {
     return detail.replaceAll(/[\r\n]+/gu, ' ').trim();
 }
-function findCutTarget(sizes, longest, overrunBytes) {
-    const below = sizes.filter((size) => size < longest && size > MIN_CUT_BYTES);
-    const share = Math.ceil(overrunBytes / sizes.filter((size) => size === longest).length);
-    const target = below.length === 0 ? longest - share : Math.max(...below, longest - overrunBytes);
+function findCutTarget(sizesBytes, longestSizeBytes, overrunBytes) {
+    const smallerSizesBytes = sizesBytes.filter((size) => size < longestSizeBytes && size > MIN_CUT_BYTES);
+    const share = Math.ceil(overrunBytes / sizesBytes.filter((size) => size === longestSizeBytes).length);
+    const target = smallerSizesBytes.length === 0
+        ? longestSizeBytes - share
+        : Math.max(...smallerSizesBytes, longestSizeBytes - overrunBytes);
     return Math.max(MIN_CUT_BYTES, target);
 }
-function isWithinBudget(rendered) {
-    return Buffer.byteLength(rendered) <= LINE_BUDGET_BYTES;
+function isWithinBudget(renderedLine) {
+    return Buffer.byteLength(renderedLine) <= LINE_BUDGET_BYTES;
 }
 function readAttribution(verdict) {
     if (verdict.outcome !== 'recalled' || verdict.replay === undefined) {
@@ -78,64 +97,64 @@ function readCuttableText(verdict) {
     return [verdict.detail ?? '', ...excerpts];
 }
 function renderClamped(record) {
-    const clamped = { ...record };
-    let rendered = JSON.stringify(clamped);
-    while (!isWithinBudget(rendered)) {
+    const clampedRecord = { ...record };
+    let renderedLine = JSON.stringify(clampedRecord);
+    while (!isWithinBudget(renderedLine)) {
         const fields = ['command', 'scope'];
-        const sizes = fields.map((field) => Buffer.byteLength(typeof clamped[field] === 'string' ? clamped[field] : ''));
-        const longest = Math.max(...sizes);
-        if (longest <= MIN_CUT_BYTES) {
-            return rendered;
+        const sizesBytes = fields.map((field) => Buffer.byteLength(typeof clampedRecord[field] === 'string' ? clampedRecord[field] : ''));
+        const longestSizeBytes = Math.max(...sizesBytes);
+        if (longestSizeBytes <= MIN_CUT_BYTES) {
+            return renderedLine;
         }
-        const target = findCutTarget(sizes, longest, Buffer.byteLength(rendered) - LINE_BUDGET_BYTES);
-        const field = fields[sizes.indexOf(longest)] ?? 'command';
-        clamped[field] = clampToBytes(typeof clamped[field] === 'string' ? clamped[field] : '', target);
-        rendered = JSON.stringify(clamped);
+        const target = findCutTarget(sizesBytes, longestSizeBytes, Buffer.byteLength(renderedLine) - LINE_BUDGET_BYTES);
+        const field = fields[sizesBytes.indexOf(longestSizeBytes)] ?? 'command';
+        clampedRecord[field] = clampToBytes(typeof clampedRecord[field] === 'string' ? clampedRecord[field] : '', target);
+        renderedLine = JSON.stringify(clampedRecord);
     }
-    return rendered;
+    return renderedLine;
 }
 function renderWithinBudget(verdict) {
-    const shortened = shortenCuttableText(verdict);
-    const shortenedLine = JSON.stringify(shortened);
+    const shortenedVerdict = shortenCuttableText(verdict);
+    const shortenedLine = JSON.stringify(shortenedVerdict);
     if (isWithinBudget(shortenedLine)) {
         return shortenedLine;
     }
-    const record = { ...shortened };
+    const record = { ...shortenedVerdict };
     delete record['detail'];
-    const attribution = readAttribution(shortened);
-    for (let kept = attribution.length; kept > 0; kept--) {
-        record['replay'] = attribution.slice(0, kept);
-        const rendered = JSON.stringify(record);
-        if (isWithinBudget(rendered)) {
-            return rendered;
+    const attribution = readAttribution(shortenedVerdict);
+    for (let keptCount = attribution.length; keptCount > 0; keptCount--) {
+        record['replay'] = attribution.slice(0, keptCount);
+        const renderedLine = JSON.stringify(record);
+        if (isWithinBudget(renderedLine)) {
+            return renderedLine;
         }
     }
     delete record['replay'];
-    const bare = JSON.stringify(record);
-    return isWithinBudget(bare) ? bare : renderClamped(record);
+    const bareLine = JSON.stringify(record);
+    return isWithinBudget(bareLine) ? bareLine : renderClamped(record);
 }
 function shortenCuttableText(verdict) {
     let candidate = verdict;
-    let rendered = JSON.stringify(candidate);
-    while (!isWithinBudget(rendered)) {
-        const shortened = shortenLongestText(candidate, Buffer.byteLength(rendered) - LINE_BUDGET_BYTES);
-        if (shortened === undefined) {
+    let renderedLine = JSON.stringify(candidate);
+    while (!isWithinBudget(renderedLine)) {
+        const shortenedVerdict = shortenLongestText(candidate, Buffer.byteLength(renderedLine) - LINE_BUDGET_BYTES);
+        if (shortenedVerdict === undefined) {
             return candidate;
         }
-        candidate = shortened;
-        rendered = JSON.stringify(candidate);
+        candidate = shortenedVerdict;
+        renderedLine = JSON.stringify(candidate);
     }
     return candidate;
 }
 function shortenLongestText(verdict, overrunBytes) {
     const texts = readCuttableText(verdict);
-    const sizes = texts.map((text) => Buffer.byteLength(text));
-    const longest = Math.max(...sizes);
-    if (longest <= MIN_CUT_BYTES) {
+    const sizesBytes = texts.map((text) => Buffer.byteLength(text));
+    const longestSizeBytes = Math.max(...sizesBytes);
+    if (longestSizeBytes <= MIN_CUT_BYTES) {
         return undefined;
     }
-    const index = sizes.indexOf(longest);
-    const target = findCutTarget(sizes, longest, overrunBytes);
+    const index = sizesBytes.indexOf(longestSizeBytes);
+    const target = findCutTarget(sizesBytes, longestSizeBytes, overrunBytes);
     return writeCuttableText(verdict, index, clampToBytes(texts[index] ?? '', target));
 }
 function writeCuttableText(verdict, index, value) {

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,9 +112,9 @@ 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 reaches no 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.',
     ].join(' ');
@@ -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

@@ -43,13 +43,13 @@ export interface VitestConfigOptions {
      * 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.
      */
-    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.
      */
-    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.

package/dist/esm/vitest.js

@@ -7,14 +7,34 @@ 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 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 holding pnpm-workspace.yaml. Pass `import.meta.dirname` in the last options layer, from the root config.';
 export function defineVitestConfig(...layers) {
+    assertOptionKeys(layers, RECOGNIZED_OPTION_KEYS);
     return buildConfig(layers, { coverageInclude: PACKAGE_COVERAGE_INCLUDE });
 }
 export function defineRootVitestConfig(...layers) {
@@ -23,6 +43,7 @@ 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: [],
         projectExclude: getWorkspaceExcludePatterns(monorepoRoot),
@@ -37,7 +58,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: {
@@ -53,12 +74,12 @@ function buildConfig(declaredLayers, { coverageInclude, projectExclude = [], pro
             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) {
     const projectTiers = [
@@ -67,12 +88,12 @@ function buildProjects(layers, extraExclude, projectRoot) {
             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 shouldIsolateGit = resolveFlag(layers, 'shouldIsolateGit', true);
+    return projectTiers.map(({ exclude, include, name, timeoutMs }) => {
         const project = {
             extends: true,
             ...(projectRoot !== undefined && { root: projectRoot }),
@@ -80,51 +101,79 @@ 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 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) {
-    const declared = layers.flatMap((layer) => layer.testCollectionExclude ?? []);
-    const globs = [...TEST_COLLECTION_EXCLUDE, ...declared].map((dir) => `**/${dir}/**`);
+    const declaredDirs = layers.flatMap((layer) => layer.testCollectionExclude ?? []);
+    const globs = [...TEST_COLLECTION_EXCLUDE, ...declaredDirs].map((dir) => `**/${dir}/**`);
     return [...new Set([...defaultExclude, ...globs])];
 }
+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,5 +1,5 @@
-/** 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.
@@ -13,19 +13,3 @@ export declare function findMonorepoRoot(startDir?: string): string;
  * `monorepoRoot` holds no manifest at all — the caller named a directory that is not a monorepo root.
  */
 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[];