@williamthorsen/nmr 0.37.0 → 0.39.0

package/dist/esm/commands/fmt.js

@@ -18,21 +18,21 @@ const MODE_ARGS = {
     write: ['--list-different', '--write'],
 };
 export function runFmt(argv, cwd = process.cwd()) {
-    const parsed = parseFmtArgs(argv);
-    if (!parsed.ok) {
-        reportError(`nmr-fmt: ${parsed.error}`);
+    const parsedArgs = parseFmtArgs(argv);
+    if (!parsedArgs.ok) {
+        reportError(`nmr-fmt: ${parsedArgs.error}`);
         process.stderr.write(`${USAGE}\n`);
         return 1;
     }
-    const resolved = resolveFormatTargets(cwd, parsed.pathspecs);
-    if (!resolved.ok) {
-        reportError(`nmr-fmt: ${resolved.error}`);
+    const resolvedTargets = resolveFormatTargets(cwd, parsedArgs.pathspecs);
+    if (!resolvedTargets.ok) {
+        reportError(`nmr-fmt: ${resolvedTargets.error}`);
         return 1;
     }
-    const { files, ignorePaths } = resolved.targets;
+    const { files, ignorePaths } = resolvedTargets.targets;
     if (files.length === 0) {
-        if (parsed.pathspecs.length > 0) {
-            reportError(`nmr-fmt: no formattable files matched: ${parsed.pathspecs.join(', ')}`);
+        if (parsedArgs.pathspecs.length > 0) {
+            reportError(`nmr-fmt: no formattable files matched: ${parsedArgs.pathspecs.join(', ')}`);
             return 1;
         }
         return 0;
@@ -42,29 +42,29 @@ export function runFmt(argv, cwd = process.cwd()) {
         reportError(`nmr-fmt: ${cli.error}`);
         return 1;
     }
-    return runPrettier({ cliPath: cli.cliPath, mode: parsed.mode, files, ignorePaths, cwd });
+    return runPrettier({ cliPath: cli.cliPath, mode: parsedArgs.mode, files, ignorePaths, cwd });
 }
 export function resolveFormatTargets(cwd, pathspecs = []) {
     const toplevel = runGit(['rev-parse', '--show-toplevel'], cwd);
     if (!toplevel.ok)
         return toplevel;
     const repositoryRoot = toplevel.stdout.trim();
-    const listed = runGit([...LIST_FILES_ARGS, '--', ...pathspecs], cwd);
-    if (!listed.ok)
-        return listed;
+    const listedFiles = runGit([...LIST_FILES_ARGS, '--', ...pathspecs], cwd);
+    if (!listedFiles.ok)
+        return listedFiles;
     const ignoreFiles = runGit([...LIST_FILES_ARGS, '--', IGNORE_FILE_PATHSPEC], repositoryRoot);
     if (!ignoreFiles.ok)
         return ignoreFiles;
-    const discovered = splitNulSeparated(ignoreFiles.stdout)
+    const discoveredIgnorePaths = splitNulSeparated(ignoreFiles.stdout)
         .filter((file) => path.basename(file) === IGNORE_FILENAME)
         .map((file) => path.resolve(repositoryRoot, file));
     return {
         ok: true,
         targets: {
-            files: dedupe(splitNulSeparated(listed.stdout))
+            files: dedupe(splitNulSeparated(listedFiles.stdout))
                 .filter((file) => isFormattableFile(cwd, file))
                 .toSorted(),
-            ignorePaths: dedupe([path.join(repositoryRoot, IGNORE_FILENAME), ...discovered]),
+            ignorePaths: dedupe([path.join(repositoryRoot, IGNORE_FILENAME), ...discoveredIgnorePaths]),
         },
     };
 }
@@ -76,11 +76,11 @@ function parseFmtArgs(argv) {
     const pathspecs = [];
     for (const arg of argv) {
         if (arg === '--check' || arg === '--write') {
-            const requested = arg === '--check' ? 'check' : 'write';
-            if (mode !== undefined && mode !== requested) {
+            const requestedMode = arg === '--check' ? 'check' : 'write';
+            if (mode !== undefined && mode !== requestedMode) {
                 return { ok: false, error: 'Pass --check or --write, not both.' };
             }
-            mode = requested;
+            mode = requestedMode;
             continue;
         }
         if (arg.startsWith('-')) {
@@ -94,7 +94,7 @@ function parseFmtArgs(argv) {
     return { ok: true, mode, pathspecs };
 }
 function resolvePrettierCli() {
-    const missing = {
+    const missingResult = {
         ok: false,
         error: `\`${PRETTIER_PACKAGE}\` (${PRETTIER_RANGE}) could not be resolved. Install it in this repository.`,
     };
@@ -103,14 +103,14 @@ function resolvePrettierCli() {
         manifestPath = createRequire(import.meta.url).resolve(`${PRETTIER_PACKAGE}/package.json`);
     }
     catch {
-        return missing;
+        return missingResult;
     }
     const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
     if (!isObject(manifest))
-        return missing;
+        return missingResult;
     const bin = isObject(manifest['bin']) ? manifest['bin'][PRETTIER_PACKAGE] : manifest['bin'];
     if (typeof bin !== 'string')
-        return missing;
+        return missingResult;
     return { ok: true, cliPath: path.resolve(path.dirname(manifestPath), bin) };
 }
 export function runPrettier(options) {
@@ -121,7 +121,7 @@ export function runPrettier(options) {
         ...ignorePaths.flatMap((ignorePath) => ['--ignore-path', ignorePath]),
         ...MODE_ARGS[mode],
     ];
-    let firstFailure = 0;
+    let firstFailureStatus = 0;
     for (const batch of batchWithinBudget(files, budgetBytes)) {
         const result = spawnSync(process.execPath, [...prettierArgs, ...batch], { cwd, stdio: 'inherit' });
         if (result.error) {
@@ -129,25 +129,25 @@ export function runPrettier(options) {
             return 1;
         }
         const status = result.status ?? 1;
-        if (status !== 0 && firstFailure === 0) {
-            firstFailure = status;
+        if (status !== 0 && firstFailureStatus === 0) {
+            firstFailureStatus = status;
         }
     }
-    return firstFailure;
+    return firstFailureStatus;
 }
-function batchWithinBudget(files, budget) {
+function batchWithinBudget(files, budgetBytes) {
     const batches = [];
     let batch = [];
-    let size = 0;
+    let sizeBytes = 0;
     for (const file of files) {
-        const cost = Buffer.byteLength(file) + 1;
-        if (batch.length > 0 && size + cost > budget) {
+        const costBytes = Buffer.byteLength(file) + 1;
+        if (batch.length > 0 && sizeBytes + costBytes > budgetBytes) {
             batches.push(batch);
             batch = [];
-            size = 0;
+            sizeBytes = 0;
         }
         batch.push(file);
-        size += cost;
+        sizeBytes += costBytes;
     }
     if (batch.length > 0)
         batches.push(batch);

package/dist/esm/commands/report-catalog.d.ts

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
  * Reports the catalogued dependencies a package-scoped upgrade pass cannot see.
  *
@@ -8,4 +9,4 @@
  *
  * Runs ahead of the report produced by the workspace `upgrade` script.
  */
-export declare function reportCatalog(cwd: string): void;
+export declare function reportCatalog(cwd: string, style: OutputStyle): void;

package/dist/esm/commands/report-catalog.js

@@ -1,10 +1,11 @@
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
 import { findContainingPackageDir } from "../context.js";
+import { NMR_GLYPHS } from "../glyphs.js";
 import { DEPENDENCY_FIELDS, readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
-const CATALOG_ICON = '📚';
 const CATALOG_PROTOCOL = 'catalog:';
-export function reportCatalog(cwd) {
+export function reportCatalog(cwd, style) {
     const monorepoRoot = findMonorepoRoot(cwd);
     const packageDir = findContainingPackageDir(cwd, getWorkspacePackageDirs(monorepoRoot));
     if (packageDir === undefined) {
@@ -14,11 +15,11 @@ export function reportCatalog(cwd) {
     if (dependencies.length === 0) {
         return;
     }
-    console.warn(`${CATALOG_ICON} WARN: A package-scoped upgrade does not read the catalogs these come from:`);
+    console.warn(formatGlyphLine(NMR_GLYPHS, style, 'catalog', 'WARN: A package-scoped upgrade does not read the catalogs these come from:'));
     for (const { name, specifier } of dependencies) {
         console.warn(`- ${name} → ${specifier}`);
     }
-    reportClosing(`${CATALOG_ICON} ${describeCatalog(dependencies.length, monorepoRoot)}`, console.warn);
+    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'catalog', describeCatalog(dependencies.length, monorepoRoot)), console.warn);
 }
 function describeCatalog(count, monorepoRoot) {
     const subject = count === 1 ? '1 catalogued dependency went' : `${count} catalogued dependencies went`;
@@ -26,15 +27,17 @@ function describeCatalog(count, monorepoRoot) {
     return `${subject} unread. Run \`nmr upgrade\` from ${monorepoRoot} to include ${object}.`;
 }
 function findCataloguedDependencies(packageDir) {
-    const pkg = readPackageJson(packageDir);
-    const found = new Map();
+    const packageJson = readPackageJson(packageDir);
+    const foundDependencies = new Map();
     for (const field of DEPENDENCY_FIELDS) {
-        const declared = Object.entries(pkg[field] ?? {});
-        for (const [name, specifier] of declared) {
-            if (specifier.startsWith(CATALOG_PROTOCOL) && !found.has(name)) {
-                found.set(name, specifier);
+        const declaredEntries = Object.entries(packageJson[field] ?? {});
+        for (const [name, specifier] of declaredEntries) {
+            if (specifier.startsWith(CATALOG_PROTOCOL) && !foundDependencies.has(name)) {
+                foundDependencies.set(name, specifier);
             }
         }
     }
-    return [...found].map(([name, specifier]) => ({ name, specifier })).toSorted((a, b) => a.name.localeCompare(b.name));
+    return [...foundDependencies]
+        .map(([name, specifier]) => ({ name, specifier }))
+        .toSorted((a, b) => a.name.localeCompare(b.name));
 }

package/dist/esm/commands/report-overrides.d.ts

@@ -1,7 +1,8 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
  * Reports the pnpm dependency overrides declared in the monorepo root's `pnpm-workspace.yaml`, and rejects a
  * `pnpm.overrides` block left behind in the root `package.json`.
  *
  * Runs ahead of the report produced by the root `upgrade` script.
  */
-export declare function reportOverrides(monorepoRoot: string): void;
+export declare function reportOverrides(monorepoRoot: string, style: OutputStyle): void;

package/dist/esm/commands/report-overrides.js

@@ -1,16 +1,17 @@
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
+import { NMR_GLYPHS } from "../glyphs.js";
 import { getPnpmOverrides, readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { UserError } from "../UserError.js";
 import { readWorkspaceOverrides } from "../workspace.js";
-const OVERRIDES_ICON = '🔒';
-export function reportOverrides(monorepoRoot) {
-    const declared = listEntries(readWorkspaceOverrides(monorepoRoot));
-    if (declared.length > 0) {
-        console.warn(`${OVERRIDES_ICON} WARN: pnpm overrides are active:`);
-        for (const [name, version] of declared) {
+export function reportOverrides(monorepoRoot, style) {
+    const declaredOverrides = listEntries(readWorkspaceOverrides(monorepoRoot));
+    if (declaredOverrides.length > 0) {
+        console.warn(formatGlyphLine(NMR_GLYPHS, style, 'overrides', 'WARN: pnpm overrides are active:'));
+        for (const [name, version] of declaredOverrides) {
             console.warn(`- ${name} → ${version}`);
         }
-        reportClosing(`${OVERRIDES_ICON} ${describeOverrides(declared.length)}`, console.warn);
+        reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'overrides', describeOverrides(declaredOverrides.length)), console.warn);
     }
     rejectLegacyOverrides(monorepoRoot);
 }
@@ -23,13 +24,13 @@ function listEntries(overrides) {
     return Object.entries(overrides ?? {}).toSorted(([a], [b]) => a.localeCompare(b));
 }
 function rejectLegacyOverrides(monorepoRoot) {
-    const legacy = listEntries(getPnpmOverrides(readPackageJson(monorepoRoot)));
-    if (legacy.length === 0) {
+    const legacyOverrides = listEntries(getPnpmOverrides(readPackageJson(monorepoRoot)));
+    if (legacyOverrides.length === 0) {
         return;
     }
     throw new UserError([
         'pnpm 11 reads no `pnpm.overrides` from package.json, so these pin nothing while an upgrade run with `--write` goes on rewriting them:',
-        ...legacy.map(([name, version]) => `- ${name} → ${String(version)}`),
+        ...legacyOverrides.map(([name, version]) => `- ${name} → ${String(version)}`),
         'Move them to the `overrides` block in pnpm-workspace.yaml, quoting each version, or run `pnpx codemod run pnpm-v10-to-v11`.',
     ].join('\n'));
 }

package/dist/esm/config.js

@@ -33,7 +33,8 @@ const RECOGNIZED_KEYS = [...CONFIG_TIERS.root.honoredKeys, ...CONFIG_TIERS.works
 const RECOGNIZED_BUILD_KEYS = ['extraIgnorePatterns'];
 const RECOGNIZED_CHECK_CACHE_KEYS = ['enabled', 'excludeCommands', 'extraCommands'];
 const RECOGNIZED_OUTPUT_KEYS = ['commandVerbosity', 'extraAgentEnvVars'];
-const RECOGNIZED_STEP_KEYS = ['declinesArgs', 'run'];
+const RECOGNIZED_STEP_KEYS = ['run', 'shouldDeclineArguments'];
+const RETIRED_STEP_KEYS = new Map([['declinesArgs', 'shouldDeclineArguments']]);
 function isScriptRecord(value) {
     if (!isObject(value))
         return false;
@@ -50,8 +51,8 @@ function isScriptElement(value) {
         return true;
     if (!isObject(value) || typeof value['run'] !== 'string')
         return false;
-    const declinesArgs = value['declinesArgs'];
-    return declinesArgs === undefined || typeof declinesArgs === 'boolean';
+    const shouldDeclineArguments = value['shouldDeclineArguments'];
+    return shouldDeclineArguments === undefined || typeof shouldDeclineArguments === 'boolean';
 }
 function validateScriptField(value, fieldName, configPath) {
     if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
@@ -60,7 +61,7 @@ function validateScriptField(value, fieldName, configPath) {
     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, declinesArgs?: boolean }`');
+            'where an element is a command string or `{ run: string, shouldDeclineArguments?: boolean }`');
     }
     assertValidElements(scripts, fieldName, configPath);
     return scripts;
@@ -71,6 +72,7 @@ function assertValidElements(scripts, fieldName, configPath) {
             continue;
         for (const spec of script) {
             if (typeof spec !== 'string') {
+                assertNoRetiredKeys(spec, RETIRED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
                 assertRecognizedKeys(spec, RECOGNIZED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
             }
             const element = typeof spec === 'string' ? spec : spec.run;
@@ -111,12 +113,12 @@ function validateCheckCacheField(value, configPath) {
     }
     assertRecognizedKeys(checkCache, RECOGNIZED_CHECK_CACHE_KEYS, configPath, 'checkCache.');
     const config = {};
-    const enabled = checkCache['enabled'];
-    if (enabled !== undefined) {
-        if (typeof enabled !== 'boolean') {
+    const enabledValue = checkCache['enabled'];
+    if (enabledValue !== undefined) {
+        if (typeof enabledValue !== 'boolean') {
             throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.enabled\` must be a boolean`);
         }
-        config.enabled = enabled;
+        config.enabled = enabledValue;
     }
     for (const field of ['excludeCommands', 'extraCommands']) {
         const commands = checkCache[field];
@@ -142,22 +144,22 @@ function assertResolvableCheckCacheCommands(config, configPath, baseDir) {
         throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${hook.field}\` names the hook \`${hook.command}\`, ` +
             'which is never gated on its own: it runs as part of the chain of the command it wraps.');
     }
-    const registered = new Set([
+    const registeredNames = new Set([
         ...Object.keys(buildRootRegistry(config)),
         ...Object.keys(buildWorkspaceRegistry(config)),
     ]);
-    const missing = entries.filter(({ command }) => !registered.has(command));
-    if (missing.length === 0) {
+    const missingEntries = entries.filter(({ command }) => !registeredNames.has(command));
+    if (missingEntries.length === 0) {
         return;
     }
-    const declared = readDeclaredScriptNames(baseDir);
-    const unresolvable = missing.find(({ command }) => !declared.has(command));
-    if (unresolvable === undefined) {
+    const declaredNames = readDeclaredScriptNames(baseDir);
+    const unresolvableEntry = missingEntries.find(({ command }) => !declaredNames.has(command));
+    if (unresolvableEntry === undefined) {
         return;
     }
-    const closest = findClosestName(unresolvable.command, [...registered, ...declared]);
-    throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${unresolvable.field}\` names no command: ` +
-        `\`${unresolvable.command}\`.${closest === undefined ? '' : ` Did you mean \`${closest}\`?`}`);
+    const closestName = findClosestName(unresolvableEntry.command, [...registeredNames, ...declaredNames]);
+    throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${unresolvableEntry.field}\` names no command: ` +
+        `\`${unresolvableEntry.command}\`.${closestName === undefined ? '' : ` Did you mean \`${closestName}\`?`}`);
 }
 function readDeclaredScriptNames(monorepoRoot) {
     let packageDirs;
@@ -201,8 +203,8 @@ function validateOutputField(value, configPath) {
     const commandVerbosity = output['commandVerbosity'];
     if (commandVerbosity !== undefined) {
         if (typeof commandVerbosity !== 'string' || !isCommandVerbosity(commandVerbosity)) {
-            const rendered = typeof commandVerbosity === 'string' ? commandVerbosity : JSON.stringify(commandVerbosity);
-            throw new UserError(`Invalid nmr config at ${configPath}: ${formatVerbosityRejection('`output.commandVerbosity`', rendered)}`);
+            const renderedValue = typeof commandVerbosity === 'string' ? commandVerbosity : JSON.stringify(commandVerbosity);
+            throw new UserError(`Invalid nmr config at ${configPath}: ${formatVerbosityRejection('`output.commandVerbosity`', renderedValue)}`);
         }
         config.commandVerbosity = commandVerbosity;
     }
@@ -256,9 +258,9 @@ export async function loadConfig(baseDir) {
     if (!existsSync(configPath)) {
         return {};
     }
-    const imported = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
-    const loaded = isObject(imported) ? imported['default'] : undefined;
-    return validateConfig(loaded, configPath, baseDir);
+    const importedModule = await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href));
+    const loadedConfig = isObject(importedModule) ? importedModule['default'] : undefined;
+    return validateConfig(loadedConfig, configPath, baseDir);
 }
 export async function loadRootConfig(monorepoRoot) {
     const config = await loadConfig(monorepoRoot);
@@ -270,21 +272,29 @@ export async function loadWorkspaceConfig(packageDir) {
     assertTierKeys(config, CONFIG_TIERS.workspace, resolveConfigPath(packageDir));
     return config;
 }
+function assertNoRetiredKeys(value, retiredKeys, configPath, prefix) {
+    for (const key of Object.keys(value)) {
+        const replacement = retiredKeys.get(key);
+        if (replacement === undefined)
+            continue;
+        throw new UserError(`Invalid nmr config at ${configPath}: \`${prefix}${key}\` was renamed to \`${prefix}${replacement}\`.`);
+    }
+}
 function assertRecognizedKeys(value, recognizedKeys, configPath, prefix = '') {
-    const unrecognized = Object.keys(value).filter((key) => !recognizedKeys.includes(key));
-    if (unrecognized.length === 0) {
+    const unrecognizedKeys = Object.keys(value).filter((key) => !recognizedKeys.includes(key));
+    if (unrecognizedKeys.length === 0) {
         return;
     }
-    throw new UserError(`Invalid nmr config at ${configPath}: unrecognized ${unrecognized.length === 1 ? 'key' : 'keys'} ` +
-        `${formatKeyList(unrecognized, prefix)}. Recognized: ${formatKeyList(recognizedKeys, prefix)}.`);
+    throw new UserError(`Invalid nmr config at ${configPath}: unrecognized ${unrecognizedKeys.length === 1 ? 'key' : 'keys'} ` +
+        `${formatKeyList(unrecognizedKeys, prefix)}. Recognized: ${formatKeyList(recognizedKeys, prefix)}.`);
 }
 function assertTierKeys(config, tier, configPath) {
-    const unsupported = Object.keys(config).filter((key) => !tier.honoredKeys.includes(key));
-    if (unsupported.length === 0) {
+    const unsupportedKeys = Object.keys(config).filter((key) => !tier.honoredKeys.includes(key));
+    if (unsupportedKeys.length === 0) {
         return;
     }
     throw new UserError(`Invalid nmr config at ${configPath}: ${tier.label} honors ${tier.honoredKeys.toSorted().join(', ')} alone, ` +
-        `not ${unsupported.toSorted().join(', ')}. Move those keys to ${tier.elsewhere}.`);
+        `not ${unsupportedKeys.toSorted().join(', ')}. Move those keys to ${tier.elsewhere}.`);
 }
 function formatKeyList(keys, prefix) {
     return keys

package/dist/esm/context.js

@@ -2,17 +2,17 @@ import path from 'node:path';
 import { loadRootConfig } from "./config.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "./workspace.js";
 export function findContainingPackageDir(dir, workspacePackageDirs) {
-    const resolved = path.resolve(dir);
-    let nearest;
-    for (const pkgDir of workspacePackageDirs) {
-        const resolvedPkgDir = path.resolve(pkgDir);
-        if (resolved !== resolvedPkgDir && !resolved.startsWith(resolvedPkgDir + path.sep))
+    const resolvedDir = path.resolve(dir);
+    let nearestDir;
+    for (const packageDir of workspacePackageDirs) {
+        const resolvedPackageDir = path.resolve(packageDir);
+        if (resolvedDir !== resolvedPackageDir && !resolvedDir.startsWith(resolvedPackageDir + path.sep))
             continue;
-        if (nearest === undefined || resolvedPkgDir.length > nearest.length) {
-            nearest = resolvedPkgDir;
+        if (nearestDir === undefined || resolvedPackageDir.length > nearestDir.length) {
+            nearestDir = resolvedPackageDir;
         }
     }
-    return nearest;
+    return nearestDir;
 }
 export async function resolveContext(cwd) {
     const resolvedCwd = path.resolve(cwd ?? process.cwd());

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

@@ -1,6 +1,6 @@
 /**
  * One element of a composite, paired with what it does with the invocation's trailing arguments. The bare
- * string form of an element is this spec with `declinesArgs` left at its default.
+ * string form of an element is this spec with `shouldDeclineArguments` left at its default.
  */
 export interface StepSpec {
     /** A command name, optionally preceded by nmr's own flags, as it would be typed after `nmr`. */
@@ -9,7 +9,7 @@ export interface StepSpec {
      * Set where the trailing arguments cannot narrow this step's work: it is a prerequisite the narrowed steps
      * run against, or the tool it reaches would be misled by them. A declining step runs unnarrowed.
      */
-    declinesArgs?: boolean;
+    shouldDeclineArguments?: boolean;
 }
 export type ScriptValue = string | ReadonlyArray<string | StepSpec>;
 export type ScriptRegistry = Record<string, ScriptValue>;

package/dist/esm/default-scripts.js

@@ -1,6 +1,6 @@
 const GATE_PROJECTS = '--project unit --project tool';
-const TYPECHECK_STEP = { run: 'typecheck', declinesArgs: true };
-const ROOT_TYPECHECK_STEP = { run: 'root:typecheck', declinesArgs: true };
+const TYPECHECK_STEP = { run: 'typecheck', shouldDeclineArguments: true };
+const ROOT_TYPECHECK_STEP = { run: 'root:typecheck', shouldDeclineArguments: true };
 export const workspaceScripts = {
     build: ['compile'],
     check: [TYPECHECK_STEP, 'fmt:check', 'lint:check', 'test'],
@@ -32,7 +32,7 @@ export const rootScripts = {
     build: ['-R build'],
     check: [TYPECHECK_STEP, 'fmt:check', 'lint:check', 'test'],
     'check:strict': [TYPECHECK_STEP, 'fmt:check', 'lint:strict', 'test'],
-    ci: [{ run: 'build', declinesArgs: true }, 'check:strict'],
+    ci: [{ run: 'build', shouldDeclineArguments: true }, 'check:strict'],
     clean: 'nmr-clean',
     fix: ['lint', 'fmt'],
     'fix:check': ['fmt:check', 'lint:check'],
@@ -41,7 +41,7 @@ export const rootScripts = {
     lint: 'eslint --fix .',
     'lint:check': 'eslint .',
     'lint:strict': 'strict-lint',
-    prepush: [{ run: 'audit', declinesArgs: true }, 'ci'],
+    prepush: [{ run: 'audit', shouldDeclineArguments: true }, 'ci'],
     'report-overrides': 'nmr-report-overrides',
     'root:check': [ROOT_TYPECHECK_STEP, 'fmt:check', 'root:lint:check', 'root:test'],
     'root:lint': "eslint --fix --ignore-pattern 'packages/**' .",
@@ -59,6 +59,6 @@ export const rootScripts = {
     'test:tool': ['root:test:tool', '-R test:tool'],
     'test:unit': ['root:test:unit', '-R test:unit'],
     'test:watch': `vitest ${GATE_PROJECTS} --watch`,
-    typecheck: [ROOT_TYPECHECK_STEP, { run: '-R typecheck', declinesArgs: true }],
+    typecheck: [ROOT_TYPECHECK_STEP, { run: '-R typecheck', shouldDeclineArguments: true }],
     upgrade: 'nmr-report-overrides && nmr-taze --recursive',
 };

package/dist/esm/glyphs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Glyphs that name no status; a status marker comes from nmr-core's `STATUS_GLYPHS`. A plain variant is empty
+ * where a word always follows the glyph, and a word where the glyph opens a line of its own.
+ *
+ * `noop` is a neutral circle: nothing ran because the repo asked for nothing to run, which is neither a
+ * failure nor a block.
+ */
+export declare const NMR_GLYPHS: Readonly<Record<"plain" | "rich", Readonly<Record<"overrides" | "clean" | "package" | "catalog" | "noop" | "recording", import("@williamthorsen/toolbelt.terminal/candidate").Glyph>>>>;
+export type NmrGlyphName = keyof (typeof NMR_GLYPHS)['rich'];

package/dist/esm/glyphs.js

@@ -0,0 +1,9 @@
+import { defineGlyphSet } from '@williamthorsen/nmr-core';
+export const NMR_GLYPHS = defineGlyphSet({
+    catalog: { plain: '', rich: '\u{1F4DA}' },
+    clean: { plain: '', rich: '\u{1F9F9}' },
+    noop: { plain: 'NOOP', rich: '\u{26AA}' },
+    overrides: { plain: '', rich: '\u{1F512}' },
+    package: { plain: '', rich: '\u{1F4E6}' },
+    recording: { plain: '', rich: '\u{1F4BE}' },
+});

package/dist/esm/help.d.ts

@@ -8,8 +8,8 @@ import type { NmrConfig } from './types.js';
  * `package.json:scripts` that match a registry name in the active section
  * are inlined as overrides: the registry value is replaced with the
  * override value and the row's command name is suffixed with `*`. The
- * active section is the root section when `useRoot` is true (root cwd
+ * active section is the root section when `shouldUseRoot` is true (root cwd
  * or `-w`), otherwise the workspace section. A footnote is appended once
  * if any override marker was rendered.
  */
-export declare function generateHelp(config: NmrConfig, packageDir: string | undefined, useRoot: boolean): string;
+export declare function generateHelp(config: NmrConfig, packageDir: string | undefined, shouldUseRoot: boolean): string;