@williamthorsen/nmr 0.36.0 → 0.38.0

package/dist/esm/runCli.js

@@ -1,14 +1,18 @@
 import path from 'node:path';
-import { readPackageVersion, reportError } from '@williamthorsen/nmr-core';
+import { describeInvalidOutputStyle, formatGlyphLine, readPackageVersion, reportError, STATUS_GLYPHS, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { certifyRetention, computeCacheKey, computeRetentionKey, CURRENT_RUNTIME, encodeTreeSnapshot, findStaleBuildOutput, formatMisplacedNoCacheWarning, isCacheableCommand, NO_CACHE_ENV_VAR, readBuildOutputState, readCheckCacheEntry, recordTranscript, resolveRunId, resolveTreeSnapshot, RUN_ID_ENV_VAR, TREE_SNAPSHOT_ENV_VAR, writeCheckCacheEntry, writeDebugNote, } from "./check-cache.js";
 import { resolveContext } from "./context.js";
+import { NMR_GLYPHS } from "./glyphs.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";
+import { isTerminalStream, OUTPUT_STYLE_ENV_VAR, OUTPUT_STYLE_FLAG, resolveOutputStyles } from "./output-style.js";
 import { renderRecording, renderRefusal, resolveRecording } from "./recording.js";
 import { assembleReplay } from "./replay-assembly.js";
 import { readReportFormatEnv, REPORT_FORMAT_ENV_VAR, resolveReportFormat } from "./report-format.js";
@@ -18,8 +22,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`],
@@ -34,11 +40,17 @@ export async function runCli(options) {
         return { exitCode: 1 };
     }
     const { parsed } = parseResult;
-    const inherited = readPresentationEnv(env);
+    const inherited = readPresentation({
+        env,
+        flagValue: parsed.outputStyle,
+        stderrIsTty: isTerminalStream(stderr),
+        stdoutIsTty: isTerminalStream(stdout),
+    });
     if (!inherited.ok) {
         reportError(inherited.error, stderr);
         return { exitCode: 1 };
     }
+    const { styles } = inherited;
     if (parsed.version) {
         stdout.write(`${VERSION}\n`);
         return { exitCode: 0 };
@@ -68,6 +80,7 @@ export async function runCli(options) {
         monorepoRoot: context.monorepoRoot,
         passthrough: parsed.passthrough,
         stderr,
+        style: styles.stderr,
     });
     const noCache = parsed.noCache || env[NO_CACHE_ENV_VAR] === '1';
     const runId = resolveRunId(env);
@@ -78,6 +91,7 @@ export async function runCli(options) {
         passthrough: parsed.passthrough,
         runId,
         snapshot,
+        styles,
         verbosity,
     });
     const runOptions = {
@@ -88,7 +102,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({
@@ -110,7 +124,7 @@ export async function runCli(options) {
     const resolvedCommand = renderChain(resolved.steps);
     const noOpReason = findNoOpReason(resolvedCommand);
     if (noOpReason !== undefined && !parsed.log) {
-        reportVerdict({ command, scope, outcome: 'no-op', reason: noOpReason }, stdout, format);
+        reportVerdict({ command, scope, outcome: 'no-op', reason: noOpReason }, stdout, format, styles.stdout);
         return { exitCode: 0 };
     }
     const substitutedSteps = applyDevBinToSteps(resolved.steps, context.config.devBin, context.monorepoRoot);
@@ -133,6 +147,7 @@ export async function runCli(options) {
         registry,
         resolved,
         stderr,
+        style: styles.stderr,
         useRoot,
         workspaceRoot: parsed.workspaceRoot,
     });
@@ -159,6 +174,7 @@ export async function runCli(options) {
             snapshot,
             stderr,
             stdout,
+            styles,
         });
     }
     const { exitCode, outcome } = await runGated({
@@ -171,7 +187,7 @@ export async function runCli(options) {
         key,
         monorepoRoot: context.monorepoRoot,
         noCache,
-        overrideNotice: formatOverrideNotice(resolved, registry, command, anchorDir, quiet),
+        overrideNotice: formatOverrideNotice(resolved, registry, command, anchorDir, quiet, styles.stdout),
         ownSteps: mainSteps,
         runId,
         runOptions,
@@ -179,33 +195,49 @@ export async function runCli(options) {
         stderr,
         stdout,
     });
-    reportVerdict({ command, scope, ...outcome }, stdout, format);
+    reportVerdict({ command, scope, ...outcome }, stdout, format, styles.stdout);
     return { exitCode };
 }
+const BOOLEAN_FLAGS = new Map([
+    ['-?', 'help'],
+    ['--help', 'help'],
+    ['--json', 'json'],
+    ['--log', 'log'],
+    ['--no-cache', 'noCache'],
+    ['-q', 'quiet'],
+    ['--quiet', 'quiet'],
+    ['-R', 'recursive'],
+    ['--recursive', 'recursive'],
+    ['-V', 'version'],
+    ['--version', 'version'],
+    ['-w', 'workspaceRoot'],
+    ['--workspace-root', 'workspaceRoot'],
+]);
 function buildChildEnv(options) {
-    const { env, format, noCache, passthrough, runId, snapshot, verbosity } = options;
+    const { env, format, noCache, passthrough, runId, snapshot, styles, verbosity } = options;
     const bypassesCache = noCache || passthrough.length > 0;
     return {
         ...env,
         ...(snapshot !== undefined && { [TREE_SNAPSHOT_ENV_VAR]: encodeTreeSnapshot(snapshot) }),
         ...(bypassesCache && { [NO_CACHE_ENV_VAR]: '1' }),
         [COMMAND_VERBOSITY_ENV_VAR]: verbosity,
+        [OUTPUT_STYLE_ENV_VAR]: styles.stdout,
         [REPORT_FORMAT_ENV_VAR]: format,
         [RUN_ID_ENV_VAR]: runId,
     };
 }
-function acceptsArgs(step) {
-    return step.kind === 'opaque' || step.declinesArgs !== true;
+function acceptsArguments(step) {
+    return step.kind === 'opaque' || step.shouldDeclineArguments !== true;
 }
 function bindPassthrough(steps, passthrough, command) {
     if (passthrough.length === 0) {
         return { ok: true, steps };
     }
-    if (!steps.some(acceptsArgs)) {
-        return { ok: false, error: formatUnroutableArgsError(command) };
+    if (!steps.some(acceptsArguments)) {
+        return { ok: false, error: formatUnroutableArgumentsError(command) };
     }
     const boundSteps = steps.map((step) => {
-        if (!acceptsArgs(step)) {
+        if (!acceptsArguments(step)) {
             return step;
         }
         return step.kind === 'structural'
@@ -214,7 +246,7 @@ function bindPassthrough(steps, passthrough, command) {
     });
     return { ok: true, steps: boundSteps };
 }
-function formatUnroutableArgsError(command) {
+function formatUnroutableArgumentsError(command) {
     return (`\`${command}\` takes no trailing arguments: every step of its chain declines them. ` +
         'Running it unnarrowed is not what the arguments asked for, so nothing ran.');
 }
@@ -309,15 +341,16 @@ function escapeControlCharacters(text) {
 }
 function formatNmrCrossingWarning(options) {
     const { remedy, subject } = describeCrossingRemedy(options);
-    return (`⚠️ ${subject} reaches nmr through a shell (\`${escapeControlCharacters(options.crossing)}\`), ` +
-        `${CROSSING_CONSEQUENCE} ${remedy}`);
+    return (`${STATUS_GLYPHS[options.style].warning.text} ${subject} reaches nmr through a shell ` +
+        `(\`${escapeControlCharacters(options.crossing)}\`), ${CROSSING_CONSEQUENCE} ${remedy}`);
 }
-function formatOverrideNotice(resolved, registry, command, anchorDir, quiet) {
+function formatOverrideNotice(resolved, registry, command, anchorDir, quiet, style) {
     const registryEntry = Object.hasOwn(registry, command) ? registry[command] : undefined;
     if (quiet || resolved.origin.tier !== 'package' || registryEntry === undefined) {
         return undefined;
     }
-    return `📦 ${path.basename(anchorDir)}: Using override script: ${renderChain(resolved.steps)}\n`;
+    const notice = `${path.basename(anchorDir)}: Using override script: ${renderChain(resolved.steps)}`;
+    return `${formatGlyphLine(NMR_GLYPHS, style, 'package', notice)}\n`;
 }
 function formatSelfReferenceRemedy(options) {
     const { command, monorepoRoot, registry, script, workspaceRoot } = options;
@@ -346,6 +379,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';
@@ -408,12 +493,12 @@ async function lookUpRecordedPass(options) {
     };
 }
 function openGate(options) {
-    const { command, config, env, monorepoRoot, passthrough, stderr } = options;
+    const { command, config, env, monorepoRoot, passthrough, stderr, style } = options;
     if (!isCacheableCommand(config.checkCache, command)) {
         return undefined;
     }
     if (passthrough.includes('--no-cache')) {
-        stderr.write(`${formatMisplacedNoCacheWarning(command)}\n`);
+        stderr.write(`${formatMisplacedNoCacheWarning(command, style)}\n`);
     }
     if (passthrough.length > 0) {
         writeDebugNote(`gate disabled: ${command} was passed arguments`, env, stderr);
@@ -446,51 +531,26 @@ 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;
             i++;
             continue;
         }
-        if (arg === '-R' || arg === '--recursive') {
-            parsed.recursive = true;
-            i++;
-            continue;
-        }
-        if (arg === '-w' || arg === '--workspace-root') {
-            parsed.workspaceRoot = true;
-            i++;
-            continue;
-        }
-        if (arg === '-?' || arg === '--help') {
-            parsed.help = true;
+        const booleanFlag = BOOLEAN_FLAGS.get(arg);
+        if (booleanFlag !== undefined) {
+            parsed[booleanFlag] = true;
             i++;
             continue;
         }
-        if (arg === '-V' || arg === '--version') {
-            parsed.version = true;
-            i++;
-            continue;
-        }
-        if (arg === '-q' || arg === '--quiet') {
-            parsed.quiet = true;
-            i++;
-            continue;
-        }
-        if (arg === '--json') {
-            parsed.json = true;
-            i++;
-            continue;
-        }
-        if (arg === '--log') {
-            parsed.log = true;
-            i++;
-            continue;
-        }
-        if (arg === '--no-cache') {
-            parsed.noCache = true;
-            i++;
+        const styleArgument = readOutputStyleArgument(args, i);
+        if (styleArgument !== undefined) {
+            if (!styleArgument.ok) {
+                return styleArgument;
+            }
+            parsed.outputStyle = styleArgument.value;
+            i += styleArgument.consumed;
             continue;
         }
         parsed.command = arg;
@@ -501,7 +561,7 @@ function parseArgs(args) {
     return error === undefined ? { ok: true, parsed } : { ok: false, error };
 }
 async function reportRecording(options) {
-    const { command, config, scope } = options;
+    const { command, config, scope, styles } = options;
     const lookup = await resolveRecording({
         anchorDir: options.anchorDir,
         command,
@@ -516,13 +576,14 @@ async function reportRecording(options) {
         monorepoRoot: options.monorepoRoot,
     });
     if (!lookup.ok) {
-        options.stderr.write(`${renderRefusal({ command, refusal: lookup.refusal, scope })}\n`);
+        options.stderr.write(`${renderRefusal({ command, refusal: lookup.refusal, scope, style: styles.stderr })}\n`);
         return { exitCode: options.env[RUN_IF_PRESENT_ENV_VAR] === '1' ? 0 : 1 };
     }
-    options.stdout.write(renderRecording({ command, recording: lookup.recording, scope }));
+    options.stdout.write(renderRecording({ command, recording: lookup.recording, scope, style: styles.stdout }));
     return { exitCode: 0 };
 }
-function readPresentationEnv(env) {
+function readPresentation(options) {
+    const { env } = options;
     const verbosity = readVerbosityEnv(env);
     if (!verbosity.ok) {
         return verbosity;
@@ -531,7 +592,23 @@ function readPresentationEnv(env) {
     if (!format.ok) {
         return format;
     }
-    return { ok: true, format: format.format, verbosity: verbosity.verbosity };
+    const { invalid, styles } = resolveOutputStyles(options);
+    if (invalid !== undefined) {
+        return { ok: false, error: describeInvalidOutputStyle(invalid) };
+    }
+    return { ok: true, format: format.format, styles, verbosity: verbosity.verbosity };
+}
+function readOutputStyleArgument(args, index) {
+    const arg = args[index] ?? '';
+    const assignment = arg.startsWith(`${OUTPUT_STYLE_FLAG}=`) ? arg.slice(OUTPUT_STYLE_FLAG.length + 1) : undefined;
+    if (arg !== OUTPUT_STYLE_FLAG && assignment === undefined) {
+        return undefined;
+    }
+    const value = assignment ?? args[index + 1];
+    if (!value) {
+        return { ok: false, error: `${OUTPUT_STYLE_FLAG} requires a value argument: auto, plain, or rich` };
+    }
+    return { ok: true, value, consumed: assignment === undefined ? 2 : 1 };
 }
 function reportNmrCrossing(options) {
     const crossing = findNmrCrossing(options.resolved.steps);
@@ -543,15 +620,16 @@ function reportNmrCrossing(options) {
         monorepoRoot: options.monorepoRoot,
         origin: describeOrigin(options.resolved.origin, options.config, options.useRoot),
         registry: options.registry,
+        style: options.style,
         workspaceRoot: options.workspaceRoot,
     });
     options.stderr.write(`${warning}\n`);
 }
-function reportVerdict(verdict, stdout, format) {
+function reportVerdict(verdict, stdout, format, style) {
     if (isHookName(verdict.command)) {
         return;
     }
-    writeVerdict(verdict, stdout, format);
+    writeVerdict(verdict, stdout, format, style);
 }
 function resolveReportingVerbosity(options) {
     const { format, ...ladder } = options;
@@ -642,6 +720,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

@@ -4,9 +4,12 @@
  *
  * A structural step's argv leads with the file to spawn, so the runner has one to hand `spawn` without a shell.
  *
- * `declinesArgs` travels from the composite element that composed the step to the one reader that acts on it,
+ * `shouldDeclineArguments` 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 `shouldDeclineArguments`, it is set only where it holds and leaves the rendered chain unchanged.
  */
 export type Step = {
     kind: 'opaque';
@@ -14,7 +17,8 @@ export type Step = {
 } | {
     kind: 'structural';
     argv: readonly [string, ...(readonly string[])];
-    declinesArgs?: boolean;
+    shouldDeclineArguments?: boolean;
+    shouldWithholdInput?: boolean;
 };
 /** What a structural step asks of the nmr process it spawns. */
 export interface NmrStepTarget {
@@ -35,10 +39,10 @@ export type SelfReference = 'chained' | 'sole';
  * The element tokenizes on whitespace, so it may carry nmr's own flags but cannot carry a space-bearing token.
  * `-w` is prepended as its own token, so the child selects the root registry on its own.
  *
- * `declinesArgs` is set only where it holds, so a step that takes the trailing arguments renders and compares
+ * `shouldDeclineArguments` is set only where it holds, so a step that takes the trailing arguments renders and compares
  * exactly as it did before any element declared anything.
  */
-export declare function composeNmrStep(element: string, workspaceRoot: boolean, declinesArgs?: boolean): Step;
+export declare function composeNmrStep(element: string, workspaceRoot: boolean, shouldDeclineArguments?: boolean): Step;
 /**
  * Returns the text of the first opaque step that reaches nmr through a shell, or `undefined` when none does.
  *

package/dist/esm/steps.js

@@ -11,9 +11,13 @@ const QUOTES = new Set(['"', "'"]);
 const SEGMENT_SEPARATORS = new Set([';', '|', '&', '\n', '\r']);
 const SHELL_SAFE_TOKEN = /^[\w@%+=:,./-]+$/;
 const TOKEN_SEPARATORS = new Set([' ', '\t', '\n', '\r']);
-export function composeNmrStep(element, workspaceRoot, declinesArgs = false) {
+export function composeNmrStep(element, workspaceRoot, shouldDeclineArguments = false) {
     const flags = workspaceRoot ? ['-w'] : [];
-    return { kind: 'structural', argv: ['nmr', ...flags, ...tokenize(element)], ...(declinesArgs && { declinesArgs }) };
+    return {
+        kind: 'structural',
+        argv: ['nmr', ...flags, ...tokenize(element)],
+        ...(shouldDeclineArguments && { shouldDeclineArguments }),
+    };
 }
 export function findNmrCrossing(steps) {
     for (const step of steps) {

package/dist/esm/verdict.d.ts

@@ -1,4 +1,5 @@
 import type { Writable } from 'node:stream';
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 import type { ReplayLine } from './check-cache.js';
 import type { ReportFormat } from './report-format.js';
 /**
@@ -54,15 +55,18 @@ export type VerdictOutcome = {
  * The line ends without terminal punctuation and reserves its tail for `detail`, so a later change appends to
  * the grammar rather than rewriting it. A detail carrying nothing but line breaks takes its whole clause with
  * it, rather than leaving a separator pointing at nothing.
+ *
+ * The marker takes no padding column: every plain marker a verdict reaches for is four characters, so the
+ * lines align by construction. `formatStatusLine` pads to a column that `BLOCK` widens, and no verdict is one.
  */
-export declare function renderVerdict(verdict: Verdict): string;
+export declare function renderVerdict(verdict: Verdict, style: OutputStyle): string;
 /**
  * Renders a verdict as the JSON object a machine consumer reads, without the newline that terminates it.
  *
  * 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;
@@ -71,4 +75,4 @@ export declare function serializeVerdict(verdict: Verdict): string;
  * share one descriptor. Both renderings spend the one record, so neither can come to report what the other
  * does not.
  */
-export declare function writeVerdict(verdict: Verdict, stream: Writable, format: ReportFormat): void;
+export declare function writeVerdict(verdict: Verdict, stream: Writable, format: ReportFormat, style: OutputStyle): void;

package/dist/esm/verdict.js

@@ -1,41 +1,47 @@
+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 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);
 }
-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 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}` };
+            return {
+                marker: statuses.skipped.text,
+                phrase: `passed ${formatDuration(verdict.ageMs)} ago on this tree${savingClause}`,
+            };
         }
         case 'no-op':
             return {
-                icon: '⛔',
+                marker: NMR_GLYPHS[style].noop.text,
                 phrase: `skipped, the override is ${verdict.reason === 'empty-override' ? 'empty' : 'a no-op'}`,
             };
         default: {

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;