@williamthorsen/nmr 0.36.0 → 0.37.0

package/agents/README.md

@@ -11,7 +11,7 @@ A line earns a place in it only if both hold:
 1. **It is absent from nmr's own output.** Bare `nmr` already prints the flags, every command, and the shell command each resolves to; failing checks already name their own fix. Repeating any of that costs launch tokens to say something the agent will be told anyway, at the moment it matters.
 2. **The obvious action goes wrong without it.** Guidance that prevents a silent mistake earns its place; guidance that prevents a mistake the next error message would diagnose does not.
 
-Everything else belongs in `packages/nmr/README.md`, reachable on demand at `node_modules/@williamthorsen/nmr/README.md`, with a pointer from the cheatsheet naming the topic so an agent knows to look. When adding a feature, document it there and extend that pointer rather than the cheatsheet.
+Everything else belongs in the topic document under `packages/nmr/docs/` that covers it, reachable on demand at `node_modules/@williamthorsen/nmr/docs/`, with a pointer from the cheatsheet naming the topic and its document so an agent knows where to look. When adding a feature, document it there and extend that pointer rather than the cheatsheet.
 
 ## Constraints on rulebook bodies
 

package/agents/guidance/rulebooks/nmr.md

@@ -13,5 +13,5 @@ delivery: ambient
 - A check that already passed on the current working tree skips, printing `⏭️ <scope>: <command>: passed …` and, where the recalled run left one, `— replayed: <excerpt>` of what that run concluded. Any edit, addition, or deletion re-runs it, so read the replayed excerpt rather than paying for the answer again: never pass `--no-cache` to get a "real" run, which costs the command's full runtime to reach the same answer. Its one use is a file rather than an exit status -- a skipped command writes none, so a fresh `coverage/` needs `nmr --no-cache test:coverage`. A composite replays its constituents' excerpts, each attributed as `<scope>: <command>: <excerpt>` and cut at the line's ceiling where there are too many to fit. A skip carrying no excerpt is one whose run wrote to a terminal, or one whose constituents recorded none.
 - `nmr --log <command>` prints the whole run behind that excerpt -- up to 256 KiB, led by when it was recorded, how long it ran, and the command string that produced it -- so output you need in full is a recording to read rather than a run to pay for again. It runs nothing, and it is held to the tree rather than to the terminal: a recording a piped run made prints for a reader at one. A composite prints its constituents' excerpts, so the transcript of one of them is `nmr -F <pkg> --log <command>` or that constituent's own name. Nothing to show is said on one line and exits non-zero, naming which it is.
 - Every command nmr runs reports one line -- `✅ <scope>: <command>: passed in 12.4s`, `❌ … failed in 1.2s (exit 1)`, `⏭️ … passed 4m ago on this tree`, or `⛔ … skipped, the override is empty` -- and a composite reports alongside every command it expands into. The lines print in every verbosity, so `-q` is the low-noise way to run rather than a silent one: it withholds the output of the commands nmr runs and keeps nmr's own verdicts, which is how a pass, a cached skip, and a `""`/`":"` override stay distinguishable. Expect a run to be quiet already without the flag: nmr recognizes a known agent harness in the environment and takes quiet from that, as it does from `NMR_COMMAND_VERBOSITY` or the repo's `output.commandVerbosity`. A command whose output you need in full is one to run with `NMR_COMMAND_VERBOSITY=full`, which outranks both.
-- Every test file lives under a `__tests__` directory and names its isolation tier last: `<subject>[.<aspect>].<tier>.test.ts`, where any earlier segment is free-form documentation. A tier is the furthest thing the test reaches -- `tool` (a program the environment supplies), `localhost` (a service on this machine), `remote` (a machine that isn't this one), or `unit`, the residual claiming everything else. A file outside `__tests__`, or one whose tier segment is missing or misspelt, fails the test run in a repo that declares nmr's exported conventions check, which reports both. In a repo that has not, neither fails anything -- the first is collected by nothing and the second runs under `unit` -- and `rdy run --packages` reports the misspelt tier alone.
-- The rest is in `node_modules/@williamthorsen/nmr/README.md`: pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`), script overrides and their `""`/`":"` skip values, `nmr upgrade` ceilings (report-only until `nmr upgrade --write`), the `nmr-compile` build (there is no repo-local build script), the test tiers' timeout budgets and the `tiers` seam that raises one, which script reaches which tier, and the check-result cache's key, the retention key a replayed excerpt is additionally held to, the retention ceiling `--log` prints within, its `checkCache` config, and every condition that disables it.
+- Every test file lives under a `__tests__` directory and names its isolation tier last: `<subject>[.<aspect>].<tier>.test.ts`, where any earlier segment is free-form documentation. A tier is the furthest thing the test reaches -- `tool` (a program the environment supplies), `localhost` (a service on this machine), `remote` (a machine that isn't this one), or `unit`, the residual claiming everything else. A file outside `__tests__`, or one whose tier segment is missing or misspelt, fails the test run in a repo that declares nmr's exported conventions check, which reports both. In a repo that has not, neither fails anything -- the first is collected by nothing and the second runs under `unit` -- and `rdy run --packages` reports both and warns that the check is missing.
+- The rest is in `node_modules/@williamthorsen/nmr/docs/`: `scripts.md` for pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`) and script overrides and their `""`/`":"` skip values; `upgrades.md` for `nmr upgrade` ceilings (report-only until `nmr upgrade --write`); `utilities.md` for the `nmr-compile` build (there is no repo-local build script); `vitest.md` for the test tiers' timeout budgets, the `tiers` seam that raises one, and which script reaches which tier; and `check-cache.md` for the check-result cache's key, the retention key a replayed excerpt is additionally held to, the retention ceiling `--log` prints within, its `checkCache` config, and every condition that disables it.

package/dist/esm/context.d.ts

@@ -3,6 +3,8 @@ export interface ResolvedContext {
     monorepoRoot: string;
     isRoot: boolean;
     packageDir?: string;
+    /** The workspace's package directories, resolved once here rather than swept for again by each reader. */
+    workspacePackageDirs: string[];
     config: NmrConfig;
 }
 /**

package/dist/esm/context.js

@@ -24,6 +24,7 @@ export async function resolveContext(cwd) {
         monorepoRoot,
         isRoot: packageDir === undefined,
         ...(packageDir !== undefined && { packageDir }),
+        workspacePackageDirs: workspaceDirs,
         config,
     };
 }

package/dist/esm/help.js

@@ -5,7 +5,7 @@ export function generateHelp(config, packageDir, useRoot) {
         'Usage: nmr [flags] <command> [args...]',
         '',
         'Flags:',
-        '  -F, --filter <pattern>   Run command in matching packages',
+        '  -F, --filter <pattern>   Run command in packages whose manifest name matches',
         '  -R, --recursive          Run command in all packages',
         '  -w, --workspace-root     Use root scripts, running at the monorepo root',
         "  -q, --quiet              Suppress command output, keeping nmr's verdicts",

package/dist/esm/helpers/filter-selection.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Asks pnpm what a `-F` pattern selects, so an invocation that would select nothing is caught before it
+ * delegates, and one selecting several packages is told from one selecting a single package.
+ *
+ * pnpm's own selector answers rather than a matcher of nmr's: `-F` means the whole selector language, names
+ * and globs alongside `./path`, `{dir}`, `pkg...`, `!negation`, and `[since]`, and a matcher here would leave
+ * every form but the simplest silently unchecked.
+ *
+ * Runs from the monorepo root, where the delegate runs, so a path pattern resolves against the same directory
+ * in the probe as in the run it stands in for.
+ *
+ * The listing counts the root project wherever the filter leaves it standing, while the `exec` a delegation
+ * composes runs there only where the pattern selects the root positively: `-F '!./packages/*'` lists the root
+ * and executes nowhere. A listing of the root alone is therefore the one reading the listing cannot settle,
+ * and it is put to `exec` itself. Every other listing settles on its own, and counts the packages beside the
+ * root: two of them run in two scopes, while one beside the root may run in that package alone.
+ */
+export declare function readFilterSelection(pattern: string, monorepoRoot: string): FilterSelection;
+/**
+ * Reduces a listing to what it proves about the selection.
+ *
+ * Every outcome the probe cannot read resolves to `unresolved`, which claims nothing about the selection, and the
+ * invocation delegates as it would have. A pattern pnpm rejects rather than resolves, such as a bad git ref in
+ * a changed-since selector, is pnpm's to report, and reporting it here as a match failure would name a
+ * different fault than the one the user has.
+ */
+export declare function interpretSelectionProbe(probe: SelectionProbe, monorepoRoot: string): ProbeReading;
+/**
+ * Reduces a marked delegate run to what it proves: a scope that wrote the marker is a scope the run reached. The
+ * run is made only for a listing of the root alone, so that scope is the only one.
+ */
+export declare function interpretDelegateProbe(probe: SelectionProbe): FilterSelection;
+/** What a `-F` pattern selected, as far as pnpm could be asked. `multiple` is two or more packages beside the root. */
+export type FilterSelection = 'empty' | 'multiple' | 'single' | 'unresolved';
+/** What a listing proves, `root-only` being the reading that only the delegate can settle. */
+export type ProbeReading = FilterSelection | 'root-only';
+/** The part of a probe's completion a selection is read from. */
+export interface SelectionProbe {
+    error: Error | undefined;
+    status: number | null;
+    stdout: string;
+}

package/dist/esm/helpers/filter-selection.js

@@ -0,0 +1,61 @@
+import { spawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { isObject } from "./type-guards.js";
+const SELECTION_MARKER = 'nmr-selected-scope';
+export function readFilterSelection(pattern, monorepoRoot) {
+    const listing = spawnSync('pnpm', ['ls', '--filter', pattern, '--depth', '-1', '--json'], {
+        cwd: monorepoRoot,
+        encoding: 'utf8',
+    });
+    const reading = interpretSelectionProbe({ error: listing.error, status: listing.status, stdout: listing.stdout }, monorepoRoot);
+    return reading === 'root-only' ? readDelegateSelection(pattern, monorepoRoot) : reading;
+}
+export function interpretSelectionProbe(probe, monorepoRoot) {
+    if (probe.error !== undefined || probe.status !== 0) {
+        return 'unresolved';
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(probe.stdout);
+    }
+    catch {
+        return 'unresolved';
+    }
+    if (!Array.isArray(parsed)) {
+        return 'unresolved';
+    }
+    if (parsed.length === 0) {
+        return 'empty';
+    }
+    const packageCount = parsed.filter((entry) => !isRootEntry(entry, monorepoRoot)).length;
+    if (packageCount === 0) {
+        return 'root-only';
+    }
+    return packageCount === 1 ? 'single' : 'multiple';
+}
+export function interpretDelegateProbe(probe) {
+    if (probe.error !== undefined || probe.status !== 0) {
+        return 'unresolved';
+    }
+    return probe.stdout.includes(SELECTION_MARKER) ? 'single' : 'empty';
+}
+function isRootEntry(entry, monorepoRoot) {
+    if (!isObject(entry) || typeof entry['path'] !== 'string') {
+        return false;
+    }
+    return readRealPath(entry['path']) === readRealPath(monorepoRoot);
+}
+function readRealPath(target) {
+    try {
+        return realpathSync(target);
+    }
+    catch {
+        return path.resolve(target);
+    }
+}
+function readDelegateSelection(pattern, monorepoRoot) {
+    const probe = spawnSync('pnpm', ['--filter', pattern, 'exec', process.execPath, '--eval', `process.stdout.write('${SELECTION_MARKER}')`], { cwd: monorepoRoot, encoding: 'utf8' });
+    return interpretDelegateProbe({ error: probe.error, status: probe.status, stdout: probe.stdout });
+}

package/dist/esm/runCli.js

@@ -6,6 +6,8 @@ import { resolveContext } from "./context.js";
 import { generateHelp } from "./help.js";
 import { resolveConfigPath } from "./helpers/config-path.js";
 import { deriveExcerpt } from "./helpers/deriveExcerpt.js";
+import { readFilterSelection } from "./helpers/filter-selection.js";
+import { findClosestName } from "./helpers/findClosestName.js";
 import { isHookName } from "./helpers/hook-name.js";
 import { resolvePackageJsonPath } from "./helpers/package-json.js";
 import { composeTranscript } from "./helpers/transcript.js";
@@ -18,8 +20,10 @@ import { composeNmrStep, findNmrCrossing, renderChain } from "./steps.js";
 import { UserError } from "./UserError.js";
 import { COMMAND_VERBOSITY_ENV_VAR, readVerbosityEnv, resolveVerbosity, } from "./verbosity.js";
 import { writeVerdict } from "./verdict.js";
+import { readWorkspacePackageNames } from "./workspace.js";
 const VERSION = readPackageVersion(import.meta.url);
 const CROSSING_CONSEQUENCE = "so nmr handles the nested run's output as a tool's.";
+const NAME_CEILING = 10;
 const NAMED_ESCAPES = new Map([
     ['\n', String.raw `\n`],
     ['\r', String.raw `\r`],
@@ -88,7 +92,7 @@ export async function runCli(options) {
     };
     const delegation = composeDelegation({ childEnv, command, parsed });
     if (delegation !== undefined) {
-        return runSteps([delegation.step], context.monorepoRoot, { ...runOptions, env: delegation.env });
+        return runDelegation({ context, delegation, parsed, runOptions, stderr });
     }
     const registry = useRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config);
     assertNoSelfReference({
@@ -346,6 +350,58 @@ function findArgError(parsed) {
     }
     return undefined;
 }
+function findEmptySelectionRefusal(options) {
+    const { context, parsed, selection } = options;
+    if (parsed.filter !== undefined) {
+        if (selection !== 'empty') {
+            return undefined;
+        }
+        return formatEmptyFilterError(parsed.filter, readWorkspacePackageNames(context.workspacePackageDirs));
+    }
+    return context.workspacePackageDirs.length === 0 ? formatEmptyWorkspaceError() : undefined;
+}
+function formatEmptyFilterError(pattern, names) {
+    const rejection = `-F/--filter matched no workspace: \`${pattern}\`.`;
+    if (pattern.startsWith('!')) {
+        return `${rejection} A pattern beginning with \`!\` excludes what it matches, and this one leaves no package standing.`;
+    }
+    if (pattern.includes('[')) {
+        return `${rejection} A pattern carrying \`[<ref>]\` selects the packages changed since a git ref, and none has changed.`;
+    }
+    if (pattern.startsWith('.') || pattern.startsWith('/') || pattern.startsWith('{')) {
+        return (`${rejection} ` +
+            'A pattern written `./dir`, `/dir`, or `{dir}` selects the packages under a directory, ' +
+            'and no package sits under this one.');
+    }
+    return (`${rejection} A pattern matches a package's manifest \`name\`, ` +
+        `not its directory name.${suggestWorkspaceNames(pattern, names)}`);
+}
+function formatEmptyWorkspaceError() {
+    return ('-R/--recursive matched no workspace: pnpm-workspace.yaml declares no package directory, ' +
+        'so there is no scope to fan out to.');
+}
+function suggestWorkspaceNames(pattern, names) {
+    if (names.length === 0) {
+        return '';
+    }
+    const containing = names.filter((name) => name.toLowerCase().includes(pattern.toLowerCase()));
+    if (containing.length > 0) {
+        return ` Did you mean ${renderNames(containing)}?`;
+    }
+    const closest = findClosestName(pattern, names);
+    if (closest !== undefined) {
+        return ` Did you mean \`${closest}\`?`;
+    }
+    return ` The workspace declares ${renderNames(names)}.`;
+}
+function renderNames(names) {
+    const shown = names
+        .slice(0, NAME_CEILING)
+        .map((name) => `\`${name}\``)
+        .join(', ');
+    const remainder = names.length - NAME_CEILING;
+    return remainder > 0 ? `${shown}, and ${remainder} more` : shown;
+}
 function findNoOpReason(resolvedCommand) {
     if (resolvedCommand === '') {
         return 'empty-override';
@@ -446,7 +502,7 @@ function parseArgs(args) {
         if (arg === '-F' || arg === '--filter') {
             i++;
             const filterValue = args[i];
-            if (filterValue === undefined) {
+            if (!filterValue) {
                 return { ok: false, error: '-F/--filter requires a pattern argument' };
             }
             parsed.filter = filterValue;
@@ -642,6 +698,18 @@ function resolveCacheKey(options) {
     }
     return result.key;
 }
+async function runDelegation(options) {
+    const { context, delegation, parsed, runOptions, stderr } = options;
+    const selection = parsed.filter === undefined ? undefined : readFilterSelection(parsed.filter, context.monorepoRoot);
+    const refusal = findEmptySelectionRefusal({ context, parsed, selection });
+    if (refusal !== undefined) {
+        reportError(refusal, stderr);
+        return { exitCode: 1 };
+    }
+    const shouldWithholdInput = parsed.filter === undefined || selection === 'multiple';
+    const step = shouldWithholdInput ? { ...delegation.step, shouldWithholdInput } : delegation.step;
+    return runSteps([step], context.monorepoRoot, { ...runOptions, env: delegation.env });
+}
 async function runGated(options) {
     const { anchorDir, command, commandString, env, key, monorepoRoot, snapshot, stderr, stdout } = options;
     const quiet = options.runOptions.quiet === true;

package/dist/esm/runner.js

@@ -39,16 +39,16 @@ export async function runSteps(steps, cwd, options) {
     return { exitCode: 0, ...composeRetainedOutput(parts, isCaptureWhole) };
 }
 export async function runCommand(command, cwd, options) {
-    return runSpawned({ args: [], file: command, useShell: true }, cwd, options);
+    return runSpawned({ args: [], file: command, input: 'inherit', useShell: true }, cwd, options);
 }
-async function runSpawned({ args, file, useShell }, cwd, options) {
+async function runSpawned({ args, file, input, useShell }, cwd, options) {
     const quiet = options.quiet === true;
     const stdout = options.stdout ?? process.stdout;
     const stderr = options.stderr ?? process.stderr;
     const env = options.env ?? process.env;
     const child = spawn(file, args, {
         shell: useShell,
-        stdio: ['inherit', options.channels.stdout, options.channels.stderr],
+        stdio: [input, options.channels.stdout, options.channels.stderr],
         cwd,
         env,
     });
@@ -78,13 +78,14 @@ async function runSpawned({ args, file, useShell }, cwd, options) {
 function runStep(step, cwd, options) {
     const { quiet, stderr, stdout } = options;
     if (step.kind === 'opaque') {
-        return runSpawned({ args: [], file: step.command, useShell: true }, cwd, {
+        return runSpawned({ args: [], file: step.command, input: 'inherit', useShell: true }, cwd, {
             ...options,
             channels: { stderr: resolveChannel(stderr, quiet), stdout: resolveChannel(stdout, quiet) },
         });
     }
     const [file, ...args] = step.argv;
-    return runSpawned({ args, file, useShell: false }, cwd, {
+    const input = step.shouldWithholdInput === true ? 'ignore' : 'inherit';
+    return runSpawned({ args, file, input, useShell: false }, cwd, {
         ...options,
         quiet: false,
         channels: { stderr: resolveInheritedChannel(stderr), stdout: resolveInheritedChannel(stdout) },

package/dist/esm/steps.d.ts

@@ -7,6 +7,9 @@
  * `declinesArgs` travels from the composite element that composed the step to the one reader that acts on it,
  * the binding of the invocation's trailing arguments. Every stage between the two -- the devBin substitution,
  * the chain rendering, the replay assembly, the runner -- passes it through and asks nothing of it.
+ *
+ * `shouldWithholdInput` is read by the runner alone, which gives the step's child the null device as stdin rather
+ * than nmr's own. Like `declinesArgs`, it is set only where it holds and leaves the rendered chain unchanged.
  */
 export type Step = {
     kind: 'opaque';
@@ -15,6 +18,7 @@ export type Step = {
     kind: 'structural';
     argv: readonly [string, ...(readonly string[])];
     declinesArgs?: boolean;
+    shouldWithholdInput?: boolean;
 };
 /** What a structural step asks of the nmr process it spawns. */
 export interface NmrStepTarget {

package/dist/esm/verdict.d.ts

@@ -62,7 +62,7 @@ export declare function renderVerdict(verdict: Verdict): string;
  * Held to the ceiling the prose line is held to, so one write still reaches a pipe whole where concurrent
  * scopes share a descriptor. Cuts land inside the record's text rather than across its structure, which is
  * what leaves the line parseable, and a record is fitted by rungs, each shedding what a reader can better
- * spare than the rung below it. What the ceiling costs is [documented](../README.md#reporting-for-a-machine)
+ * spare than the rung below it. What the ceiling costs is [documented](../docs/reporting.md#reporting-for-a-machine)
  * in the same order.
  */
 export declare function serializeVerdict(verdict: Verdict): string;

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

@@ -0,0 +1,37 @@
+import type { Plugin } from 'vite';
+/**
+ * Builds the plugin that resolves a package's `source` export condition, for a package whose files sit 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
+ * 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.
+ *
+ * Resolving here instead keeps the condition inside Vite, which transforms what it resolves. A package under
+ * `node_modules` resolves through its remaining conditions, whatever its `exports` map declares.
+ */
+export declare function createSourceResolutionPlugin(): Plugin;
+/** What a resolution needs beyond the specifier and its importer: the resolving environment, and the caches. */
+export interface SourceResolutionContext {
+    /** The Vite environment resolving the specifier, which decides the environment-specific condition. */
+    environmentName: string;
+    /** Parsed manifests, keyed by package directory. Absent from a caller that resolves once. */
+    manifests?: Map<string, unknown>;
+    /** Package directories, keyed by specifier and importer directory. Absent from a caller that resolves once. */
+    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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare function resolveSourceTarget(specifier: string, importer: string | undefined, context: SourceResolutionContext): string | undefined;

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

@@ -0,0 +1,205 @@
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
+import path from 'node:path';
+import { parsePackageJson } from "./helpers/package-json.js";
+import { isObject } from "./helpers/type-guards.js";
+import { UserError } from "./UserError.js";
+const SHARED_CONDITIONS = ['module', 'import', 'development', 'default'];
+const CLIENT_CONDITION = 'browser';
+const SERVER_CONDITION = 'node';
+const SOURCE_CONDITION = 'source';
+const NODE_MODULES = 'node_modules';
+const TARGET_EXTENSIONS = ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'];
+export function createSourceResolutionPlugin() {
+    const packageDirs = new Map();
+    const manifests = new Map();
+    return {
+        name: 'nmr:resolve-from-source',
+        enforce: 'pre',
+        resolveId(id, importer) {
+            return resolveSourceTarget(id, importer, { environmentName: this.environment.name, manifests, packageDirs });
+        },
+    };
+}
+export function resolveSourceTarget(specifier, importer, context) {
+    if (importer === undefined)
+        return undefined;
+    const parsed = parseSpecifier(specifier);
+    if (!parsed)
+        return undefined;
+    const packageDir = findPackageDir(parsed.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)
+        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)
+        return undefined;
+    const wildcard = matched.wildcard;
+    const declared = wildcard === undefined ? selected.target : selected.target.replaceAll('*', () => wildcard);
+    if (!declared.startsWith('./'))
+        return undefined;
+    const declaredPath = path.resolve(packageDir, declared);
+    const target = findTargetFile(declaredPath);
+    if (target === undefined) {
+        throw new UserError(formatMissingTarget(parsed.name, parsed.subpath, declared, declaredPath));
+    }
+    return `${target}${parsed.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 dir = fromDir;
+    while (found === undefined) {
+        const candidate = path.join(dir, NODE_MODULES, name);
+        if (existsSync(path.join(candidate, 'package.json'))) {
+            found = realpathSync(candidate);
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    cache?.set(key, found);
+    return found;
+}
+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 parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function findSuffixIndex(specifier) {
+    const queryIndex = specifier.indexOf('?');
+    const hashIndex = specifier.indexOf('#');
+    if (queryIndex === -1)
+        return hashIndex;
+    if (hashIndex === -1)
+        return queryIndex;
+    return Math.min(queryIndex, hashIndex);
+}
+function findTargetFile(declaredPath) {
+    if (isFile(declaredPath))
+        return declaredPath;
+    for (const extension of TARGET_EXTENSIONS) {
+        const candidate = `${declaredPath}${extension}`;
+        if (isFile(candidate))
+            return candidate;
+    }
+    for (const extension of TARGET_EXTENSIONS) {
+        const candidate = path.join(declaredPath, `index${extension}`);
+        if (isFile(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function formatMissingTarget(name, subpath, declared, target) {
+    return [
+        `Package "${name}" declares a \`source\` export for "${subpath}" at "${declared}", 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(' ');
+}
+function isFile(candidate) {
+    return statSync(candidate, { throwIfNoEntry: false })?.isFile() === true;
+}
+function isInsideNodeModules(dir) {
+    return dir.split(path.sep).includes(NODE_MODULES);
+}
+function matchSubpath(exportsValue, subpath) {
+    if (exportsValue === undefined)
+        return undefined;
+    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;
+    for (const [key, value] of Object.entries(exportsValue)) {
+        const star = key.indexOf('*');
+        if (star === -1)
+            continue;
+        const base = key.slice(0, star);
+        const suffix = key.slice(star + 1);
+        if (!subpath.startsWith(base) || !subpath.endsWith(suffix))
+            continue;
+        if (subpath.length < base.length + suffix.length)
+            continue;
+        if (best !== undefined && best.base.length >= base.length)
+            continue;
+        best = { base, value, wildcard: subpath.slice(base.length, subpath.length - suffix.length) };
+    }
+    return best && { value: best.value, wildcard: best.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))
+        return undefined;
+    const segments = bare.split('/');
+    const nameLength = bare.startsWith('@') ? 2 : 1;
+    if (segments.length < nameLength || segments.includes(''))
+        return undefined;
+    const rest = segments.slice(nameLength);
+    return {
+        name: segments.slice(0, nameLength).join('/'),
+        postfix: suffixIndex === -1 ? '' : specifier.slice(suffixIndex),
+        subpath: rest.length === 0 ? '.' : `./${rest.join('/')}`,
+    };
+}
+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;
+}
+function selectTarget(value, conditions) {
+    if (typeof value === 'string')
+        return { target: value, usedSource: false };
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const selected = selectTarget(entry, conditions);
+            if (selected)
+                return selected;
+        }
+        return undefined;
+    }
+    if (!isObject(value))
+        return undefined;
+    const source = value[SOURCE_CONDITION];
+    if (source !== undefined) {
+        const selected = selectTarget(source, conditions);
+        if (selected)
+            return { target: selected.target, usedSource: 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;
+    }
+    return undefined;
+}

package/dist/esm/vitest.d.ts

@@ -45,8 +45,9 @@ export interface VitestConfigOptions {
      */
     isolateGit?: boolean;
     /**
-     * Resolves workspace packages through their `source` export condition, so a suite runs without a prior build.
-     * Defaults to `true`. A package declaring no such condition is unaffected.
+     * 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;
     /**

package/dist/esm/vitest.js

@@ -3,13 +3,14 @@ import { fileURLToPath } from 'node:url';
 import { defaultExclude, mergeConfig } from 'vitest/config';
 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 GIT_ISOLATION_SETUP_FILE = resolveGitIsolationSetupFile();
-const SOURCE_CLIENT_CONDITIONS = ['source', 'module', 'browser', 'development|production'];
-const SOURCE_SERVER_CONDITIONS = ['source', 'module', 'node', 'development|production'];
+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.';
@@ -31,14 +32,14 @@ export function defineRootVitestConfig(...layers) {
 function buildConfig(declaredLayers, { coverageInclude, projectExclude = [], projectRoot }) {
     const layers = declaredLayers.filter((layer) => layer !== undefined);
     assertKnownTiers(layers);
-    const resolveFromSource = resolveFlag(layers, 'resolveFromSource', true);
     const resolve = {
-        ...(resolveFromSource && { conditions: SOURCE_CLIENT_CONDITIONS }),
+        conditions: CLIENT_CONDITIONS,
         ...(resolveFlag(layers, 'tsconfigPaths', false) && { tsconfigPaths: true }),
     };
     const config = {
-        ...(Object.keys(resolve).length > 0 && { resolve }),
-        ...(resolveFromSource && { ssr: { resolve: { conditions: SOURCE_SERVER_CONDITIONS } } }),
+        ...(resolveFlag(layers, 'resolveFromSource', true) && { plugins: [createSourceResolutionPlugin()] }),
+        resolve,
+        ssr: { resolve: { conditions: SERVER_CONDITIONS } },
         test: {
             coverage: {
                 enabled: false,

package/dist/esm/workspace.d.ts

@@ -20,3 +20,12 @@ export declare function getWorkspacePackageDirs(monorepoRoot: string): string[];
  * 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[];