@williamthorsen/nmr 0.42.0 → 0.44.0

package/dist/esm/default-scripts.d.ts

@@ -10,6 +10,11 @@ export interface StepSpec {
      * narrowed steps run, or the tool that it invokes would be misled by them. A declining step runs unnarrowed.
      */
     shouldDeclineArguments?: boolean;
+    /**
+     * Set to start this step and run the steps after it without waiting for it. The composite waits for it before
+     * ending, and prints its output whole at the first step boundary after it ends.
+     */
+    shouldRunInBackground?: boolean;
 }
 export type ScriptValue = string | ReadonlyArray<string | StepSpec>;
 export type ScriptRegistry = Record<string, ScriptValue>;
@@ -19,4 +24,8 @@ export type ScriptRegistry = Record<string, ScriptValue>;
  * collects every file that does not name any other tier.
  */
 export declare const workspaceScripts: ScriptRegistry;
-export declare const rootScripts: ScriptRegistry;
+/**
+ * Builds the root scripts. Each root-only lint command excludes the workspaces, given as globs relative to the root,
+ * so that the root ESLint config never lints a package.
+ */
+export declare function buildRootScripts(workspaceGlobs: readonly string[]): ScriptRegistry;

package/dist/esm/default-scripts.js

@@ -1,10 +1,13 @@
+import { quoteToken } from "./steps.js";
 const GATE_PROJECTS = '--project unit --project tool';
 const TYPECHECK_STEP = { run: 'typecheck', shouldDeclineArguments: true };
 const ROOT_TYPECHECK_STEP = { run: 'root:typecheck', shouldDeclineArguments: true };
+const LINT_CHECK_STEP = { run: 'lint:check', shouldRunInBackground: true };
+const LINT_STRICT_STEP = { run: 'lint:strict', shouldRunInBackground: true };
 export const workspaceScripts = {
     build: ['compile'],
-    check: [TYPECHECK_STEP, 'fmt:check', 'lint:check', 'test'],
-    'check:strict': [TYPECHECK_STEP, 'fmt:check', 'lint:strict', 'test'],
+    check: [LINT_CHECK_STEP, TYPECHECK_STEP, 'fmt:check', 'test'],
+    'check:strict': [LINT_STRICT_STEP, TYPECHECK_STEP, 'fmt:check', 'test'],
     clean: 'nmr-clean',
     compile: 'nmr-compile',
     fix: ['lint', 'fmt'],
@@ -25,40 +28,43 @@ export const workspaceScripts = {
     upgrade: 'nmr-report-catalog && nmr-taze',
     'view-coverage': 'open coverage/index.html',
 };
-export const rootScripts = {
-    audit: ['audit:prod', 'audit:dev'],
-    'audit:dev': 'pnpm exec v11y --dev',
-    'audit:prod': 'pnpm exec v11y --prod',
-    build: ['-R build'],
-    check: [TYPECHECK_STEP, 'fmt:check', 'lint:check', 'test'],
-    'check:strict': [TYPECHECK_STEP, 'fmt:check', 'lint:strict', 'test'],
-    ci: [{ run: 'build', shouldDeclineArguments: true }, 'check:strict'],
-    clean: 'nmr-clean',
-    fix: ['lint', 'fmt'],
-    'fix:check': ['fmt:check', 'lint:check'],
-    fmt: 'nmr-fmt --write',
-    'fmt:check': 'nmr-fmt --check',
-    lint: 'eslint --fix .',
-    'lint:check': 'eslint .',
-    'lint:strict': 'strict-lint',
-    prepush: [{ run: 'audit', shouldDeclineArguments: true }, 'ci'],
-    'report-overrides': 'nmr-report-overrides',
-    'root:check': [ROOT_TYPECHECK_STEP, 'fmt:check', 'root:lint:check', 'root:test'],
-    'root:lint': "eslint --fix --ignore-pattern 'packages/**' .",
-    'root:lint:check': "eslint --ignore-pattern 'packages/**' .",
-    'root:lint:strict': "strict-lint --ignore-pattern 'packages/**' .",
-    'root:test': `vitest --config ./vitest.root.config.ts ${GATE_PROJECTS}`,
-    'root:test:all': 'vitest --config ./vitest.root.config.ts',
-    'root:test:tool': 'vitest --config ./vitest.root.config.ts --project tool',
-    'root:test:unit': 'vitest --config ./vitest.root.config.ts --project unit',
-    'root:typecheck': 'tsgo --noEmit',
-    'root:upgrade': 'nmr-report-overrides && nmr-taze',
-    test: ['root:test', '-R test'],
-    'test:all': ['root:test:all', '-R test:all'],
-    'test:coverage': ['root:test', '-R test:coverage'],
-    'test:tool': ['root:test:tool', '-R test:tool'],
-    'test:unit': ['root:test:unit', '-R test:unit'],
-    'test:watch': `vitest ${GATE_PROJECTS} --watch`,
-    typecheck: [ROOT_TYPECHECK_STEP, { run: '-R typecheck', shouldDeclineArguments: true }],
-    upgrade: 'nmr-report-overrides && nmr-taze --recursive',
-};
+export function buildRootScripts(workspaceGlobs) {
+    const ignorePatterns = workspaceGlobs.map((glob) => `--ignore-pattern ${quoteToken(glob)} `).join('');
+    return {
+        audit: ['audit:prod', 'audit:dev'],
+        'audit:dev': 'pnpm exec v11y --dev',
+        'audit:prod': 'pnpm exec v11y --prod',
+        build: ['-R build'],
+        check: [LINT_CHECK_STEP, TYPECHECK_STEP, 'fmt:check', 'test'],
+        'check:strict': [LINT_STRICT_STEP, TYPECHECK_STEP, 'fmt:check', 'test'],
+        ci: [{ run: 'build', shouldDeclineArguments: true }, 'check:strict'],
+        clean: 'nmr-clean',
+        fix: ['lint', 'fmt'],
+        'fix:check': ['fmt:check', 'lint:check'],
+        fmt: 'nmr-fmt --write',
+        'fmt:check': 'nmr-fmt --check',
+        lint: 'eslint --fix .',
+        'lint:check': 'eslint .',
+        'lint:strict': 'strict-lint',
+        prepush: [{ run: 'audit', shouldDeclineArguments: true }, 'ci'],
+        'report-overrides': 'nmr-report-overrides',
+        'root:check': [ROOT_TYPECHECK_STEP, 'fmt:check', 'root:lint:check', 'root:test'],
+        'root:lint': `eslint --fix ${ignorePatterns}.`,
+        'root:lint:check': `eslint ${ignorePatterns}.`,
+        'root:lint:strict': `strict-lint ${ignorePatterns}.`,
+        'root:test': `vitest --config ./vitest.root.config.ts ${GATE_PROJECTS}`,
+        'root:test:all': 'vitest --config ./vitest.root.config.ts',
+        'root:test:tool': 'vitest --config ./vitest.root.config.ts --project tool',
+        'root:test:unit': 'vitest --config ./vitest.root.config.ts --project unit',
+        'root:typecheck': 'tsgo --noEmit',
+        'root:upgrade': 'nmr-report-overrides && nmr-taze',
+        test: ['root:test', '-R test'],
+        'test:all': ['root:test:all', '-R test:all'],
+        'test:coverage': ['root:test', '-R test:coverage'],
+        'test:tool': ['root:test:tool', '-R test:tool'],
+        'test:unit': ['root:test:unit', '-R test:unit'],
+        'test:watch': `vitest ${GATE_PROJECTS} --watch`,
+        typecheck: [ROOT_TYPECHECK_STEP, { run: '-R typecheck', shouldDeclineArguments: true }],
+        upgrade: 'nmr-report-overrides && nmr-taze --recursive',
+    };
+}

package/dist/esm/defineConfig.d.ts

@@ -1,5 +1,5 @@
 import type { NmrConfig } from './types.js';
-export type { BuildConfig, CheckCacheConfig, CommandVerbosity, NmrConfig, OutputConfig, ScriptValue, StepSpec, } from './types.js';
+export type { BuildConfig, CheckCacheConfig, CommandVerbosity, NmrConfig, OutputConfig, ScriptValue, SelfHostedRunnerConfig, StepSpec, } from './types.js';
 /**
  * Returns `config` unchanged, typing a configuration file's default export as `NmrConfig`.
  *

package/dist/esm/help.d.ts

@@ -16,4 +16,4 @@ import type { NmrConfig } from './types.js';
  * unless it is an npm or pnpm lifecycle script or the active registry
  * contains its name.
  */
-export declare function generateHelp(config: NmrConfig, packageDir: string | undefined, shouldUseRoot: boolean): string;
+export declare function generateHelp(config: NmrConfig, monorepoRoot: string, packageDir: string | undefined, shouldUseRoot: boolean): string;

package/dist/esm/help.js

@@ -23,7 +23,7 @@ const LIFECYCLE_SCRIPT_NAMES = new Set([
     'uninstall',
     'version',
 ]);
-export function generateHelp(config, packageDir, shouldUseRoot) {
+export function generateHelp(config, monorepoRoot, packageDir, shouldUseRoot) {
     const lines = [
         'Usage: nmr [flags] <command> [args...]',
         '',
@@ -54,12 +54,12 @@ export function generateHelp(config, packageDir, shouldUseRoot) {
         hadOverride = true;
     formatRegistry(workspaceRegistry, workspaceMarkedNames, lines);
     lines.push('', 'Root commands:');
-    const rootRegistry = filterHooks(buildRootRegistry(config));
+    const rootRegistry = filterHooks(buildRootRegistry(config, monorepoRoot));
     const rootMarkedNames = shouldUseRoot ? applyOverrides(rootRegistry, overrides) : new Set();
     if (rootMarkedNames.size > 0)
         hadOverride = true;
     formatRegistry(rootRegistry, rootMarkedNames, lines);
-    const activeRegistry = shouldUseRoot ? buildRootRegistry(config) : buildWorkspaceRegistry(config);
+    const activeRegistry = shouldUseRoot ? buildRootRegistry(config, monorepoRoot) : buildWorkspaceRegistry(config);
     const unregisteredScripts = collectUnregisteredScripts(packageScripts, activeRegistry);
     if (Object.keys(unregisteredScripts).length > 0) {
         lines.push('', 'Package scripts:');

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

@@ -0,0 +1,17 @@
+import { Writable } from 'node:stream';
+/** Which of a child's output streams a recorded chunk arrived on. */
+type StreamName = 'stderr' | 'stdout';
+export interface OutputRecorder {
+    /** Destination for the child's stderr. It does not have a descriptor, so a child writing to it is given a pipe. */
+    stderr: Writable;
+    /** Destination for the child's stdout. It does not have a descriptor, so a child writing to it is given a pipe. */
+    stdout: Writable;
+    /** Writes every recorded chunk to the destination matching its stream, in the order in which the chunks arrived. */
+    replay: (destinations: Record<StreamName, Writable>) => void;
+}
+/**
+ * Creates a pair of in-memory destinations that hold everything written to them, unbounded, so that output
+ * produced while other output is streaming can be printed whole afterwards.
+ */
+export declare function createOutputRecorder(): OutputRecorder;
+export {};

package/dist/esm/helpers/createOutputRecorder.js

@@ -0,0 +1,22 @@
+import { Writable } from 'node:stream';
+export function createOutputRecorder() {
+    const entries = [];
+    function createSink(stream) {
+        return new Writable({
+            write(chunk, encoding, callback) {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), encoding);
+                entries.push({ chunk: buffer, stream });
+                callback();
+            },
+        });
+    }
+    return {
+        stderr: createSink('stderr'),
+        stdout: createSink('stdout'),
+        replay: (destinations) => {
+            for (const { chunk, stream } of entries) {
+                destinations[stream].write(chunk);
+            }
+        },
+    };
+}

package/dist/esm/resolve-scripts.d.ts

@@ -6,7 +6,9 @@ export type { ScriptRegistry, ScriptValue, StepSpec } from './default-scripts.js
  */
 export declare function getDefaultWorkspaceScripts(): ScriptRegistry;
 /**
- * Returns a shallow copy of the default root scripts, whose entries a caller may replace without changing the
- * defaults.
+ * Returns the default root scripts for the monorepo at `monorepoRoot`, whose root-only lint commands exclude every
+ * workspace package that its `pnpm-workspace.yaml` declares. A directory without that manifest yields commands
+ * without exclusions rather than an error, so that a caller reading only the command names need not stand in a
+ * workspace.
  */
-export declare function getDefaultRootScripts(): ScriptRegistry;
+export declare function getDefaultRootScripts(monorepoRoot: string): ScriptRegistry;

package/dist/esm/resolve-scripts.js

@@ -1,7 +1,11 @@
-import { rootScripts, workspaceScripts } from "./default-scripts.js";
+import { buildRootScripts, workspaceScripts } from "./default-scripts.js";
+import { resolveWorkspace } from "./workspace.js";
+import { toWorkspacePackageGlobs } from "./workspace-globs.js";
 export function getDefaultWorkspaceScripts() {
     return { ...workspaceScripts };
 }
-export function getDefaultRootScripts() {
-    return { ...rootScripts };
+export function getDefaultRootScripts(monorepoRoot) {
+    const resolution = resolveWorkspace(monorepoRoot);
+    const packageDirs = resolution.kind === 'packages' ? resolution.packageDirs : [];
+    return buildRootScripts(toWorkspacePackageGlobs(monorepoRoot, packageDirs));
 }

package/dist/esm/resolver.d.ts

@@ -35,8 +35,9 @@ export interface ResolvedScript {
  * Expands a script value into the ordered steps that it runs as: a string is one opaque step, and an array is one
  * structural step per element.
  *
- * A bare string element and the `{ run }` spec compose the same step. The spec's only addition is the
- * declaration of what the step does with the invocation's trailing arguments, which position cannot express.
+ * A bare string element and the `{ run }` spec compose the same step. The spec adds only declarations that
+ * position cannot express: what the step does with the invocation's trailing arguments, and whether it runs in
+ * the background.
  */
 export declare function expandScript(script: ScriptValue, isWorkspaceRoot: boolean): readonly Step[];
 /**
@@ -56,10 +57,10 @@ export declare function readPackageJsonScripts(packageDir: string): Record<strin
  */
 export declare function buildWorkspaceRegistry(config: NmrConfig): ScriptRegistry;
 /**
- * Builds the merged root script registry:
+ * Builds the merged root script registry for the monorepo at `monorepoRoot`:
  * tier 1 (defaults) + tier 2 (config overrides)
  */
-export declare function buildRootRegistry(config: NmrConfig): ScriptRegistry;
+export declare function buildRootRegistry(config: NmrConfig, monorepoRoot: string): ScriptRegistry;
 /**
  * Returns a `package.json` entry that re-invokes the command under which it is declared alongside other steps,
  * or `undefined` when the entry does not.

package/dist/esm/resolver.js

@@ -46,7 +46,10 @@ export function expandScript(script, isWorkspaceRoot) {
     }
     return script.map((element) => typeof element === 'string'
         ? composeNmrStep(element, isWorkspaceRoot)
-        : composeNmrStep(element.run, isWorkspaceRoot, element.shouldDeclineArguments));
+        : composeNmrStep(element.run, isWorkspaceRoot, {
+            shouldDeclineArguments: element.shouldDeclineArguments,
+            shouldRunInBackground: element.shouldRunInBackground,
+        }));
 }
 export function describeScript(script) {
     return typeof script === 'string' ? script : `[${script.map(describeElement).join(', ')}]`;
@@ -55,7 +58,11 @@ function describeElement(element) {
     if (typeof element === 'string') {
         return element;
     }
-    return element.shouldDeclineArguments === true ? `${element.run} (no args)` : element.run;
+    const notes = [
+        ...(element.shouldRunInBackground === true ? ['background'] : []),
+        ...(element.shouldDeclineArguments === true ? ['no args'] : []),
+    ];
+    return notes.length === 0 ? element.run : `${element.run} (${notes.join(', ')})`;
 }
 export function readPackageJsonScripts(packageDir) {
     const file = resolvePackageJsonPath(packageDir);
@@ -83,9 +90,9 @@ export function buildWorkspaceRegistry(config) {
         ...config.workspaceScripts,
     };
 }
-export function buildRootRegistry(config) {
+export function buildRootRegistry(config, monorepoRoot) {
     return {
-        ...getDefaultRootScripts(),
+        ...getDefaultRootScripts(monorepoRoot),
         ...config.rootScripts,
     };
 }

package/dist/esm/runCli.js

@@ -81,7 +81,7 @@ async function runInvocation(options) {
     const shouldUseRoot = parsedArgs.isWorkspaceRoot || context.isRoot;
     const anchorDir = shouldUseRoot ? context.monorepoRoot : (context.packageDir ?? context.monorepoRoot);
     if (parsedArgs.shouldShowHelp || !parsedArgs.command) {
-        stdout.write(`${generateHelp(context.config, anchorDir, shouldUseRoot)}\n`);
+        stdout.write(`${generateHelp(context.config, context.monorepoRoot, anchorDir, shouldUseRoot)}\n`);
         return { exitCode: 0 };
     }
     const { command } = parsedArgs;
@@ -118,7 +118,9 @@ async function runInvocation(options) {
         const result = await runDelegation({ context, delegation, parsedArgs, runOptions, stderr });
         return { ...result, isUnknownCommand: result.exitCode !== 0 && !isDefinedInAnyScope(command, context) };
     }
-    const registry = shouldUseRoot ? buildRootRegistry(context.config) : buildWorkspaceRegistry(context.config);
+    const registry = shouldUseRoot
+        ? buildRootRegistry(context.config, context.monorepoRoot)
+        : buildWorkspaceRegistry(context.config);
     assertNoSelfReference({
         anchorDir,
         command,
@@ -894,7 +896,7 @@ function formatMisplacedFlagHint(args, passthrough, style) {
         `nmr reads its flags only before the command: \`${correctedTokens.map(quoteToken).join(' ')}\``);
 }
 function isDefinedInAnyScope(command, context) {
-    const registries = [buildRootRegistry(context.config), buildWorkspaceRegistry(context.config)];
+    const registries = [buildRootRegistry(context.config, context.monorepoRoot), buildWorkspaceRegistry(context.config)];
     if (registries.some((registry) => Object.hasOwn(registry, command))) {
         return true;
     }

package/dist/esm/runner.d.ts

@@ -75,6 +75,13 @@ export declare function resolveInheritedChannel(stream: Writable): OutputChannel
  * makes a signal to nmr end the run: The steps after it are never reached, whereas a shell would have gone on
  * running them unsupervised.
  *
+ * A background step is started and left running while the steps after it run. Its output is recorded rather
+ * than streamed, and printed whole at the first step boundary after it ends, so that it never interleaves with
+ * another step's. A failing foreground step still ends the sequence, but the list waits for every background step
+ * that it started and reports the first failure among them when the foreground did not fail. While a background
+ * step runs, a SIGINT or SIGTERM to nmr is forwarded to every running child, so that a signal sent to nmr alone
+ * still ends the children.
+ *
  * Returns a bounded copy of what the list's own commands wrote, so that a caller can retain it. Only opaque
  * steps contribute: A structural step is another nmr process reporting for the subtree beneath it, and its
  * output is that subtree's to account for.

package/dist/esm/runner.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import process from 'node:process';
 import { reportError } from '@williamthorsen/nmr-core';
 import { createBoundedBuffer } from "./helpers/createBoundedBuffer.js";
+import { createOutputRecorder } from "./helpers/createOutputRecorder.js";
 const SIGNAL_EXIT_BASE = 128;
 const PIPE_DRAIN_GRACE_MS = 2_000;
 export function resolveChannel(stream, quiet) {
@@ -22,26 +23,81 @@ export async function runSteps(steps, cwd, options) {
     };
     const parts = [];
     let isCaptureWhole = true;
-    for (const step of steps) {
-        const result = await runStep(step, cwd, resolvedOptions);
-        if (step.kind === 'opaque') {
-            if (result.stderr === undefined || result.stdout === undefined) {
-                isCaptureWhole = false;
+    const backgroundRuns = [];
+    const runningChildren = new Set();
+    let receivedSignal;
+    let foregroundExitCode = 0;
+    function forwardSignal(signal) {
+        receivedSignal ??= signal;
+        for (const child of runningChildren)
+            child.kill(signal);
+    }
+    function launch(step, launchOptions) {
+        const started = startStep(step, cwd, launchOptions);
+        runningChildren.add(started.child);
+        void started.result.finally(() => runningChildren.delete(started.child));
+        return started;
+    }
+    function flushEndedBackgroundRuns() {
+        for (const run of backgroundRuns) {
+            if (run.result === undefined || run.isFlushed)
+                continue;
+            run.recorder.replay({ stderr: resolvedOptions.stderr, stdout: resolvedOptions.stdout });
+            run.isFlushed = true;
+        }
+    }
+    try {
+        for (const step of steps) {
+            if (receivedSignal !== undefined) {
+                foregroundExitCode = describeSignalExitCode(receivedSignal);
+                break;
             }
-            else {
-                parts.push({ stderr: result.stderr, stdout: result.stdout });
+            if (step.kind === 'structural' && step.shouldRunInBackground === true) {
+                if (backgroundRuns.length === 0) {
+                    process.on('SIGINT', forwardSignal);
+                    process.on('SIGTERM', forwardSignal);
+                }
+                backgroundRuns.push(startBackgroundRun(step, resolvedOptions, launch));
+                continue;
+            }
+            const result = await launch(step, resolvedOptions).result;
+            flushEndedBackgroundRuns();
+            if (step.kind === 'opaque') {
+                if (result.stderr === undefined || result.stdout === undefined) {
+                    isCaptureWhole = false;
+                }
+                else {
+                    parts.push({ stderr: result.stderr, stdout: result.stdout });
+                }
+            }
+            if (result.exitCode !== 0) {
+                foregroundExitCode = result.exitCode;
+                if (result.outcome === 'signaled') {
+                    for (const run of backgroundRuns)
+                        run.child.kill(result.signal);
+                }
+                break;
             }
         }
-        if (result.exitCode !== 0) {
-            return { exitCode: result.exitCode, ...composeRetainedOutput(parts, isCaptureWhole) };
+        for (const run of backgroundRuns) {
+            await run.settled;
+            flushEndedBackgroundRuns();
         }
     }
-    return { exitCode: 0, ...composeRetainedOutput(parts, isCaptureWhole) };
+    finally {
+        process.off('SIGINT', forwardSignal);
+        process.off('SIGTERM', forwardSignal);
+    }
+    const exitCode = selectExitCode(foregroundExitCode, receivedSignal, backgroundRuns);
+    return { exitCode, ...composeRetainedOutput(parts, isCaptureWhole) };
 }
 export async function runCommand(command, cwd, options) {
     return runSpawned({ args: [], file: command, input: 'inherit', shouldUseShell: true }, cwd, options);
 }
-async function runSpawned({ args, file, input, shouldUseShell }, cwd, options) {
+function runSpawned(spec, cwd, options) {
+    return startSpawned(spec, cwd, options).result;
+}
+function startSpawned({ args, file, input, shouldUseShell }, cwd, options) {
     const quiet = options.quiet === true;
     const stdout = options.stdout ?? process.stdout;
     const stderr = options.stderr ?? process.stderr;
@@ -52,6 +108,9 @@ async function runSpawned({ args, file, input, shouldUseShell }, cwd, options) {
         cwd,
         env,
     });
+    return { child, result: collectResult(child, { quiet, stderr, stdout }) };
+}
+async function collectResult(child, { quiet, stderr, stdout }) {
     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 commandCompletion = await awaitCompletion(child, () => {
@@ -75,17 +134,17 @@ async function runSpawned({ args, file, input, shouldUseShell }, cwd, options) {
     }
     return result;
 }
-function runStep(step, cwd, options) {
+function startStep(step, cwd, options) {
     const { quiet, stderr, stdout } = options;
     if (step.kind === 'opaque') {
-        return runSpawned({ args: [], file: step.command, input: 'inherit', shouldUseShell: true }, cwd, {
+        return startSpawned({ args: [], file: step.command, input: 'inherit', shouldUseShell: true }, cwd, {
             ...options,
             channels: { stderr: resolveChannel(stderr, quiet), stdout: resolveChannel(stdout, quiet) },
         });
     }
     const [file, ...args] = step.argv;
     const input = step.shouldWithholdInput === true ? 'ignore' : 'inherit';
-    return runSpawned({ args, file, input, shouldUseShell: false }, cwd, {
+    return startSpawned({ args, file, input, shouldUseShell: false }, cwd, {
         ...options,
         quiet: false,
         channels: { stderr: resolveInheritedChannel(stderr), stdout: resolveInheritedChannel(stdout) },
@@ -157,18 +216,49 @@ function awaitCompletion(child, stopReading) {
         });
     });
 }
+function buildBackgroundEnv(options) {
+    const env = options.env ?? process.env;
+    const shouldForceColor = isTerminal(options.stdout) && (env['NO_COLOR'] ?? '') === '' && env['FORCE_COLOR'] === undefined;
+    return shouldForceColor ? { ...env, FORCE_COLOR: '1' } : env;
+}
 function describeExit(code, signal) {
     if (signal !== null) {
-        return { outcome: 'signaled', exitCode: SIGNAL_EXIT_BASE + os.constants.signals[signal], signal };
+        return { outcome: 'signaled', exitCode: describeSignalExitCode(signal), signal };
     }
     return { outcome: 'exited', exitCode: code ?? 1 };
 }
+function describeSignalExitCode(signal) {
+    return SIGNAL_EXIT_BASE + os.constants.signals[signal];
+}
 function hasDescriptor(stream) {
     return 'fd' in stream && typeof stream.fd === 'number';
 }
 function isTerminal(stream) {
     return 'isTTY' in stream && stream.isTTY === true && hasDescriptor(stream);
 }
+async function recordResult(run, result) {
+    run.result = await result;
+}
+function selectExitCode(foregroundExitCode, receivedSignal, backgroundRuns) {
+    if (foregroundExitCode !== 0)
+        return foregroundExitCode;
+    if (receivedSignal !== undefined)
+        return describeSignalExitCode(receivedSignal);
+    return backgroundRuns.find((run) => run.result !== undefined && run.result.exitCode !== 0)?.result?.exitCode ?? 0;
+}
+function startBackgroundRun(step, options, launch) {
+    const recorder = createOutputRecorder();
+    const started = launch({ ...step, shouldWithholdInput: true }, { ...options, env: buildBackgroundEnv(options), stderr: recorder.stderr, stdout: recorder.stdout });
+    const run = {
+        child: started.child,
+        isFlushed: false,
+        recorder,
+        result: undefined,
+        settled: Promise.resolve(),
+    };
+    run.settled = recordResult(run, started.result);
+    return run;
+}
 function writeBuffer(buffer, destination) {
     if (buffer !== undefined && buffer.length > 0)
         destination.write(buffer);

package/dist/esm/steps.d.ts

@@ -8,8 +8,9 @@
  * `shouldDeclineArguments` is passed from the composite element that composed the step to the one reader that acts
  * on it, the binding of the invocation's trailing arguments. Every stage between the two passes it through unread.
  *
- * `shouldWithholdInput` is read by the runner alone, which gives the step's child the null device as stdin rather
- * than nmr's own. Like `shouldDeclineArguments`, it is set only when it holds and leaves the rendered chain unchanged.
+ * `shouldRunInBackground` and `shouldWithholdInput` are read by the runner alone. The first starts the step without
+ * waiting for it; the second gives the step's child the null device as stdin rather than nmr's own. Like
+ * `shouldDeclineArguments`, each is set only when it holds and leaves the rendered chain unchanged.
  */
 export type Step = {
     kind: 'opaque';
@@ -18,8 +19,14 @@ export type Step = {
     kind: 'structural';
     argv: readonly [string, ...(readonly string[])];
     shouldDeclineArguments?: boolean;
+    shouldRunInBackground?: boolean;
     shouldWithholdInput?: boolean;
 };
+/** The declarations that a composite element adds to the step that it composes. */
+export interface StepFlags {
+    shouldDeclineArguments?: boolean | undefined;
+    shouldRunInBackground?: boolean | undefined;
+}
 /** What a structural step asks of the nmr process that it spawns. */
 export interface NmrStepTarget {
     command: string;
@@ -44,10 +51,10 @@ export type SelfReference = 'chained' | 'sole';
  * The element tokenizes on whitespace, so it may contain nmr's own flags but cannot contain a space-bearing
  * token. `-w` is prepended as its own token: The child selects the root registry on its own.
  *
- * Because `shouldDeclineArguments` is set only when it holds, a step that takes the trailing arguments compares
- * equal to one composed without the option.
+ * Because each flag is set only when it holds, a step composed with a flag at `false` compares equal to one
+ * composed without it.
  */
-export declare function composeNmrStep(element: string, isWorkspaceRoot: boolean, shouldDeclineArguments?: boolean): Step;
+export declare function composeNmrStep(element: string, isWorkspaceRoot: boolean, flags?: StepFlags): Step;
 /**
  * Returns the steps that still run in a workspace without any package: every step but the ones that a `-R` fans
  * out.

package/dist/esm/steps.js

@@ -11,12 +11,14 @@ const QUOTES = new Set(['"', "'"]);
 const SEGMENT_SEPARATORS = new Set([';', '|', '&', '\n', '\r']);
 const SHELL_SAFE_TOKEN = /^[\w@%+=:,./-]+$/;
 const TOKEN_SEPARATORS = new Set([' ', '\t', '\n', '\r']);
-export function composeNmrStep(element, isWorkspaceRoot, shouldDeclineArguments = false) {
-    const flags = isWorkspaceRoot ? ['-w'] : [];
+export function composeNmrStep(element, isWorkspaceRoot, flags = {}) {
+    const { shouldDeclineArguments = false, shouldRunInBackground = false } = flags;
+    const nmrFlags = isWorkspaceRoot ? ['-w'] : [];
     return {
         kind: 'structural',
-        argv: ['nmr', ...flags, ...tokenize(element)],
+        argv: ['nmr', ...nmrFlags, ...tokenize(element)],
         ...(shouldDeclineArguments && { shouldDeclineArguments }),
+        ...(shouldRunInBackground && { shouldRunInBackground }),
     };
 }
 export function dropRecursiveSteps(steps) {

package/dist/esm/taze.d.ts

@@ -12,8 +12,11 @@ export type TazeConfig = {
 /**
  * Builds a taze configuration from nmr's shared upgrade policy and a repo's own settings.
  *
- * Any property that the caller supplies wins, including `0` and an explicit `undefined`. The latter restores
- * taze's inheritance of pnpm's `minimumReleaseAge`, which only applies while `maturityPeriod` is unset.
+ * Any property that the caller supplies wins, including `0` and an explicit `undefined`, which clears nmr's
+ * default and hands the setting back to taze. Clearing `maturityPeriod` restores taze's inheritance of pnpm's
+ * `minimumReleaseAge`, which only applies while it is unset. Clearing `mode` yields taze's own `'default'`, which
+ * follows each declared range; passed through as `undefined`, it would overwrite taze's default and leave no
+ * valid range to search.
  *
  * The merge is shallow, which suits a policy of scalar defaults. A nested default would clobber rather
  * than merge, so adding one means revisiting this.

package/dist/esm/taze.js

@@ -4,5 +4,8 @@ const SHARED_POLICY = {
     mode: 'minor',
 };
 export function defineConfig(config) {
-    return { ...SHARED_POLICY, ...config };
+    const merged = { ...SHARED_POLICY, ...config };
+    if ('mode' in config && config.mode === undefined)
+        merged.mode = 'default';
+    return merged;
 }

package/dist/esm/types.d.ts

@@ -28,6 +28,15 @@ export interface CheckCacheConfig {
      */
     extraCommands?: string[];
 }
+/** Self-hosted runner settings honored at the monorepo root, read by nmr's readyup kit. */
+export interface SelfHostedRunnerConfig {
+    /**
+     * Why the repo keeps its CI off the self-hosted runners although it qualifies, such as a circular dependency on
+     * the runners themselves. Declaring it stops the kit from recommending `CI_RUNS_ON`. A missing tool is not a
+     * reason: A workflow step installs it.
+     */
+    exempt: string;
+}
 /** Output settings honored at the monorepo root. */
 export interface OutputConfig {
     /**
@@ -49,4 +58,5 @@ export interface NmrConfig {
     output?: OutputConfig;
     workspaceScripts?: Record<string, ScriptValue>;
     rootScripts?: Record<string, ScriptValue>;
+    selfHostedRunner?: SelfHostedRunnerConfig;
 }