@williamthorsen/nmr 0.28.0 → 0.29.0

package/.readyup/kits/default.js

@@ -1,6 +1,6 @@
 /** @noformat — @generated. Do not edit. Compiled by rdy. */
 /* eslint-disable */
-export const __readyupVersion = "0.24.0";
+export const __readyupVersion = "0.26.0";
 
 
 // .readyup/kits/default.ts
@@ -61,7 +61,8 @@ var rootScripts = {
   lint: "eslint --fix .",
   "lint:check": "eslint .",
   "lint:strict": "strict-lint",
-  prepush: ["ci", "audit"],
+  // The audit costs seconds and `ci` costs minutes, so the cheap gate fails first.
+  prepush: ["audit", "ci"],
   "report-overrides": "nmr-report-overrides",
   "root:check": ["root:typecheck", "fmt:check", "root:lint:check", "root:test"],
   "root:lint": "eslint --fix --ignore-pattern 'packages/**' .",
@@ -375,7 +376,7 @@ function formatPaths(paths) {
 ${paths.map((path2) => `      ${path2}`).join("\n")}`;
 }
 function getMinVersion() {
-  const picked = { "version": "0.28.0" };
+  const picked = { "version": "0.29.0" };
   if (typeof picked["version"] !== "string") {
     throw new TypeError("nmr/package.json: 'version' must be a string");
   }

package/.readyup/manifest.json

@@ -7,10 +7,10 @@
       ],
       "name": "default",
       "path": "kits/default.js",
-      "readyupVersion": "0.24.0",
+      "readyupVersion": "0.26.0",
       "source": "kits/default.ts",
       "sourceHash": "7b2a223f",
-      "targetHash": "b7abeb12"
+      "targetHash": "26c3d9eb"
     }
   ]
 }

package/README.md

@@ -3,29 +3,23 @@
 Context-aware script runner for pnpm monorepos. Ships an `nmr` (node-monorepo run) binary that provides centralized, consistent script execution across workspace packages and the monorepo root.
 
 <!-- section:release-notes -->
-## Release notes — v0.28.0 (2026-08-08)
+## Release notes — v0.29.0 (2026-08-09)
 
 ### 🎉 Features
 
-- Stop reporting absence checks that pass (#610)
+- Run the dependency audit before ci in prepush (#634)
 
-  A ReadyUp check that checks for a problem (such as an unwanted file or a stale config reference) now stays silent unless it finds one. The `nmr`, `release-kit`, and `v11y-check` ReadyUp kits previously printed a line for every such check on every run.
-
-- Stop reporting non-issues in the readyup kits (#613)
-
-  Modifies the `release-kit` and `nmr` ReadyUp kits to avoid verbose reporting when an initial check determines that further checks aren't applicable. In particular, a repo with no `release-kit` config file gets a single line in the `release-kit` report, and a repo that publishes nothing now bypasses the `npm-auto-publish` kit instead of failing it.
+  `nmr prepush` now runs the dependency audit before the code-quality gate, so a vulnerability surfaces within seconds instead of after a full build-and-check pass. A failing audit now stops the run before the code-quality gate.
 
 ### 🐛 Bug fixes
 
-- Fix prototype-key hole in nmr command runner (#624)
+- Record no pass when build output changes while a check runs (#641)
 
-  Fixes an issue where running `nmr` with a command named for property inherited by JS objects (such as `constructor` or `toString`) failed with a type error instead of reporting the command as unknown.
+  Fixes an issue where rebuilding a package in one terminal while `nmr prepush` ran in another could mark a check as passed against build output it never saw, causing a later run on the same tree to skip it. Because `nmr ci` builds during its own run, it now needs one further run before it can skip, and that run repeats only the build phase.
 
-  Also fixes all lint issues in the `nmr` package.
+- Stream command output so a large writer is no longer killed (#642)
 
-- Publish build output atomically so a failed build cannot destroy it (#631)
-
-  Fixes an issue where a failed or still-running `nmr build` could leave a package with no build output at all, breaking the tooling that a subsequent build depends on. Separately, the error reported when a package's build output is missing now names the correct recovery command.
+  Fixes an issue where a command that wrote more than a mebibyte of output under `nmr -q` was cut off and reported as failed while the tool itself kept running. When `nmr`'s output is piped or redirected to a file, a command's output now appears as it is produced instead of arriving all at once when the command exits. Piping `nmr` into a reader that stops early, such as `head`, now ends the run cleanly. A command killed by a signal now reports 128 plus the signal number rather than a bare 1.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -277,7 +271,7 @@ A hit requires all of these to match the run that recorded the pass:
 
 A hit additionally requires the build output of every package nmr's own build covers to be present, and to have been built from this tree. Output is git-ignored, so neither its removal nor its replacement moves the hash: restoring a tree with `git stash` or `git checkout` restores none of the output that tree was built with. nmr compares each covered package's recorded build digest against the one on disk, so a `dist` compiled from another tree is a miss the following run repairs. A package that overrides `build` or `compile` emits on terms nmr does not know and is exempt.
 
-A pass is recorded only when the command exits 0, only when the tree still matches the one the run started against, only when every covered package's output is present, and never for a run that executed nothing (a `""`/`":"` skip override, or an `NMR_RUN_IF_PRESENT` miss).
+A pass is recorded only when the command exits 0, only when the tree still matches the one the run started against, only when every covered package's output is present and unchanged since the run started, and never for a run that executed nothing (a `""`/`":"` skip override, or an `NMR_RUN_IF_PRESENT` miss). Output that moves mid-run leaves no answer to which output the pass was earned over, whether another process rebuilt it or the chain built it itself: `nmr ci` is the one default command whose chain does, and it records nothing on a run whose build did work. The `nmr check:strict` inside that chain still records, because its own window opens after the build.
 
 ### Out of contract
 
@@ -438,9 +432,11 @@ A run that collects no test files passes. That is what lets `nmr test:tool` fan
 | `build`   | `pnpm --recursive exec nmr build` |
 | `ci`      | `build`, `check:strict`           |
 | `clean`   | `nmr-clean`                       |
-| `prepush` | `ci`, `audit`                     |
+| `prepush` | `audit`, `ci`                     |
+
+`ci` is what a code-quality workflow runs; it leaves out the audit, which belongs in a workflow of its own. `prepush` is what a developer runs before pushing: both gates, audit first. The audit takes seconds and `ci` takes minutes, so a vulnerability surfaces before the long gate runs. It composes `ci` rather than restating its stages, so a stage added to `ci` joins the pre-push run too.
 
-`ci` is what a code-quality workflow runs; it leaves out the audit, which belongs in a workflow of its own. `prepush` is what a developer runs before pushing: both gates. It composes `ci` rather than restating its stages, so a stage added to `ci` joins the pre-push run too.
+The audit reaches the network. With no network, `ci` is the gate that still runs.
 
 Neither is bound to a git hook. `prepush` is named for when you run it, not for a hook nmr installs.
 
@@ -576,7 +572,7 @@ nmr build # Compile to .js and .d.ts in one pass
 # From the monorepo root
 nmr test    # Root tests + recursive workspace tests
 nmr ci      # build + check:strict
-nmr prepush # ci + audit
+nmr prepush # audit + ci
 
 # Target specific packages
 nmr --filter core test # Test only the core package

package/agents/guidance/rulebooks/nmr.md

@@ -9,6 +9,6 @@ delivery: ambient
 - Use `nmr <command>`, not `pnpm run <command>`, for anything nmr provides. Run bare `nmr` to list every command and the shell command it resolves to; a wrong guess reports only `Unknown command`, with no list.
 - Scope follows cwd, and bare `nmr` lists both registries: from the repo root a command covers root files and every workspace; from inside a package, that package alone. `nmr -F <pkg> <command>` targets one package from anywhere; `nmr root:<command>` targets root files alone, which isolates a failure to root code.
 - Never `npx nmr`: inside a git worktree it can resolve a different nmr from outside the tree. Fall back to `pnpm exec nmr`.
-- `nmr ci` runs what a code-quality workflow runs (build, then strict checks) and not the dependency audit, which belongs to a workflow of its own; `nmr prepush` runs both. Neither installs or binds a git hook.
+- `nmr ci` runs what a code-quality workflow runs (build, then strict checks) and not the dependency audit, which belongs to a workflow of its own; `nmr prepush` runs the audit first, then `ci`, so a vulnerability stops the run before the long gate. Neither installs or binds a git hook.
 - A check that already passed on the current working tree skips, printing `⏭️ <command>: passed …`. Any edit, addition, or deletion re-runs it, so a skip is a real pass and needs no confirming: 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`.
 - 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), and the check-result cache's key, its `checkCache` config, and every condition that disables it.

package/dist/esm/check-cache.d.ts

@@ -46,7 +46,7 @@ export declare function computeCacheKey(options: {
     reason: string;
 };
 export declare function encodeTreeSnapshot(snapshot: TreeSnapshot): string;
-export declare function findStaleBuildOutput(recorded: Record<string, string>, current: Record<string, string>): string | undefined;
+export declare function findStaleBuildOutput(earlier: Record<string, string>, later: Record<string, string>): string | undefined;
 export declare function formatMisplacedNoCacheWarning(command: string): string;
 export declare function formatSkipLine(command: string, entry: CheckCacheEntry, now: number): string;
 export declare function readBuildOutputState(monorepoRoot: string, config: NmrConfig): Promise<BuildOutputState>;

package/dist/esm/check-cache.js

@@ -81,9 +81,9 @@ export function computeCacheKey(options) {
 export function encodeTreeSnapshot(snapshot) {
     return `${snapshot.hash} ${snapshot.headSha}`;
 }
-export function findStaleBuildOutput(recorded, current) {
-    const names = [...new Set([...Object.keys(recorded), ...Object.keys(current)])].toSorted();
-    return names.find((name) => recorded[name] !== current[name]);
+export function findStaleBuildOutput(earlier, later) {
+    const names = [...new Set([...Object.keys(earlier), ...Object.keys(later)])].toSorted();
+    return names.find((name) => earlier[name] !== later[name]);
 }
 export function formatMisplacedNoCacheWarning(command) {
     return (`⚠️ --no-cache after the command name is passed to \`${command}\`, not read by nmr. ` +

package/dist/esm/commands/clean.js

@@ -52,7 +52,7 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
             continue;
         }
         const command = applyDevBin(resolved.command, config.devBin, monorepoRoot);
-        const exitCode = runCommand(command, packageDir);
+        const { exitCode } = await runCommand(command, packageDir);
         if (exitCode !== 0) {
             throw new Error(`nmr-clean: \`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }

package/dist/esm/default-scripts.js

@@ -38,7 +38,7 @@ export const rootScripts = {
     lint: 'eslint --fix .',
     'lint:check': 'eslint .',
     'lint:strict': 'strict-lint',
-    prepush: ['ci', 'audit'],
+    prepush: ['audit', 'ci'],
     'report-overrides': 'nmr-report-overrides',
     'root:check': ['root:typecheck', 'fmt:check', 'root:lint:check', 'root:test'],
     'root:lint': "eslint --fix --ignore-pattern 'packages/**' .",

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

@@ -0,0 +1,9 @@
+export interface BoundedBufferOptions {
+    headLimitBytes?: number;
+    tailLimitBytes?: number;
+}
+export interface BoundedBuffer {
+    append: (chunk: Buffer) => void;
+    toBuffer: () => Buffer;
+}
+export declare function createBoundedBuffer(options?: BoundedBufferOptions): BoundedBuffer;

package/dist/esm/helpers/createBoundedBuffer.js

@@ -0,0 +1,60 @@
+const DEFAULT_HEAD_LIMIT_BYTES = 1_048_576;
+const DEFAULT_TAIL_LIMIT_BYTES = 1_048_576;
+export function createBoundedBuffer(options = {}) {
+    const headLimitBytes = options.headLimitBytes ?? DEFAULT_HEAD_LIMIT_BYTES;
+    const tailLimitBytes = options.tailLimitBytes ?? DEFAULT_TAIL_LIMIT_BYTES;
+    const headChunks = [];
+    let headBytes = 0;
+    let tailRing;
+    let tailOffset = 0;
+    let tailBytes = 0;
+    let elidedBytes = 0;
+    function append(chunk) {
+        let remainder = chunk;
+        if (headBytes < headLimitBytes) {
+            const takenBytes = Math.min(headLimitBytes - headBytes, remainder.length);
+            headChunks.push(remainder.subarray(0, takenBytes));
+            headBytes += takenBytes;
+            remainder = remainder.subarray(takenBytes);
+        }
+        if (remainder.length > 0) {
+            appendToTail(remainder);
+        }
+    }
+    function appendToTail(chunk) {
+        const ring = (tailRing ??= Buffer.alloc(tailLimitBytes));
+        if (chunk.length >= tailLimitBytes) {
+            elidedBytes += tailBytes + chunk.length - tailLimitBytes;
+            chunk.copy(ring, 0, chunk.length - tailLimitBytes);
+            tailOffset = 0;
+            tailBytes = tailLimitBytes;
+            return;
+        }
+        elidedBytes += Math.max(0, tailBytes + chunk.length - tailLimitBytes);
+        const untilWrapBytes = Math.min(chunk.length, tailLimitBytes - tailOffset);
+        chunk.copy(ring, tailOffset, 0, untilWrapBytes);
+        if (untilWrapBytes < chunk.length) {
+            chunk.copy(ring, 0, untilWrapBytes);
+        }
+        tailOffset = (tailOffset + chunk.length) % tailLimitBytes;
+        tailBytes = Math.min(tailLimitBytes, tailBytes + chunk.length);
+    }
+    function toBuffer() {
+        const headBuffer = Buffer.concat(headChunks);
+        if (tailRing === undefined) {
+            return headBuffer;
+        }
+        const tailBuffer = tailBytes < tailLimitBytes
+            ? tailRing.subarray(0, tailBytes)
+            : Buffer.concat([tailRing.subarray(tailOffset), tailRing.subarray(0, tailOffset)]);
+        if (elidedBytes === 0) {
+            return Buffer.concat([headBuffer, tailBuffer]);
+        }
+        return Buffer.concat([headBuffer, Buffer.from(formatElisionMarker(elidedBytes)), tailBuffer]);
+    }
+    return { append, toBuffer };
+}
+function formatElisionMarker(byteCount) {
+    const unit = byteCount === 1 ? 'byte' : 'bytes';
+    return `\n… nmr elided ${byteCount.toLocaleString('en-US')} ${unit} …\n`;
+}

package/dist/esm/runCli.js

@@ -41,13 +41,13 @@ export async function runCli(options) {
     const runOptions = { quiet: parsed.quiet, stdout, stderr, env: childEnv };
     if (parsed.filter) {
         const delegateCmd = `pnpm --filter ${shellQuote(parsed.filter)} exec nmr ${command}${passthrough}`;
-        const exitCode = runCommand(delegateCmd, context.monorepoRoot, runOptions);
+        const { exitCode } = await runCommand(delegateCmd, context.monorepoRoot, runOptions);
         return { exitCode };
     }
     if (parsed.recursive) {
         const delegateEnv = { ...childEnv, NMR_RUN_IF_PRESENT: '1' };
         const delegateCmd = `pnpm --recursive exec nmr ${command}${passthrough}`;
-        const exitCode = runCommand(delegateCmd, context.monorepoRoot, { ...runOptions, env: delegateEnv });
+        const { exitCode } = await runCommand(delegateCmd, context.monorepoRoot, { ...runOptions, env: delegateEnv });
         return { exitCode };
     }
     const registry = useRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config);
@@ -133,7 +133,7 @@ function hasRunnableHook(hookName, registry, anchorDir, workspaceRoot) {
     return resolved.command !== '' && resolved.command !== ':';
 }
 async function lookUpRecordedPass(options) {
-    const { anchorDir, command, env, key, monorepoRoot, stderr } = options;
+    const { anchorDir, buildOutput, command, env, key, monorepoRoot, stderr } = options;
     const entry = await readCheckCacheEntry({ anchorDir, command, monorepoRoot });
     if (entry === undefined) {
         writeDebugNote(`running ${command}: no pass recorded for this scope`, env, stderr);
@@ -143,13 +143,12 @@ async function lookUpRecordedPass(options) {
         writeDebugNote(`running ${command}: the tree or its inputs changed since the last pass`, env, stderr);
         return undefined;
     }
-    const output = await readBuildOutputState(monorepoRoot, options.config);
-    const [missing] = output.missing;
+    const [missing] = buildOutput.missing;
     if (missing !== undefined) {
         writeDebugNote(`running ${command}: ${missing} has no build output`, env, stderr);
         return undefined;
     }
-    const stale = findStaleBuildOutput(entry.buildDigests, output.digests);
+    const stale = findStaleBuildOutput(entry.buildDigests, buildOutput.digests);
     if (stale !== undefined) {
         writeDebugNote(`running ${command}: ${stale}'s build output came from a different tree`, env, stderr);
         return undefined;
@@ -255,6 +254,11 @@ async function recordPass(options) {
         writeDebugNote(`not recording ${command}: ${missing} has no build output`, env, stderr);
         return;
     }
+    const changed = findStaleBuildOutput(options.buildOutputBefore.digests, output.digests);
+    if (changed !== undefined) {
+        writeDebugNote(`not recording ${command}: ${changed}'s build output changed while it ran`, env, stderr);
+        return;
+    }
     try {
         await writeCheckCacheEntry({
             anchorDir,
@@ -304,14 +308,16 @@ function resolveCacheKey(options) {
 }
 async function runGated(options) {
     const { anchorDir, command, commandString, env, key, monorepoRoot, snapshot, stderr, stdout } = options;
-    const gated = key !== undefined && snapshot !== undefined;
-    if (gated && !options.noCache) {
+    const gate = key !== undefined && snapshot !== undefined
+        ? { buildOutputBefore: await readBuildOutputState(monorepoRoot, options.config), key, snapshot }
+        : undefined;
+    if (gate !== undefined && !options.noCache) {
         const skipLine = await lookUpRecordedPass({
             anchorDir,
+            buildOutput: gate.buildOutputBefore,
             command,
-            config: options.config,
             env,
-            key,
+            key: gate.key,
             monorepoRoot,
             stderr,
         });
@@ -326,18 +332,19 @@ async function runGated(options) {
         stdout.write(options.overrideNotice);
     }
     const startedAt = Date.now();
-    const exitCode = runCommand(commandString, anchorDir, options.runOptions);
-    if (exitCode === 0 && gated) {
+    const { exitCode } = await runCommand(commandString, anchorDir, options.runOptions);
+    if (exitCode === 0 && gate !== undefined) {
         await recordPass({
             anchorDir,
+            buildOutputBefore: gate.buildOutputBefore,
             command,
             commandString,
             config: options.config,
             durationMs: Date.now() - startedAt,
             env,
-            key,
+            key: gate.key,
             monorepoRoot,
-            snapshot,
+            snapshot: gate.snapshot,
             stderr,
         });
     }

package/dist/esm/runner.d.ts

@@ -5,4 +5,21 @@ export interface RunCommandOptions {
     stderr?: Writable;
     env?: NodeJS.ProcessEnv;
 }
-export declare function runCommand(command: string, cwd?: string, options?: RunCommandOptions): number;
+type CommandCompletion = {
+    outcome: 'exited';
+    exitCode: number;
+} | {
+    outcome: 'signaled';
+    exitCode: number;
+    signal: NodeJS.Signals;
+} | {
+    outcome: 'spawn-failed';
+    exitCode: number;
+    error: Error;
+};
+export type RunCommandResult = CommandCompletion & {
+    stdout: Buffer | undefined;
+    stderr: Buffer | undefined;
+};
+export declare function runCommand(command: string, cwd?: string, options?: RunCommandOptions): Promise<RunCommandResult>;
+export {};

package/dist/esm/runner.js

@@ -1,41 +1,114 @@
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import os from 'node:os';
 import process from 'node:process';
 import { reportError } from '@williamthorsen/nmr-core';
-export function runCommand(command, cwd, options) {
+import { createBoundedBuffer } from "./helpers/createBoundedBuffer.js";
+const SIGNAL_EXIT_BASE = 128;
+const PIPE_DRAIN_GRACE_MS = 2_000;
+export async function runCommand(command, 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 stdoutChannel = quiet ? 'pipe' : streamFdOrPipe(stdout);
-    const stderrChannel = quiet ? 'pipe' : streamFdOrPipe(stderr);
-    const result = spawnSync(command, [], {
+    const child = spawn(command, [], {
         shell: true,
-        stdio: ['inherit', stdoutChannel, stderrChannel],
+        stdio: ['inherit', resolveChannel(stdout, quiet), resolveChannel(stderr, quiet)],
         cwd,
         env,
     });
-    if (result.error) {
+    const stdoutCapture = child.stdout === null ? undefined : captureStream(child.stdout, quiet ? undefined : stdout);
+    const stderrCapture = child.stderr === null ? undefined : captureStream(child.stderr, quiet ? undefined : stderr);
+    const completion = await awaitCompletion(child, () => {
+        stdoutCapture?.stopReading();
+        stderrCapture?.stopReading();
+    });
+    stdoutCapture?.detach();
+    stderrCapture?.detach();
+    const result = {
+        ...completion,
+        stdout: stdoutCapture?.toBuffer(),
+        stderr: stderrCapture?.toBuffer(),
+    };
+    if (result.outcome === 'spawn-failed') {
         reportError(result.error.message, stderr);
-        return 1;
+        return result;
     }
-    if (quiet) {
-        if (result.status !== 0) {
-            writeBuffer(result.stdout, stderr);
-            writeBuffer(result.stderr, stderr);
-        }
+    if (quiet && result.exitCode !== 0) {
+        writeBuffer(result.stdout, stderr);
+        writeBuffer(result.stderr, stderr);
+    }
+    return result;
+}
+function captureStream(source, destination) {
+    const retained = createBoundedBuffer();
+    let isComplete = true;
+    function stopReading() {
+        if (destination !== undefined)
+            source.unpipe(destination);
+        source.destroy();
+    }
+    function abandon() {
+        isComplete = false;
+        stopReading();
     }
-    else {
-        if (stdoutChannel === 'pipe')
-            writeBuffer(result.stdout, stdout);
-        if (stderrChannel === 'pipe')
-            writeBuffer(result.stderr, stderr);
+    source.on('error', abandon);
+    if (destination !== undefined) {
+        destination.on('error', abandon);
+        source.pipe(destination, { end: false });
     }
-    return result.status ?? 1;
+    source.on('data', (chunk) => retained.append(chunk));
+    return {
+        toBuffer: () => (isComplete ? retained.toBuffer() : undefined),
+        detach: () => {
+            destination?.off('error', abandon);
+        },
+        stopReading,
+    };
+}
+function awaitCompletion(child, stopReading) {
+    return new Promise((resolve) => {
+        let exitCompletion;
+        let graceTimer;
+        let isSettled = false;
+        function settle(completion) {
+            if (isSettled)
+                return;
+            isSettled = true;
+            if (graceTimer !== undefined)
+                clearTimeout(graceTimer);
+            resolve(completion);
+        }
+        child.on('error', (error) => {
+            settle({ outcome: 'spawn-failed', exitCode: 1, error });
+        });
+        child.on('exit', (code, signal) => {
+            const completion = describeExit(code, signal);
+            exitCompletion = completion;
+            graceTimer = setTimeout(() => {
+                stopReading();
+                settle(completion);
+            }, PIPE_DRAIN_GRACE_MS);
+        });
+        child.on('close', () => {
+            settle(exitCompletion ?? { outcome: 'exited', exitCode: 1 });
+        });
+    });
+}
+function describeExit(code, signal) {
+    if (signal !== null) {
+        return { outcome: 'signaled', exitCode: SIGNAL_EXIT_BASE + os.constants.signals[signal], signal };
+    }
+    return { outcome: 'exited', exitCode: code ?? 1 };
+}
+function resolveChannel(stream, quiet) {
+    if (quiet)
+        return 'pipe';
+    return isTerminal(stream) ? stream.fd : 'pipe';
 }
-function streamFdOrPipe(stream) {
-    return 'fd' in stream && typeof stream.fd === 'number' ? stream.fd : 'pipe';
+function isTerminal(stream) {
+    return 'isTTY' in stream && stream.isTTY === true && 'fd' in stream && typeof stream.fd === 'number';
 }
-function writeBuffer(buffer, dest) {
-    if (buffer.length > 0)
-        dest.write(buffer);
+function writeBuffer(buffer, destination) {
+    if (buffer !== undefined && buffer.length > 0)
+        destination.write(buffer);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
@@ -72,7 +72,7 @@
   },
   "devDependencies": {
     "prettier": "3.9.6",
-    "readyup": "0.24.0",
+    "readyup": "0.26.0",
     "tinyglobby": "0.2.17",
     "vitest": "4.1.10"
   },