@williamthorsen/nmr 0.37.0 → 0.39.0

package/dist/esm/help.js

@@ -1,35 +1,41 @@
 import { isHookName } from "./helpers/hook-name.js";
+import { OUTPUT_STYLE_ENV_VAR, OUTPUT_STYLE_FLAG } from "./output-style.js";
 import { buildRootRegistry, buildWorkspaceRegistry, describeScript, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
-export function generateHelp(config, packageDir, useRoot) {
+export function generateHelp(config, packageDir, shouldUseRoot) {
     const lines = [
         'Usage: nmr [flags] <command> [args...]',
         '',
         'Flags:',
-        '  -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",
-        '      --json               Report one JSON object per command, withholding command output',
-        '      --log                Print the recorded run instead of running (up to 256 KiB)',
-        '      --no-cache           Run even if this tree already passed; record the result',
-        '  -?, --help               Show this help',
-        '  -V, --version            Show version number',
+        '  -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",
+        '      --json                  Report one JSON object per command, withholding command output',
+        '      --log                   Print the recorded run instead of running (up to 256 KiB)',
+        '      --no-cache              Run even if this tree already passed; record the result',
+        `      ${OUTPUT_STYLE_FLAG} <style>  Output style: auto (default), plain, or rich`,
+        '  -?, --help                  Show this help',
+        '  -V, --version               Show version number',
+        '',
+        'Environment:',
+        `  ${OUTPUT_STYLE_ENV_VAR}            Output style: auto (default), plain, or rich. auto prints`,
+        '                              plain, without emoji, when CI is set or the stream is not a terminal.',
         '',
         'Workspace commands:',
     ];
     const overrides = packageDir === undefined ? {} : collectOverrides(packageDir);
     let hadOverride = false;
     const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config));
-    const workspaceMarked = !useRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
-    if (workspaceMarked.size > 0)
+    const workspaceMarkedNames = !shouldUseRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
+    if (workspaceMarkedNames.size > 0)
         hadOverride = true;
-    formatRegistry(workspaceRegistry, workspaceMarked, lines);
+    formatRegistry(workspaceRegistry, workspaceMarkedNames, lines);
     lines.push('', 'Root commands:');
     const rootRegistry = filterHooks(buildRootRegistry(config));
-    const rootMarked = useRoot ? applyOverrides(rootRegistry, overrides) : new Set();
-    if (rootMarked.size > 0)
+    const rootMarkedNames = shouldUseRoot ? applyOverrides(rootRegistry, overrides) : new Set();
+    if (rootMarkedNames.size > 0)
         hadOverride = true;
-    formatRegistry(rootRegistry, rootMarked, lines);
+    formatRegistry(rootRegistry, rootMarkedNames, lines);
     if (hadOverride) {
         lines.push('', '* Overridden by package.json');
     }
@@ -39,43 +45,43 @@ function collectOverrides(packageDir) {
     const scripts = readPackageJsonScripts(packageDir);
     if (!scripts)
         return {};
-    const filtered = {};
+    const candidateOverrides = {};
     for (const [name, value] of Object.entries(scripts)) {
         if (isHookName(name))
             continue;
         if (isSelfReferential(value, name, packageDir))
             continue;
-        filtered[name] = value;
+        candidateOverrides[name] = value;
     }
-    return filtered;
+    return candidateOverrides;
 }
 function applyOverrides(registry, overrides) {
-    const marked = new Set();
+    const markedNames = new Set();
     for (const [name, value] of Object.entries(overrides)) {
         if (!Object.hasOwn(registry, name)) {
             continue;
         }
         registry[name] = value;
-        marked.add(name);
+        markedNames.add(name);
     }
-    return marked;
+    return markedNames;
 }
 function filterHooks(registry) {
-    const filtered = {};
+    const hooklessRegistry = {};
     for (const [key, value] of Object.entries(registry)) {
         if (!isHookName(key))
-            filtered[key] = value;
+            hooklessRegistry[key] = value;
     }
-    return filtered;
+    return hooklessRegistry;
 }
-function formatRegistry(registry, marked, lines) {
+function formatRegistry(registry, markedNames, lines) {
     const keys = Object.keys(registry);
     if (keys.length === 0)
         return;
-    const maxKeyLen = Math.max(...keys.map((k) => k.length));
-    const pad = Math.max(maxKeyLen + 1 + 2, 20);
+    const maxKeyLength = Math.max(...keys.map((k) => k.length));
+    const padWidth = Math.max(maxKeyLength + 1 + 2, 20);
     for (const [key, value] of Object.entries(registry)) {
-        const marker = marked.has(key) ? '*' : ' ';
-        lines.push(`  ${(key + marker).padEnd(pad)} ${describeScript(value)}`);
+        const marker = markedNames.has(key) ? '*' : ' ';
+        lines.push(`  ${(key + marker).padEnd(padWidth)} ${describeScript(value)}`);
     }
 }

package/dist/esm/helpers/clampToBytes.js

@@ -7,14 +7,14 @@ export function clampToBytes(value, budgetBytes) {
     if (budget < 0) {
         return '';
     }
-    let kept = '';
+    let keptText = '';
     let bytes = 0;
     for (const character of value) {
         const size = Buffer.byteLength(character);
         if (bytes + size > budget)
             break;
-        kept += character;
+        keptText += character;
         bytes += size;
     }
-    return `${kept}${TRUNCATION_MARK}`;
+    return `${keptText}${TRUNCATION_MARK}`;
 }

package/dist/esm/helpers/createBoundedBuffer.d.ts

@@ -6,7 +6,7 @@ export interface BoundedBuffer {
     /** Retains a chunk, dropping bytes from the middle once both ends are full. */
     append: (chunk: Buffer) => void;
     /** Renders the retained bytes, with a marker naming the dropped count standing in for what was dropped. */
-    toBuffer: () => Buffer;
+    readBuffer: () => Buffer;
 }
 /**
  * Creates an accumulator that retains the first and last bytes it is fed and drops the middle.

package/dist/esm/helpers/createBoundedBuffer.js

@@ -40,7 +40,7 @@ export function createBoundedBuffer(options = {}) {
         tailOffset = (tailOffset + chunk.length) % tailLimitBytes;
         tailBytes = Math.min(tailLimitBytes, tailBytes + chunk.length);
     }
-    function toBuffer() {
+    function readBuffer() {
         const headBuffer = Buffer.concat(headChunks);
         if (tailRing === undefined) {
             return headBuffer;
@@ -53,5 +53,5 @@ export function createBoundedBuffer(options = {}) {
         }
         return Buffer.concat([headBuffer, Buffer.from(formatElisionMarker(elidedBytes)), tailBuffer]);
     }
-    return { append, toBuffer };
+    return { append, readBuffer };
 }

package/dist/esm/helpers/duration.d.ts

@@ -5,7 +5,7 @@
  * `1m 30s`, where rounding would claim `2m`. Below a minute the tenth is kept, since that is the scale at which
  * one check's runtime differs from another's; a whole number sheds the `.0` rather than reading `12.0s`.
  */
-export declare function formatDuration(milliseconds: number): string;
+export declare function formatDuration(durationMs: number): string;
 /**
  * Renders the clause a skip spends on the time it saved, or `undefined` when there is no saving worth naming.
  * A skip that can say what it saved earns the clause; one that cannot says nothing, and the caller drops it
@@ -14,4 +14,4 @@ export declare function formatDuration(milliseconds: number): string;
  * Guards its own input rather than trusting the caller's, because the clause is shared: a non-finite duration
  * compares false against the threshold, and would reach a reader as `saved ~NaNs`.
  */
-export declare function formatSaving(milliseconds: number): string | undefined;
+export declare function formatSaving(durationMs: number): string | undefined;

package/dist/esm/helpers/duration.js

@@ -1,5 +1,5 @@
-export function formatDuration(milliseconds) {
-    const total = Math.max(0, milliseconds);
+export function formatDuration(durationMs) {
+    const total = Math.max(0, durationMs);
     if (total < MILLISECONDS_PER_MINUTE) {
         return `${truncateToTenth(total)}s`;
     }
@@ -10,11 +10,11 @@ export function formatDuration(milliseconds) {
     }
     return joinUnits(`${Math.floor(totalMinutes / MINUTES_PER_HOUR)}h`, totalMinutes % MINUTES_PER_HOUR, 'm');
 }
-export function formatSaving(milliseconds) {
-    if (!Number.isFinite(milliseconds) || milliseconds < MILLISECONDS_PER_SECOND) {
+export function formatSaving(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < MILLISECONDS_PER_SECOND) {
         return undefined;
     }
-    return `saved ~${formatDuration(milliseconds)}`;
+    return `saved ~${formatDuration(durationMs)}`;
 }
 const MILLISECONDS_PER_MINUTE = 60_000;
 const MILLISECONDS_PER_SECOND = 1_000;
@@ -23,6 +23,6 @@ const SECONDS_PER_MINUTE = 60;
 function joinUnits(major, minor, minorUnit) {
     return minor === 0 ? major : `${major} ${minor}${minorUnit}`;
 }
-function truncateToTenth(milliseconds) {
-    return Math.floor(milliseconds / 100) / 10;
+function truncateToTenth(durationMs) {
+    return Math.floor(durationMs / 100) / 10;
 }

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

@@ -5,31 +5,31 @@ 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'], {
+    const listingRun = 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;
+    const probeReading = interpretSelectionProbe({ error: listingRun.error, status: listingRun.status, stdout: listingRun.stdout }, monorepoRoot);
+    return probeReading === 'root-only' ? readDelegateSelection(pattern, monorepoRoot) : probeReading;
 }
 export function interpretSelectionProbe(probe, monorepoRoot) {
     if (probe.error !== undefined || probe.status !== 0) {
         return 'unresolved';
     }
-    let parsed;
+    let parsedListing;
     try {
-        parsed = JSON.parse(probe.stdout);
+        parsedListing = JSON.parse(probe.stdout);
     }
     catch {
         return 'unresolved';
     }
-    if (!Array.isArray(parsed)) {
+    if (!Array.isArray(parsedListing)) {
         return 'unresolved';
     }
-    if (parsed.length === 0) {
+    if (parsedListing.length === 0) {
         return 'empty';
     }
-    const packageCount = parsed.filter((entry) => !isRootEntry(entry, monorepoRoot)).length;
+    const packageCount = parsedListing.filter((entry) => !isRootEntry(entry, monorepoRoot)).length;
     if (packageCount === 0) {
         return 'root-only';
     }
@@ -45,9 +45,9 @@ function isRootEntry(entry, monorepoRoot) {
     if (!isObject(entry) || typeof entry['path'] !== 'string') {
         return false;
     }
-    return readRealPath(entry['path']) === readRealPath(monorepoRoot);
+    return resolveRealPath(entry['path']) === resolveRealPath(monorepoRoot);
 }
-function readRealPath(target) {
+function resolveRealPath(target) {
     try {
         return realpathSync(target);
     }
@@ -56,6 +56,6 @@ function readRealPath(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 });
+    const probeRun = spawnSync('pnpm', ['--filter', pattern, 'exec', process.execPath, '--eval', `process.stdout.write('${SELECTION_MARKER}')`], { cwd: monorepoRoot, encoding: 'utf8' });
+    return interpretDelegateProbe({ error: probeRun.error, status: probeRun.status, stdout: probeRun.stdout });
 }

package/dist/esm/helpers/findClosestName.js

@@ -1,33 +1,33 @@
 export function findClosestName(name, candidates) {
     const ceiling = Math.max(1, Math.floor(name.length / 4));
-    let closest;
-    let shortest = Infinity;
+    let closestName;
+    let shortestDistance = Infinity;
     for (const candidate of candidates) {
         const distance = measureDistance(name, candidate);
-        if (distance < shortest) {
-            shortest = distance;
-            closest = candidate;
+        if (distance < shortestDistance) {
+            shortestDistance = distance;
+            closestName = candidate;
         }
     }
-    return shortest <= ceiling ? closest : undefined;
+    return shortestDistance <= ceiling ? closestName : undefined;
 }
 function measureDistance(first, second) {
     if (first.length === 0 || second.length === 0) {
         return Math.max(first.length, second.length);
     }
-    let previous = Array.from({ length: second.length + 1 }, (_unused, column) => column);
-    let current = Array.from({ length: second.length + 1 }, () => 0);
+    let previousRow = Array.from({ length: second.length + 1 }, (_unused, column) => column);
+    let currentRow = Array.from({ length: second.length + 1 }, () => 0);
     for (let row = 1; row <= first.length; row += 1) {
-        current[0] = row;
+        currentRow[0] = row;
         for (let column = 1; column <= second.length; column += 1) {
-            const substitution = readCell(previous, column - 1) + (first[row - 1] === second[column - 1] ? 0 : 1);
-            current[column] = Math.min(readCell(current, column - 1) + 1, readCell(previous, column) + 1, substitution);
+            const substitution = readCell(previousRow, column - 1) + (first[row - 1] === second[column - 1] ? 0 : 1);
+            currentRow[column] = Math.min(readCell(currentRow, column - 1) + 1, readCell(previousRow, column) + 1, substitution);
         }
-        const completed = current;
-        current = previous;
-        previous = completed;
+        const completedRow = currentRow;
+        currentRow = previousRow;
+        previousRow = completedRow;
     }
-    return readCell(previous, second.length);
+    return readCell(previousRow, second.length);
 }
 function readCell(row, index) {
     const value = row[index];

package/dist/esm/helpers/package-json.d.ts

@@ -25,14 +25,14 @@ export declare function readPackageJson(dir: string): PackageJson;
 /**
  * Returns the `pnpm.overrides` block a package.json declares, every key it holds and each value as written.
  */
-export declare function getPnpmOverrides(pkg: PackageJson): Record<string, unknown> | undefined;
+export declare function getPnpmOverrides(packageJson: PackageJson): Record<string, unknown> | undefined;
 /**
  * Parses a `package.json`'s text, rejecting what does not parse.
  *
  * A file the user wrote by hand is theirs to fix, so the failure names it rather than reporting the parser's
  * own stack.
  */
-export declare function parsePackageJson(raw: string, file: string): unknown;
+export declare function parsePackageJson(rawText: string, file: string): unknown;
 /**
  * Narrows a `scripts` record to strings, rejecting any value that is not one.
  *

package/dist/esm/helpers/package-json.js

@@ -14,45 +14,46 @@ export const DEPENDENCY_FIELDS = [
 ];
 export function readPackageJson(dir) {
     const file = resolvePackageJsonPath(dir);
-    const parsed = parsePackageJson(readFileSync(file, 'utf8'), file);
-    if (!isObject(parsed)) {
+    const parsedManifest = parsePackageJson(readFileSync(file, 'utf8'), file);
+    if (!isObject(parsedManifest)) {
         throw new UserError(`Invalid package.json in ${dir}: expected an object`);
     }
-    const pkg = {};
-    if (typeof parsed['name'] === 'string')
-        pkg.name = parsed['name'];
-    if (parsed['private'] === true)
-        pkg.private = true;
-    if (typeof parsed['version'] === 'string')
-        pkg.version = parsed['version'];
-    if (typeof parsed['packageManager'] === 'string')
-        pkg.packageManager = parsed['packageManager'];
-    if (isObject(parsed['scripts'])) {
-        pkg.scripts = readScriptRecord(dir, parsed['scripts']);
+    const packageJson = {};
+    if (typeof parsedManifest['name'] === 'string')
+        packageJson.name = parsedManifest['name'];
+    if (parsedManifest['private'] === true)
+        packageJson.private = true;
+    if (typeof parsedManifest['version'] === 'string')
+        packageJson.version = parsedManifest['version'];
+    if (typeof parsedManifest['packageManager'] === 'string') {
+        packageJson.packageManager = parsedManifest['packageManager'];
     }
-    if (isObject(parsed['pnpm'])) {
-        const pnpm = parsed['pnpm'];
+    if (isObject(parsedManifest['scripts'])) {
+        packageJson.scripts = readScriptRecord(dir, parsedManifest['scripts']);
+    }
+    if (isObject(parsedManifest['pnpm'])) {
+        const pnpm = parsedManifest['pnpm'];
         if (isObject(pnpm['overrides'])) {
-            pkg.pnpm = { overrides: pnpm['overrides'] };
+            packageJson.pnpm = { overrides: pnpm['overrides'] };
         }
     }
     for (const field of DEPENDENCY_FIELDS) {
-        const declared = parsed[field];
-        if (isObject(declared)) {
-            pkg[field] = readStringValues(declared);
+        const declaredDependencies = parsedManifest[field];
+        if (isObject(declaredDependencies)) {
+            packageJson[field] = readStringValues(declaredDependencies);
         }
     }
-    return pkg;
+    return packageJson;
 }
-export function getPnpmOverrides(pkg) {
-    if (!isObject(pkg.pnpm))
+export function getPnpmOverrides(packageJson) {
+    if (!isObject(packageJson.pnpm))
         return undefined;
-    const overrides = pkg.pnpm.overrides;
+    const overrides = packageJson.pnpm.overrides;
     return isObject(overrides) ? overrides : undefined;
 }
-export function parsePackageJson(raw, file) {
+export function parsePackageJson(rawText, file) {
     try {
-        return JSON.parse(raw);
+        return JSON.parse(rawText);
     }
     catch (error) {
         throw new UserError(`Invalid package.json at ${file}: ${describeError(error)}`);

package/dist/esm/helpers/transcript.d.ts

@@ -16,7 +16,7 @@ export declare const TRANSCRIPT_LIMIT_BYTES = 262144;
  * stderr on failure is the command's own output going to a stream that may be a terminal, and stripping its
  * color there would be a loss.
  */
-export declare function cleanTranscript(raw: string): string;
+export declare function cleanTranscript(rawText: string): string;
 /**
  * Composes what a pass persists from what its command wrote, or `undefined` where it wrote nothing worth
  * keeping.
@@ -25,6 +25,6 @@ export declare function cleanTranscript(raw: string): string;
  * failure: nmr reads each through a pipe of its own, so their true interleaving is not among the facts it
  * holds. A stream carrying nothing contributes neither content nor marker.
  */
-export declare function composeTranscript(retained: RetainedOutput): string | undefined;
+export declare function composeTranscript(retainedOutput: RetainedOutput): string | undefined;
 /** Renders the line that stands in for dropped bytes, in nmr's voice so it is not mistaken for the tool's. */
 export declare function formatElisionMarker(byteCount: number): string;

package/dist/esm/helpers/transcript.js

@@ -2,15 +2,15 @@ export const TRANSCRIPT_LIMIT_BYTES = 262_144;
 const ANSI_PATTERN = /\u{1B}(?:\[[\u{30}-\u{3F}]*[\u{20}-\u{2F}]*[\u{40}-\u{7E}]|\][^\u{7}\u{1B}]*(?:\u{7}|\u{1B}\\))/gu;
 const END_LIMIT_BYTES = TRANSCRIPT_LIMIT_BYTES / 2;
 const STREAM_MARKER = '\n… nmr: stderr …\n';
-export function cleanTranscript(raw) {
-    return raw
+export function cleanTranscript(rawText) {
+    return rawText
         .replaceAll(ANSI_PATTERN, '')
         .split('\n')
         .map((line) => renderCarriageReturns(line))
         .join('\n');
 }
-export function composeTranscript(retained) {
-    const streams = [retained.stdout, retained.stderr]
+export function composeTranscript(retainedOutput) {
+    const streams = [retainedOutput.stdout, retainedOutput.stderr]
         .map((stream) => cleanTranscript(stream.toString('utf8')))
         .filter((stream) => stream.trim() !== '');
     if (streams.length === 0) {
@@ -22,19 +22,19 @@ export function formatElisionMarker(byteCount) {
     const unit = byteCount === 1 ? 'byte' : 'bytes';
     return `\n… nmr elided ${byteCount.toLocaleString('en-US')} ${unit} …\n`;
 }
-function alignEnd(buffer, end) {
-    let aligned = Math.min(buffer.length, end);
-    while (aligned > 0 && isContinuationByte(buffer[aligned])) {
-        aligned--;
+function alignEnd(buffer, endOffset) {
+    let alignedOffset = Math.min(buffer.length, endOffset);
+    while (alignedOffset > 0 && isContinuationByte(buffer[alignedOffset])) {
+        alignedOffset--;
     }
-    return aligned;
+    return alignedOffset;
 }
-function alignStart(buffer, start) {
-    let aligned = Math.max(0, start);
-    while (aligned < buffer.length && isContinuationByte(buffer[aligned])) {
-        aligned++;
+function alignStart(buffer, startOffset) {
+    let alignedOffset = Math.max(0, startOffset);
+    while (alignedOffset < buffer.length && isContinuationByte(buffer[alignedOffset])) {
+        alignedOffset++;
     }
-    return aligned;
+    return alignedOffset;
 }
 function clampTranscript(transcript) {
     const buffer = Buffer.from(transcript, 'utf8');

package/dist/esm/output-style.d.ts

@@ -0,0 +1,41 @@
+import type { Writable } from 'node:stream';
+import { type StreamStyleResolution } from '@williamthorsen/nmr-core';
+/**
+ * Reports whether a stream is backed by a terminal, which is what detection reads where no source names a
+ * style. A stream carrying no `isTTY`, which is the one a test injects, is not one.
+ */
+export declare function isTerminalStream(stream: Writable): boolean;
+/**
+ * Carries the resolved style down the spawned chain, so the flag reaches every process rather than the first
+ * and a child writing to a pipe renders as its parent does rather than detecting plain on its own descriptor.
+ *
+ * Deliberately not a keyed variable, on neither the pass key nor the retention key: it changes how a run
+ * renders and never what a command concludes, so folding it into either would stop a plain run from hitting a
+ * pass a rich one recorded.
+ */
+export declare const OUTPUT_STYLE_ENV_VAR = "NMR_OUTPUT_STYLE";
+/**
+ * The flag naming a style for one invocation, which outranks `OUTPUT_STYLE_ENV_VAR`.
+ *
+ * `nmr` alone carries it. A standalone bin takes the variable, which `nmr <command>` exports to it, so adding
+ * a style to a bin does not mean adding a flag to each bin's own parser.
+ */
+export declare const OUTPUT_STYLE_FLAG = "--output-style";
+/**
+ * Resolves the style of each output stream: the flag, then `NMR_OUTPUT_STYLE`, then detection from `CI`, the
+ * stream's terminal state, and `TERM`.
+ *
+ * Never throws. A value naming no style is returned in `invalid`, for the caller to report with
+ * `describeInvalidOutputStyle`, because the caller has to render that complaint in some style.
+ *
+ * The flag's raw value is handed to nmr-core as an assignment rather than narrowed here, so nmr rejects a
+ * misspelling in the words its siblings use and no second ladder can come to name a different one.
+ */
+export declare function resolveOutputStyles(options: ResolveOutputStylesOptions): StreamStyleResolution;
+export interface ResolveOutputStylesOptions {
+    env: NodeJS.ProcessEnv;
+    /** The value the flag was given, absent where the invocation carries none, as a bin's invocation always does. */
+    flagValue?: string | undefined;
+    stderrIsTty: boolean;
+    stdoutIsTty: boolean;
+}

package/dist/esm/output-style.js

@@ -0,0 +1,17 @@
+import { resolveStreamStyles } from '@williamthorsen/nmr-core';
+export function isTerminalStream(stream) {
+    return 'isTTY' in stream && stream.isTTY === true;
+}
+export const OUTPUT_STYLE_ENV_VAR = 'NMR_OUTPUT_STYLE';
+export const OUTPUT_STYLE_FLAG = '--output-style';
+export function resolveOutputStyles(options) {
+    const { env, flagValue, stderrIsTty, stdoutIsTty } = options;
+    return resolveStreamStyles({
+        argv: flagValue === undefined ? [] : [`${OUTPUT_STYLE_FLAG}=${flagValue}`],
+        env,
+        envVar: OUTPUT_STYLE_ENV_VAR,
+        flag: OUTPUT_STYLE_FLAG,
+        stderrIsTty,
+        stdoutIsTty,
+    });
+}

package/dist/esm/prettier.js

@@ -57,23 +57,23 @@ export function definePrettierConfig(options = {}) {
 function buildShellPlugin() {
     return {
         ...shPlugin,
-        languages: shPlugin.languages.filter(isInferredLanguage).map(withoutExcludedFilenames),
+        languages: shPlugin.languages.filter(isInferredLanguage).map(dropExcludedFilenames),
     };
 }
 function isInferredLanguage(language) {
     return INFERRED_LANGUAGES.has(language.name);
 }
-function withoutExcludedFilenames(language) {
+function dropExcludedFilenames(language) {
     if (language.filenames === undefined)
         return language;
     return { ...language, filenames: language.filenames.filter((name) => !EXCLUDED_FILENAMES.has(name)) };
 }
 function assertNoReplacement(options) {
     if ('overrides' in options)
-        throw ownedKeyError('overrides', 'additionalOverrides');
+        throw buildOwnedKeyError('overrides', 'additionalOverrides');
     if ('plugins' in options)
-        throw ownedKeyError('plugins', 'additionalPlugins');
+        throw buildOwnedKeyError('plugins', 'additionalPlugins');
 }
-function ownedKeyError(key, seam) {
+function buildOwnedKeyError(key, seam) {
     return new TypeError(`definePrettierConfig: \`${key}\` is owned by this config. Use \`${seam}\` to append to it.`);
 }

package/dist/esm/recording.d.ts

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 import { type CheckCacheEntry } from './check-cache.js';
 /**
  * What this invocation would be recorded under, insofar as an entry records the same facts. A mismatch is read
@@ -27,12 +28,12 @@ export type KeyDifference = {
     ingredient: 'command-string';
 } | {
     ingredient: 'nmr-version';
-    current: string;
-    recorded: string;
+    currentVersion: string;
+    recordedVersion: string;
 } | {
     ingredient: 'node-version';
-    current: string;
-    recorded: string;
+    currentVersion: string;
+    recordedVersion: string;
 } | {
     ingredient: 'other';
 };
@@ -75,6 +76,7 @@ export declare function renderRecording(options: {
     command: string;
     recording: Recording;
     scope: string;
+    style: OutputStyle;
 }): string;
 /**
  * Renders a refusal on the one line a fan-out can attribute, in the grammar a verdict uses: the scope, the
@@ -84,6 +86,7 @@ export declare function renderRefusal(options: {
     command: string;
     refusal: RecordingRefusal;
     scope: string;
+    style: OutputStyle;
 }): string;
 /**
  * Resolves what one scope has to show for one command.
@@ -96,7 +99,7 @@ export declare function renderRefusal(options: {
 export declare function resolveRecording(options: {
     anchorDir: string;
     command: string;
-    current: RunIdentity;
+    currentIdentity: RunIdentity;
     isCacheable: boolean;
     key: string | undefined;
     monorepoRoot: string;