@williamthorsen/nmr 2.2.0 → 2.2.2

package/dist/esm/config-validation.js

@@ -98,6 +98,13 @@ function formatKeyList(keys, prefix) {
 function isOptionalBoolean(value) {
     return value === undefined || typeof value === 'boolean';
 }
+function isScriptElement(value) {
+    if (typeof value === 'string')
+        return true;
+    if (!isRecord(value) || typeof value['run'] !== 'string')
+        return false;
+    return isOptionalBoolean(value['shouldDeclineArguments']) && isOptionalBoolean(value['shouldRunInBackground']);
+}
 function isScriptRecord(value) {
     if (!isRecord(value))
         return false;
@@ -109,13 +116,6 @@ function isScriptRecord(value) {
     }
     return true;
 }
-function isScriptElement(value) {
-    if (typeof value === 'string')
-        return true;
-    if (!isRecord(value) || typeof value['run'] !== 'string')
-        return false;
-    return isOptionalBoolean(value['shouldDeclineArguments']) && isOptionalBoolean(value['shouldRunInBackground']);
-}
 function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
@@ -215,6 +215,19 @@ function validateOutputField(value, configPath) {
     }
     return config;
 }
+function validateScriptField(value, fieldName, configPath) {
+    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
+        return undefined;
+    }
+    const scripts = value[fieldName];
+    if (!isScriptRecord(scripts)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | element[]>, ` +
+            'where an element is a command string or ' +
+            '`{ run: string, shouldDeclineArguments?: boolean, shouldRunInBackground?: boolean }`');
+    }
+    assertValidElements(scripts, fieldName, configPath);
+    return scripts;
+}
 function validateSelfHostedRunnerField(value, configPath) {
     const selfHostedRunner = value['selfHostedRunner'];
     if (selfHostedRunner === undefined) {
@@ -230,16 +243,3 @@ function validateSelfHostedRunnerField(value, configPath) {
     }
     return { exempt };
 }
-function validateScriptField(value, fieldName, configPath) {
-    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
-        return undefined;
-    }
-    const scripts = value[fieldName];
-    if (!isScriptRecord(scripts)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | element[]>, ` +
-            'where an element is a command string or ' +
-            '`{ run: string, shouldDeclineArguments?: boolean, shouldRunInBackground?: boolean }`');
-    }
-    assertValidElements(scripts, fieldName, configPath);
-    return scripts;
-}

package/dist/esm/delegation/delegate-host.js

@@ -98,19 +98,6 @@ function createTee(stream, buffer) {
         },
     });
 }
-function describeDelegationSource(target, parsedArgs, env) {
-    switch (target.source) {
-        case 'config':
-            return `${formatDisplayPath(target.configPath, env)} (when: ${target.when})`;
-        case 'env':
-            return DELEGATE_ENV_VAR;
-        case 'flag':
-            return parsedArgs.delegateHosts === undefined ? DELEGATE_FLAG : DELEGATE_TO_FLAG;
-    }
-}
-function describeUnreachableHost(host, sshMessage) {
-    return sshMessage === '' ? `${host} did not answer` : `${host} did not answer: ${sshMessage}`;
-}
 async function delegate(options) {
     const { invocation, remoteEnv, target } = options;
     const { command, context, cwd, env, parsedArgs, stderr, stdout } = invocation;
@@ -178,6 +165,19 @@ async function delegate(options) {
         : { outcome: 'failed', durationMs, exitCode: result.exitCode };
     return { ...ran, exitCode: result.exitCode, outcome, passes: result.passes };
 }
+function describeDelegationSource(target, parsedArgs, env) {
+    switch (target.source) {
+        case 'config':
+            return `${formatDisplayPath(target.configPath, env)} (when: ${target.when})`;
+        case 'env':
+            return DELEGATE_ENV_VAR;
+        case 'flag':
+            return parsedArgs.delegateHosts === undefined ? DELEGATE_FLAG : DELEGATE_TO_FLAG;
+    }
+}
+function describeUnreachableHost(host, sshMessage) {
+    return sshMessage === '' ? `${host} did not answer` : `${host} did not answer: ${sshMessage}`;
+}
 function formatRunHereLine(command, listedHosts, reason) {
     return `nmr: running ${command} here rather than on ${listedHosts}: ${reason}\n`;
 }

package/dist/esm/delegation/remote-host-session.d.ts

@@ -55,6 +55,10 @@ export type SessionRecord = {
  * out the snapshot, installs, runs nmr, and reports the passes that nmr wrote to the pass manifest. It is sent as
  * source, so it refers to nothing outside its own body.
  *
+ * Every process that the session starts runs on the login shell's `PATH`, which the session script passes as the
+ * argument after `params`: A version manager's `node` shim puts the `bin` directory of the Node that it chose before
+ * the checkout in front of the session's own `PATH`, and the snapshot may pin another.
+ *
  * The lock follows the machine lock's rules: A waiter reclaims it at once when the holder's pid is gone, and once the
  * holder has stopped refreshing it for a minute otherwise. When the session's stdin ends, which the local `ssh` causes
  * by exiting, the session stops its current phase's process group, releases the lock, and exits.

package/dist/esm/delegation/remote-host-session.js

@@ -16,6 +16,8 @@ export function runHostSession(params) {
     const STOP_GRACE_MS = 5000;
     const NODE_MODULES_DIR = path.join(params.rootDir, 'node_modules');
     const BINS_RECORD_PATH = path.join(NODE_MODULES_DIR, '.nmr-delegate-bins');
+    const loginPath = process.argv[2] || process.env['PATH'];
+    const childEnv = { ...process.env, PATH: loginPath };
     const token = crypto.randomUUID();
     let isHolding = false;
     let activeChild;
@@ -30,7 +32,7 @@ export function runHostSession(params) {
             ['checkout', '--quiet', '--force', '--detach', params.sha],
             ['clean', '--force', '-d', '--quiet'],
         ]) {
-            const result = await runPhase('git', args, '.', process.env);
+            const result = await runPhase('git', args, '.', childEnv);
             if (isStopping)
                 return;
             if (result.exitCode !== 0) {
@@ -43,7 +45,7 @@ export function runHostSession(params) {
             removeWorkspaceState();
         }
         const install = await runPhase('pnpm', ['install', '--frozen-lockfile'], params.rootDir, {
-            ...process.env,
+            ...childEnv,
             CI: 'true',
         });
         if (isStopping)
@@ -62,7 +64,7 @@ export function runHostSession(params) {
         const child = childProcess.spawn('pnpm', ['exec', 'nmr', '--no-delegate', ...params.nmrArgs], {
             cwd: params.runDir,
             detached: true,
-            env: { ...process.env, ...params.remoteEnv, ...manifestEnv },
+            env: { ...childEnv, ...params.remoteEnv, ...manifestEnv },
             stdio: ['ignore', 'inherit', 'inherit'],
         });
         activeChild = child;

package/dist/esm/delegation/remote-session.d.ts

@@ -14,8 +14,8 @@ export interface SessionDemultiplexer {
     stream: Writable;
 }
 /**
- * Composes the script that runs the host session from the checkout. `checkoutDir` is a shell expression, so that it
- * can name the host's home directory.
+ * Composes the script that runs the host session from the checkout, passing it the shell's `PATH` for the processes
+ * that it starts. `checkoutDir` is a shell expression, so that it can name the host's home directory.
  */
 export declare function composeSessionScript(options: {
     checkoutDir: string;

package/dist/esm/delegation/remote-session.js

@@ -5,7 +5,7 @@ import { runHostSession, } from "./remote-host-session.js";
 export function composeSessionScript(options) {
     const { checkoutDir, params } = options;
     const source = `(${runHostSession.toString()})(JSON.parse(process.argv[1]));`;
-    return `cd ${checkoutDir} && exec node -e ${quoteForShell(source)} ${quoteForShell(JSON.stringify(params))}`;
+    return `cd ${checkoutDir} && exec node -e ${quoteForShell(source)} ${quoteForShell(JSON.stringify(params))} "$PATH"`;
 }
 export function createSessionDemultiplexer(options) {
     const { marker, onMalformedRecord, onRecord, stderr } = options;

package/dist/esm/describeHelp.js

@@ -57,6 +57,17 @@ const ENVIRONMENT_AND_FILES_LINES = [
     '                              ($XDG_CONFIG_HOME/nmr/config.ts when that is set)',
     '                              A command that it sends runs here when no host answers',
 ];
+function applyOverrides(registry, overrides) {
+    const markedNames = new Set();
+    for (const [name, value] of Object.entries(overrides)) {
+        if (!Object.hasOwn(registry, name)) {
+            continue;
+        }
+        registry[name] = value;
+        markedNames.add(name);
+    }
+    return markedNames;
+}
 function collectOverrides(packageScripts) {
     const candidateOverrides = {};
     for (const [name, value] of Object.entries(packageScripts)) {
@@ -74,28 +85,6 @@ function collectUnregisteredScripts(packageScripts, registry) {
     }
     return unregisteredScripts;
 }
-function readRunnableScripts(packageDir) {
-    const scripts = readPackageJsonScripts(packageDir);
-    if (!scripts)
-        return {};
-    const runnableScripts = {};
-    for (const [name, value] of Object.entries(scripts)) {
-        if (!isSelfReferential(value, name, packageDir))
-            runnableScripts[name] = value;
-    }
-    return runnableScripts;
-}
-function applyOverrides(registry, overrides) {
-    const markedNames = new Set();
-    for (const [name, value] of Object.entries(overrides)) {
-        if (!Object.hasOwn(registry, name)) {
-            continue;
-        }
-        registry[name] = value;
-        markedNames.add(name);
-    }
-    return markedNames;
-}
 function filterHooks(registry) {
     const hooklessRegistry = {};
     for (const [key, value] of Object.entries(registry)) {
@@ -115,3 +104,14 @@ function formatRegistry(registry, markedNames, lines) {
         lines.push(`  ${(key + marker).padEnd(padWidth)} ${describeScript(value)}`);
     }
 }
+function readRunnableScripts(packageDir) {
+    const scripts = readPackageJsonScripts(packageDir);
+    if (!scripts)
+        return {};
+    const runnableScripts = {};
+    for (const [name, value] of Object.entries(scripts)) {
+        if (!isSelfReferential(value, name, packageDir))
+            runnableScripts[name] = value;
+    }
+    return runnableScripts;
+}

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

@@ -47,6 +47,10 @@ function isRootEntry(entry, monorepoRoot) {
     }
     return resolveRealPath(entry['path']) === resolveRealPath(monorepoRoot);
 }
+function readDelegateSelection(pattern, monorepoRoot) {
+    const probeRun = spawnSync('pnpm', ['--filter', pattern, 'exec', process.execPath, '--eval', `process.stdout.write('${SELECTION_MARKER}')`], { cwd: monorepoRoot, encoding: 'utf8' });
+    return interpretDelegateProbe({ error: probeRun.error, status: probeRun.status, stdout: probeRun.stdout });
+}
 function resolveRealPath(target) {
     try {
         return realpathSync(target);
@@ -55,7 +59,3 @@ function resolveRealPath(target) {
         return path.resolve(target);
     }
 }
-function readDelegateSelection(pattern, monorepoRoot) {
-    const probeRun = spawnSync('pnpm', ['--filter', pattern, 'exec', process.execPath, '--eval', `process.stdout.write('${SELECTION_MARKER}')`], { cwd: monorepoRoot, encoding: 'utf8' });
-    return interpretDelegateProbe({ error: probeRun.error, status: probeRun.status, stdout: probeRun.stdout });
-}

package/dist/esm/machine-lock.js

@@ -140,14 +140,6 @@ function isHolderRecord(value) {
         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);
@@ -163,6 +155,14 @@ function isStale(state, staleAfterMs) {
     }
     return state.holder !== undefined && isProcessGone(state.holder.pid);
 }
+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 parseHolder(content) {
     try {
         const value = JSON.parse(content);

package/dist/esm/prettier.js

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

package/dist/esm/resolver.js

@@ -18,16 +18,6 @@ export function expandScript(script, isWorkspaceRoot) {
 export function describeScript(script) {
     return typeof script === 'string' ? script : `[${script.map(describeElement).join(', ')}]`;
 }
-function describeElement(element) {
-    if (typeof element === 'string') {
-        return element;
-    }
-    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);
     let rawText;
@@ -101,6 +91,16 @@ export function resolveScript(commandName, registry, packageDir, isWorkspaceRoot
     }
     return { origin: { tier: 'registry', key: commandName }, steps: expandScript(registryEntry, isWorkspaceRoot) };
 }
+function describeElement(element) {
+    if (typeof element === 'string') {
+        return element;
+    }
+    const notes = [
+        ...(element.shouldRunInBackground === true ? ['background'] : []),
+        ...(element.shouldDeclineArguments === true ? ['no args'] : []),
+    ];
+    return notes.length === 0 ? element.run : `${element.run} (${notes.join(', ')})`;
+}
 function readPackageScope(packageDir) {
     return isMonorepoRoot(packageDir) ? 'root' : 'package';
 }

package/dist/esm/runCli.js

@@ -47,29 +47,20 @@ export async function runCli(options) {
     const routedArgs = isBare ? [...args, '--help'] : args;
     return { exitCode: await runRouter(routedArgs, root, routerOptions) };
 }
-async function runInvocation(invocation, options) {
-    const resolvedTarget = await resolveExecutionTarget(invocation);
-    if (resolvedTarget.settled) {
-        return resolvedTarget.result.exitCode;
-    }
-    let target = resolvedTarget.value;
-    const { filter, recursive } = invocation.parsedArgs;
-    if (target.kind === 'remote' && (filter !== undefined || recursive)) {
-        const delegated = await runInvocationOnHost(invocation, target);
-        if (delegated !== undefined) {
-            return delegated.exitCode;
-        }
-        target = { kind: 'local' };
+async function executePlan(plan) {
+    const { command, format, parsedArgs, scope, stdout, styles } = plan.invocation;
+    if (parsedArgs.shouldPrintLog) {
+        return reportRecording(plan);
     }
-    const planned = await planRun(invocation, target);
-    const { exitCode, isUnknownCommand = false } = planned.settled ? planned.result : await executePlan(planned.value);
-    if (exitCode !== 0 && !isUnknownCommand && isTopLevelInvocation(options.env)) {
-        const hint = formatMisplacedFlagHint(options.args, invocation.parsedArgs.passthrough, invocation.styles.stderr);
-        if (hint !== undefined) {
-            options.stderr.write(`${hint}\n`);
-        }
+    const { exitCode, host, outcome } = await runGated(plan);
+    if (outcome !== undefined) {
+        reportVerdict({ command, ...(host !== undefined && { host }), scope, ...outcome }, stdout, format, styles.stdout);
     }
-    return exitCode;
+    return { exitCode };
+}
+function isTopLevelInvocation(env) {
+    const runId = env[RUN_ID_ENV_VAR];
+    return runId === undefined || runId === '';
 }
 async function planRun(invocation, target) {
     const { anchorDir, command, context, env, parsedArgs, stderr, stdout, styles } = invocation;
@@ -176,18 +167,27 @@ async function planRun(invocation, target) {
         },
     };
 }
-async function executePlan(plan) {
-    const { command, format, parsedArgs, scope, stdout, styles } = plan.invocation;
-    if (parsedArgs.shouldPrintLog) {
-        return reportRecording(plan);
+async function runInvocation(invocation, options) {
+    const resolvedTarget = await resolveExecutionTarget(invocation);
+    if (resolvedTarget.settled) {
+        return resolvedTarget.result.exitCode;
     }
-    const { exitCode, host, outcome } = await runGated(plan);
-    if (outcome !== undefined) {
-        reportVerdict({ command, ...(host !== undefined && { host }), scope, ...outcome }, stdout, format, styles.stdout);
+    let target = resolvedTarget.value;
+    const { filter, recursive } = invocation.parsedArgs;
+    if (target.kind === 'remote' && (filter !== undefined || recursive)) {
+        const delegated = await runInvocationOnHost(invocation, target);
+        if (delegated !== undefined) {
+            return delegated.exitCode;
+        }
+        target = { kind: 'local' };
     }
-    return { exitCode };
-}
-function isTopLevelInvocation(env) {
-    const runId = env[RUN_ID_ENV_VAR];
-    return runId === undefined || runId === '';
+    const planned = await planRun(invocation, target);
+    const { exitCode, isUnknownCommand = false } = planned.settled ? planned.result : await executePlan(planned.value);
+    if (exitCode !== 0 && !isUnknownCommand && isTopLevelInvocation(options.env)) {
+        const hint = formatMisplacedFlagHint(options.args, invocation.parsedArgs.passthrough, invocation.styles.stderr);
+        if (hint !== undefined) {
+            options.stderr.write(`${hint}\n`);
+        }
+    }
+    return exitCode;
 }

package/dist/esm/runner.js

@@ -116,24 +116,10 @@ export async function runSteps(steps, cwd, options) {
 export async function runCommand(command, cwd, options) {
     return runSpawned({ args: [], file: command, input: 'inherit', shouldUseShell: true }, cwd, options);
 }
-function runSpawned(spec, cwd, options) {
-    return startSpawned(spec, cwd, options).result;
-}
-function startStep(step, cwd, options) {
-    const { quiet, stderr, stdout } = options;
-    if (step.kind === 'opaque') {
-        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 startSpawned({ args, file, input, shouldUseShell: false }, cwd, {
-        ...options,
-        quiet: false,
-        channels: { stderr: resolveInheritedChannel(stderr), stdout: resolveInheritedChannel(stdout) },
-    });
+function buildBackgroundEnv(options) {
+    const { env } = options;
+    const shouldForceColor = isTerminal(options.stdout) && (env['NO_COLOR'] ?? '') === '' && env['FORCE_COLOR'] === undefined;
+    return shouldForceColor ? { ...env, FORCE_COLOR: '1' } : env;
 }
 function composeRetainedOutput(parts, isCaptureWhole) {
     if (!isCaptureWhole || parts.length === 0) {
@@ -146,14 +132,12 @@ function composeRetainedOutput(parts, isCaptureWhole) {
         },
     };
 }
-function buildBackgroundEnv(options) {
-    const { env } = options;
-    const shouldForceColor = isTerminal(options.stdout) && (env['NO_COLOR'] ?? '') === '' && env['FORCE_COLOR'] === undefined;
-    return shouldForceColor ? { ...env, FORCE_COLOR: '1' } : env;
-}
 async function recordResult(run, result) {
     run.result = await result;
 }
+function runSpawned(spec, cwd, options) {
+    return startSpawned(spec, cwd, options).result;
+}
 function selectExitCode(foregroundExitCode, receivedSignal, backgroundRuns) {
     if (foregroundExitCode !== 0)
         return foregroundExitCode;
@@ -174,3 +158,19 @@ function startBackgroundRun(step, options, launch) {
     run.settled = recordResult(run, started.result);
     return run;
 }
+function startStep(step, cwd, options) {
+    const { quiet, stderr, stdout } = options;
+    if (step.kind === 'opaque') {
+        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 startSpawned({ args, file, input, shouldUseShell: false }, cwd, {
+        ...options,
+        quiet: false,
+        channels: { stderr: resolveInheritedChannel(stderr), stdout: resolveInheritedChannel(stdout) },
+    });
+}

package/dist/esm/verdict.js

@@ -21,6 +21,20 @@ const NEWLINE_BYTES = 1;
 const LINE_BUDGET_BYTES = VERDICT_LINE_LIMIT_BYTES - NEWLINE_BYTES;
 const MIN_CUT_BYTES = Buffer.byteLength(TRUNCATION_MARK);
 const REPLAY_MARKER = 'replayed:';
+function describeNoOpReason(reason) {
+    switch (reason) {
+        case 'empty-override':
+            return 'the override is empty';
+        case 'empty-workspace':
+            return 'the workspace does not declare any package';
+        case 'noop-override':
+            return 'the override is a no-op';
+        default: {
+            const unhandledReason = reason;
+            throw new Error(`Unhandled no-op reason: ${String(unhandledReason)}`);
+        }
+    }
+}
 function describeOutcome(verdict, style) {
     const statuses = STATUS_GLYPHS[style];
     const onHost = verdict.host === undefined ? '' : ` on ${formatHost(verdict.host, style)}`;
@@ -49,41 +63,6 @@ function describeOutcome(verdict, style) {
         }
     }
 }
-function describeNoOpReason(reason) {
-    switch (reason) {
-        case 'empty-override':
-            return 'the override is empty';
-        case 'empty-workspace':
-            return 'the workspace does not declare any package';
-        case 'noop-override':
-            return 'the override is a no-op';
-        default: {
-            const unhandledReason = reason;
-            throw new Error(`Unhandled no-op reason: ${String(unhandledReason)}`);
-        }
-    }
-}
-function renderReplay(verdict) {
-    if (verdict.outcome !== 'recalled' || verdict.replay === undefined || verdict.replay.length === 0) {
-        return undefined;
-    }
-    const [first] = verdict.replay;
-    if (verdict.replay.length === 1 && first?.command === verdict.command && first.scope === verdict.scope) {
-        return `${REPLAY_MARKER} ${first.excerpt}`;
-    }
-    const lines = verdict.replay.map((line) => `${line.scope}: ${line.command}: ${line.excerpt}`);
-    return `${REPLAY_MARKER} ${lines.join('; ')}`;
-}
-function renderStated(verdict) {
-    if (verdict.outcome !== 'passed' || verdict.stated === undefined) {
-        return undefined;
-    }
-    const saving = formatSaving(verdict.stated.savedMs ?? 0);
-    return saving === undefined ? 'build skipped as unchanged' : `build skipped as unchanged, ${saving}`;
-}
-function flattenDetail(detail) {
-    return detail.replaceAll(/[\r\n]+/gu, ' ').trim();
-}
 function findCutTarget(sizesBytes, longestSizeBytes, overrunBytes) {
     const smallerSizesBytes = sizesBytes.filter((size) => size < longestSizeBytes && size > MIN_CUT_BYTES);
     const share = Math.ceil(overrunBytes / sizesBytes.filter((size) => size === longestSizeBytes).length);
@@ -92,13 +71,16 @@ function findCutTarget(sizesBytes, longestSizeBytes, overrunBytes) {
         : Math.max(...smallerSizesBytes, longestSizeBytes - overrunBytes);
     return Math.max(MIN_CUT_BYTES, target);
 }
-function isWithinBudget(renderedLine) {
-    return Buffer.byteLength(renderedLine) <= LINE_BUDGET_BYTES;
+function flattenDetail(detail) {
+    return detail.replaceAll(/[\r\n]+/gu, ' ').trim();
 }
 function formatHost(host, style) {
     const glyph = NMR_GLYPHS[style].host.text;
     return glyph === '' ? host : `${glyph} ${host}`;
 }
+function isWithinBudget(renderedLine) {
+    return Buffer.byteLength(renderedLine) <= LINE_BUDGET_BYTES;
+}
 function readAttribution(verdict) {
     if (verdict.outcome !== 'recalled' || verdict.replay === undefined) {
         return [];
@@ -126,6 +108,24 @@ function renderClamped(record) {
     }
     return renderedLine;
 }
+function renderReplay(verdict) {
+    if (verdict.outcome !== 'recalled' || verdict.replay === undefined || verdict.replay.length === 0) {
+        return undefined;
+    }
+    const [first] = verdict.replay;
+    if (verdict.replay.length === 1 && first?.command === verdict.command && first.scope === verdict.scope) {
+        return `${REPLAY_MARKER} ${first.excerpt}`;
+    }
+    const lines = verdict.replay.map((line) => `${line.scope}: ${line.command}: ${line.excerpt}`);
+    return `${REPLAY_MARKER} ${lines.join('; ')}`;
+}
+function renderStated(verdict) {
+    if (verdict.outcome !== 'passed' || verdict.stated === undefined) {
+        return undefined;
+    }
+    const saving = formatSaving(verdict.stated.savedMs ?? 0);
+    return saving === undefined ? 'build skipped as unchanged' : `build skipped as unchanged, ${saving}`;
+}
 function renderWithinBudget(verdict) {
     const shortenedVerdict = shortenCuttableText(verdict);
     const shortenedLine = JSON.stringify(shortenedVerdict);