@williamthorsen/nmr 0.27.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.23.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/**' .",
@@ -163,6 +164,7 @@ var default_default = defineRdyKit({
         {
           name: ".tool-versions does not list pnpm",
           severity: "warn",
+          quiet: true,
           check: toolVersionsHasNoPnpm,
           fix: "Remove pnpm from .tool-versions \u2014 manage via packageManager field and corepack"
         },
@@ -201,16 +203,10 @@ var default_default = defineRdyKit({
         {
           name: "root package.json has no nmr-provided scripts",
           severity: "warn",
+          quiet: true,
           check: noRedundantRootScripts,
           fix: "Remove scripts from root package.json that nmr provides as built-in root scripts \u2014 invoke via nmr directly"
         },
-        {
-          name: "root:lint:strict does not use echo fallback",
-          severity: "warn",
-          skip: () => !scriptExists("root:lint:strict") ? "no root:lint:strict script" : false,
-          check: () => !scriptMatches("root:lint:strict", /\becho\b/),
-          fix: "Replace the echo fallback in root:lint:strict \u2014 strict-lint now supports path arguments"
-        },
         // -- Workspace build readiness -------------------------------------------
         {
           name: "all workspace packages can build",
@@ -222,6 +218,7 @@ var default_default = defineRdyKit({
         {
           name: "no retired Vitest config variants",
           severity: "error",
+          quiet: true,
           check: () => noRetiredVitestConfigs(),
           fix: "Delete every vitest.standalone.config.* and vitest.integration.config.*. nmr's test scripts select Vitest projects instead of naming config files"
         },
@@ -246,6 +243,7 @@ var default_default = defineRdyKit({
         {
           name: "no package re-exports the ancestor Vitest config",
           severity: "recommend",
+          quiet: true,
           check: () => noReExportOnlyVitestConfigs(),
           fix: "Delete these files. Vitest resolves config by walking up from the run root, so a per-package re-export is redundant"
         },
@@ -263,23 +261,18 @@ var default_default = defineRdyKit({
           check: () => hasDevDependency("v11y-check"),
           fix: "pnpm add --save-dev v11y-check"
         },
-        {
-          name: "code-quality workflow does not use nmr prepush",
-          severity: "warn",
-          skip: () => !fileExists(".github/workflows/code-quality.yaml") ? "no code-quality workflow" : false,
-          check: codeQualityWorkflowDoesNotUseNmrPrepush,
-          fix: 'Change the check-command in .github/workflows/code-quality.yaml from "pnpm exec nmr prepush" to "pnpm exec nmr ci", which runs the same checks without the audit that audit.yaml already runs'
-        },
         // -- Legacy script runner ------------------------------------------------
         {
           name: "scripts/run-workspace-script.ts does not exist",
           severity: "error",
+          quiet: true,
           check: () => !fileExists("scripts/run-workspace-script.ts"),
           fix: "Delete scripts/run-workspace-script.ts \u2014 nmr replaces this custom script runner"
         },
         {
           name: 'no workspace packages reference run-workspace-script or "pnpm run ws"',
           severity: "error",
+          quiet: true,
           check: noWorkspaceRunScriptReferences,
           fix: 'Remove "ws" script entries and replace any "pnpm run ws" invocations with nmr in each packages/*/package.json'
         }
@@ -365,16 +358,11 @@ function hasPrettierConfigKey(cwd) {
   if (manifest === void 0) return false;
   try {
     const parsed = JSON.parse(manifest);
-    return isRecord(parsed) && parsed.prettier !== void 0;
+    return isRecord(parsed) && parsed["prettier"] !== void 0;
   } catch {
     return false;
   }
 }
-function codeQualityWorkflowDoesNotUseNmrPrepush() {
-  const content = readFile(".github/workflows/code-quality.yaml");
-  if (content === void 0) return true;
-  return !/check-command:\s*pnpm exec nmr prepush(\s|$)/.test(content);
-}
 function everyTestFileNamesItsTier(cwd = process.cwd()) {
   const untiered = findTestFiles(cwd).filter((path2) => !hasTierInfix(path2));
   if (untiered.length === 0) return true;
@@ -388,11 +376,11 @@ function formatPaths(paths) {
 ${paths.map((path2) => `      ${path2}`).join("\n")}`;
 }
 function getMinVersion() {
-  const picked = { "version": "0.27.0" };
-  if (typeof picked.version !== "string") {
+  const picked = { "version": "0.29.0" };
+  if (typeof picked["version"] !== "string") {
     throw new TypeError("nmr/package.json: 'version' must be a string");
   }
-  return picked.version;
+  return picked["version"];
 }
 function hasSupportedEslintVersion() {
   return hasMinDevDependencyVersion("eslint", MIN_ESLINT_VERSION, {
@@ -423,7 +411,7 @@ function noReExportOnlyVitestConfigs(cwd = process.cwd()) {
 function noRedundantRootScripts() {
   const pkg = readPackageJson();
   if (!pkg) return true;
-  const scripts = pkg.scripts;
+  const scripts = pkg["scripts"];
   if (!isRecord(scripts)) return true;
   const builtInNames = Object.keys(getDefaultRootScripts());
   const redundant = Object.keys(scripts).filter((name) => builtInNames.includes(name));
@@ -468,20 +456,6 @@ function readFileIn(cwd, relativePath) {
 function resolvesVersionViaWorkspace(range) {
   return WORKSPACE_VERSION_MARKERS.some((marker) => range.startsWith(marker));
 }
-function scriptExists(name) {
-  const pkg = readPackageJson();
-  if (!pkg) return false;
-  const scripts = pkg.scripts;
-  return isRecord(scripts) && Object.hasOwn(scripts, name);
-}
-function scriptMatches(name, pattern) {
-  const pkg = readPackageJson();
-  if (!pkg) return false;
-  const scripts = pkg.scripts;
-  if (!isRecord(scripts)) return false;
-  const value = scripts[name];
-  return typeof value === "string" && pattern.test(value);
-}
 function toolVersionsHasNoPnpm() {
   const content = readFile(".tool-versions");
   if (content === void 0) return true;
@@ -494,7 +468,6 @@ function vitestRootConfigBuildsOnSharedConfig(cwd = process.cwd()) {
   return checkRootVitestConfig("vitest.root.config", "defineRootVitestConfig", cwd);
 }
 export {
-  codeQualityWorkflowDoesNotUseNmrPrepush,
   default_default as default,
   everyTestFileNamesItsTier,
   hasSupportedEslintVersion,

package/.readyup/manifest.json

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

package/README.md

@@ -3,15 +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.27.0 (2026-08-05)
+## Release notes — v0.29.0 (2026-08-09)
 
 ### 🎉 Features
 
-- 🚨 **Breaking:** Lint the whole tree in one process, not one per workspace (#604)
+- Run the dependency audit before ci in prepush (#634)
 
-  Linting of the entire monorepo now runs in a single call instead of via fan-out, eliminating the startup time previously incurred for each workspace.
+  `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.
 
-  As a result of the change, `lint:pre` and `lint:post` hooks in a workspace are no longer triggered by a run from the monorepo root. They continue to be triggered by a run targeting the workspace itself.
+### 🐛 Bug fixes
+
+- Record no pass when build output changes while a check runs (#641)
+
+  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.
+
+- Stream command output so a large writer is no longer killed (#642)
+
+  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
@@ -263,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
 
@@ -424,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.
 
@@ -562,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
@@ -628,7 +638,9 @@ Compile a single package's `src` tree to `dist/esm` with the TypeScript compiler
 
 **What it compiles.** Entry points are `src/**/*.ts` less the directories that hold test scaffolding rather than shipped code: `__fixtures__/`, `__mocks__/`, `__tests__/`, and `test-utils/`. Add to that list per package with [`build.extraIgnorePatterns`](#package-level-configuration). Ignoring a directory drops it as an _entry point_, not from the emit: the compiler still emits whatever the surviving entry points import, so a helper that production code uses is still compiled and its importer never emits a dangling specifier. This list is deliberately not the Vitest [coverage exclusions](#what-the-config-excludes) — helpers live in `test-utils/` precisely so they stay covered.
 
-**The build owns its output directory.** Every rebuild wipes `dist/esm` before emitting, so the directory holds exactly the current emit: a source that was deleted, or that a widened ignore set now covers, leaves nothing behind. Assets therefore belong outside the output directory, or in a `build:post` hook, which runs after the wipe and so composes correctly. Note that a bare `nmr compile` runs no hook, so assets a `build:post` step copies in are absent until a full `nmr build` restores them. An `outdir` that does not resolve inside the package is rejected rather than wiped.
+**The build owns its output directory.** Every rebuild replaces `dist/esm` wholesale, so the directory holds exactly the current emit: a source that was deleted, or that a widened ignore set now covers, leaves nothing behind. Assets therefore belong outside the output directory, or in a `build:post` hook, which runs after the output is published and so composes correctly. Note that a bare `nmr compile` runs no hook, so assets a `build:post` step copies in are absent until a full `nmr build` restores them. An `outdir` that does not resolve inside the package is rejected rather than replaced.
+
+**The replacement is atomic.** The emit is buffered in memory, written to a staging directory beside the output directory, and swapped into place by rename. A build that fails for any reason -- a malformed tsconfig, an unresolvable alias, a full disk -- therefore leaves the previous output exactly as it was. `dist/esm` is never observed mid-write: it holds the previous build or the new one, and is absent only between the two renames. This matters most when the package being rebuilt supplies a binary that other packages in the same recursive build invoke.
 
 `typescript` is a peer dependency (`>=5.7.0 <7`); the consuming repo provides it. The floor is what `rewriteRelativeImportExtensions` requires; the ceiling is because TypeScript 7 ships no compiler API — its root export is a version constant, so `nmr-compile` cannot run on it. Relative imports in source must carry explicit `.ts` extensions for them to be rewritten.
 

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/bin/ensure-prepublish-hooks.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli-ensure-prepublish-hooks.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('ensure-prepublish-hooks: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('ensure-prepublish-hooks: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`ensure-prepublish-hooks: failed to load: ${error.message}\n`);
   }

package/bin/nmr-clean.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli-clean.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-clean: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('nmr-clean: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`nmr-clean: failed to load: ${error.message}\n`);
   }

package/bin/nmr-compile.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli-build.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-compile: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('nmr-compile: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`nmr-compile: failed to load: ${error.message}\n`);
   }

package/bin/nmr-fmt.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli-fmt.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-fmt: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('nmr-fmt: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`nmr-fmt: failed to load: ${error.message}\n`);
   }

package/bin/nmr-report-overrides.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli-report-overrides.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-report-overrides: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('nmr-report-overrides: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`nmr-report-overrides: failed to load: ${error.message}\n`);
   }

package/bin/nmr-taze.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli-taze.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-taze: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('nmr-taze: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`nmr-taze: failed to load: ${error.message}\n`);
   }

package/bin/nmr.js

@@ -3,7 +3,7 @@ try {
   await import('../dist/esm/cli.js');
 } catch (error) {
   if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr: build output not found — run `pnpm run build` first\n');
+    process.stderr.write('nmr: build output not found — run `pnpm run bootstrap` first\n');
   } else {
     process.stderr.write(`nmr: failed to load: ${error.message}\n`);
   }

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. ` +
@@ -105,7 +105,7 @@ export async function readBuildOutputState(monorepoRoot, config) {
         return state;
     }
     const registry = buildWorkspaceRegistry(config);
-    if (JSON.stringify(registry.build) !== JSON.stringify(getDefaultWorkspaceScripts().build)) {
+    if (JSON.stringify(registry['build']) !== JSON.stringify(getDefaultWorkspaceScripts()['build'])) {
         return state;
     }
     for (const packageDir of packageDirs) {
@@ -132,7 +132,8 @@ export async function removeCheckCache(scopeDir) {
 }
 export function resolveCacheableCommands(checkCache) {
     const commands = new Set([...DEFAULT_CACHEABLE_COMMANDS, ...(checkCache?.extraCommands ?? [])]);
-    for (const excluded of checkCache?.excludeCommands ?? []) {
+    const excludedCommands = checkCache?.excludeCommands ?? [];
+    for (const excluded of excludedCommands) {
         commands.delete(excluded);
     }
     return commands;
@@ -184,10 +185,10 @@ function isCheckCacheEntry(value) {
     if (stringFields.some((field) => typeof value[field] !== 'string')) {
         return false;
     }
-    return (typeof value.durationMs === 'number' &&
-        Number.isFinite(value.durationMs) &&
-        !Number.isNaN(Date.parse(String(value.recordedAt))) &&
-        isStringRecord(value.buildDigests));
+    return (typeof value['durationMs'] === 'number' &&
+        Number.isFinite(value['durationMs']) &&
+        !Number.isNaN(Date.parse(String(value['recordedAt']))) &&
+        isStringRecord(value['buildDigests']));
 }
 function isProbeSubject(packageDir, registry) {
     const build = resolveScript('build', registry, packageDir, false);

package/dist/esm/commands/build-output.d.ts

@@ -4,6 +4,10 @@ export interface BuildOptions {
     ignorePatterns?: string[];
     outdir?: string;
 }
+export interface ScratchDirs {
+    previous: string;
+    staging: string;
+}
 export declare const DEFAULT_ENTRY_GLOBS: string[];
 export declare const DEFAULT_IGNORE_PATTERNS: string[];
 export declare const DEFAULT_OUTDIR = "dist/esm/";
@@ -11,3 +15,4 @@ export declare function hasBuildOutput(packageDir: string, options?: BuildOption
 export declare function hasExpectedBuildOutput(packageDir: string, outdir: string, entryPoints: string[]): boolean;
 export declare function readBuildDigest(packageDir: string): Promise<string | undefined>;
 export declare function resolveBuildCachePath(packageDir: string): string;
+export declare function resolveScratchDirs(emitDir: string): ScratchDirs;

package/dist/esm/commands/build-output.js

@@ -34,3 +34,11 @@ export function resolveBuildCachePath(packageDir) {
         extension: '.hash',
     });
 }
+export function resolveScratchDirs(emitDir) {
+    const parent = path.dirname(emitDir);
+    const name = path.basename(emitDir);
+    return {
+        previous: path.join(parent, `.${name}.previous`),
+        staging: path.join(parent, `.${name}.staging`),
+    };
+}

package/dist/esm/commands/build.js

@@ -1,12 +1,12 @@
 import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { readFile, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { readCacheEntry, writeCacheEntry } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
 import * as ts from 'typescript';
 import { resolveConfigPath } from "../config.js";
-import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, } from "./build-output.js";
+import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, resolveScratchDirs, } from "./build-output.js";
 const PACKAGE_ICON = '📦';
 const SKIPPED_ICON = '⏭️';
 const SOURCE_ROOT = 'src';
@@ -18,7 +18,7 @@ export async function buildPackage(packageDir, options = {}) {
     assertSupportedTypeScript();
     const cachePath = resolveBuildCachePath(packageDir);
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
-    resolveEmitDir(packageDir, outdir);
+    const emitDir = resolveEmitDir(packageDir, outdir);
     const emitConfig = { outdir, declaration: true, rewriteRelativeImportExtensions: true };
     const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
         cwd: packageDir,
@@ -32,6 +32,7 @@ export async function buildPackage(packageDir, options = {}) {
     ];
     const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, ts.version, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
     if (!changed) {
+        await discardScratchDirs(resolveScratchDirs(emitDir));
         return;
     }
     await emitPackage(packageDir, entryPoints, outdir);
@@ -64,10 +65,7 @@ export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json
             throw new Error(`nmr-compile: failed to read ${normalized}.\n${formatDiagnostics([configFile.error])}`);
         }
         for (const entry of normalizeExtendsField(configFile.config)) {
-            const baseConfig = resolveExtendsTarget(entry, normalized);
-            if (baseConfig !== undefined) {
-                walk(baseConfig);
-            }
+            walk(resolveExtendsTarget(entry, normalized));
         }
     }
     walk(path.resolve(packageDir, configFileName));
@@ -77,29 +75,64 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     const compilerOptions = synthesizeCompilerOptions(packageDir, outdir);
     const rootNames = entryPoints.map((entry) => path.resolve(packageDir, entry));
     const sourceRoot = path.resolve(packageDir, SOURCE_ROOT);
+    const emitDir = resolveEmitDir(packageDir, outdir);
+    const scratchDirs = resolveScratchDirs(emitDir);
+    await removeScratchDirs(scratchDirs);
     const program = ts.createProgram(rootNames, compilerOptions);
-    await rm(resolveEmitDir(packageDir, outdir), { force: true, recursive: true });
-    const emittedFiles = [];
+    const emitted = new Map();
     const emitResult = program.emit(undefined, (fileName, text, writeByteOrderMark) => {
-        ts.sys.writeFile(fileName, text, writeByteOrderMark);
-        emittedFiles.push(fileName);
+        emitted.set(fileName, { text, writeByteOrderMark });
     });
     if (emitResult.emitSkipped) {
         throw new Error(`nmr-compile: emit failed.\n${formatDiagnostics(emitResult.diagnostics)}`);
     }
-    for (const file of emittedFiles) {
-        rewriteOutputSpecifiers(file, compilerOptions, sourceRoot);
+    const staged = new Map();
+    for (const [fileName, file] of emitted) {
+        staged.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
+    }
+    if (staged.size === 0) {
+        await rm(emitDir, { force: true, recursive: true });
+        return;
+    }
+    writeStagedOutput(staged, emitDir, scratchDirs.staging);
+    await swapIntoPlace(emitDir, scratchDirs);
+}
+async function discardScratchDirs(scratchDirs) {
+    try {
+        await removeScratchDirs(scratchDirs);
+    }
+    catch {
     }
 }
+async function removeScratchDirs(scratchDirs) {
+    await rm(scratchDirs.previous, { force: true, recursive: true });
+    await rm(scratchDirs.staging, { force: true, recursive: true });
+}
 function resolveEmitDir(packageDir, outdir) {
     const resolved = path.resolve(packageDir, outdir);
     const relative = path.relative(packageDir, resolved);
     if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
         throw new Error(`nmr-compile: refusing to build into '${outdir}', which does not resolve inside the package. ` +
-            'The build wipes its output directory before each emit, so the directory must sit below the package root.');
+            'The build replaces its output directory on each emit, so the directory must sit below the package root.');
     }
     return resolved;
 }
+async function swapIntoPlace(emitDir, scratchDirs) {
+    const hadPreviousOutput = existsSync(emitDir);
+    if (hadPreviousOutput) {
+        await rename(emitDir, scratchDirs.previous);
+    }
+    try {
+        await rename(scratchDirs.staging, emitDir);
+    }
+    catch (error) {
+        if (hadPreviousOutput && !existsSync(emitDir)) {
+            await rename(scratchDirs.previous, emitDir);
+        }
+        throw error;
+    }
+    await discardScratchDirs(scratchDirs);
+}
 function synthesizeCompilerOptions(packageDir, outdir) {
     const configPath = path.join(packageDir, 'tsconfig.json');
     const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
@@ -125,12 +158,20 @@ function synthesizeCompilerOptions(packageDir, outdir) {
         noEmitOnError: false,
     };
 }
-function rewriteOutputSpecifiers(outputFile, compilerOptions, sourceRoot) {
+function writeStagedOutput(staged, emitDir, stagingDir) {
+    for (const [fileName, file] of staged) {
+        if (!isWithin(emitDir, fileName)) {
+            throw new Error(`nmr-compile: the compiler emitted ${fileName}, which is outside the output directory ${emitDir}. ` +
+                "Verify the resolved tsconfig's 'outDir' and 'declarationDir'.");
+        }
+        ts.sys.writeFile(path.join(stagingDir, path.relative(emitDir, fileName)), file.text, file.writeByteOrderMark);
+    }
+}
+function rewriteSpecifiers(outputFile, text, compilerOptions, sourceRoot) {
     if (!isRewritableOutput(outputFile)) {
-        return;
+        return text;
     }
-    const originalText = readFileSync(outputFile, 'utf8');
-    const sourceFile = ts.createSourceFile(outputFile, originalText, ts.ScriptTarget.Latest, false, scriptKindFor(outputFile));
+    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, scriptKindFor(outputFile));
     const aliasPrefixes = collectAliasPrefixes(compilerOptions);
     const sourceContainingFile = mapOutputToSource(outputFile, compilerOptions, sourceRoot);
     const edits = [];
@@ -140,18 +181,18 @@ function rewriteOutputSpecifiers(outputFile, compilerOptions, sourceRoot) {
             return;
         }
         const start = literal.getStart(sourceFile);
-        const quote = originalText[start] ?? '"';
+        const quote = text[start] ?? '"';
         edits.push({ start, end: literal.getEnd(), text: `${quote}${replacement}${quote}` });
     });
     if (edits.length === 0) {
-        return;
+        return text;
     }
     const orderedEdits = [...edits].sort((a, b) => b.start - a.start);
-    let updatedText = originalText;
+    let updatedText = text;
     for (const edit of orderedEdits) {
         updatedText = updatedText.slice(0, edit.start) + edit.text + updatedText.slice(edit.end);
     }
-    writeFileSync(outputFile, updatedText);
+    return updatedText;
 }
 function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes) {
     if (isRelativeSpecifier(specifier)) {
@@ -267,9 +308,20 @@ function resolveExtendsTarget(extendsEntry, fromConfigPath) {
             return base;
         }
         const withJsonExtension = `${base}.json`;
-        return ts.sys.fileExists(withJsonExtension) ? withJsonExtension : undefined;
+        if (ts.sys.fileExists(withJsonExtension)) {
+            return withJsonExtension;
+        }
+        throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not exist.`);
+    }
+    const resolved = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
+        resolvePackageSpecifier(`${extendsEntry}/tsconfig.json`, fromConfigPath);
+    if (resolved === undefined) {
+        throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not resolve to a file.`);
     }
-    const { resolvedModule } = ts.resolveModuleName(extendsEntry, fromConfigPath, { moduleResolution: ts.ModuleResolutionKind.NodeNext, resolveJsonModule: true }, ts.sys);
+    return resolved;
+}
+function resolvePackageSpecifier(specifier, fromConfigPath) {
+    const { resolvedModule } = ts.resolveModuleName(specifier, fromConfigPath, { moduleResolution: ts.ModuleResolutionKind.NodeNext, resolveJsonModule: true }, ts.sys);
     return resolvedModule?.resolvedFileName;
 }
 function isRelativeSpecifier(specifier) {

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/commands/ensure-prepublish-hooks.js

@@ -17,12 +17,12 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
                 packageName,
                 packageDir,
                 isPrivate: true,
-                prepublishOnly: pkg.scripts?.prepublishOnly,
+                prepublishOnly: pkg.scripts?.['prepublishOnly'],
                 action: 'ok',
             });
             continue;
         }
-        const existing = pkg.scripts?.prepublishOnly;
+        const existing = pkg.scripts?.['prepublishOnly'];
         if (existing) {
             packages.push({
                 packageName,
@@ -66,8 +66,8 @@ function addPrepublishOnly(packageDir, command) {
     if (!isObject(parsed)) {
         throw new TypeError(`Invalid package.json in ${packageDir}: expected an object`);
     }
-    const scripts = isObject(parsed.scripts) ? parsed.scripts : {};
-    scripts.prepublishOnly = command;
-    parsed.scripts = scripts;
+    const scripts = isObject(parsed['scripts']) ? parsed['scripts'] : {};
+    scripts['prepublishOnly'] = command;
+    parsed['scripts'] = scripts;
     writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
 }

package/dist/esm/commands/fmt.js

@@ -108,7 +108,7 @@ function resolvePrettierCli() {
     const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
     if (!isObject(manifest))
         return missing;
-    const bin = isObject(manifest.bin) ? manifest.bin[PRETTIER_PACKAGE] : manifest.bin;
+    const bin = isObject(manifest['bin']) ? manifest['bin'][PRETTIER_PACKAGE] : manifest['bin'];
     if (typeof bin !== 'string')
         return missing;
     return { ok: true, cliPath: path.resolve(path.dirname(manifestPath), bin) };

package/dist/esm/config.js

@@ -42,7 +42,7 @@ function isScriptRecord(value) {
     return true;
 }
 function validateScriptField(value, fieldName, configPath) {
-    if (!(fieldName in value) || value[fieldName] === undefined) {
+    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
         return undefined;
     }
     if (!isScriptRecord(value[fieldName])) {
@@ -54,7 +54,7 @@ function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
 function validateBuildField(value, configPath) {
-    const build = value.build;
+    const build = value['build'];
     if (build === undefined) {
         return undefined;
     }
@@ -62,14 +62,14 @@ function validateBuildField(value, configPath) {
         throw new Error(`Invalid nmr config at ${configPath}: \`build\` must be an object`);
     }
     assertRecognizedKeys(build, RECOGNIZED_BUILD_KEYS, configPath, 'build.');
-    const extraIgnorePatterns = build.extraIgnorePatterns;
+    const extraIgnorePatterns = build['extraIgnorePatterns'];
     if (extraIgnorePatterns !== undefined && !isStringArray(extraIgnorePatterns)) {
         throw new Error(`Invalid nmr config at ${configPath}: \`build.extraIgnorePatterns\` must be a string[]`);
     }
     return extraIgnorePatterns === undefined ? {} : { extraIgnorePatterns };
 }
 function validateCheckCacheField(value, configPath) {
-    const checkCache = value.checkCache;
+    const checkCache = value['checkCache'];
     if (checkCache === undefined) {
         return undefined;
     }
@@ -78,7 +78,7 @@ function validateCheckCacheField(value, configPath) {
     }
     assertRecognizedKeys(checkCache, RECOGNIZED_CHECK_CACHE_KEYS, configPath, 'checkCache.');
     const config = {};
-    const enabled = checkCache.enabled;
+    const enabled = checkCache['enabled'];
     if (enabled !== undefined) {
         if (typeof enabled !== 'boolean') {
             throw new TypeError(`Invalid nmr config at ${configPath}: \`checkCache.enabled\` must be a boolean`);
@@ -98,7 +98,7 @@ function validateCheckCacheField(value, configPath) {
     return config;
 }
 function validateStringRecordField(value, fieldName, configPath) {
-    if (!(fieldName in value) || value[fieldName] === undefined) {
+    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
         return undefined;
     }
     if (!isStringRecord(value[fieldName])) {
@@ -135,7 +135,7 @@ export async function loadConfig(baseDir) {
         return {};
     }
     const imported = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
-    const loaded = isObject(imported) ? imported.default : undefined;
+    const loaded = isObject(imported) ? imported['default'] : undefined;
     return validateConfig(loaded, configPath);
 }
 export async function loadRootConfig(monorepoRoot) {

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/help.js

@@ -50,7 +50,7 @@ function collectOverrides(packageDir) {
 function applyOverrides(registry, overrides) {
     const marked = new Set();
     for (const [name, value] of Object.entries(overrides)) {
-        if (!(name in registry)) {
+        if (!Object.hasOwn(registry, name)) {
             continue;
         }
         registry[name] = value;

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/helpers/package-json.js

@@ -7,27 +7,29 @@ export function readPackageJson(dir) {
         throw new TypeError(`Invalid package.json in ${dir}: expected an object`);
     }
     const pkg = {};
-    if (typeof parsed.name === 'string')
-        pkg.name = parsed.name;
-    if (parsed.private === true)
+    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)) {
+    if (typeof parsed['version'] === 'string')
+        pkg.version = parsed['version'];
+    if (typeof parsed['packageManager'] === 'string')
+        pkg.packageManager = parsed['packageManager'];
+    if (isObject(parsed['scripts'])) {
         const scripts = {};
-        for (const [key, val] of Object.entries(parsed.scripts)) {
+        const scriptEntries = Object.entries(parsed['scripts']);
+        for (const [key, val] of scriptEntries) {
             if (typeof val === 'string')
                 scripts[key] = val;
         }
         pkg.scripts = scripts;
     }
-    if (isObject(parsed.pnpm)) {
-        const pnpm = parsed.pnpm;
-        if (isObject(pnpm.overrides)) {
+    if (isObject(parsed['pnpm'])) {
+        const pnpm = parsed['pnpm'];
+        if (isObject(pnpm['overrides'])) {
             const overrides = {};
-            for (const [key, val] of Object.entries(pnpm.overrides)) {
+            const overrideEntries = Object.entries(pnpm['overrides']);
+            for (const [key, val] of overrideEntries) {
                 if (typeof val === 'string')
                     overrides[key] = val;
             }

package/dist/esm/resolver.js

@@ -46,7 +46,7 @@ export function readPackageJsonScripts(packageDir) {
         const parsed = JSON.parse(raw);
         if (!isObject(parsed))
             return undefined;
-        const scripts = parsed.scripts;
+        const scripts = parsed['scripts'];
         if (!isObject(scripts))
             return undefined;
         const result = {};
@@ -82,13 +82,16 @@ export function isSelfReferential(script, commandName) {
 export function resolveScript(commandName, registry, packageDir, workspaceRoot) {
     if (packageDir) {
         const pkgScripts = readPackageJsonScripts(packageDir);
-        if (pkgScripts && commandName in pkgScripts) {
+        if (pkgScripts && Object.hasOwn(pkgScripts, commandName)) {
             const override = pkgScripts[commandName];
             if (override !== undefined && !isSelfReferential(override, commandName)) {
                 return { command: override, source: 'package' };
             }
         }
     }
+    if (!Object.hasOwn(registry, commandName)) {
+        return undefined;
+    }
     const registryEntry = registry[commandName];
     if (registryEntry === undefined) {
         return undefined;

package/dist/esm/runCli.js

@@ -41,19 +41,19 @@ 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);
     const resolved = resolveScript(command, registry, anchorDir, parsed.workspaceRoot);
     if (!resolved) {
-        if (env.NMR_RUN_IF_PRESENT === '1') {
+        if (env['NMR_RUN_IF_PRESENT'] === '1') {
             return { exitCode: 0 };
         }
         reportError(`Unknown command: ${command}`, stderr);
@@ -105,7 +105,8 @@ function buildChildEnv(env, snapshot, noCache) {
     };
 }
 function formatOverrideNotice(resolved, registry, command, anchorDir, quiet) {
-    if (quiet || resolved.source !== 'package' || registry[command] === undefined) {
+    const registryEntry = Object.hasOwn(registry, command) ? registry[command] : undefined;
+    if (quiet || resolved.source !== 'package' || registryEntry === undefined) {
         return undefined;
     }
     return `📦 ${path.basename(anchorDir)}: Using override script: ${resolved.command}\n`;
@@ -132,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);
@@ -142,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;
@@ -254,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,
@@ -303,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,
         });
@@ -325,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/dist/esm/vitest.js

@@ -15,7 +15,7 @@ export function defineVitestConfig(...layers) {
 }
 export function defineRootVitestConfig(...layers) {
     const lastLayer = layers.at(-1);
-    const monorepoRoot = isObject(lastLayer) ? lastLayer.monorepoRoot : undefined;
+    const monorepoRoot = isObject(lastLayer) ? lastLayer['monorepoRoot'] : undefined;
     if (typeof monorepoRoot !== 'string' || !path.isAbsolute(monorepoRoot)) {
         throw new TypeError(MISSING_MONOREPO_ROOT);
     }
@@ -42,7 +42,12 @@ function buildConfig(declaredLayers, { coverageInclude, projectExclude = [], pro
             watch: false,
         },
     };
-    return layers.reduce((merged, { root }) => (root ? mergeConfig(merged, root) : merged), config);
+    let merged = config;
+    for (const { root } of layers) {
+        if (root)
+            merged = mergeConfig(merged, root);
+    }
+    return merged;
 }
 function buildProjects(layers, extraExclude, projectRoot) {
     const projectTiers = [
@@ -65,7 +70,11 @@ function buildProjects(layers, extraExclude, projectRoot) {
                 ...(timeout !== undefined && { hookTimeout: timeout, testTimeout: timeout }),
             },
         };
-        return layers.reduce((merged, layer) => applyLayer(merged, layer, name), project);
+        let merged = project;
+        for (const layer of layers) {
+            merged = applyLayer(merged, layer, name);
+        }
+        return merged;
     });
 }
 function applyLayer(project, layer, tier) {
@@ -76,7 +85,8 @@ function applyLayer(project, layer, tier) {
 function assertKnownTiers(layers) {
     const known = TIER_NAMES;
     for (const { tiers } of layers) {
-        for (const name of Object.keys(tiers ?? {})) {
+        const declaredTiers = Object.keys(tiers ?? {});
+        for (const name of declaredTiers) {
             if (!known.includes(name)) {
                 throw new TypeError(`Unknown tier "${name}" in \`tiers\`. Valid tiers: ${TIER_NAMES.join(', ')}.`);
             }

package/dist/esm/workspace.js

@@ -33,7 +33,7 @@ export function getWorkspacePackageDirs(monorepoRoot) {
 function getPackagesFromParsedYaml(parsed) {
     if (!isObject(parsed))
         return undefined;
-    const packages = parsed.packages;
+    const packages = parsed['packages'];
     if (!Array.isArray(packages))
         return undefined;
     if (!packages.every((p) => typeof p === 'string'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
@@ -68,11 +68,11 @@
     "prettier-plugin-sh": "0.19.0",
     "taze": "19.16.0",
     "yaml": "2.9.0",
-    "@williamthorsen/nmr-core": "0.9.2"
+    "@williamthorsen/nmr-core": "0.9.3"
   },
   "devDependencies": {
     "prettier": "3.9.6",
-    "readyup": "0.23.0",
+    "readyup": "0.26.0",
     "tinyglobby": "0.2.17",
     "vitest": "4.1.10"
   },