@williamthorsen/nmr 0.38.0 → 0.39.0

package/dist/esm/commands/ensure-prepublish-hooks.js

@@ -11,33 +11,33 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     const packageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packages = [];
     for (const packageDir of packageDirs) {
-        const pkg = readPackageJson(packageDir);
-        const packageName = pkg.name ?? path.basename(packageDir);
-        const isPrivate = pkg.private === true;
+        const packageJson = readPackageJson(packageDir);
+        const packageName = packageJson.name ?? path.basename(packageDir);
+        const isPrivate = packageJson.private === true;
         if (isPrivate) {
             packages.push({
                 packageName,
                 packageDir,
                 isPrivate: true,
-                prepublishOnly: pkg.scripts?.['prepublishOnly'],
+                prepublishOnly: packageJson.scripts?.['prepublishOnly'],
                 action: 'ok',
             });
             continue;
         }
-        const existing = pkg.scripts?.['prepublishOnly'];
-        if (existing) {
+        const existingHook = packageJson.scripts?.['prepublishOnly'];
+        if (existingHook) {
             packages.push({
                 packageName,
                 packageDir,
                 isPrivate: false,
-                prepublishOnly: existing,
+                prepublishOnly: existingHook,
                 action: 'ok',
             });
             continue;
         }
-        if (options.fix) {
-            const action = options.dryRun ? 'would-fix' : 'fixed';
-            if (!options.dryRun) {
+        if (options.shouldFix) {
+            const action = options.isDryRun ? 'would-fix' : 'fixed';
+            if (!options.isDryRun) {
                 addPrepublishOnly(packageDir, hookCommand);
             }
             packages.push({
@@ -62,57 +62,57 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     return { packages, hasFailures };
 }
 export function reportPrepublishHooks(result, hookCommand, style) {
-    const publishable = result.packages.filter((pkg) => !pkg.isPrivate);
-    if (publishable.length === 0) {
+    const publishablePackages = result.packages.filter((packageStatus) => !packageStatus.isPrivate);
+    if (publishablePackages.length === 0) {
         console.info('No publishable packages found.');
         return;
     }
-    for (const pkg of publishable) {
-        console.info(renderHookStatus(pkg, hookCommand, style));
+    for (const packageStatus of publishablePackages) {
+        console.info(renderHookStatus(packageStatus, hookCommand, style));
     }
-    reportClosing(describeHookRun(publishable));
+    reportClosing(describeHookRun(publishablePackages));
 }
 function addPrepublishOnly(packageDir, command) {
     const filePath = path.join(packageDir, 'package.json');
-    const raw = readFileSync(filePath, 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!isObject(parsed)) {
+    const rawText = readFileSync(filePath, 'utf8');
+    const parsedManifest = JSON.parse(rawText);
+    if (!isObject(parsedManifest)) {
         throw new TypeError(`Invalid package.json in ${packageDir}: expected an object`);
     }
-    const scripts = isObject(parsed['scripts']) ? parsed['scripts'] : {};
+    const scripts = isObject(parsedManifest['scripts']) ? parsedManifest['scripts'] : {};
     scripts['prepublishOnly'] = command;
-    parsed['scripts'] = scripts;
-    writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
+    parsedManifest['scripts'] = scripts;
+    writeFileSync(filePath, JSON.stringify(parsedManifest, null, 2) + '\n', 'utf8');
 }
-function countAction(publishable, action) {
-    return publishable.filter((pkg) => pkg.action === action).length;
+function countAction(publishablePackages, action) {
+    return publishablePackages.filter((packageStatus) => packageStatus.action === action).length;
 }
-function describeHookRun(publishable) {
-    const packages = publishable.length === 1 ? '1 publishable package' : `${publishable.length} publishable packages`;
-    const missing = countAction(publishable, 'missing');
-    if (missing > 0) {
-        return `${missing} of ${packages} ${missing === 1 ? 'is' : 'are'} missing prepublishOnly. Run with --fix to add it.`;
+function describeHookRun(publishablePackages) {
+    const packages = publishablePackages.length === 1 ? '1 publishable package' : `${publishablePackages.length} publishable packages`;
+    const missingCount = countAction(publishablePackages, 'missing');
+    if (missingCount > 0) {
+        return `${missingCount} of ${packages} ${missingCount === 1 ? 'is' : 'are'} missing prepublishOnly. Run with --fix to add it.`;
     }
-    const fixed = countAction(publishable, 'fixed');
-    if (fixed > 0) {
-        return `Added prepublishOnly to ${fixed} of ${packages}.`;
+    const fixedCount = countAction(publishablePackages, 'fixed');
+    if (fixedCount > 0) {
+        return `Added prepublishOnly to ${fixedCount} of ${packages}.`;
     }
-    const wouldFix = countAction(publishable, 'would-fix');
-    if (wouldFix > 0) {
-        return `Would add prepublishOnly to ${wouldFix} of ${packages}.`;
+    const wouldFixCount = countAction(publishablePackages, 'would-fix');
+    if (wouldFixCount > 0) {
+        return `Would add prepublishOnly to ${wouldFixCount} of ${packages}.`;
     }
-    return `${packages} ${publishable.length === 1 ? 'has' : 'have'} prepublishOnly.`;
+    return `${packages} ${publishablePackages.length === 1 ? 'has' : 'have'} prepublishOnly.`;
 }
-function renderHookStatus(pkg, hookCommand, style) {
+function renderHookStatus(packageStatus, hookCommand, style) {
     const statuses = STATUS_GLYPHS[style];
-    switch (pkg.action) {
+    switch (packageStatus.action) {
         case 'ok':
-            return `${statuses.passed.text} ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
+            return `${statuses.passed.text} ${packageStatus.packageName}: prepublishOnly = "${packageStatus.prepublishOnly}"`;
         case 'missing':
-            return `${statuses.failed.text} ${pkg.packageName}: missing prepublishOnly`;
+            return `${statuses.failed.text} ${packageStatus.packageName}: missing prepublishOnly`;
         case 'fixed':
-            return `${statuses.passed.text} ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
+            return `${statuses.passed.text} ${packageStatus.packageName}: added prepublishOnly = "${hookCommand}"`;
         case 'would-fix':
-            return `~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`;
+            return `~ ${packageStatus.packageName}: would add prepublishOnly = "${hookCommand}"`;
     }
 }

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.js

@@ -27,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.js

@@ -5,13 +5,13 @@ import { reportClosing } from "../helpers/reportClosing.js";
 import { UserError } from "../UserError.js";
 import { readWorkspaceOverrides } from "../workspace.js";
 export function reportOverrides(monorepoRoot, style) {
-    const declared = listEntries(readWorkspaceOverrides(monorepoRoot));
-    if (declared.length > 0) {
+    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 declared) {
+        for (const [name, version] of declaredOverrides) {
             console.warn(`- ${name} → ${version}`);
         }
-        reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'overrides', describeOverrides(declared.length)), console.warn);
+        reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'overrides', describeOverrides(declaredOverrides.length)), console.warn);
     }
     rejectLegacyOverrides(monorepoRoot);
 }
@@ -24,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

@@ -113,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];
@@ -144,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;
@@ -203,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;
     }
@@ -258,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);
@@ -281,20 +281,20 @@ function assertNoRetiredKeys(value, retiredKeys, configPath, prefix) {
     }
 }
 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/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;

package/dist/esm/help.js

@@ -1,7 +1,7 @@
 import { isHookName } from "./helpers/hook-name.js";
 import { OUTPUT_STYLE_ENV_VAR, OUTPUT_STYLE_FLAG } from "./output-style.js";
 import { buildRootRegistry, buildWorkspaceRegistry, describeScript, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
-export function generateHelp(config, packageDir, useRoot) {
+export function generateHelp(config, packageDir, shouldUseRoot) {
     const lines = [
         'Usage: nmr [flags] <command> [args...]',
         '',
@@ -26,16 +26,16 @@ export function generateHelp(config, packageDir, useRoot) {
     const overrides = packageDir === undefined ? {} : collectOverrides(packageDir);
     let hadOverride = false;
     const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config));
-    const workspaceMarked = !useRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
-    if (workspaceMarked.size > 0)
+    const workspaceMarkedNames = !shouldUseRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
+    if (workspaceMarkedNames.size > 0)
         hadOverride = true;
-    formatRegistry(workspaceRegistry, workspaceMarked, lines);
+    formatRegistry(workspaceRegistry, workspaceMarkedNames, lines);
     lines.push('', 'Root commands:');
     const rootRegistry = filterHooks(buildRootRegistry(config));
-    const rootMarked = useRoot ? applyOverrides(rootRegistry, overrides) : new Set();
-    if (rootMarked.size > 0)
+    const rootMarkedNames = shouldUseRoot ? applyOverrides(rootRegistry, overrides) : new Set();
+    if (rootMarkedNames.size > 0)
         hadOverride = true;
-    formatRegistry(rootRegistry, rootMarked, lines);
+    formatRegistry(rootRegistry, rootMarkedNames, lines);
     if (hadOverride) {
         lines.push('', '* Overridden by package.json');
     }
@@ -45,43 +45,43 @@ function collectOverrides(packageDir) {
     const scripts = readPackageJsonScripts(packageDir);
     if (!scripts)
         return {};
-    const filtered = {};
+    const candidateOverrides = {};
     for (const [name, value] of Object.entries(scripts)) {
         if (isHookName(name))
             continue;
         if (isSelfReferential(value, name, packageDir))
             continue;
-        filtered[name] = value;
+        candidateOverrides[name] = value;
     }
-    return filtered;
+    return candidateOverrides;
 }
 function applyOverrides(registry, overrides) {
-    const marked = new Set();
+    const markedNames = new Set();
     for (const [name, value] of Object.entries(overrides)) {
         if (!Object.hasOwn(registry, name)) {
             continue;
         }
         registry[name] = value;
-        marked.add(name);
+        markedNames.add(name);
     }
-    return marked;
+    return markedNames;
 }
 function filterHooks(registry) {
-    const filtered = {};
+    const hooklessRegistry = {};
     for (const [key, value] of Object.entries(registry)) {
         if (!isHookName(key))
-            filtered[key] = value;
+            hooklessRegistry[key] = value;
     }
-    return filtered;
+    return hooklessRegistry;
 }
-function formatRegistry(registry, marked, lines) {
+function formatRegistry(registry, markedNames, lines) {
     const keys = Object.keys(registry);
     if (keys.length === 0)
         return;
-    const maxKeyLen = Math.max(...keys.map((k) => k.length));
-    const pad = Math.max(maxKeyLen + 1 + 2, 20);
+    const maxKeyLength = Math.max(...keys.map((k) => k.length));
+    const padWidth = Math.max(maxKeyLength + 1 + 2, 20);
     for (const [key, value] of Object.entries(registry)) {
-        const marker = marked.has(key) ? '*' : ' ';
-        lines.push(`  ${(key + marker).padEnd(pad)} ${describeScript(value)}`);
+        const marker = markedNames.has(key) ? '*' : ' ';
+        lines.push(`  ${(key + marker).padEnd(padWidth)} ${describeScript(value)}`);
     }
 }

package/dist/esm/helpers/clampToBytes.js

@@ -7,14 +7,14 @@ export function clampToBytes(value, budgetBytes) {
     if (budget < 0) {
         return '';
     }
-    let kept = '';
+    let keptText = '';
     let bytes = 0;
     for (const character of value) {
         const size = Buffer.byteLength(character);
         if (bytes + size > budget)
             break;
-        kept += character;
+        keptText += character;
         bytes += size;
     }
-    return `${kept}${TRUNCATION_MARK}`;
+    return `${keptText}${TRUNCATION_MARK}`;
 }

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

@@ -6,7 +6,7 @@ export interface BoundedBuffer {
     /** Retains a chunk, dropping bytes from the middle once both ends are full. */
     append: (chunk: Buffer) => void;
     /** Renders the retained bytes, with a marker naming the dropped count standing in for what was dropped. */
-    toBuffer: () => Buffer;
+    readBuffer: () => Buffer;
 }
 /**
  * Creates an accumulator that retains the first and last bytes it is fed and drops the middle.

package/dist/esm/helpers/createBoundedBuffer.js

@@ -40,7 +40,7 @@ export function createBoundedBuffer(options = {}) {
         tailOffset = (tailOffset + chunk.length) % tailLimitBytes;
         tailBytes = Math.min(tailLimitBytes, tailBytes + chunk.length);
     }
-    function toBuffer() {
+    function readBuffer() {
         const headBuffer = Buffer.concat(headChunks);
         if (tailRing === undefined) {
             return headBuffer;
@@ -53,5 +53,5 @@ export function createBoundedBuffer(options = {}) {
         }
         return Buffer.concat([headBuffer, Buffer.from(formatElisionMarker(elidedBytes)), tailBuffer]);
     }
-    return { append, toBuffer };
+    return { append, readBuffer };
 }

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

@@ -5,7 +5,7 @@
  * `1m 30s`, where rounding would claim `2m`. Below a minute the tenth is kept, since that is the scale at which
  * one check's runtime differs from another's; a whole number sheds the `.0` rather than reading `12.0s`.
  */
-export declare function formatDuration(milliseconds: number): string;
+export declare function formatDuration(durationMs: number): string;
 /**
  * Renders the clause a skip spends on the time it saved, or `undefined` when there is no saving worth naming.
  * A skip that can say what it saved earns the clause; one that cannot says nothing, and the caller drops it
@@ -14,4 +14,4 @@ export declare function formatDuration(milliseconds: number): string;
  * Guards its own input rather than trusting the caller's, because the clause is shared: a non-finite duration
  * compares false against the threshold, and would reach a reader as `saved ~NaNs`.
  */
-export declare function formatSaving(milliseconds: number): string | undefined;
+export declare function formatSaving(durationMs: number): string | undefined;