@williamthorsen/nmr 0.55.0 → 1.0.0

package/dist/esm/helpers/package-json.js

@@ -1,11 +1,10 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
-import { UserError } from '@williamthorsen/nmr-core';
+import { isRecord, UserError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { isMonorepoRoot } from "../workspace.js";
 import { CONFIG_RELATIVE_PATH } from "./config-path.js";
 import { readStringValues } from "./readStringValues.js";
-import { isObject } from "./type-guards.js";
 export const DEPENDENCY_FIELDS = [
     'dependencies',
     'devDependencies',
@@ -15,7 +14,7 @@ export const DEPENDENCY_FIELDS = [
 export function readPackageJson(dir) {
     const file = resolvePackageJsonPath(dir);
     const parsedManifest = parsePackageJson(readFileSync(file, 'utf8'), file);
-    if (!isObject(parsedManifest)) {
+    if (!isRecord(parsedManifest)) {
         throw new UserError(`Invalid package.json in ${dir}: expected an object`);
     }
     const packageJson = {};
@@ -28,28 +27,28 @@ export function readPackageJson(dir) {
     if (typeof parsedManifest['packageManager'] === 'string') {
         packageJson.packageManager = parsedManifest['packageManager'];
     }
-    if (isObject(parsedManifest['scripts'])) {
+    if (isRecord(parsedManifest['scripts'])) {
         packageJson.scripts = readScriptRecord(dir, parsedManifest['scripts']);
     }
-    if (isObject(parsedManifest['pnpm'])) {
+    if (isRecord(parsedManifest['pnpm'])) {
         const pnpm = parsedManifest['pnpm'];
-        if (isObject(pnpm['overrides'])) {
+        if (isRecord(pnpm['overrides'])) {
             packageJson.pnpm = { overrides: pnpm['overrides'] };
         }
     }
     for (const field of DEPENDENCY_FIELDS) {
         const declaredDependencies = parsedManifest[field];
-        if (isObject(declaredDependencies)) {
+        if (isRecord(declaredDependencies)) {
             packageJson[field] = readStringValues(declaredDependencies);
         }
     }
     return packageJson;
 }
 export function getPnpmOverrides(packageJson) {
-    if (!isObject(packageJson.pnpm))
+    if (!isRecord(packageJson.pnpm))
         return undefined;
     const overrides = packageJson.pnpm.overrides;
-    return isObject(overrides) ? overrides : undefined;
+    return isRecord(overrides) ? overrides : undefined;
 }
 export function parsePackageJson(rawText, file) {
     try {

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

@@ -0,0 +1,5 @@
+/**
+ * Returns an XDG base directory, resolved from `env` alone: the variable's value when that is an absolute path, as the
+ * XDG base-directory spec requires, otherwise `homeSubdir` under `HOME`. Returns `undefined` when `env` names neither.
+ */
+export declare function resolveXdgBaseDir(env: NodeJS.ProcessEnv, variable: 'XDG_CACHE_HOME' | 'XDG_CONFIG_HOME', homeSubdir: string): string | undefined;

package/dist/esm/helpers/resolveXdgBaseDir.js

@@ -0,0 +1,12 @@
+import path from 'node:path';
+export function resolveXdgBaseDir(env, variable, homeSubdir) {
+    const baseDir = env[variable];
+    if (baseDir !== undefined && path.isAbsolute(baseDir)) {
+        return baseDir;
+    }
+    const home = env['HOME'];
+    if (home !== undefined && path.isAbsolute(home)) {
+        return path.join(home, homeSubdir);
+    }
+    return undefined;
+}

package/dist/esm/helpers/type-guards.d.ts

@@ -1,4 +1,2 @@
-/** Narrows an unknown value to a plain object, excluding `null` and arrays. */
-export declare function isObject(value: unknown): value is Record<string, unknown>;
 /** Narrows an unknown value to a record of plain strings. */
 export declare function isStringRecord(value: unknown): value is Record<string, string>;

package/dist/esm/helpers/type-guards.js

@@ -1,6 +1,4 @@
-export function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from '@williamthorsen/nmr-core';
 export function isStringRecord(value) {
-    return isObject(value) && Object.values(value).every((entry) => typeof entry === 'string');
+    return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'string');
 }

package/dist/esm/invocation-args.d.ts

@@ -6,35 +6,3 @@ import { type OutputStyle } from '@williamthorsen/nmr-core';
 export declare function formatMisplacedFlagHint(args: readonly string[], passthrough: readonly string[], style: OutputStyle): string | undefined;
 /** Reports whether an argument is one of nmr's delegation flags, in any spelling. */
 export declare function isDelegationFlag(arg: string): boolean;
-/** Parses the CLI arguments into nmr's flags, the command name, and the arguments passed through to it. */
-export declare function parseArgs(args: string[]): ParseResult;
-/** @internal */
-export interface ParsedArgs {
-    /** The comma-separated hosts that `--delegate-to` names, as written. */
-    delegateHosts?: string;
-    filter?: string;
-    isWorkspaceRoot: boolean;
-    /** The flag's value as it was written, which the style resolver rather than the parser narrows. */
-    outputStyle?: string;
-    quiet: boolean;
-    recursive: boolean;
-    shouldBypassCache: boolean;
-    shouldBypassLock: boolean;
-    /** Set by `--delegate`, which leaves the hosts to `NMR_DELEGATE` or the user config. */
-    shouldDelegate: boolean;
-    shouldEmitJson: boolean;
-    shouldPrintLog: boolean;
-    shouldRunLocally: boolean;
-    shouldShowHelp: boolean;
-    shouldShowVersion: boolean;
-    command?: string;
-    passthrough: string[];
-}
-type ParseResult = {
-    ok: true;
-    parsedArgs: ParsedArgs;
-} | {
-    ok: false;
-    error: string;
-};
-export {};

package/dist/esm/invocation-args.js

@@ -1,27 +1,8 @@
 import { STATUS_GLYPHS } from '@williamthorsen/nmr-core';
 import { renderQuotedList } from "./helpers/renderQuotedList.js";
-import { OUTPUT_STYLE_FLAG } from "./output-style.js";
-import { DELEGATE_FLAG, DELEGATE_TO_FLAG, NO_DELEGATE_FLAG } from "./remote-run.js";
+import { formatFlagSpelling, formatShortSpelling, NMR_FLAGS } from "./nmr-flags.js";
 import { quoteToken } from "./shell-syntax.js";
-const FILTER_FLAGS = new Set(['-F', '--filter']);
-const BOOLEAN_FLAGS = new Map([
-    ['-?', 'shouldShowHelp'],
-    [DELEGATE_FLAG, 'shouldDelegate'],
-    ['--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'],
-]);
+const DELEGATION_FLAG_KEYS = ['delegate', 'delegateTo', 'noDelegate'];
 export function formatMisplacedFlagHint(args, passthrough, style) {
     const { flagNames, movedTokens, remainingTokens } = splitMisplacedFlags(passthrough);
     if (flagNames.length === 0) {
@@ -40,118 +21,39 @@ export function formatMisplacedFlagHint(args, passthrough, style) {
         `nmr reads its flags only before the command: \`${correctedTokens.map(quoteToken).join(' ')}\``);
 }
 export function isDelegationFlag(arg) {
-    return (arg === DELEGATE_FLAG ||
-        arg === DELEGATE_TO_FLAG ||
-        arg === NO_DELEGATE_FLAG ||
-        arg.startsWith(`${DELEGATE_FLAG}=`) ||
-        arg.startsWith(`${DELEGATE_TO_FLAG}=`));
+    return DELEGATION_FLAG_KEYS.some((key) => {
+        const spelling = formatFlagSpelling(key);
+        return arg === spelling || arg.startsWith(`${spelling}=`);
+    });
 }
-export function parseArgs(args) {
-    const parsedArgs = {
-        isWorkspaceRoot: false,
-        quiet: false,
-        recursive: false,
-        shouldBypassCache: false,
-        shouldBypassLock: false,
-        shouldDelegate: 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;
-        }
-        if (arg.startsWith(`${DELEGATE_FLAG}=`)) {
-            const value = arg.slice(DELEGATE_FLAG.length + 1);
-            return {
-                ok: false,
-                error: `${DELEGATE_FLAG} does not take a value; name hosts with ${DELEGATE_TO_FLAG} ${value}`,
-            };
-        }
-        const styleArgument = readOutputStyleArgument(args, index);
-        if (styleArgument !== undefined) {
-            if (!styleArgument.ok) {
-                return styleArgument;
-            }
-            parsedArgs.outputStyle = styleArgument.value;
-            index += styleArgument.consumedCount;
+function findFlagKey(arg) {
+    const name = arg.split('=', 1)[0] ?? arg;
+    for (const key of Object.keys(NMR_FLAGS)) {
+        if (!isNmrFlagKey(key))
             continue;
+        if (name === formatFlagSpelling(key) || arg === formatShortSpelling(key)) {
+            return key;
         }
-        const delegateArgument = readDelegateArgument(args, index);
-        if (delegateArgument !== undefined) {
-            if (!delegateArgument.ok) {
-                return delegateArgument;
-            }
-            parsedArgs.delegateHosts = 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 };
-}
-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 readDelegateArgument(args, index) {
-    return readFlagValue(args, index, DELEGATE_TO_FLAG, 'a host argument');
+function isNmrFlagKey(key) {
+    return Object.hasOwn(NMR_FLAGS, key);
 }
-function readFlagValue(args, index, flag, requirement) {
+function readMisplacedFlagLength(args, index) {
     const arg = args[index] ?? '';
-    const assignment = arg.startsWith(`${flag}=`) ? arg.slice(flag.length + 1) : undefined;
-    if (arg !== flag && assignment === undefined) {
+    const key = findFlagKey(arg);
+    if (key === undefined) {
         return undefined;
     }
-    const value = assignment ?? args[index + 1];
-    if (!value) {
-        return { ok: false, error: `${flag} requires ${requirement}` };
+    const isAssignment = arg.includes('=');
+    if (NMR_FLAGS[key].type === 'boolean') {
+        return isAssignment ? undefined : 1;
     }
-    return { ok: true, value, consumedCount: assignment === undefined ? 2 : 1 };
-}
-function readMisplacedFlagLength(args, index) {
-    const arg = args[index] ?? '';
-    if (FILTER_FLAGS.has(arg)) {
-        return (args[index + 1] ?? '') === '' ? undefined : 2;
+    if (isAssignment) {
+        return arg.slice(arg.indexOf('=') + 1) === '' ? undefined : 1;
     }
-    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 readOutputStyleArgument(args, index) {
-    return readFlagValue(args, index, OUTPUT_STYLE_FLAG, 'a value argument: auto, plain, or rich');
+    return (args[index + 1] ?? '') === '' ? undefined : 2;
 }
 function splitMisplacedFlags(passthrough) {
     const flagNames = new Set();

package/dist/esm/invocation.d.ts

@@ -3,7 +3,7 @@ import { type StreamStyles } from '@williamthorsen/nmr-core';
 import type { TreeSnapshot } from './check-cache.js';
 import type { ResolvedContext } from './context.js';
 import type { DelegationTarget } from './delegation-target.js';
-import type { ParsedArgs } from './invocation-args.js';
+import type { ParsedArgs } from './nmr-flags.js';
 import type { ReportFormat } from './report-format.js';
 import type { RunStepsOptions } from './runner.js';
 import type { Step } from './steps.js';
@@ -64,4 +64,6 @@ export interface RunPlan {
 export type SettledResult = RunCliResult & {
     isUnknownCommand?: boolean;
 };
+/** The exit status of an invocation that nmr refuses as written, which matches the router's for a usage error. */
+export declare const USAGE_EXIT_CODE = 2;
 export declare const VERSION: string;

package/dist/esm/invocation.js

@@ -1,3 +1,4 @@
 import { resolveSelfVersion } from '@williamthorsen/nmr-core';
 export const RUN_IF_PRESENT_ENV_VAR = 'NMR_RUN_IF_PRESENT';
+export const USAGE_EXIT_CODE = 2;
 export const VERSION = resolveSelfVersion(import.meta.url);

package/dist/esm/machine-lock.js

@@ -4,8 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { setTimeout as delay } from 'node:timers/promises';
-import { STATUS_GLYPHS } from '@williamthorsen/nmr-core';
-import { isObject } from "./helpers/type-guards.js";
+import { isRecord, STATUS_GLYPHS } from '@williamthorsen/nmr-core';
 const RECLAIM_GUARD = 'heavy.lock.reclaim';
 const RECLAIM_GUARD_STALE_AFTER_MS = 10_000;
 export const HEARTBEAT_INTERVAL_MS = 10_000;
@@ -133,7 +132,7 @@ function formatWaitingLine(holder, lockPath) {
     return `nmr: waiting for ${holder.command} in ${holder.dir} (pid ${holder.pid}) to finish`;
 }
 function isHolderRecord(value) {
-    return (isObject(value) &&
+    return (isRecord(value) &&
         typeof value['command'] === 'string' &&
         typeof value['dir'] === 'string' &&
         typeof value['pid'] === 'number' &&
@@ -173,7 +172,7 @@ function parseHolder(content) {
     }
 }
 function readErrorCode(error) {
-    return isObject(error) && typeof error['code'] === 'string' ? error['code'] : undefined;
+    return isRecord(error) && typeof error['code'] === 'string' ? error['code'] : undefined;
 }
 async function readLockState(lockPath) {
     try {

package/dist/esm/nmr-flags.d.ts

@@ -0,0 +1,109 @@
+import { type ParsedFlags } from '@williamthorsen/nmr-core/cli';
+/** nmr's own flags, each read only before the command name. */
+export declare const NMR_FLAGS: {
+    delegate: {
+        type: "boolean";
+        description: string;
+    };
+    delegateTo: {
+        type: "string";
+        description: string;
+        valueHint: string;
+    };
+    filter: {
+        type: "string";
+        description: string;
+        short: string;
+        valueHint: string;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+    };
+    log: {
+        type: "boolean";
+        description: string;
+    };
+    noCache: {
+        type: "boolean";
+        description: string;
+    };
+    noDelegate: {
+        type: "boolean";
+        description: string;
+    };
+    noLock: {
+        type: "boolean";
+        description: string;
+    };
+    outputStyle: {
+        type: "string";
+        description: string;
+        valueHint: string;
+    };
+    quiet: {
+        type: "boolean";
+        description: string;
+        short: string;
+    };
+    recursive: {
+        type: "boolean";
+        description: string;
+        short: string;
+    };
+    workspaceRoot: {
+        type: "boolean";
+        description: string;
+        short: string;
+    };
+};
+/** The key of one of nmr's flags. */
+export type NmrFlagKey = keyof typeof NMR_FLAGS;
+/** @internal */
+export interface ParsedArgs {
+    /** The comma-separated hosts that `--delegate-to` names, as written. */
+    delegateHosts?: string;
+    filter?: string;
+    isWorkspaceRoot: boolean;
+    /** The flag's value as it was written, which the style resolver rather than the parser narrows. */
+    outputStyle?: string;
+    quiet: boolean;
+    recursive: boolean;
+    shouldBypassCache: boolean;
+    shouldBypassLock: boolean;
+    /** Set by `--delegate`, which leaves the hosts to `NMR_DELEGATE` or the user config. */
+    shouldDelegate: boolean;
+    shouldEmitJson: boolean;
+    shouldPrintLog: boolean;
+    shouldRunLocally: boolean;
+    shouldShowHelp: boolean;
+    shouldShowVersion: boolean;
+    command?: string;
+    passthrough: string[];
+}
+/** What the arguments ask of nmr, or that its flags do not parse. */
+export type FlagReading = {
+    ok: true;
+    parsedArgs: ParsedArgs;
+} | {
+    ok: false;
+};
+/** Returns the `--long` spelling of one of nmr's flags. */
+export declare function formatFlagSpelling(key: NmrFlagKey): string;
+/** Returns the `-x` spelling of one of nmr's flags, or `undefined` when it does not have one. */
+export declare function formatShortSpelling(key: NmrFlagKey): string | undefined;
+/**
+ * Reads nmr's flags, the command name, and the arguments passed through to it, without reporting anything.
+ *
+ * The help and version flags are read here as well, though the router reserves them, so that a caller can tell
+ * what the invocation asks for before it builds the command tree. Arguments whose flags do not parse report only
+ * that: The router parses the same arguments against the same schema and reports the error itself.
+ */
+export declare function readInvocationFlags(args: readonly string[]): FlagReading;
+/**
+ * Maps nmr's parsed flags, and the arguments from the command name on, to the fields that the rest of nmr reads.
+ * Help is false, since the parser reserves it, and version is false unless the flags include it.
+ */
+export declare function toParsedArgs(flags: ParsedFlags<typeof NMR_FLAGS> & {
+    version?: boolean;
+}, rest: readonly string[]): ParsedArgs;

package/dist/esm/nmr-flags.js

@@ -0,0 +1,120 @@
+import { parseArgs, ParseError } from '@williamthorsen/nmr-core/cli';
+export const NMR_FLAGS = {
+    delegate: {
+        type: 'boolean',
+        description: 'Run over SSH on the first free host that NMR_DELEGATE or the user config names',
+    },
+    delegateTo: {
+        type: 'string',
+        description: 'Run over SSH on the first free of <hosts>, comma-separated',
+        valueHint: 'hosts',
+    },
+    filter: {
+        type: 'string',
+        description: 'Run command in packages whose manifest name matches',
+        short: 'F',
+        valueHint: 'pattern',
+    },
+    json: { type: 'boolean', description: 'Report one JSON object per command, withholding command output' },
+    log: { type: 'boolean', description: 'Print the recorded run instead of running (up to 256 KiB)' },
+    noCache: { type: 'boolean', description: 'Run even if this tree already passed; record the result' },
+    noDelegate: { type: 'boolean', description: 'Run here, whatever NMR_DELEGATE or the user config says' },
+    noLock: { type: 'boolean', description: 'Run without waiting for another heavy command on this machine' },
+    outputStyle: {
+        type: 'string',
+        description: 'Output style: auto (default), plain, or rich',
+        valueHint: 'auto|plain|rich',
+    },
+    quiet: { type: 'boolean', description: "Suppress command output, keeping nmr's verdicts", short: 'q' },
+    recursive: { type: 'boolean', description: 'Run command in all packages', short: 'R' },
+    workspaceRoot: { type: 'boolean', description: 'Use root scripts, running at the monorepo root', short: 'w' },
+};
+export function formatFlagSpelling(key) {
+    return `--${toKebabCase(key)}`;
+}
+export function formatShortSpelling(key) {
+    const definition = NMR_FLAGS[key];
+    return 'short' in definition ? `-${definition.short}` : undefined;
+}
+export function readInvocationFlags(args) {
+    const remaining = [...args];
+    let shouldShowHelp = false;
+    for (;;) {
+        try {
+            const parsed = parseArgs(remaining, { flags: READER_FLAGS }, { stopAtPositional: true });
+            return { ok: true, parsedArgs: { ...toParsedArgs(parsed.flags, parsed.rest), shouldShowHelp } };
+        }
+        catch (error) {
+            if (!(error instanceof ParseError)) {
+                throw error;
+            }
+            if (error.kind !== 'unknown-flag' ||
+                !HELP_SPELLINGS.has(error.token) ||
+                !removeHelpFlag(remaining, error.token)) {
+                return { ok: false };
+            }
+            shouldShowHelp = true;
+        }
+    }
+}
+export function toParsedArgs(flags, rest) {
+    const [first, ...remaining] = rest;
+    const hasCommand = first !== undefined && first !== '--';
+    return {
+        ...(flags.delegateTo !== undefined && { delegateHosts: flags.delegateTo }),
+        ...(flags.filter !== undefined && { filter: flags.filter }),
+        isWorkspaceRoot: flags.workspaceRoot,
+        ...(flags.outputStyle !== undefined && { outputStyle: flags.outputStyle }),
+        quiet: flags.quiet,
+        recursive: flags.recursive,
+        shouldBypassCache: flags.noCache,
+        shouldBypassLock: flags.noLock,
+        shouldDelegate: flags.delegate,
+        shouldEmitJson: flags.json,
+        shouldPrintLog: flags.log,
+        shouldRunLocally: flags.noDelegate,
+        shouldShowHelp: false,
+        shouldShowVersion: flags.version ?? false,
+        ...(hasCommand && { command: first }),
+        passthrough: hasCommand ? remaining : [],
+    };
+}
+const HELP_SPELLINGS = new Set(['--help', '-h']);
+const READER_FLAGS = {
+    ...NMR_FLAGS,
+    version: { type: 'boolean', description: 'Print the version', short: 'V' },
+};
+function isBooleanCluster(arg) {
+    if (!/^-[^-]./.test(arg)) {
+        return false;
+    }
+    const booleanShorts = new Set(['h', 'V']);
+    for (const definition of Object.values(NMR_FLAGS)) {
+        if (definition.type === 'boolean' && 'short' in definition) {
+            booleanShorts.add(definition.short);
+        }
+    }
+    for (const letter of arg.slice(1)) {
+        if (!booleanShorts.has(letter)) {
+            return false;
+        }
+    }
+    return true;
+}
+function removeHelpFlag(args, token) {
+    const index = args.indexOf(token);
+    if (index !== -1) {
+        args.splice(index, 1);
+        return true;
+    }
+    const clusterIndex = args.findIndex((arg) => isBooleanCluster(arg) && arg.includes('h'));
+    const cluster = args[clusterIndex];
+    if (cluster === undefined) {
+        return false;
+    }
+    args[clusterIndex] = cluster.replace('h', '');
+    return true;
+}
+function toKebabCase(key) {
+    return key.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}

package/dist/esm/output-style.d.ts

@@ -19,7 +19,7 @@ export declare const OUTPUT_STYLE_ENV_VAR = "NMR_OUTPUT_STYLE";
  *
  * Only `nmr` accepts it. A standalone bin reads the variable, which `nmr <command>` exports to it.
  */
-export declare const OUTPUT_STYLE_FLAG = "--output-style";
+export declare const OUTPUT_STYLE_FLAG: string;
 /**
  * Resolves the style of each output stream: the flag, then `NMR_OUTPUT_STYLE`, then detection from `CI`, the
  * stream's terminal state, and `TERM`.

package/dist/esm/output-style.js

@@ -1,9 +1,10 @@
 import { resolveStreamStyles } from '@williamthorsen/nmr-core';
+import { formatFlagSpelling } from "./nmr-flags.js";
 export function isTerminalStream(stream) {
     return 'isTTY' in stream && stream.isTTY === true;
 }
 export const OUTPUT_STYLE_ENV_VAR = 'NMR_OUTPUT_STYLE';
-export const OUTPUT_STYLE_FLAG = '--output-style';
+export const OUTPUT_STYLE_FLAG = formatFlagSpelling('outputStyle');
 export function resolveOutputStyles(options) {
     const { env, flagValue, stderrIsTty, stdoutIsTty } = options;
     return resolveStreamStyles({

package/dist/esm/pass-manifest.js

@@ -2,11 +2,11 @@ import { randomUUID } from 'node:crypto';
 import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
+import { isRecord } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { isCacheableCommand, PASS_MANIFEST_DIR_ENV_VAR, writeDebugNote } from "./check-cache.js";
 import { isReplayLine } from "./check-cache-entries.js";
 import { MAX_EXCERPT_BYTES } from "./helpers/deriveExcerpt.js";
-import { isObject } from "./helpers/type-guards.js";
 export function formatManifestScope(monorepoRoot, anchorDir) {
     const scope = path.relative(monorepoRoot, anchorDir);
     return scope === '' ? '.' : scope.split(path.sep).join('/');
@@ -70,7 +70,7 @@ function findRejection(entry, options) {
     return undefined;
 }
 function isPassManifestEntry(value) {
-    return (isObject(value) &&
+    return (isRecord(value) &&
         typeof value['command'] === 'string' &&
         typeof value['commandString'] === 'string' &&
         typeof value['durationMs'] === 'number' &&

package/dist/esm/presentation.d.ts

@@ -8,7 +8,7 @@ import { type Verdict } from './verdict.js';
  * output stream resolves to. Reports the first value that cannot be read.
  *
  * The style is resolved here rather than beside its use, so that a value that does not name a style is rejected
- * at the same point as an unreadable variable, which is ahead of `--version` and of the config load.
+ * at the same point as an unreadable variable, which is before any command runs.
  */
 export declare function readPresentation(options: {
     env: NodeJS.ProcessEnv;

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

@@ -8,6 +8,8 @@ export interface DelegationHolder {
 }
 /** What the host session needs, sent to it as JSON. Every directory is relative to the checkout. */
 export interface HostSessionParams {
+    /** The `maxBuffer` for the session's git calls; the session is sent as source, so it cannot import the constant. */
+    gitOutputLimitBytes: number;
     holder: DelegationHolder;
     lockPath: string;
     /** Begins each record line on stderr; it contains a per-delegation nonce, so that a command cannot forge one. */

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

@@ -160,6 +160,7 @@ export function runHostSession(params) {
             listing = childProcess.execFileSync('git', ['ls-files', '-z', '--', '*package.json'], {
                 cwd: params.rootDir,
                 encoding: 'utf8',
+                maxBuffer: params.gitOutputLimitBytes,
                 stdio: ['ignore', 'pipe', 'ignore'],
             });
         }