@williamthorsen/nmr 0.46.2 → 0.47.0

package/.meta/changelog.json

@@ -1,4 +1,41 @@
 [
+  {
+    "version": "0.47.0",
+    "date": "2026-10-15",
+    "sections": [
+      {
+        "title": "🎉 Features",
+        "audience": "all",
+        "items": [
+          {
+            "description": "Sets `maxWorkers` on every project built by `defineVitestConfig` and `defineRootVitestConfig` to one worker per 4 GiB of total memory, bounded by one fewer than the core count, in place of Vitest's default of one fewer than the core count, which does not take memory into account; machines with 2 or fewer cores keep 3 workers. (#1044)",
+            "hash": "8c761e2b054daf91ba362d3f3e878329d35d2eb4",
+            "entry": 1
+          },
+          {
+            "description": "Applies the `--maxWorkers` (or `--max-workers`) flag to every project, which Vitest does not do itself, making the flag override both the derived count and a `maxWorkers` set through the `project` or `tiers` seam, while the `VITEST_MAX_WORKERS` environment variable still overrides the flag. (#1044)",
+            "hash": "8c761e2b054daf91ba362d3f3e878329d35d2eb4",
+            "entry": 2
+          },
+          {
+            "description": "Adds a machine lock that makes a heavy command (`check`, `ci`, and every `test` command except `test:watch`) wait, printing `nmr: waiting for …`, until the heavy command already running on the machine finishes; a nested command and a `-R` or `-F` fan-out take the lock once, and a cached pass does not wait. (#1045)",
+            "hash": "2797c36e73b431c848a5819909aae7f3de6e0af6",
+            "entry": 1
+          },
+          {
+            "description": "Adds the `--no-lock` flag and the `NMR_NO_LOCK=1` environment variable, which run a command and the commands nested in it without waiting for the machine lock, for example on a self-hosted CI machine that runs several runners in parallel. (#1045)",
+            "hash": "2797c36e73b431c848a5819909aae7f3de6e0af6",
+            "entry": 2
+          },
+          {
+            "description": "Extends the `nmr` rulebook to state that a run printing `nmr: waiting for …` is waiting for the machine lock rather than stuck, and that an agent must neither kill it nor rerun it with `--no-lock`. (#1045)",
+            "hash": "2797c36e73b431c848a5819909aae7f3de6e0af6",
+            "entry": 3
+          }
+        ]
+      }
+    ]
+  },
   {
     "version": "0.46.2",
     "date": "2026-10-14",

package/.readyup/kits/default.js

@@ -8939,7 +8939,7 @@ function formatPaths(paths) {
 ${paths.map((path7) => `      ${path7}`).join("\n")}`;
 }
 function getMinVersion() {
-  const pickedFields = { "version": "0.46.2" };
+  const pickedFields = { "version": "0.47.0" };
   if (typeof pickedFields["version"] !== "string") {
     throw new TypeError("nmr/package.json: 'version' must be a string");
   }

package/.readyup/manifest.json

@@ -86,7 +86,7 @@
           "path": "kits/default.ts"
         },
         {
-          "hash": "43858381",
+          "hash": "a06b470a",
           "kind": "inline",
           "path": "../package.json",
           "paths": [
@@ -189,7 +189,7 @@
       "readyupVersion": "0.40.0",
       "source": "kits/default.ts",
       "sourceHash": "aaeb1a84",
-      "targetHash": "32ebc3f7"
+      "targetHash": "125a39cc"
     }
   ]
 }

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.47.0 — 2026-10-15
+
+### 🎉 Features
+
+- Sets `maxWorkers` on every project built by `defineVitestConfig` and `defineRootVitestConfig` to one worker per 4 GiB of total memory, bounded by one fewer than the core count, in place of Vitest's default of one fewer than the core count, which does not take memory into account; machines with 2 or fewer cores keep 3 workers. (#1044)
+- Applies the `--maxWorkers` (or `--max-workers`) flag to every project, which Vitest does not do itself, making the flag override both the derived count and a `maxWorkers` set through the `project` or `tiers` seam, while the `VITEST_MAX_WORKERS` environment variable still overrides the flag. (#1044)
+- Adds a machine lock that makes a heavy command (`check`, `ci`, and every `test` command except `test:watch`) wait, printing `nmr: waiting for …`, until the heavy command already running on the machine finishes; a nested command and a `-R` or `-F` fan-out take the lock once, and a cached pass does not wait. (#1045)
+- Adds the `--no-lock` flag and the `NMR_NO_LOCK=1` environment variable, which run a command and the commands nested in it without waiting for the machine lock, for example on a self-hosted CI machine that runs several runners in parallel. (#1045)
+- Extends the `nmr` rulebook to state that a run printing `nmr: waiting for …` is waiting for the machine lock rather than stuck, and that an agent must neither kill it nor rerun it with `--no-lock`. (#1045)
+
 ## 0.46.2 — 2026-10-14
 
 ### 🐛 Bug fixes

package/README.md

@@ -5,11 +5,15 @@
 Context-aware script runner for pnpm monorepos. Includes 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.46.2 (2026-10-14)
+## Release notes — v0.47.0 (2026-10-15)
 
-### 🐛 Bug fixes
+### 🎉 Features
 
-- Fixes the issue that `checkTestFileConventions` failed with a bare `TypeError` when `node_modules` contained a second `@vitest/runner` copy, and replaces that error with one that names the resolved `vitest` and gives `pnpm install --force` as the remedy. (#1041)
+- Sets `maxWorkers` on every project built by `defineVitestConfig` and `defineRootVitestConfig` to one worker per 4 GiB of total memory, bounded by one fewer than the core count, in place of Vitest's default of one fewer than the core count, which does not take memory into account; machines with 2 or fewer cores keep 3 workers. (#1044)
+- Applies the `--maxWorkers` (or `--max-workers`) flag to every project, which Vitest does not do itself, making the flag override both the derived count and a `maxWorkers` set through the `project` or `tiers` seam, while the `VITEST_MAX_WORKERS` environment variable still overrides the flag. (#1044)
+- Adds a machine lock that makes a heavy command (`check`, `ci`, and every `test` command except `test:watch`) wait, printing `nmr: waiting for …`, until the heavy command already running on the machine finishes; a nested command and a `-R` or `-F` fan-out take the lock once, and a cached pass does not wait. (#1045)
+- Adds the `--no-lock` flag and the `NMR_NO_LOCK=1` environment variable, which run a command and the commands nested in it without waiting for the machine lock, for example on a self-hosted CI machine that runs several runners in parallel. (#1045)
+- Extends the `nmr` rulebook to state that a run printing `nmr: waiting for …` is waiting for the machine lock rather than stuck, and that an agent must neither kill it nor rerun it with `--no-lock`. (#1045)
 <!-- /section:release-notes -->
 
 ## Installation
@@ -180,6 +184,17 @@ $ nmr ci
 
 [Check-result cache](docs/check-cache.md) covers what is cached, what a hit requires, replaying and reading a recorded run, and bypassing or configuring the cache.
 
+## Machine lock
+
+Tests and checks peak at several gigabytes, so nmr runs one heavy command at a time on a machine. A second `check`, `ci`, or `test` from any repository waits for the first rather than competing with it for memory:
+
+```console
+$ nmr check
+nmr: waiting for test in /Users/me/repos/other-repo (pid 41872) to finish
+```
+
+The lock lives in `/tmp/nmr-<uid>/`, or in `NMR_LOCK_DIR`; a sandboxed session needs write access to it. `nmr --no-lock <command>` or `NMR_NO_LOCK=1` runs without waiting. [Machine lock](docs/machine-lock.md) covers which commands take it, nesting and fan-outs, reclaiming a lock that its holder left behind, and CI.
+
 ## Shared configs and helpers
 
 ### Shared Vitest config
@@ -283,6 +298,7 @@ rdy list --from npm:@williamthorsen/nmr  # what nmr publishes
 - [Scripts and configuration](docs/scripts.md): Override tiers, script values, hooks, `defineConfig` fields, `devBin`, and the default commands
 - [What nmr reports](docs/reporting.md): Verdicts, `--json`, output style, and verbosity
 - [Check-result cache](docs/check-cache.md): What is skipped, what a hit requires, and replaying, reading, and bypassing recorded runs
+- [Machine lock](docs/machine-lock.md): Which commands wait for one another, where the lock lives, and bypassing it
 - [Dependency upgrades](docs/upgrades.md): `nmr upgrade`, the upgrade policy, `report-catalog`, `report-overrides`, and `nmr-taze`
 - [Standalone utilities](docs/utilities.md): `nmr-clean`, `nmr-compile`, `nmr-fmt`, and `ensure-prepublish-hooks`
 - [Shared Vitest config](docs/vitest.md): Test tiers, test selections, the conventions check, and customization

package/agents/guidance/rulebooks/nmr.md

@@ -14,4 +14,5 @@ delivery: ambient
 - `nmr --log <command>` prints the whole run behind that excerpt -- up to 256 KiB, led by when it was recorded, how long it ran, and the command string that produced it. Output that you need in full is a recording to read rather than a command to run again. It runs nothing, and it is held to the tree rather than to the terminal: A recording made by a piped run prints for a reader at one. A composite prints its constituents' excerpts, not their transcripts, so the transcript of one of them is `nmr -F <pkg> --log <command>` or that constituent's own name. When there is nothing to show, `--log` says so on one line, names which case it is, and exits non-zero.
 - Every command that nmr runs reports one line -- `PASS <scope>: <command>: passed in 12.4s`, `FAIL … failed in 1.2s (exit 1)`, `SKIP … passed 4m ago on this tree`, or `NOOP … skipped, the override is empty` -- and a composite reports alongside every command into which it expands. Those are the words that a pipe and a CI log get; a terminal gets ✅, ❌, ⏩, and ⚪ in their place, and `--output-style rich` or `NMR_OUTPUT_STYLE=rich` forces the emoji on any stream. The lines print in every verbosity, so `nmr -q <command>` is the low-noise way to run rather than a silent one: It withholds the output of the commands that nmr runs and keeps nmr's own verdicts, which is how a pass, a cached skip, and a `""`/`":"` override stay distinguishable. nmr reads its own flags only before the command name and passes everything after the name to the commands that run: `nmr ci -q` hands `-q` to `nmr-fmt`, which rejects it. Expect a run to be quiet already without the flag: nmr recognizes a known agent harness in the environment and takes quiet from that, as it does from `NMR_COMMAND_VERBOSITY` or the repo's `output.commandVerbosity`. A command whose output you need in full is one to run with `NMR_COMMAND_VERBOSITY=full`, which outranks both.
 - Every test file lives under a `__tests__` directory and names its isolation tier last: `<subject>[.<aspect>].<tier>.test.ts`, where any earlier segment is free-form documentation. A tier is the furthest thing that the test reaches -- `tool` (a process that the test starts, or a program other than the package's own code that the test makes do its work, including an embedded engine, which the package installs and the test runs in-process, such as PGlite), `localhost` (a service already running on this machine), `remote` (a machine that isn't this one), or `unit`, the residual claiming everything else. A file outside `__tests__`, or one whose tier segment is missing or misspelt, fails the test run in a repo that declares nmr's exported conventions check, which reports both. In a repo that has not, neither fails anything -- the first is collected by nothing and the second runs under `unit` -- and `rdy run --sources` reports both and warns that the check is missing.
-- The rest is in `node_modules/@williamthorsen/nmr/docs/`: `scripts.md` for pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`) and script overrides and their `""`/`":"` skip values; `upgrades.md` for `nmr upgrade` ceilings (report-only until `nmr upgrade --write`); `utilities.md` for the `nmr-compile` build (the repo does not define a build script of its own); `vitest.md` for the test tiers' timeout budgets, the `tiers` seam that raises one, and which script reaches which tier; and `check-cache.md` for the check-result cache's key, the retention key to which a replayed excerpt is additionally held, the retention ceiling within which `--log` prints, its `checkCache` config, and every condition that disables it.
+- A heavy command (`check`, `ci`, and the `test` commands but `test:watch`) may print `nmr: waiting for <command> in <dir> (pid <pid>) to finish` and wait: nmr runs one at a time on the machine, across every repository. The run is not stuck, and it continues once the holder ends. Do not kill it, and do not rerun it with `--no-lock` to get past the wait, which defeats the memory protection that the lock exists for. A warning that nmr is `running without the machine lock` names a directory that the sandbox cannot write.
+- The rest is in `node_modules/@williamthorsen/nmr/docs/`: `scripts.md` for pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`) and script overrides and their `""`/`":"` skip values; `upgrades.md` for `nmr upgrade` ceilings (report-only until `nmr upgrade --write`); `utilities.md` for the `nmr-compile` build (the repo does not define a build script of its own); `vitest.md` for the test tiers' timeout budgets, the `tiers` seam that raises one, and which script reaches which tier; `machine-lock.md` for which commands take the machine lock, where it lives, and its bypass; and `check-cache.md` for the check-result cache's key, the retention key to which a replayed excerpt is additionally held, the retention ceiling within which `--log` prints, its `checkCache` config, and every condition that disables it.

package/dist/esm/help.js

@@ -35,6 +35,7 @@ export function generateHelp(config, monorepoRoot, packageDir, shouldUseRoot) {
         '      --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',
+        '      --no-lock               Run without waiting for another heavy command on this machine',
         `      ${OUTPUT_STYLE_FLAG} <style>  Output style: auto (default), plain, or rich`,
         '  -?, --help                  Show this help',
         '  -V, --version               Show version number',

package/dist/esm/machine-lock.d.ts

@@ -0,0 +1,64 @@
+import type { Writable } from 'node:stream';
+import { type OutputStyle } from '@williamthorsen/nmr-core';
+/** How often a holder refreshes the lock file's mtime. */
+export declare const HEARTBEAT_INTERVAL_MS = 10000;
+/**
+ * The commands that take the machine lock: the ones whose memory peak makes two concurrent runs slower than two in
+ * sequence. `test:watch` is absent because it runs until it is stopped, and holding the lock would block every other
+ * run for as long.
+ */
+export declare const HEAVY_COMMANDS: ReadonlySet<string>;
+/** Overrides the directory that contains the lock file. */
+export declare const LOCK_DIR_ENV_VAR = "NMR_LOCK_DIR";
+/** Passes the holder's token to the processes below it, which run under its hold rather than waiting on it. */
+export declare const LOCK_TOKEN_ENV_VAR = "NMR_MACHINE_LOCK_TOKEN";
+/** Set to `1` to run without the lock, for the whole chain. */
+export declare const NO_LOCK_ENV_VAR = "NMR_NO_LOCK";
+/** How often a waiter checks the lock again. */
+export declare const POLL_INTERVAL_MS = 1000;
+/**
+ * Age at which an unrefreshed lock file is abandoned. It covers a holder whose pid was reused by another process,
+ * and a file left half-written, neither of which a liveness check detects.
+ */
+export declare const STALE_AFTER_MS = 60000;
+/** A taken lock, or the hold-free stand-in for a run that does not take one. */
+export interface MachineLock {
+    /**
+     * Whether the chain runs without the lock: the bypass is set, or the lock directory cannot be written. The processes
+     * below then skip the lock rather than each trying it again and repeating the warning.
+     */
+    isChainUnlocked: boolean;
+    release: () => Promise<void>;
+    /** The token in the lock file, when this call took the lock. */
+    token: string | undefined;
+    /** Whether the call waited for another holder before returning. */
+    waited: boolean;
+}
+/**
+ * Takes the machine lock, waiting while another process holds it. Resolves to a hold-free lock without waiting when
+ * the bypass is set, when this process runs under an ancestor's hold, or when the lock directory cannot be written.
+ */
+export declare function acquireMachineLock(options: {
+    command: string;
+    dir: string;
+    env: NodeJS.ProcessEnv;
+    stderr: Writable;
+    heartbeatIntervalMs?: number;
+    lockDir?: string;
+    pollIntervalMs?: number;
+    staleAfterMs?: number;
+}): Promise<MachineLock>;
+/**
+ * Renders the warning for a `--no-lock` that appears after the command name, which makes it an argument to the
+ * command rather than a flag to nmr.
+ */
+export declare function formatMisplacedNoLockWarning(command: string, style: OutputStyle): string;
+/**
+ * Returns the directory that contains the lock file: one per user under `/tmp`, which a sandboxed session and a
+ * terminal resolve alike, where `TMPDIR` does not. Windows does not have `/tmp` or a uid.
+ */
+export declare function resolveLockDir(options: {
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
+    uid: number | undefined;
+}): string;

package/dist/esm/machine-lock.js

@@ -0,0 +1,229 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { STATUS_GLYPHS } from '@williamthorsen/nmr-core';
+import { isObject } from "./helpers/type-guards.js";
+const LOCK_FILE = 'heavy.lock';
+const RECLAIM_GUARD = 'heavy.lock.reclaim';
+const RECLAIM_GUARD_STALE_AFTER_MS = 10_000;
+export const HEARTBEAT_INTERVAL_MS = 10_000;
+export const HEAVY_COMMANDS = new Set([
+    'check',
+    'check:strict',
+    'ci',
+    'root:check',
+    'root:test',
+    'root:test:all',
+    'root:test:tool',
+    'root:test:unit',
+    'test',
+    'test:all',
+    'test:coverage',
+    'test:tool',
+    'test:unit',
+]);
+export const LOCK_DIR_ENV_VAR = 'NMR_LOCK_DIR';
+export const LOCK_TOKEN_ENV_VAR = 'NMR_MACHINE_LOCK_TOKEN';
+export const NO_LOCK_ENV_VAR = 'NMR_NO_LOCK';
+export const POLL_INTERVAL_MS = 1_000;
+export const STALE_AFTER_MS = 60_000;
+export async function acquireMachineLock(options) {
+    const { command, dir, env, stderr } = options;
+    if (env[NO_LOCK_ENV_VAR] === '1') {
+        return createHoldFreeLock({ isChainUnlocked: true, waited: false });
+    }
+    const lockDir = options.lockDir ?? resolveLockDir({ env, platform: process.platform, uid: process.getuid?.() });
+    if (await isUnderAncestorHold(lockDir, env)) {
+        return createHoldFreeLock({ isChainUnlocked: false, waited: false });
+    }
+    const lockPath = path.join(lockDir, LOCK_FILE);
+    try {
+        await fs.mkdir(lockDir, { recursive: true, mode: 0o700 });
+    }
+    catch (error) {
+        reportUnwritableDir(lockDir, error, stderr);
+        return createHoldFreeLock({ isChainUnlocked: true, waited: false });
+    }
+    const heartbeatIntervalMs = options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
+    const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
+    const staleAfterMs = options.staleAfterMs ?? STALE_AFTER_MS;
+    const record = {
+        command,
+        dir,
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        token: randomUUID(),
+    };
+    let waited = false;
+    let reportedHolder;
+    for (;;) {
+        try {
+            await fs.writeFile(lockPath, JSON.stringify(record), { flag: 'wx' });
+            return createHeldLock({ heartbeatIntervalMs, lockPath, token: record.token, waited });
+        }
+        catch (error) {
+            if (readErrorCode(error) !== 'EEXIST') {
+                reportUnwritableDir(lockDir, error, stderr);
+                return createHoldFreeLock({ isChainUnlocked: true, waited });
+            }
+        }
+        const state = await readLockState(lockPath);
+        if (state === undefined) {
+            continue;
+        }
+        if (isStale(state, staleAfterMs)) {
+            await reclaimStaleLock({ lockDir, lockPath, observed: state, staleAfterMs });
+            continue;
+        }
+        const holderIdentity = state.holder?.token ?? 'unreadable';
+        if (holderIdentity !== reportedHolder) {
+            stderr.write(`${formatWaitingLine(state.holder, lockPath)}\n`);
+            reportedHolder = holderIdentity;
+        }
+        waited = true;
+        await delay(pollIntervalMs);
+    }
+}
+export function formatMisplacedNoLockWarning(command, style) {
+    return (`${STATUS_GLYPHS[style].warning.text} --no-lock after the command name is passed to \`${command}\`, ` +
+        `not read by nmr. Did you mean \`nmr --no-lock ${command}\`?`);
+}
+export function resolveLockDir(options) {
+    const { env, platform, uid } = options;
+    const override = env[LOCK_DIR_ENV_VAR];
+    if (override !== undefined && override !== '') {
+        return override;
+    }
+    if (platform === 'win32' || uid === undefined) {
+        return path.join(os.tmpdir(), 'nmr');
+    }
+    return `/tmp/nmr-${uid}`;
+}
+function createHeldLock(options) {
+    const { heartbeatIntervalMs, lockPath, token, waited } = options;
+    const heartbeat = setInterval(() => void refreshMtime(lockPath), heartbeatIntervalMs);
+    heartbeat.unref();
+    let isReleased = false;
+    return {
+        isChainUnlocked: false,
+        async release() {
+            if (isReleased)
+                return;
+            isReleased = true;
+            clearInterval(heartbeat);
+            const state = await readLockState(lockPath);
+            if (state?.holder?.token === token) {
+                await fs.rm(lockPath, { force: true });
+            }
+        },
+        token,
+        waited,
+    };
+}
+function createHoldFreeLock(options) {
+    return { ...options, release: () => Promise.resolve(), token: undefined };
+}
+function formatWaitingLine(holder, lockPath) {
+    if (holder === undefined) {
+        return `nmr: waiting for the machine lock at ${lockPath}`;
+    }
+    return `nmr: waiting for ${holder.command} in ${holder.dir} (pid ${holder.pid}) to finish`;
+}
+function isHolderRecord(value) {
+    return (isObject(value) &&
+        typeof value['command'] === 'string' &&
+        typeof value['dir'] === 'string' &&
+        typeof value['pid'] === 'number' &&
+        typeof value['startedAt'] === 'string' &&
+        typeof value['token'] === 'string');
+}
+async function isUnderAncestorHold(lockDir, env) {
+    const inheritedToken = env[LOCK_TOKEN_ENV_VAR];
+    if (inheritedToken === undefined || inheritedToken === '') {
+        return false;
+    }
+    const state = await readLockState(path.join(lockDir, LOCK_FILE));
+    return state?.holder?.token === inheritedToken;
+}
+function isProcessGone(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return readErrorCode(error) === 'ESRCH';
+    }
+}
+function isStale(state, staleAfterMs) {
+    if (Date.now() - state.mtimeMs > staleAfterMs) {
+        return true;
+    }
+    return state.holder !== undefined && isProcessGone(state.holder.pid);
+}
+function parseHolder(content) {
+    try {
+        const value = JSON.parse(content);
+        return isHolderRecord(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readErrorCode(error) {
+    return isObject(error) && typeof error['code'] === 'string' ? error['code'] : undefined;
+}
+async function readLockState(lockPath) {
+    try {
+        const [content, stats] = await Promise.all([fs.readFile(lockPath, 'utf8'), fs.stat(lockPath)]);
+        return { holder: parseHolder(content), mtimeMs: stats.mtimeMs };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function reclaimStaleLock(options) {
+    const { lockDir, lockPath, observed, staleAfterMs } = options;
+    const guardPath = path.join(lockDir, RECLAIM_GUARD);
+    try {
+        await fs.mkdir(guardPath);
+    }
+    catch {
+        await removeAbandonedGuard(guardPath);
+        return;
+    }
+    try {
+        const current = await readLockState(lockPath);
+        if (current !== undefined && current.holder?.token === observed.holder?.token && isStale(current, staleAfterMs)) {
+            await fs.rm(lockPath, { force: true });
+        }
+    }
+    finally {
+        await fs.rm(guardPath, { force: true, recursive: true });
+    }
+}
+async function refreshMtime(lockPath) {
+    const now = new Date();
+    try {
+        await fs.utimes(lockPath, now, now);
+    }
+    catch {
+    }
+}
+async function removeAbandonedGuard(guardPath) {
+    try {
+        const stats = await fs.stat(guardPath);
+        if (Date.now() - stats.mtimeMs > RECLAIM_GUARD_STALE_AFTER_MS) {
+            await fs.rm(guardPath, { force: true, recursive: true });
+        }
+    }
+    catch {
+    }
+}
+function reportUnwritableDir(lockDir, error, stderr) {
+    const code = readErrorCode(error) ?? 'unknown error';
+    stderr.write(`nmr: running without the machine lock: cannot write ${lockDir} (${code}). ` +
+        `Grant write access to it, or set ${LOCK_DIR_ENV_VAR} to a writable directory.\n`);
+}

package/dist/esm/runCli.js

@@ -15,6 +15,7 @@ import { findClosestName } from "./helpers/findClosestName.js";
 import { isHookName } from "./helpers/hook-name.js";
 import { resolvePackageJsonPath } from "./helpers/package-json.js";
 import { composeTranscript } from "./helpers/transcript.js";
+import { acquireMachineLock, formatMisplacedNoLockWarning, HEAVY_COMMANDS, LOCK_TOKEN_ENV_VAR, NO_LOCK_ENV_VAR, } from "./machine-lock.js";
 import { isTerminalStream, OUTPUT_STYLE_ENV_VAR, OUTPUT_STYLE_FLAG, resolveOutputStyles } from "./output-style.js";
 import { renderRecording, renderRefusal, resolveRecording } from "./recording.js";
 import { assembleReplay } from "./replay-assembly.js";
@@ -121,6 +122,7 @@ async function planRun(invocation) {
         env,
         format: invocation.format,
         shouldBypassCache,
+        shouldBypassLock: parsedArgs.shouldBypassLock,
         passthrough: parsedArgs.passthrough,
         runId,
         snapshot,
@@ -135,7 +137,15 @@ async function planRun(invocation) {
     };
     const delegation = composeDelegation({ childEnv, command, parsedArgs });
     if (delegation !== undefined) {
-        const result = await runDelegation({ context, delegation, parsedArgs, runOptions, stderr });
+        const lock = await takeMachineLock(invocation);
+        let result;
+        try {
+            const heldDelegation = { ...delegation, env: addLockEnv(delegation.env, lock) };
+            result = await runDelegation({ context, delegation: heldDelegation, parsedArgs, runOptions, stderr });
+        }
+        finally {
+            await lock?.release();
+        }
         return {
             settled: true,
             result: { ...result, isUnknownCommand: result.exitCode !== 0 && !isDefinedInAnyScope(command, context) },
@@ -250,6 +260,7 @@ const BOOLEAN_FLAGS = new Map([
     ['--json', 'shouldEmitJson'],
     ['--log', 'shouldPrintLog'],
     ['--no-cache', 'shouldBypassCache'],
+    ['--no-lock', 'shouldBypassLock'],
     ['-q', 'quiet'],
     ['--quiet', 'quiet'],
     ['-R', 'recursive'],
@@ -260,18 +271,28 @@ const BOOLEAN_FLAGS = new Map([
     ['--workspace-root', 'isWorkspaceRoot'],
 ]);
 function buildChildEnv(options) {
-    const { env, format, passthrough, runId, shouldBypassCache, snapshot, styles, verbosity } = options;
+    const { env, format, passthrough, runId, shouldBypassCache, shouldBypassLock, snapshot, styles, verbosity } = options;
     const bypassesCache = shouldBypassCache || passthrough.length > 0;
     return {
         ...env,
         ...(snapshot !== undefined && { [TREE_SNAPSHOT_ENV_VAR]: encodeTreeSnapshot(snapshot) }),
         ...(bypassesCache && { [NO_CACHE_ENV_VAR]: '1' }),
+        ...(shouldBypassLock && { [NO_LOCK_ENV_VAR]: '1' }),
         [COMMAND_VERBOSITY_ENV_VAR]: verbosity,
         [OUTPUT_STYLE_ENV_VAR]: styles.stdout,
         [REPORT_FORMAT_ENV_VAR]: format,
         [RUN_ID_ENV_VAR]: runId,
     };
 }
+function addLockEnv(env, lock) {
+    if (lock?.token !== undefined) {
+        return { ...env, [LOCK_TOKEN_ENV_VAR]: lock.token };
+    }
+    if (lock?.isChainUnlocked === true) {
+        return { ...env, [NO_LOCK_ENV_VAR]: '1' };
+    }
+    return env;
+}
 function acceptsArguments(step) {
     return step.kind === 'opaque' || step.shouldDeclineArguments !== true;
 }
@@ -638,6 +659,7 @@ function parseArgs(args) {
         quiet: false,
         recursive: false,
         shouldBypassCache: false,
+        shouldBypassLock: false,
         shouldEmitJson: false,
         shouldPrintLog: false,
         shouldShowHelp: false,
@@ -764,6 +786,46 @@ function resolveReportingVerbosity(options) {
     const { format, ...ladder } = options;
     return format === 'json' ? 'quiet' : resolveVerbosity(ladder);
 }
+async function readGate(plan) {
+    const { key, snapshot } = plan;
+    const { context, env, stderr, stdout } = plan.invocation;
+    if (key === undefined || snapshot === undefined) {
+        return undefined;
+    }
+    const quiet = plan.runOptions.quiet === true;
+    return {
+        buildOutputBefore: await readBuildOutputState(context.monorepoRoot, context.config),
+        key,
+        retentionKey: computeRetentionKey({
+            channels: { stderr: resolveChannel(stderr, quiet), stdout: resolveChannel(stdout, quiet) },
+            env,
+            passKey: key,
+        }),
+        snapshot,
+    };
+}
+async function recallPass(plan, gate) {
+    const { anchorDir, command, context, env, stderr } = plan.invocation;
+    const { monorepoRoot } = context;
+    const recalledPass = await lookUpRecordedPass({
+        anchorDir,
+        buildOutput: gate.buildOutputBefore,
+        command,
+        env,
+        key: gate.key,
+        monorepoRoot,
+        retentionKey: gate.retentionKey,
+        stderr,
+    });
+    if (recalledPass === undefined) {
+        return undefined;
+    }
+    const { entry, ...recall } = recalledPass;
+    if (recall.replay !== undefined) {
+        await certifyRetention({ anchorDir, command, entry, env, monorepoRoot, runId: plan.runId, stderr });
+    }
+    return { exitCode: 0, outcome: { outcome: 'recalled', ...recall } };
+}
 async function recordPass(options) {
     const { anchorDir, command, env, monorepoRoot, snapshot, stderr } = options;
     const currentRead = resolveTreeSnapshot({ monorepoRoot, env: {} });
@@ -862,70 +924,61 @@ async function runDelegation(options) {
     return runSteps([step], context.monorepoRoot, { ...runOptions, env: delegation.env });
 }
 async function runGated(plan) {
-    const { commandString, key, snapshot } = plan;
+    const { commandString, key } = plan;
     const { anchorDir, command, context, env, stderr, stdout } = plan.invocation;
     const { config, monorepoRoot } = context;
-    const quiet = plan.runOptions.quiet === true;
-    const gate = key !== undefined && snapshot !== undefined
-        ? {
-            buildOutputBefore: await readBuildOutputState(monorepoRoot, config),
-            key,
-            retentionKey: computeRetentionKey({
-                channels: { stderr: resolveChannel(stderr, quiet), stdout: resolveChannel(stdout, quiet) },
-                env,
-                passKey: key,
-            }),
-            snapshot,
-        }
-        : undefined;
+    let gate = await readGate(plan);
     if (gate !== undefined && !plan.shouldBypassCache) {
-        const recalledPass = await lookUpRecordedPass({
-            anchorDir,
-            buildOutput: gate.buildOutputBefore,
-            command,
-            env,
-            key: gate.key,
-            monorepoRoot,
-            retentionKey: gate.retentionKey,
-            stderr,
-        });
-        if (recalledPass !== undefined) {
-            const { entry, ...recall } = recalledPass;
-            if (recall.replay !== undefined) {
-                await certifyRetention({ anchorDir, command, entry, env, monorepoRoot, runId: plan.runId, stderr });
-            }
-            return { exitCode: 0, outcome: { outcome: 'recalled', ...recall } };
+        const recalled = await recallPass(plan, gate);
+        if (recalled !== undefined) {
+            return recalled;
         }
     }
-    if (plan.overrideNotice !== undefined) {
-        stdout.write(plan.overrideNotice);
+    const lock = await takeMachineLock(plan.invocation);
+    try {
+        if (lock?.waited === true && key !== undefined) {
+            gate = await readGate(plan);
+            if (gate !== undefined && !plan.shouldBypassCache) {
+                const recalled = await recallPass(plan, gate);
+                if (recalled !== undefined) {
+                    return recalled;
+                }
+            }
+        }
+        if (plan.overrideNotice !== undefined) {
+            stdout.write(plan.overrideNotice);
+        }
+        const runOptions = { ...plan.runOptions, env: addLockEnv(plan.runOptions.env ?? env, lock) };
+        const startedAtMs = Date.now();
+        const { exitCode, retainedOutput } = await runSteps(plan.steps, anchorDir, runOptions);
+        const durationMs = Date.now() - startedAtMs;
+        if (exitCode === 0 && gate !== undefined) {
+            await recordPass({
+                anchorDir,
+                buildOutputBefore: gate.buildOutputBefore,
+                command,
+                commandString,
+                config,
+                durationMs,
+                env,
+                key: gate.key,
+                monorepoRoot,
+                ownSteps: plan.ownSteps,
+                retainedOutput,
+                retentionKey: gate.retentionKey,
+                runId: plan.runId,
+                snapshot: gate.snapshot,
+                stderr,
+            });
+        }
+        return {
+            exitCode,
+            outcome: exitCode === 0 ? { outcome: 'passed', durationMs } : { outcome: 'failed', durationMs, exitCode },
+        };
     }
-    const startedAtMs = Date.now();
-    const { exitCode, retainedOutput } = await runSteps(plan.steps, anchorDir, plan.runOptions);
-    const durationMs = Date.now() - startedAtMs;
-    if (exitCode === 0 && gate !== undefined) {
-        await recordPass({
-            anchorDir,
-            buildOutputBefore: gate.buildOutputBefore,
-            command,
-            commandString,
-            config,
-            durationMs,
-            env,
-            key: gate.key,
-            monorepoRoot,
-            ownSteps: plan.ownSteps,
-            retainedOutput,
-            retentionKey: gate.retentionKey,
-            runId: plan.runId,
-            snapshot: gate.snapshot,
-            stderr,
-        });
+    finally {
+        await lock?.release();
     }
-    return {
-        exitCode,
-        outcome: exitCode === 0 ? { outcome: 'passed', durationMs } : { outcome: 'failed', durationMs, exitCode },
-    };
 }
 function formatMisplacedFlagHint(args, passthrough, style) {
     const { flagNames, movedTokens, remainingTokens } = splitMisplacedFlags(passthrough);
@@ -955,6 +1008,21 @@ function isTopLevelInvocation(env) {
     const runId = env[RUN_ID_ENV_VAR];
     return runId === undefined || runId === '';
 }
+async function takeMachineLock(invocation) {
+    const { anchorDir, command, env, parsedArgs, stderr, styles } = invocation;
+    if (!HEAVY_COMMANDS.has(command) || parsedArgs.shouldPrintLog) {
+        return undefined;
+    }
+    if (parsedArgs.passthrough.includes('--no-lock')) {
+        stderr.write(`${formatMisplacedNoLockWarning(command, styles.stderr)}\n`);
+    }
+    return acquireMachineLock({
+        command,
+        dir: anchorDir,
+        env: parsedArgs.shouldBypassLock ? { ...env, [NO_LOCK_ENV_VAR]: '1' } : env,
+        stderr,
+    });
+}
 function readMisplacedFlagLength(args, index) {
     const arg = args[index] ?? '';
     if (FILTER_FLAGS.has(arg)) {

package/dist/esm/vitest-max-workers.d.ts

@@ -0,0 +1,11 @@
+export interface MachineCapacity {
+    coreCount: number;
+    totalMemoryBytes: number;
+}
+/** Returns the worker count for a machine: one per `GIB_PER_WORKER` of memory, bounded by one fewer than the cores. */
+export declare function deriveDefaultMaxWorkers({ coreCount, totalMemoryBytes }: MachineCapacity): number;
+/**
+ * Returns the value of the last `--maxWorkers` argument: a number, or a percentage string that Vitest resolves against
+ * the core count. An argument whose value is neither counts as absent, which leaves Vitest to report it.
+ */
+export declare function readMaxWorkersFlag(args: readonly string[]): number | string | undefined;

package/dist/esm/vitest-max-workers.js

@@ -0,0 +1,35 @@
+const SMALL_MACHINE_MAX_CORES = 2;
+const SMALL_MACHINE_MAX_WORKERS = 3;
+const GIB_PER_WORKER = 4;
+const BYTES_PER_GIB = 2 ** 30;
+const MAX_WORKERS_FLAGS = ['--maxWorkers', '--max-workers'];
+const PERCENTAGE_PATTERN = /^\d+%$/;
+const POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
+export function deriveDefaultMaxWorkers({ coreCount, totalMemoryBytes }) {
+    if (coreCount <= SMALL_MACHINE_MAX_CORES)
+        return SMALL_MACHINE_MAX_WORKERS;
+    const memoryBound = Math.max(1, Math.floor(totalMemoryBytes / (GIB_PER_WORKER * BYTES_PER_GIB)));
+    return Math.min(coreCount - 1, memoryBound);
+}
+export function readMaxWorkersFlag(args) {
+    let rawValue;
+    args.forEach((arg, index) => {
+        if (MAX_WORKERS_FLAGS.includes(arg)) {
+            rawValue = args[index + 1];
+            return;
+        }
+        const flag = MAX_WORKERS_FLAGS.find((name) => arg.startsWith(`${name}=`));
+        if (flag !== undefined)
+            rawValue = arg.slice(flag.length + 1);
+    });
+    return parseMaxWorkersValue(rawValue);
+}
+function parseMaxWorkersValue(rawValue) {
+    if (rawValue === undefined)
+        return undefined;
+    if (POSITIVE_INTEGER_PATTERN.test(rawValue))
+        return Number(rawValue);
+    if (PERCENTAGE_PATTERN.test(rawValue))
+        return rawValue;
+    return undefined;
+}

package/dist/esm/vitest.js

@@ -5,14 +5,13 @@ import { defaultExclude, mergeConfig } from 'vitest/config';
 import { listGitIgnoredPaths } from "./git-ignored-paths.js";
 import { isObject } from "./helpers/type-guards.js";
 import { ALL_TEST_PATTERNS, buildTierPatterns, TEST_COLLECTION_EXCLUDE, TIER_NAMES } from "./tiers.js";
+import { deriveDefaultMaxWorkers, readMaxWorkersFlag } from "./vitest-max-workers.js";
 import { createSourceResolutionPlugin } from "./vitest-source-resolution.js";
 import { getWorkspacePackageDirs } from "./workspace.js";
 import { toWorkspacePackageGlobs } from "./workspace-globs.js";
 const [RESIDUAL_TIER, ...NAMED_TIERS] = TIER_NAMES;
 const TIERED_PATTERNS = NAMED_TIERS.flatMap(buildTierPatterns);
 const TIER_TIMEOUT_MS = 30_000;
-const SMALL_MACHINE_MAX_CORES = 2;
-const SMALL_MACHINE_MAX_WORKERS = 3;
 const GIT_ISOLATION_SETUP_FILE = resolveGitIsolationSetupFile();
 const CLIENT_CONDITIONS = ['module', 'browser', 'development|production'];
 const SERVER_CONDITIONS = ['module', 'node', 'development|production'];
@@ -99,7 +98,11 @@ function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
         })),
     ];
     const collectionExclude = buildCollectionExclude(layers, ignoredPathsRoot);
-    const maxWorkers = resolveDefaultMaxWorkers();
+    const defaultMaxWorkers = deriveDefaultMaxWorkers({
+        coreCount: os.availableParallelism(),
+        totalMemoryBytes: os.totalmem(),
+    });
+    const flagMaxWorkers = readMaxWorkersFlag(process.argv.slice(2));
     const shouldIsolateGit = resolveFlag(layers, 'shouldIsolateGit', true);
     return projectTiers.map(({ exclude, include, name, timeoutMs }) => {
         const project = {
@@ -108,7 +111,7 @@ function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
             test: {
                 exclude: [...collectionExclude, ...exclude, ...extraExclude],
                 include,
-                ...(maxWorkers !== undefined && { maxWorkers }),
+                maxWorkers: defaultMaxWorkers,
                 name,
                 ...(shouldIsolateGit && { setupFiles: [GIT_ISOLATION_SETUP_FILE] }),
                 ...(timeoutMs !== undefined && { hookTimeout: timeoutMs, testTimeout: timeoutMs }),
@@ -118,7 +121,9 @@ function buildProjects(layers, extraExclude, projectRoot, ignoredPathsRoot) {
         for (const layer of layers) {
             mergedProject = applyLayer(mergedProject, layer, name);
         }
-        return mergedProject;
+        return flagMaxWorkers === undefined
+            ? mergedProject
+            : mergeConfig(mergedProject, { test: { maxWorkers: flagMaxWorkers } });
     });
 }
 function applyLayer(project, layer, tier) {
@@ -175,9 +180,6 @@ function formatOptionKeys(keys) {
         .map((key) => `\`${key}\``)
         .join(', ');
 }
-function resolveDefaultMaxWorkers() {
-    return os.availableParallelism() <= SMALL_MACHINE_MAX_CORES ? SMALL_MACHINE_MAX_WORKERS : undefined;
-}
 function resolveFlag(layers, name, isOnByDefault) {
     let resolvedFlag = isOnByDefault;
     for (const layer of layers) {

package/docs/machine-lock.md

@@ -0,0 +1,61 @@
+# Machine lock
+
+nmr runs one heavy command at a time on a machine. A heavy command started while another is running, from any repository or worktree, waits for it to finish rather than competing with it for memory:
+
+```console
+$ nmr check
+nmr: waiting for test in /Users/me/repos/other-repo (pid 41872) to finish
+✅ my-repo: check: passed in 1m 12s
+```
+
+The waiting line goes to stderr in every verbosity and report format. The time spent waiting does not count in the verdict's duration.
+
+## Which commands take the lock
+
+`check`, `check:strict`, `ci`, `root:check`, `test`, `test:all`, `test:coverage`, `test:tool`, `test:unit`, `root:test`, `root:test:all`, `root:test:tool`, and `root:test:unit`, at any scope. The set is fixed.
+
+- **`test:watch` does not take the lock.** It runs until it is stopped, and would block every other run for as long.
+- **A composite takes the lock when it reaches a heavy step.** `prepush` runs its audit unlocked, then waits, if it has to, before `ci`.
+- **A command nested in a heavy one runs under its hold.** The holder passes its token to the processes that it starts, so `ci` running `check:strict` running `test` takes the lock once.
+- **A fan-out takes the lock once.** `nmr -R test` and `nmr -F <pattern> test` hold it in the delegating process, so the packages that pnpm runs in parallel do not wait on one another.
+- **A cached pass does not wait.** nmr consults the [check-result cache](check-cache.md) before it takes the lock, and a command that the cache serves never waits. A run that did wait consults the cache again, because the run that it waited on may have recorded a pass for the same tree.
+- **`--log` does not take the lock**, because it runs nothing.
+
+## Where the lock lives
+
+| Platform     | Directory               |
+| ------------ | ----------------------- |
+| Linux, macOS | `/tmp/nmr-<uid>/`       |
+| Windows      | `<os.tmpdir()>/nmr/`    |
+| Any          | `$NMR_LOCK_DIR`, if set |
+
+The lock is the file `heavy.lock` in that directory. It names its holder's command, directory, and pid. The directory is `/tmp` rather than `TMPDIR` because a sandboxed agent session and a terminal shell set `TMPDIR` differently, and would not see each other's lock. `NMR_LOCK_DIR` changes the location for every invocation that sees it, so a machine that sets it sets it in every environment that runs nmr.
+
+**A sandbox needs write access to the directory.** When nmr cannot write it, nmr warns and runs the command without the lock:
+
+```console
+nmr: running without the machine lock: cannot write /tmp/nmr-501 (EPERM). Grant write access to it, or set NMR_LOCK_DIR to a writable directory.
+```
+
+On macOS `/tmp` is a link to `/private/tmp`, and a sandbox that matches resolved paths, such as Claude Code's, needs the grant for `/private/tmp/nmr-<uid>`.
+
+## A lock that its holder left behind
+
+A holder removes the lock when its command ends, whether the command passed or failed. A holder that is interrupted or killed leaves the lock behind, and the next run reclaims it: at once when the holder's pid no longer exists, and otherwise once the holder has stopped refreshing the file for a minute, which covers a pid that another process has since taken.
+
+## Bypassing the lock
+
+| Step                      | Effect                                                     |
+| ------------------------- | ---------------------------------------------------------- |
+| `nmr --no-lock <command>` | Runs without waiting. Applies to the whole chain.          |
+| `NMR_NO_LOCK=1`           | The same, for every nmr invocation that sees the variable. |
+
+`--no-lock` belongs before the command name. After it, it is an argument to the command rather than a flag to nmr; nmr reports this rather than silently ignoring the bypass.
+
+**CI.** A GitHub-hosted runner runs one job per machine, so the lock never makes it wait. A self-hosted machine that runs several runner instances serializes their heavy jobs, which protects its memory as the lock does on a workstation, and a job's wait counts against its timeout. Set `NMR_NO_LOCK=1` in the runners' environment to run them in parallel instead.
+
+**A test suite that runs nmr.** A suite run by `nmr test` runs under that command's hold only while the processes that it starts inherit `NMR_MACHINE_LOCK_TOKEN`. A test that starts a heavy command with an environment of its own waits on the suite that started it, so it sets `NMR_NO_LOCK=1`.
+
+## Reserved environment variables
+
+`NMR_MACHINE_LOCK_TOKEN` is nmr's own: The holder passes it to the processes that it starts, which run under its hold. nmr honors an inherited token only while the lock file still contains it, so a process that outlives its run waits like any other.

package/docs/vitest.md

@@ -125,11 +125,25 @@ export default defineVitestConfig({ shouldIsolateGit: false, shouldResolveFromSo
 
 **The boundary is Vite's resolution, not the package's role.** Because Node does not apply the `source` condition, a workspace package that an externalized dependency imports resolves through Node to its build output. Nothing else in a suite resolves that way.
 
-### Worker count on small machines
+### Worker count
 
-On a machine with 2 or fewer cores, the factory gives every project `maxWorkers: 3`. Vitest's run-mode default is one fewer worker than the core count, so a 2-core CI runner, GitHub's standard runner for a private repo, would otherwise run every test file serially on one worker. Three workers are faster there, because the main process transforms files while the workers run them. On a machine with more cores, the projects do not set `maxWorkers`, and Vitest's own default applies.
+The factory gives every project a worker count derived from the machine, one worker per 4 GiB of total memory, bounded by one fewer than the core count:
 
-Where the default applies, Vitest's `--maxWorkers` flag has no effect, because Vitest does not forward that flag to projects. Override the default with the `VITEST_MAX_WORKERS` environment variable, with `--no-file-parallelism` for a single worker, or with `maxWorkers` in the `project` seam.
+```
+min(availableParallelism - 1, max(1, floor(totalmem / 4 GiB)))
+```
+
+Vitest's own default, one fewer worker than the core count, does not take memory into account. On a 10-core, 16 GB machine it starts 9 workers per run, and several concurrent runs push the machine into swap; the derived count there is 4. The 4 GiB budget leaves room for concurrent runs and other workloads, rather than measuring one worker's footprint. The divisor is total memory, because `os.freemem()` on macOS excludes cached pages and reports near zero.
+
+On a machine with 2 or fewer cores, every project gets 3 workers, whatever the memory. A 2-core CI runner, GitHub's standard runner for a private repo, would otherwise run every test file serially on one worker. Three workers are faster there, because the main process transforms files while the workers run them.
+
+Each of these overrides the derived count, the highest first:
+
+1. The `VITEST_MAX_WORKERS` environment variable, which Vitest applies after the config.
+2. `--maxWorkers` (or `--max-workers`) on the command line, as a count or a percentage of the cores. Vitest does not forward the flag to projects, so the factory reads it from the command line and applies it to every project.
+3. `maxWorkers` in the `project` seam.
+
+`--no-file-parallelism` runs a single worker whatever the count.
 
 ## Resolving through tsconfig paths
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.46.2",
+  "version": "0.47.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [