@williamthorsen/nmr 0.48.0 → 0.49.0

package/dist/esm/runCli.js

@@ -1,50 +1,44 @@
 import path from 'node:path';
-import { describeInvalidOutputStyle, formatGlyphLine, reportError, resolveSelfVersion, STATUS_GLYPHS, } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
+import { reportError } from '@williamthorsen/nmr-core';
 import { prependBinDirs } from "./bin-path.js";
-import { certifyRetention, computeCacheKey, computeRetentionKey, CURRENT_RUNTIME, encodeTreeSnapshot, findStaleBuildOutput, formatMisplacedNoCacheWarning, isCacheableCommand, NO_CACHE_ENV_VAR, readBuildOutputState, readCheckCacheEntry, recordTranscript, resolveRunId, resolveTreeSnapshot, RUN_ID_ENV_VAR, TREE_SNAPSHOT_ENV_VAR, writeCheckCacheEntry, writeDebugNote, } from "./check-cache.js";
+import { NO_CACHE_ENV_VAR, resolveRunId, RUN_ID_ENV_VAR } from "./check-cache.js";
+import { openGate, runGated } from "./check-cache-gate.js";
+import { reportRecording } from "./check-cache-record.js";
+import { addLockEnv, buildChildEnv, takeMachineLock } from "./child-env.js";
 import { resolveContext } from "./context.js";
+import { assertNoSelfReference } from "./crossing-diagnostics.js";
+import { resolveExecutionTarget, runInvocationOnHost } from "./delegate-host.js";
 import { enterChain } from "./entry-chain.js";
-import { NMR_GLYPHS } from "./glyphs.js";
+import { composeDelegation, isDefinedInAnyScope, runDelegation } from "./fan-out.js";
 import { generateHelp } from "./help.js";
-import { resolveConfigPath } from "./helpers/config-path.js";
-import { deriveExcerpt } from "./helpers/deriveExcerpt.js";
-import { escapeControlCharacters } from "./helpers/escapeControlCharacters.js";
-import { readFilterSelection } from "./helpers/filter-selection.js";
-import { findClosestName } from "./helpers/findClosestName.js";
-import { isHookName } from "./helpers/hook-name.js";
-import { resolvePackageJsonPath } from "./helpers/package-json.js";
-import { quoteForShell } from "./helpers/quoteForShell.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 { createSnapshot, DELEGATE_ENV_VAR, DELEGATE_FLAG, DELEGATION_FAILURE_EXIT_CODE, formatMisplacedDelegationWarning, NO_DELEGATE_FLAG, resolveDelegationTarget, runRemotely, } from "./remote-run.js";
-import { assembleReplay } from "./replay-assembly.js";
-import { readReportFormatEnv, REPORT_FORMAT_ENV_VAR, resolveReportFormat } from "./report-format.js";
-import { applyDevBinToSteps, buildRootRegistry, buildWorkspaceRegistry, expandScript, findChainedSelfReference, readPackageJsonScripts, resolveScript, } from "./resolver.js";
-import { resolveChannel, runSteps } from "./runner.js";
-import { composeNmrStep, dropRecursiveSteps, findNmrCrossing, quoteToken, readSoleNmrCommand, renderChain, } from "./steps.js";
-import { UserError } from "./UserError.js";
-import { COMMAND_VERBOSITY_ENV_VAR, readVerbosityEnv, resolveVerbosity, } from "./verbosity.js";
-import { writeVerdict } from "./verdict.js";
-import { readWorkspacePackageNames, resolveWorkspace } from "./workspace.js";
-const VERSION = resolveSelfVersion(import.meta.url);
-const CROSSING_CONSEQUENCE = "so nmr handles the nested run's output as a tool's.";
-const RECURSIVE_REJECTION = '-R/--recursive did not match any workspace:';
-const LIST_CEILING = 10;
-export const RUN_IF_PRESENT_ENV_VAR = 'NMR_RUN_IF_PRESENT';
+import { RUN_IF_PRESENT_ENV_VAR, VERSION, } from "./invocation.js";
+import { formatMisplacedFlagHint, parseArgs } from "./invocation-args.js";
+import { isTerminalStream } from "./output-style.js";
+import { readPresentation, reportVerdict, resolveReportingVerbosity } from "./presentation.js";
+import { DELEGATE_TO_FLAG } from "./remote-run.js";
+import { resolveReportFormat } from "./report-format.js";
+import { buildRootRegistry, buildWorkspaceRegistry, resolveScript } from "./resolver.js";
+import { assembleChain, formatOverrideNotice } from "./run-chain.js";
 export async function runCli(options) {
     const established = await establishInvocation(options);
     if (established.settled) {
         return { exitCode: established.result.exitCode };
     }
     const invocation = established.value;
-    const delegated = await runOnDelegateHost(invocation);
-    if (delegated !== undefined) {
-        return delegated;
+    const resolvedTarget = await resolveExecutionTarget(invocation);
+    if (resolvedTarget.settled) {
+        return { exitCode: resolvedTarget.result.exitCode };
     }
-    const planned = await planRun(invocation);
+    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;
+        }
+        target = { kind: 'local' };
+    }
+    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);
@@ -111,7 +105,7 @@ async function establishInvocation(options) {
         },
     };
 }
-async function planRun(invocation) {
+async function planRun(invocation, target) {
     const { anchorDir, command, context, env, parsedArgs, stderr, stdout, styles } = invocation;
     const quiet = invocation.verbosity === 'quiet';
     const snapshot = openGate({
@@ -174,7 +168,10 @@ async function planRun(invocation) {
         if (env[RUN_IF_PRESENT_ENV_VAR] === '1') {
             return { settled: true, result: { exitCode: 0 } };
         }
-        reportError(`Unknown command: ${command}`, stderr);
+        const delegateToHint = parsedArgs.shouldDelegate && parsedArgs.delegateHosts === undefined
+            ? `. \`${command}\` is not a command; name a host with ${DELEGATE_TO_FLAG} ${command}`
+            : '';
+        reportError(`Unknown command: ${command}${delegateToHint}`, stderr);
         return { settled: true, result: { exitCode: 1, isUnknownCommand: true } };
     }
     const entryRunOptions = parsedArgs.shouldPrintLog
@@ -202,982 +199,22 @@ async function planRun(invocation) {
             runOptions: entryRunOptions,
             shouldBypassCache,
             snapshot,
+            target,
         },
     };
 }
-function assembleChain(options) {
-    const { invocation, registry, resolvedScript, snapshot } = options;
-    const { anchorDir, command, context, env, parsedArgs, stderr, stdout, styles } = invocation;
-    const { isEmptiedByWorkspace, steps: runnableSteps } = readRunnableSteps(resolvedScript, context.workspacePackageDirs);
-    const resolvedCommand = renderChain(runnableSteps);
-    const noOpReason = findNoOpReason(resolvedCommand, isEmptiedByWorkspace);
-    if (noOpReason !== undefined && !parsedArgs.shouldPrintLog) {
-        reportVerdict({ command, scope: invocation.scope, outcome: 'no-op', reason: noOpReason }, stdout, invocation.format, styles.stdout);
-        return { settled: true, result: { exitCode: 0 } };
-    }
-    const substitutedSteps = applyDevBinToSteps(runnableSteps, context.config.devBin, context.monorepoRoot);
-    const substitutedCommand = renderChain(substitutedSteps);
-    const bindResult = bindPassthrough(substitutedSteps, parsedArgs.passthrough, command);
-    if (!bindResult.ok) {
-        reportError(bindResult.error, stderr);
-        return { settled: true, result: { exitCode: 1 } };
-    }
-    const mainSteps = bindResult.steps;
-    const isHookInvocation = isHookName(command);
-    const fullSteps = isHookInvocation
-        ? mainSteps
-        : wrapWithHooks(command, mainSteps, registry, anchorDir, parsedArgs.isWorkspaceRoot);
-    const fullCommand = renderChain(fullSteps);
-    reportNmrCrossing({
-        config: context.config,
-        isReading: parsedArgs.shouldPrintLog,
-        isWorkspaceRoot: parsedArgs.isWorkspaceRoot,
-        monorepoRoot: context.monorepoRoot,
-        registry,
-        resolvedScript,
-        shouldUseRoot: invocation.shouldUseRoot,
-        stderr,
-        style: styles.stderr,
-    });
-    const key = resolveCacheKey({
-        anchorDir,
-        command,
-        commandString: fullCommand,
-        env,
-        monorepoRoot: context.monorepoRoot,
-        snapshot,
-        stderr,
-        substitution: substitutedCommand === resolvedCommand ? undefined : substitutedCommand,
-    });
-    return { settled: false, value: { commandString: fullCommand, key, ownSteps: mainSteps, steps: fullSteps } };
-}
 async function executePlan(plan) {
     const { command, format, parsedArgs, scope, stdout, styles } = plan.invocation;
     if (parsedArgs.shouldPrintLog) {
         return reportRecording(plan);
     }
-    const { exitCode, outcome } = await runGated(plan);
-    reportVerdict({ command, scope, ...outcome }, stdout, format, styles.stdout);
-    return { exitCode };
-}
-async function runOnDelegateHost(invocation) {
-    const { command, context, cwd, env, format, parsedArgs, scope, stderr, stdout, styles } = invocation;
-    if (parsedArgs.passthrough.some(isDelegationFlag)) {
-        stderr.write(`${formatMisplacedDelegationWarning(command, styles.stderr)}
-`);
-    }
-    const target = resolveDelegationTarget({
-        command,
-        env,
-        flagHost: parsedArgs.delegateHost,
-        isOptedOut: parsedArgs.shouldRunLocally,
-        isReading: parsedArgs.shouldPrintLog,
-    });
-    if (target.kind === 'local') {
-        return undefined;
-    }
-    if (target.kind === 'refused') {
-        reportError(target.error, stderr);
-        return { exitCode: 1 };
-    }
-    const { host } = target;
-    const startedAtMs = Date.now();
-    const snapshot = createSnapshot(cwd, env);
-    if (!snapshot.ok && snapshot.isUnsupported) {
-        if (target.source === 'flag') {
-            reportError(`Cannot delegate to ${host}: ${snapshot.reason}`, stderr);
-            return { exitCode: 1 };
-        }
-        stderr.write(`nmr: running ${command} here rather than on ${host}: ${snapshot.reason}\n`);
-        return undefined;
-    }
-    const result = snapshot.ok
-        ? await runRemotely({
-            cwd,
-            env,
-            host,
-            monorepoRoot: context.monorepoRoot,
-            nmrArgs: composeForwardedArgs(command, parsedArgs),
-            remoteEnv: {
-                [COMMAND_VERBOSITY_ENV_VAR]: invocation.verbosity,
-                [OUTPUT_STYLE_ENV_VAR]: styles.stdout,
-                [REPORT_FORMAT_ENV_VAR]: format,
-            },
-            snapshot,
-            stderr,
-            stdout,
-        })
-        : { ok: false, message: 'could not snapshot the working tree', output: snapshot.reason };
-    const durationMs = Date.now() - startedAtMs;
-    if (!result.ok) {
-        if (result.output.trim() !== '') {
-            stderr.write(result.output.endsWith('\n') ? result.output : `${result.output}\n`);
-        }
-        const verdict = {
-            command,
-            detail: result.message,
-            durationMs,
-            exitCode: DELEGATION_FAILURE_EXIT_CODE,
-            host,
-            outcome: 'failed',
-            scope,
-        };
-        reportVerdict(verdict, stdout, format, styles.stdout);
-        return { exitCode: DELEGATION_FAILURE_EXIT_CODE };
-    }
-    const outcome = result.exitCode === 0
-        ? { outcome: 'passed', durationMs }
-        : { outcome: 'failed', durationMs, exitCode: result.exitCode };
-    reportVerdict({ command, host, scope, ...outcome }, stdout, format, styles.stdout);
-    return { exitCode: result.exitCode };
-}
-const FILTER_FLAGS = new Set(['-F', '--filter']);
-const BOOLEAN_FLAGS = new Map([
-    ['-?', 'shouldShowHelp'],
-    ['--help', 'shouldShowHelp'],
-    ['--json', 'shouldEmitJson'],
-    ['--log', 'shouldPrintLog'],
-    ['--no-cache', 'shouldBypassCache'],
-    [NO_DELEGATE_FLAG, 'shouldRunLocally'],
-    ['--no-lock', 'shouldBypassLock'],
-    ['-q', 'quiet'],
-    ['--quiet', 'quiet'],
-    ['-R', 'recursive'],
-    ['--recursive', 'recursive'],
-    ['-V', 'shouldShowVersion'],
-    ['--version', 'shouldShowVersion'],
-    ['-w', 'isWorkspaceRoot'],
-    ['--workspace-root', 'isWorkspaceRoot'],
-]);
-function buildChildEnv(options) {
-    const { env, format, passthrough, runId, shouldBypassCache, shouldBypassLock, snapshot, styles, verbosity } = options;
-    const bypassesCache = shouldBypassCache || passthrough.length > 0;
-    const { [DELEGATE_ENV_VAR]: _delegateHost, ...inheritedEnv } = env;
-    return {
-        ...inheritedEnv,
-        ...(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;
-}
-function bindPassthrough(steps, passthrough, command) {
-    if (passthrough.length === 0) {
-        return { ok: true, steps };
-    }
-    if (!steps.some(acceptsArguments)) {
-        return { ok: false, error: formatUnroutableArgumentsError(command) };
-    }
-    const boundSteps = steps.map((step) => {
-        if (!acceptsArguments(step)) {
-            return step;
-        }
-        return step.kind === 'structural'
-            ? { ...step, argv: [...step.argv, ...passthrough] }
-            : { kind: 'opaque', command: `${step.command} ${passthrough.map(quoteForShell).join(' ')}` };
-    });
-    return { ok: true, steps: boundSteps };
-}
-function formatUnroutableArgumentsError(command) {
-    return (`\`${command}\` does not take trailing arguments: every step of its chain declines them. ` +
-        'Running it unnarrowed is not what the arguments asked for, so nothing ran.');
-}
-function composeDelegation(options) {
-    const { childEnv, command, parsedArgs } = options;
-    let scope;
-    let shouldRunIfPresent = parsedArgs.shouldPrintLog;
-    if (parsedArgs.filter) {
-        scope = ['--filter', parsedArgs.filter];
-    }
-    else if (parsedArgs.recursive) {
-        scope = ['--recursive'];
-        shouldRunIfPresent = true;
-    }
-    if (scope === undefined) {
-        return undefined;
-    }
-    const flags = parsedArgs.shouldPrintLog ? ['--log'] : [];
-    return {
-        env: shouldRunIfPresent ? { ...childEnv, [RUN_IF_PRESENT_ENV_VAR]: '1' } : childEnv,
-        step: {
-            kind: 'structural',
-            argv: ['pnpm', ...scope, 'exec', 'nmr', ...flags, command, ...parsedArgs.passthrough],
-        },
-    };
-}
-function composeForwardedArgs(command, parsedArgs) {
-    return [
-        ...(parsedArgs.filter === undefined ? [] : ['--filter', parsedArgs.filter]),
-        ...(parsedArgs.recursive ? ['--recursive'] : []),
-        ...(parsedArgs.isWorkspaceRoot ? ['--workspace-root'] : []),
-        ...(parsedArgs.quiet ? ['--quiet'] : []),
-        ...(parsedArgs.shouldEmitJson ? ['--json'] : []),
-        ...(parsedArgs.shouldBypassCache ? ['--no-cache'] : []),
-        ...(parsedArgs.shouldBypassLock ? ['--no-lock'] : []),
-        command,
-        ...parsedArgs.passthrough,
-    ];
-}
-async function composeRetention(options) {
-    const { anchorDir, command, key, retainedOutput, runId } = options;
-    if (retainedOutput !== undefined) {
-        const excerpt = deriveExcerpt(retainedOutput.stdout.toString('utf8')) ?? deriveExcerpt(retainedOutput.stderr.toString('utf8'));
-        if (excerpt === undefined) {
-            return undefined;
-        }
-        return { key, replay: [{ command, excerpt, scope: path.basename(anchorDir) }], runId };
-    }
-    const replay = await assembleReplay({
-        anchorDir,
-        monorepoRoot: options.monorepoRoot,
-        runId,
-        steps: options.steps,
-        treeHash: options.treeHash,
-    });
-    return replay.length === 0 ? undefined : { key, replay, runId };
-}
-function describeCrossingRemedy(options) {
-    const { crossingStep, isWorkspaceRoot, monorepoRoot, origin, registry } = options;
-    const configSite = path.relative(monorepoRoot, resolveConfigPath(monorepoRoot));
-    switch (origin.tier) {
-        case 'default':
-            return {
-                remedy: 'A built-in default reaching nmr through a shell is an nmr defect: please report it.',
-                subject: `nmr built-in \`${origin.key}\``,
-            };
-        case 'config':
-            return {
-                remedy: `Write the nmr steps as a step list, and move any others to ${describeStepDestination(origin.key)}.`,
-                subject: `${configSite}: \`${origin.field}.${origin.key}\``,
-            };
-        case 'package':
-            return {
-                remedy: formatInlineRemedy({ crossingStep, file: origin.file, isWorkspaceRoot, key: origin.key, registry }) ??
-                    formatPackageRemedy({ configSite, crossingStep, isWorkspaceRoot, key: origin.key, registry }),
-                subject: `${path.relative(monorepoRoot, origin.file)}: \`scripts.${origin.key}\``,
-            };
-        default: {
-            const unhandledOrigin = origin;
-            throw new Error(`Unhandled script origin: ${JSON.stringify(unhandledOrigin)}`);
-        }
-    }
-}
-function describeStepDestination(key) {
-    if (isHookName(key)) {
-        return 'a script of their own that the step list names, because a hook does not have a `:pre` or `:post` of its own';
-    }
-    return `a \`${key}:pre\` or \`${key}:post\` script`;
-}
-function describeOrigin(origin, config, shouldUseRoot) {
-    if (origin.tier === 'package') {
-        return origin;
-    }
-    const field = shouldUseRoot ? 'rootScripts' : 'workspaceScripts';
-    const configScripts = config[field];
-    return configScripts !== undefined && Object.hasOwn(configScripts, origin.key)
-        ? { tier: 'config', field, key: origin.key }
-        : { tier: 'default', key: origin.key };
-}
-function formatInlineRemedy(options) {
-    const { crossingStep, file, isWorkspaceRoot, key, registry } = options;
-    const name = readSoleNmrCommand(crossingStep);
-    if (name === undefined || name === key) {
-        return undefined;
-    }
-    const scripts = readPackageJsonScripts(path.dirname(file));
-    const value = scripts !== undefined && Object.hasOwn(scripts, name) ? scripts[name]?.trim() : undefined;
-    if (value === undefined || ['', ':'].includes(value)) {
-        return undefined;
-    }
-    if (findNmrCrossing([{ kind: 'opaque', command: value }]) !== undefined) {
-        return undefined;
-    }
-    const anchorDir = path.dirname(file);
-    if (!isHookName(name) &&
-        [`${name}:pre`, `${name}:post`].some((hook) => hasRunnableHook(hook, registry, anchorDir, isWorkspaceRoot))) {
-        return undefined;
-    }
-    const inlinedValue = escapeControlCharacters(value);
-    return Object.hasOwn(registry, name)
-        ? `Replace the value with \`${inlinedValue}\`, and keep \`${name}\`, which overrides nmr's own.`
-        : `Replace the value with \`${inlinedValue}\` and delete \`${name}\`, the script that it names.`;
-}
-function formatNmrCrossingWarning(options) {
-    const { remedy, subject } = describeCrossingRemedy(options);
-    return (`${STATUS_GLYPHS[options.style].warning.text} ${subject} reaches nmr through a shell ` +
-        `(\`${escapeControlCharacters(options.crossingStep)}\`), ${CROSSING_CONSEQUENCE} ${remedy}`);
-}
-function formatOverrideNotice(resolvedScript, registry, command, anchorDir, quiet, style) {
-    const registryEntry = Object.hasOwn(registry, command) ? registry[command] : undefined;
-    if (quiet || resolvedScript.origin.tier !== 'package' || registryEntry === undefined) {
-        return undefined;
-    }
-    const notice = `${path.basename(anchorDir)}: Using override script: ${renderChain(resolvedScript.steps)}`;
-    return `${formatGlyphLine(NMR_GLYPHS, style, 'package', notice)}\n`;
-}
-function formatSelfReferenceRemedy(options) {
-    const { command, isWorkspaceRoot, monorepoRoot, registry, script } = options;
-    if (isHookName(command)) {
-        return `Delete the re-invocation: \`${command}\` runs the steps beside it.`;
-    }
-    const configSite = path.relative(monorepoRoot, resolveConfigPath(monorepoRoot));
-    return formatPackageRemedy({ configSite, crossingStep: script, isWorkspaceRoot, key: command, registry });
-}
-function formatPackageRemedy(options) {
-    const { configSite, crossingStep, isWorkspaceRoot, key, registry } = options;
-    const registryEntry = Object.hasOwn(registry, key) ? registry[key] : undefined;
-    if (registryEntry === undefined) {
-        return (`A \`package.json\` script cannot contain a step list: define \`${key}\` in \`${configSite}\` and move the ` +
-            `package-specific steps to ${describeStepDestination(key)}.`);
-    }
-    const registryChain = renderChain(expandScript(registryEntry, isWorkspaceRoot));
-    if (registryChain === crossingStep) {
-        return `Delete the entry: nmr's own \`${key}\` already runs \`${escapeControlCharacters(registryChain)}\`.`;
-    }
-    return `Delete the entry and move the steps that it adds to ${describeStepDestination(key)}.`;
-}
-function findArgError(parsedArgs) {
-    if (parsedArgs.shouldPrintLog &&
-        parsedArgs.command === undefined &&
-        !parsedArgs.shouldShowHelp &&
-        !parsedArgs.shouldShowVersion) {
-        return '--log requires a command name: `nmr --log <command>`';
-    }
-    return undefined;
-}
-function findEmptySelectionRefusal(options) {
-    const { context, parsedArgs, selection } = options;
-    const isPackageless = context.workspacePackageDirs.length === 0;
-    if (parsedArgs.filter !== undefined) {
-        if (selection !== 'empty') {
-            return undefined;
-        }
-        if (isPackageless) {
-            return `${formatFilterRejection(parsedArgs.filter)} ${describeEmptyWorkspace(context.monorepoRoot)}`;
-        }
-        return formatEmptyFilterError(parsedArgs.filter, readWorkspacePackageNames(context.workspacePackageDirs));
-    }
-    return isPackageless ? `${RECURSIVE_REJECTION} ${describeEmptyWorkspace(context.monorepoRoot)}` : undefined;
-}
-function formatEmptyFilterError(pattern, names) {
-    const rejection = formatFilterRejection(pattern);
-    if (pattern.startsWith('!')) {
-        return `${rejection} A pattern beginning with \`!\` excludes what it matches, and this one excludes every package.`;
-    }
-    if (pattern.includes('[')) {
-        return `${rejection} A pattern containing \`[<ref>]\` selects the packages changed since a git ref, and none has changed.`;
-    }
-    if (pattern.startsWith('.') || pattern.startsWith('/') || pattern.startsWith('{')) {
-        return (`${rejection} ` +
-            'A pattern written `./dir`, `/dir`, or `{dir}` selects the packages under a directory, ' +
-            'and this directory does not contain any package.');
-    }
-    return (`${rejection} A pattern matches a package's manifest \`name\`, ` +
-        `not its directory name.${suggestWorkspaceNames(pattern, names)}`);
-}
-function describeEmptyWorkspace(monorepoRoot) {
-    const resolution = resolveWorkspace(monorepoRoot);
-    if (resolution.kind !== 'empty') {
-        return `pnpm-workspace.yaml at ${monorepoRoot} resolves differently now than it did when the run started.`;
-    }
-    const { cause, patterns } = resolution;
-    const declaredClause = describeDeclaredPatterns(patterns);
-    switch (cause) {
-        case 'all-excluded':
-            return (`pnpm-workspace.yaml ${declaredClause}, whose \`!\` entries exclude every directory matched by the positive ` +
-                'patterns. Drop or narrow the exclusion.');
-        case 'no-package':
-            return (`pnpm-workspace.yaml ${declaredClause}, and the matcher did not find any directory containing a \`package.json\`. ` +
-                'nmr counts a directory as a package only when it contains `package.json`; unlike pnpm, it recognizes ' +
-                'neither `package.yaml` nor `package.json5`. Add a `package.json` to the directory that should be a ' +
-                'package, or declare a pattern reaching a directory that contains one.');
-        case 'no-packages-list':
-            return (`pnpm-workspace.yaml at ${monorepoRoot} does not declare a \`packages\` list, so the workspace contains the root ` +
-                'package alone. Declare a positive pattern such as `packages/*` to reach the packages beneath it.');
-        case 'no-pattern':
-            return (`pnpm-workspace.yaml ${declaredClause}, so the matcher does not receive any pattern. Declare a positive ` +
-                'pattern such as `packages/*`, and quote any `!` entry, which YAML reads as a tag rather than a string ' +
-                'when it is unquoted.');
-        case 'unreadable-packages':
-            return (`pnpm-workspace.yaml at ${monorepoRoot} declares a \`packages\` value that is not a list of strings, so ` +
-                'nothing it declares reaches the matcher. Make it a list whose every entry is a quoted pattern; a bare ' +
-                'value and an entry YAML read as a number or a map are the usual ones.');
-        case 'unreadable-manifest':
-            return (`pnpm-workspace.yaml at ${monorepoRoot} is not valid YAML, so the matcher does not receive anything that it declares. ` +
-                'Repair the syntax error and run the command again. An unterminated quoted string and a mis-indented ' +
-                'entry are the usual ones.');
-        default: {
-            const unhandledCause = cause;
-            throw new Error(`Unhandled empty-workspace cause: ${String(unhandledCause)}`);
-        }
-    }
-}
-function describeDeclaredPatterns(patterns) {
-    const quotablePatterns = patterns.filter((pattern) => pattern.trim() !== '');
-    const emptiedCount = patterns.length - quotablePatterns.length;
-    if (emptiedCount === 0) {
-        return `declares ${renderQuotedList(patterns)}`;
-    }
-    const emptiedClause = `${emptiedCount} ${emptiedCount === 1 ? 'entry' : 'entries'} that YAML left empty`;
-    return quotablePatterns.length === 0
-        ? `declares ${emptiedClause}`
-        : `declares ${renderQuotedList(quotablePatterns)}, beside ${emptiedClause}`;
-}
-function formatFilterRejection(pattern) {
-    return `-F/--filter did not match any workspace: \`${pattern}\`.`;
-}
-function suggestWorkspaceNames(pattern, names) {
-    if (names.length === 0) {
-        return '';
-    }
-    const containingNames = names.filter((name) => name.toLowerCase().includes(pattern.toLowerCase()));
-    if (containingNames.length > 0) {
-        return ` Did you mean ${renderQuotedList(containingNames)}?`;
-    }
-    const closestName = findClosestName(pattern, names);
-    if (closestName !== undefined) {
-        return ` Did you mean \`${closestName}\`?`;
-    }
-    return ` The workspace declares ${renderQuotedList(names)}.`;
-}
-function renderQuotedList(items) {
-    const shownItems = items
-        .slice(0, LIST_CEILING)
-        .map((item) => `\`${item}\``)
-        .join(', ');
-    const remainder = items.length - LIST_CEILING;
-    return remainder > 0 ? `${shownItems}, and ${remainder} more` : shownItems;
-}
-function findNoOpReason(resolvedCommand, isEmptiedByWorkspace) {
-    if (isEmptiedByWorkspace) {
-        return 'empty-workspace';
-    }
-    if (resolvedCommand === '') {
-        return 'empty-override';
-    }
-    if (resolvedCommand === ':') {
-        return 'noop-override';
-    }
-    return undefined;
-}
-function assertNoSelfReference(options) {
-    const { anchorDir, command, isReading, isWorkspaceRoot, monorepoRoot, registry } = options;
-    if (isReading) {
-        return;
-    }
-    const script = findChainedSelfReference(anchorDir, command);
-    if (script === undefined) {
-        return;
-    }
-    const remedy = formatSelfReferenceRemedy({ command, isWorkspaceRoot, monorepoRoot, registry, script });
-    const site = path.relative(monorepoRoot, resolvePackageJsonPath(anchorDir));
-    throw new UserError(`${site}: \`scripts.${command}\` re-invokes \`nmr ${command}\` (\`${escapeControlCharacters(script)}\`), ` +
-        `so nmr cannot run the steps that it chains. ${remedy}`);
-}
-function hasRunnableHook(hookName, registry, anchorDir, isWorkspaceRoot) {
-    if (findChainedSelfReference(anchorDir, hookName) !== undefined) {
-        return true;
-    }
-    const resolvedScript = resolveScript(hookName, registry, anchorDir, isWorkspaceRoot);
-    if (!resolvedScript)
-        return false;
-    const chain = renderChain(resolvedScript.steps);
-    return chain !== '' && chain !== ':';
-}
-async function lookUpRecordedPass(options) {
-    const { anchorDir, buildOutput, command, env, key, monorepoRoot, stderr } = options;
-    const entry = await readCheckCacheEntry({ anchorDir, command, monorepoRoot });
-    if (entry === undefined) {
-        writeDebugNote(`running ${command}: no pass recorded for this scope`, env, stderr);
-        return undefined;
-    }
-    if (entry.key !== key) {
-        writeDebugNote(`running ${command}: the tree or its inputs changed since the last pass`, env, stderr);
-        return undefined;
-    }
-    const [missingPackage] = buildOutput.missingPackages;
-    if (missingPackage !== undefined) {
-        writeDebugNote(`running ${command}: ${missingPackage} does not have build output`, env, stderr);
-        return undefined;
-    }
-    const stalePackage = findStaleBuildOutput(entry.buildDigests, buildOutput.digests);
-    if (stalePackage !== undefined) {
-        writeDebugNote(`running ${command}: ${stalePackage}'s build output came from a different tree`, env, stderr);
-        return undefined;
-    }
-    return {
-        ageMs: Math.max(0, Date.now() - Date.parse(entry.recordedAt)),
-        entry,
-        savedMs: entry.durationMs,
-        ...(entry.retention?.key === options.retentionKey && { replay: entry.retention.replay }),
-    };
-}
-function openGate(options) {
-    const { command, config, env, monorepoRoot, passthrough, stderr, style } = options;
-    if (!isCacheableCommand(config.checkCache, command)) {
-        return undefined;
-    }
-    if (passthrough.includes('--no-cache')) {
-        stderr.write(`${formatMisplacedNoCacheWarning(command, style)}\n`);
-    }
-    if (passthrough.length > 0) {
-        writeDebugNote(`gate disabled: ${command} was passed arguments`, env, stderr);
-        return undefined;
-    }
-    const snapshot = resolveTreeSnapshot({ monorepoRoot, env });
-    if (!snapshot.ok) {
-        writeDebugNote(`gate disabled: ${snapshot.reason}`, env, stderr);
-        return undefined;
-    }
-    return snapshot.snapshot;
-}
-function parseArgs(args) {
-    const parsedArgs = {
-        isWorkspaceRoot: false,
-        quiet: false,
-        recursive: false,
-        shouldBypassCache: false,
-        shouldBypassLock: false,
-        shouldEmitJson: false,
-        shouldPrintLog: false,
-        shouldRunLocally: false,
-        shouldShowHelp: false,
-        shouldShowVersion: false,
-        passthrough: [],
-    };
-    let index = 0;
-    while (index < args.length) {
-        const arg = args[index];
-        if (arg === undefined)
-            break;
-        if (FILTER_FLAGS.has(arg)) {
-            index++;
-            const filterValue = args[index];
-            if (!filterValue) {
-                return { ok: false, error: '-F/--filter requires a pattern argument' };
-            }
-            parsedArgs.filter = filterValue;
-            index++;
-            continue;
-        }
-        const booleanFlag = BOOLEAN_FLAGS.get(arg);
-        if (booleanFlag !== undefined) {
-            parsedArgs[booleanFlag] = true;
-            index++;
-            continue;
-        }
-        const styleArgument = readOutputStyleArgument(args, index);
-        if (styleArgument !== undefined) {
-            if (!styleArgument.ok) {
-                return styleArgument;
-            }
-            parsedArgs.outputStyle = styleArgument.value;
-            index += styleArgument.consumedCount;
-            continue;
-        }
-        const delegateArgument = readDelegateArgument(args, index);
-        if (delegateArgument !== undefined) {
-            if (!delegateArgument.ok) {
-                return delegateArgument;
-            }
-            parsedArgs.delegateHost = delegateArgument.value;
-            index += delegateArgument.consumedCount;
-            continue;
-        }
-        parsedArgs.command = arg;
-        parsedArgs.passthrough = args.slice(index + 1);
-        break;
-    }
-    const error = findArgError(parsedArgs);
-    return error === undefined ? { ok: true, parsedArgs } : { ok: false, error };
-}
-async function reportRecording(plan) {
-    const { anchorDir, command, context, env, scope, stderr, stdout, styles } = plan.invocation;
-    const { config, monorepoRoot } = context;
-    const lookup = await resolveRecording({
-        anchorDir,
-        command,
-        currentIdentity: {
-            commandString: plan.commandString,
-            nmrVersion: VERSION,
-            nodeVersion: CURRENT_RUNTIME.nodeVersion,
-            treeHash: plan.snapshot?.hash,
-        },
-        isCacheable: isCacheableCommand(config.checkCache, command),
-        key: plan.key,
-        monorepoRoot,
-    });
-    if (!lookup.ok) {
-        stderr.write(`${renderRefusal({ command, refusal: lookup.refusal, scope, style: styles.stderr })}\n`);
-        return { exitCode: env[RUN_IF_PRESENT_ENV_VAR] === '1' ? 0 : 1 };
-    }
-    stdout.write(renderRecording({ command, recording: lookup.recording, scope, style: styles.stdout }));
-    return { exitCode: 0 };
-}
-function readPresentation(options) {
-    const { env } = options;
-    const verbosity = readVerbosityEnv(env);
-    if (!verbosity.ok) {
-        return verbosity;
-    }
-    const format = readReportFormatEnv(env);
-    if (!format.ok) {
-        return format;
-    }
-    const { invalid: invalidStyle, styles } = resolveOutputStyles(options);
-    if (invalidStyle !== undefined) {
-        return { ok: false, error: describeInvalidOutputStyle(invalidStyle) };
-    }
-    return { ok: true, format: format.format, styles, verbosity: verbosity.verbosity };
-}
-function readDelegateArgument(args, index) {
-    return readFlagValue(args, index, DELEGATE_FLAG, 'a host argument');
-}
-function readFlagValue(args, index, flag, requirement) {
-    const arg = args[index] ?? '';
-    const assignment = arg.startsWith(`${flag}=`) ? arg.slice(flag.length + 1) : undefined;
-    if (arg !== flag && assignment === undefined) {
-        return undefined;
-    }
-    const value = assignment ?? args[index + 1];
-    if (!value) {
-        return { ok: false, error: `${flag} requires ${requirement}` };
-    }
-    return { ok: true, value, consumedCount: assignment === undefined ? 2 : 1 };
-}
-function readOutputStyleArgument(args, index) {
-    return readFlagValue(args, index, OUTPUT_STYLE_FLAG, 'a value argument: auto, plain, or rich');
-}
-function readRunnableSteps(resolvedScript, workspacePackageDirs) {
-    if (workspacePackageDirs.length > 0) {
-        return { isEmptiedByWorkspace: false, steps: resolvedScript.steps };
-    }
-    const steps = dropRecursiveSteps(resolvedScript.steps);
-    return { isEmptiedByWorkspace: steps.length === 0 && resolvedScript.steps.length > 0, steps };
-}
-function reportNmrCrossing(options) {
-    const crossingStep = findNmrCrossing(options.resolvedScript.steps);
-    if (options.isReading || crossingStep === undefined) {
-        return;
-    }
-    const warning = formatNmrCrossingWarning({
-        crossingStep,
-        isWorkspaceRoot: options.isWorkspaceRoot,
-        monorepoRoot: options.monorepoRoot,
-        origin: describeOrigin(options.resolvedScript.origin, options.config, options.shouldUseRoot),
-        registry: options.registry,
-        style: options.style,
-    });
-    options.stderr.write(`${warning}\n`);
-}
-function reportVerdict(verdict, stdout, format, style) {
-    if (isHookName(verdict.command)) {
-        return;
-    }
-    writeVerdict(verdict, stdout, format, style);
-}
-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: {} });
-    if (!currentRead.ok) {
-        writeDebugNote(`not recording ${command}: ${currentRead.reason}`, env, stderr);
-        return;
-    }
-    if (currentRead.snapshot.hash !== snapshot.hash) {
-        writeDebugNote(`not recording ${command}: the tree changed while it ran`, env, stderr);
-        return;
-    }
-    const output = await readBuildOutputState(monorepoRoot, options.config);
-    const [missingPackage] = output.missingPackages;
-    if (missingPackage !== undefined) {
-        writeDebugNote(`not recording ${command}: ${missingPackage} does not have build output`, env, stderr);
-        return;
-    }
-    const changedPackage = findStaleBuildOutput(options.buildOutputBefore.digests, output.digests);
-    if (changedPackage !== undefined) {
-        writeDebugNote(`not recording ${command}: ${changedPackage}'s build output changed while it ran`, env, stderr);
-        return;
-    }
-    const retention = await composeRetention({
-        anchorDir,
-        command,
-        key: options.retentionKey,
-        monorepoRoot,
-        retainedOutput: options.retainedOutput,
-        runId: options.runId,
-        steps: options.ownSteps,
-        treeHash: snapshot.hash,
-    });
-    const ref = { anchorDir, command, monorepoRoot };
-    const transcript = options.retainedOutput === undefined ? undefined : composeTranscript(options.retainedOutput);
-    try {
-        await recordTranscript(ref, transcript);
-        await writeCheckCacheEntry({
-            ...ref,
-            entry: {
-                key: options.key,
-                treeHash: snapshot.hash,
-                headSha: snapshot.headSha,
-                commandString: options.commandString,
-                nmrVersion: VERSION,
-                nodeVersion: CURRENT_RUNTIME.nodeVersion,
-                durationMs: options.durationMs,
-                recordedAt: new Date().toISOString(),
-                buildDigests: output.digests,
-                ...(retention !== undefined && { retention }),
-            },
-        });
-    }
-    catch (error) {
-        try {
-            await recordTranscript(ref, undefined);
-        }
-        catch {
-        }
-        writeDebugNote(`could not record ${command}: ${describeError(error)}`, env, stderr);
-    }
-}
-function resolveCacheKey(options) {
-    const { env, snapshot, stderr, substitution } = options;
-    if (snapshot === undefined) {
-        return undefined;
-    }
-    if (substitution !== undefined) {
-        writeDebugNote(`gate disabled: devBin substituted \`${substitution}\``, env, stderr);
-        return undefined;
-    }
-    const result = computeCacheKey({
-        anchorDir: options.anchorDir,
-        command: options.command,
-        commandString: options.commandString,
-        env,
-        monorepoRoot: options.monorepoRoot,
-        nmrVersion: VERSION,
-        snapshot,
-    });
-    if (!result.ok) {
-        writeDebugNote(`gate disabled: ${result.reason}`, env, stderr);
-        return undefined;
-    }
-    return result.key;
-}
-async function runDelegation(options) {
-    const { context, delegation, parsedArgs, runOptions, stderr } = options;
-    const selection = parsedArgs.filter === undefined ? undefined : readFilterSelection(parsedArgs.filter, context.monorepoRoot);
-    const refusal = findEmptySelectionRefusal({ context, parsedArgs, selection });
-    if (refusal !== undefined) {
-        reportError(refusal, stderr);
-        return { exitCode: 1 };
-    }
-    const shouldWithholdInput = parsedArgs.filter === undefined || selection === 'multiple';
-    const step = shouldWithholdInput ? { ...delegation.step, shouldWithholdInput } : delegation.step;
-    return runSteps([step], context.monorepoRoot, { ...runOptions, env: delegation.env });
-}
-async function runGated(plan) {
-    const { commandString, key } = plan;
-    const { anchorDir, command, context, env, stderr, stdout } = plan.invocation;
-    const { config, monorepoRoot } = context;
-    let gate = await readGate(plan);
-    if (gate !== undefined && !plan.shouldBypassCache) {
-        const recalled = await recallPass(plan, gate);
-        if (recalled !== undefined) {
-            return recalled;
-        }
-    }
-    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 { exitCode, host, outcome } = await runGated(plan);
+    if (outcome !== undefined) {
+        reportVerdict({ command, ...(host !== undefined && { host }), scope, ...outcome }, stdout, format, styles.stdout);
     }
-    finally {
-        await lock?.release();
-    }
-}
-function formatMisplacedFlagHint(args, passthrough, style) {
-    const { flagNames, movedTokens, remainingTokens } = splitMisplacedFlags(passthrough);
-    if (flagNames.length === 0) {
-        return undefined;
-    }
-    const commandIndex = args.length - passthrough.length - 1;
-    const correctedTokens = [
-        'nmr',
-        ...args.slice(0, commandIndex),
-        ...movedTokens,
-        ...args.slice(commandIndex, commandIndex + 1),
-        ...remainingTokens,
-    ];
-    const subject = flagNames.length === 1 ? 'is an nmr flag' : 'are nmr flags';
-    return (`${STATUS_GLYPHS[style].warning.text} ${renderQuotedList(flagNames)} ${subject}; ` +
-        `nmr reads its flags only before the command: \`${correctedTokens.map(quoteToken).join(' ')}\``);
-}
-function isDefinedInAnyScope(command, context) {
-    const registries = [buildRootRegistry(context.config, context.monorepoRoot), buildWorkspaceRegistry(context.config)];
-    if (registries.some((registry) => Object.hasOwn(registry, command))) {
-        return true;
-    }
-    return [context.monorepoRoot, ...context.workspacePackageDirs].some((dir) => Object.hasOwn(readPackageJsonScripts(dir) ?? {}, command));
-}
-function isDelegationFlag(arg) {
-    return arg === DELEGATE_FLAG || arg === NO_DELEGATE_FLAG || arg.startsWith(`${DELEGATE_FLAG}=`);
+    return { exitCode };
 }
 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)) {
-        return (args[index + 1] ?? '') === '' ? undefined : 2;
-    }
-    const booleanFlag = BOOLEAN_FLAGS.get(arg);
-    if (booleanFlag !== undefined) {
-        return booleanFlag === 'shouldShowHelp' || booleanFlag === 'shouldShowVersion' ? undefined : 1;
-    }
-    const valueArgument = readOutputStyleArgument(args, index) ?? readDelegateArgument(args, index);
-    return valueArgument?.ok === true ? valueArgument.consumedCount : undefined;
-}
-function splitMisplacedFlags(passthrough) {
-    const flagNames = new Set();
-    const movedTokens = [];
-    const remainingTokens = [];
-    let index = 0;
-    while (index < passthrough.length) {
-        const arg = passthrough[index] ?? '';
-        if (arg === '--') {
-            remainingTokens.push(...passthrough.slice(index));
-            break;
-        }
-        const flagLength = readMisplacedFlagLength(passthrough, index);
-        if (flagLength === undefined) {
-            remainingTokens.push(arg);
-            index++;
-            continue;
-        }
-        flagNames.add(arg.split('=', 1)[0] ?? arg);
-        movedTokens.push(...passthrough.slice(index, index + flagLength));
-        index += flagLength;
-    }
-    return { flagNames: [...flagNames], movedTokens, remainingTokens };
-}
-function wrapWithHooks(command, mainSteps, registry, anchorDir, isWorkspaceRoot) {
-    const steps = [];
-    if (hasRunnableHook(`${command}:pre`, registry, anchorDir, isWorkspaceRoot)) {
-        steps.push(composeNmrStep(`${command}:pre`, isWorkspaceRoot));
-    }
-    steps.push(...mainSteps);
-    if (hasRunnableHook(`${command}:post`, registry, anchorDir, isWorkspaceRoot)) {
-        steps.push(composeNmrStep(`${command}:post`, isWorkspaceRoot));
-    }
-    return steps;
-}