@williamthorsen/nmr 0.38.0 → 0.39.0

package/README.md

@@ -5,24 +5,50 @@
 Context-aware script runner for pnpm monorepos. Ships an `nmr` (node-monorepo run) binary that provides centralized, consistent script execution across workspace packages and the monorepo root.
 
 <!-- section:release-notes -->
-## Release notes — v0.38.0 (2026-09-18)
+## Release notes — v0.39.0 (2026-09-22)
 
 ### 🎉 Features
 
-- Give nmr plain output in pipes and CI logs (#838)
+- Report why a workspace selects no package, and no-op nmr's own -R steps (#841)
 
-  - Stops `nmr` from printing emoji to a pipe or a CI log: When the output stream is not a terminal or `CI` is set, a verdict reads `PASS`, `FAIL`, `SKIP`, or `NOOP` and a command icon is omitted, so that a log can be searched for a verdict.
-  - Adds `--output-style <auto|plain|rich>` to `nmr` and the `NMR_OUTPUT_STYLE` variable, each forcing either style; the flag outranks the variable, a value that names no style exits 1 with a usage error, and neither enters a check-cache key: A rich run and a plain run share a recorded pass.
-  - Replaces several rich glyphs, taking the status markers from the set that release-kit and v11y-check print so that one status has one glyph across the three tools: a recalled pass shows ⏩ in place of ⏭️, a skipped empty override shows ⚪ in place of ⛔, a warning and the `--log` refusal show 🟠 in place of ⚠️ and 📭, the `--log` header shows 💾 in place of 📼, and `nmr-ensure-prepublish-hooks` reports ✅ and ❌ in place of ✓ and ✗.
+  - Drops a `-R` step that nmr composed into a script where the workspace holds no package, so `typecheck` and the five `test` scripts run there instead of failing the run.
+  - Adds a no-op verdict for a command that the drop leaves with no step at all.
+  - Replaces the single refusal for a workspace that selects no package with one message per cause.
 
-### 🪦 Removed
+  Migration: In a repo that declares a workspace package pattern and deliberately holds no package, delete the `.config/nmr.config.ts` entries added to work around the `-R` refusal, the `build: ':'` override included.
 
-- 🚨 **Breaking:** Rename the declinesArgs step declaration to shouldDeclineArguments (#822)
+- 🚨 **Breaking:** Prefix the booleans and reject unrecognized Vitest option keys (#849)
 
-  - Makes a `.config/nmr.config.ts` that still declares `declinesArgs` on a composite script's `{ run, declinesArgs }` step fail to load, with an error that names `shouldDeclineArguments` as the replacement.
-  - Renames the matching field of the `StepSpec` type exported by `@williamthorsen/nmr/config` and `@williamthorsen/nmr/scripts`.
+  - Renames two boolean options of `defineVitestConfig` and `defineRootVitestConfig`, the factories that build a repo's Vitest config: `isolateGit` becomes `shouldIsolateGit`, and `resolveFromSource` becomes `shouldResolveFromSource`.
+  - Makes both factories reject an option key outside the recognized set, naming the offending keys and the recognized ones, rather than ignoring a misspelled or retired key and letting its option fall back to the default with nothing in the run reporting it.
+  - Adds a retired-key check that runs ahead of the unrecognized-key check, reporting the new name for a config that still sets `isolateGit` or `resolveFromSource`.
 
-  Migration: Rename `declinesArgs` to `shouldDeclineArguments` in each composite script step of `.config/nmr.config.ts`, and in any code that sets or reads the field on a `StepSpec`.
+  Migration: In each options object passed to `defineVitestConfig` or `defineRootVitestConfig`, rename `isolateGit` to `shouldIsolateGit` and `resolveFromSource` to `shouldResolveFromSource`, and correct any other key that the factory now rejects. `defineRootVitestConfig` recognizes `monorepoRoot` on the last layer alone, so a config that sets it on an earlier layer now throws where the old code ignored it.
+
+- 🚨 **Breaking:** End nmr's source value names with the kind of the value (#850)
+
+  - Renames two fields of `TestFileConventionsReport`, `misplaced` and `untiered`, to `misplacedFiles` and `untieredFiles`, and renames `TestFileConventionsOptions`'s `exclude` to `excludedBasenames`, in the `@williamthorsen/nmr/tests` entry point.
+  - Adds a guard to `checkTestFileConventions` and `reportTestFileConventions` that throws a `TypeError` naming `excludedBasenames` when a call still sets `exclude`.
+
+  Migration: Read `report.misplacedFiles` and `report.untieredFiles` in place of `report.misplaced` and `report.untiered`, and pass `excludedBasenames` in place of `exclude`. A call that still sets `exclude` throws rather than running with no exclusions, so the failure surfaces where Vitest loads the call site.
+
+- 🚨 **Breaking:** Hoist the pnpm-workspace resolver into nmr-core as a total API (#864)
+
+  - Adds a `./workspace` subpath export to `@williamthorsen/nmr-core`, whose `resolveWorkspace` returns a pnpm workspace's package directories, or the cause of an empty result, as a value rather than as a thrown error.
+  - Reports a `pnpm-workspace.yaml` that the YAML parser rejects under a cause of its own, `unreadable-manifest`, so `nmr -R build` names the syntax error and its remedy in place of failing with the parser's own error.
+  - Removes `diagnoseEmptyWorkspace` and `EmptyWorkspaceDiagnosis` from `@williamthorsen/nmr/workspace`, since `resolveWorkspace` reports the same cause in one call.
+
+  Migration: Replace each `diagnoseEmptyWorkspace` call with `resolveWorkspace`, which reports the cause on the empty result it already returns, and rename the `no-manifest` cause to `no-package`. `EmptyWorkspaceCause` also gains `unreadable-manifest`, so an exhaustive switch over it stops compiling until it handles the new member; every other export of `@williamthorsen/nmr/workspace` keeps its signature and its `UserError` throws.
+
+- 🚨 **Breaking:** Adopt the shared workspace resolver in release-kit, honoring exclusions (#865)
+
+  - 🚨 **Breaking:** Narrows `no-pattern` in `@williamthorsen/nmr-core`'s `EmptyWorkspaceCause`, moving an absent or empty `packages` list onto `no-packages-list` and a value that is not a list of strings onto `unreadable-packages`.
+  - Stops `release-kit` from tagging, publishing, and label-syncing a package that a `!` entry in `pnpm-workspace.yaml` excludes, which its previous `glob`-based resolution could not remove from the match.
+  - Replaces the release of the root package alone with a failure naming the condition that emptied the workspace, when `pnpm-workspace.yaml` does not hold valid YAML or declares a workspace that does not resolve to a package.
+  - Replaces the `no-pattern` remedy that `nmr` printed for a `pnpm-workspace.yaml` declaring no `packages` list, and for one declaring a `packages` value that is not a list of strings.
+  - Raises `engines.node` to `>=24.16.0` in `@williamthorsen/nmr-core` and `@williamthorsen/release-kit`, because Node 24.0 through 24.15 ignores the `followSymlinks` option that the workspace matcher passes to `globSync` and drops a symlinked package directory from the resolution without reporting it.
+
+  Migration: Add a `no-packages-list` arm and an `unreadable-packages` arm to any `switch` that covers `EmptyWorkspaceCause` exhaustively. `no-pattern` now names only a list that the resolver read in full and whose entries all failed to become a positive pattern, so move the handling of an absent `packages` key, an empty list, and a value that is not a list of strings out of the `no-pattern` arm into the two new ones. Route `no-packages-list` to single-package behavior rather than to a failure path: pnpm resolves such a manifest to the root package alone.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -163,7 +189,7 @@ Every command nmr runs reports one line naming the scope it ran at, the command,
 
 **A pipe and a CI log get words rather than emoji.** The same four lines read `PASS`, `FAIL`, `SKIP`, and `NOOP` there, which `grep FAIL` finds. `--output-style` and `NMR_OUTPUT_STYLE` each force either style.
 
-**Verdicts print in every verbosity.** `-q` withholds the output of the commands nmr runs, never nmr's own words: a passing quiet run reports its verdicts and nothing else. A command whose override resolved to `""` or `":"` reports the skip rather than exiting 0 in silence, which is what separates it from a command that passed. An `NMR_RUN_IF_PRESENT` miss reports nothing, having no command to report on.
+**Verdicts print in every verbosity.** `-q` withholds the output of the commands nmr runs, never nmr's own words: a passing quiet run reports its verdicts and nothing else. A command that ran nothing reports the skip rather than exiting 0 in silence, which is what separates it from a command that passed: an override resolving to `""` or `":"`, and a fan-out step that a package-free workspace left nothing to do. An `NMR_RUN_IF_PRESENT` miss reports nothing, having no command to report on.
 
 [What nmr reports](docs/reporting.md) covers how verdicts nest, the `--json` format, the output style, and where the verbosity of a run comes from.
 

package/dist/esm/check-cache.d.ts

@@ -53,7 +53,7 @@ export interface Retention {
 /** What nmr's own build has left on disk across the workspace. */
 export interface BuildOutputState {
     /** Covered packages whose output is absent. */
-    missing: string[];
+    missingPackages: string[];
     /** The digest of the inputs each covered package's output was built from, keyed by package name. */
     digests: Record<string, string>;
 }
@@ -154,7 +154,7 @@ export declare function encodeTreeSnapshot(snapshot: TreeSnapshot): string;
  * package agrees. A package that has appeared or disappeared between them counts as a disagreement, because
  * the output the earlier observation describes is not the output the later one found.
  */
-export declare function findStaleBuildOutput(earlier: Record<string, string>, later: Record<string, string>): string | undefined;
+export declare function findStaleBuildOutput(earlierDigests: Record<string, string>, laterDigests: Record<string, string>): string | undefined;
 /**
  * Renders the warning for a `--no-cache` that landed after the command name, where it is an argument to the
  * command rather than a flag to nmr. Passing it on unchanged is the honest thing to do with an argument, so

package/dist/esm/check-cache.js

@@ -103,9 +103,9 @@ export function computeRetentionKey(options) {
 export function encodeTreeSnapshot(snapshot) {
     return `${snapshot.hash} ${snapshot.headSha}`;
 }
-export function findStaleBuildOutput(earlier, later) {
-    const names = [...new Set([...Object.keys(earlier), ...Object.keys(later)])].toSorted();
-    return names.find((name) => earlier[name] !== later[name]);
+export function findStaleBuildOutput(earlierDigests, laterDigests) {
+    const names = [...new Set([...Object.keys(earlierDigests), ...Object.keys(laterDigests)])].toSorted();
+    return names.find((name) => earlierDigests[name] !== laterDigests[name]);
 }
 export function formatMisplacedNoCacheWarning(command, style) {
     return (`${STATUS_GLYPHS[style].warning.text} --no-cache after the command name is passed to \`${command}\`, ` +
@@ -115,7 +115,7 @@ export function isCacheableCommand(checkCache, command) {
     return !isHookName(command) && checkCache?.enabled !== false && resolveCacheableCommands(checkCache).has(command);
 }
 export async function readBuildOutputState(monorepoRoot, config) {
-    const state = { missing: [], digests: {} };
+    const state = { missingPackages: [], digests: {} };
     let packageDirs;
     try {
         packageDirs = getWorkspacePackageDirs(monorepoRoot);
@@ -138,17 +138,17 @@ export async function readBuildOutputState(monorepoRoot, config) {
             state.digests[name] = (await readBuildDigest(packageDir)) ?? '';
         }
         else {
-            state.missing.push(name);
+            state.missingPackages.push(name);
         }
     }
     return state;
 }
 export async function readCheckCacheEntry(options) {
-    const parsed = await readJsonCacheEntry(resolveEntryPath(options), isParsedCheckCacheEntry);
-    if (parsed === undefined) {
+    const parsedEntry = await readJsonCacheEntry(resolveEntryPath(options), isParsedCheckCacheEntry);
+    if (parsedEntry === undefined) {
         return undefined;
     }
-    const { retention, ...pass } = parsed;
+    const { retention, ...pass } = parsedEntry;
     return isRetention(retention) ? { ...pass, retention } : pass;
 }
 export async function readTranscript(ref) {
@@ -168,23 +168,23 @@ export async function removeCheckCache(scopeDir) {
 export function resolveCacheableCommands(checkCache) {
     const commands = new Set([...DEFAULT_CACHEABLE_COMMANDS, ...(checkCache?.extraCommands ?? [])]);
     const excludedCommands = checkCache?.excludeCommands ?? [];
-    for (const excluded of excludedCommands) {
-        commands.delete(excluded);
+    for (const excludedCommand of excludedCommands) {
+        commands.delete(excludedCommand);
     }
     return commands;
 }
 export function resolveRunId(env) {
-    const inherited = env[RUN_ID_ENV_VAR];
-    return inherited === undefined || inherited === '' ? randomUUID() : inherited;
+    const inheritedRunId = env[RUN_ID_ENV_VAR];
+    return inheritedRunId === undefined || inheritedRunId === '' ? randomUUID() : inheritedRunId;
 }
 export function resolveTreeSnapshot(options) {
-    const inherited = decodeTreeSnapshot(options.env[TREE_SNAPSHOT_ENV_VAR]);
-    if (inherited !== undefined && readHeadSha(options.monorepoRoot) === inherited.headSha) {
-        return { ok: true, snapshot: inherited };
+    const inheritedSnapshot = decodeTreeSnapshot(options.env[TREE_SNAPSHOT_ENV_VAR]);
+    if (inheritedSnapshot !== undefined && readHeadSha(options.monorepoRoot) === inheritedSnapshot.headSha) {
+        return { ok: true, snapshot: inheritedSnapshot };
     }
-    const hashed = hashWorkingTree(options.monorepoRoot);
-    if (!hashed.ok) {
-        return hashed;
+    const hashedTree = hashWorkingTree(options.monorepoRoot);
+    if (!hashedTree.ok) {
+        return hashedTree;
     }
     let physicalRoot;
     try {
@@ -193,10 +193,10 @@ export function resolveTreeSnapshot(options) {
     catch {
         return { ok: false, reason: `could not resolve ${options.monorepoRoot}` };
     }
-    if (hashed.toplevel !== physicalRoot) {
-        return { ok: false, reason: `the monorepo root is not the git toplevel (${hashed.toplevel})` };
+    if (hashedTree.toplevel !== physicalRoot) {
+        return { ok: false, reason: `the monorepo root is not the git toplevel (${hashedTree.toplevel})` };
     }
-    return { ok: true, snapshot: { hash: hashed.hash, headSha: hashed.headSha } };
+    return { ok: true, snapshot: { hash: hashedTree.hash, headSha: hashedTree.headSha } };
 }
 export async function writeCheckCacheEntry(options) {
     await writeCacheEntry(resolveEntryPath(options), JSON.stringify(options.entry, undefined, 2));
@@ -212,11 +212,11 @@ function composeEnvParts(names, env) {
         return [name, value === undefined ? 'unset' : 'set', value ?? ''];
     });
 }
-function decodeTreeSnapshot(encoded) {
-    if (encoded === undefined) {
+function decodeTreeSnapshot(encodedSnapshot) {
+    if (encodedSnapshot === undefined) {
         return undefined;
     }
-    const [hash, headSha] = encoded.split(' ', 2);
+    const [hash, headSha] = encodedSnapshot.split(' ', 2);
     if (hash === undefined || headSha === undefined || hash === '' || headSha === '') {
         return undefined;
     }

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

@@ -4,15 +4,15 @@ import { DEFAULT_HOOK, ensurePrepublishHooks, reportPrepublishHooks } from "./co
 import { resolveBinStyles } from "./resolveBinStyles.js";
 import { findMonorepoRoot } from "./workspace.js";
 const flagSchema = {
-    fix: { long: '--fix', type: 'boolean' },
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    shouldFix: { long: '--fix', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
     command: { long: '--command', type: 'string' },
 };
-const { fix, dryRun, command } = parseArgsOrExit(process.argv.slice(2), flagSchema).flags;
+const { shouldFix, isDryRun, command } = parseArgsOrExit(process.argv.slice(2), flagSchema).flags;
 try {
     const { stdout } = resolveBinStyles();
     const monorepoRoot = findMonorepoRoot();
-    const options = command ? { fix, dryRun, command } : { fix, dryRun };
+    const options = command ? { shouldFix, isDryRun, command } : { shouldFix, isDryRun };
     const result = ensurePrepublishHooks(monorepoRoot, options);
     reportPrepublishHooks(result, command ?? DEFAULT_HOOK, stdout);
     if (result.hasFailures) {

package/dist/esm/commands/build-output.d.ts

@@ -8,8 +8,8 @@ export interface BuildOptions {
 }
 /** The pair of directories a build publishes through, both siblings of the emit directory. */
 export interface ScratchDirs {
-    previous: string;
-    staging: string;
+    previousDir: string;
+    stagingDir: string;
 }
 export declare const DEFAULT_ENTRY_GLOBS: string[];
 /**

package/dist/esm/commands/build-output.js

@@ -17,8 +17,8 @@ export async function hasBuildOutput(packageDir, options = {}) {
     return hasExpectedBuildOutput(packageDir, outdir, entryPoints);
 }
 export function hasExpectedBuildOutput(packageDir, outdir, entryPoints) {
-    const emitsOutput = entryPoints.some((entry) => !entry.endsWith('.d.ts'));
-    if (!emitsOutput) {
+    const doesEmitOutput = entryPoints.some((entry) => !entry.endsWith('.d.ts'));
+    if (!doesEmitOutput) {
         return true;
     }
     const outputDir = path.resolve(packageDir, outdir);
@@ -40,8 +40,8 @@ export function resolveScratchDirs(emitDir) {
     const parent = path.dirname(emitDir);
     const name = path.basename(emitDir);
     return {
-        previous: path.join(parent, `.${name}.previous`),
-        staging: path.join(parent, `.${name}.staging`),
+        previousDir: path.join(parent, `.${name}.previous`),
+        stagingDir: path.join(parent, `.${name}.staging`),
     };
 }
 export async function resolveToolchainFingerprint(packageDir, selfDir = SELF_DIR) {
@@ -54,14 +54,14 @@ export async function resolveToolchainFingerprint(packageDir, selfDir = SELF_DIR
     return readPackageJson(selfDir).version ?? '';
 }
 function isSameDir(left, right) {
-    return toRealPath(left) === toRealPath(right);
+    return resolveRealPath(left) === resolveRealPath(right);
 }
-function toRealPath(dir) {
-    const absolute = path.resolve(dir);
+function resolveRealPath(dir) {
+    const absoluteDir = path.resolve(dir);
     try {
-        return realpathSync(absolute);
+        return realpathSync(absoluteDir);
     }
     catch {
-        return absolute;
+        return absoluteDir;
     }
 }

package/dist/esm/commands/build.js

@@ -60,18 +60,18 @@ export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json
     const resolvedChain = [];
     const seen = new Set();
     function walk(configPath) {
-        const normalized = path.resolve(configPath);
-        if (seen.has(normalized)) {
+        const normalizedPath = path.resolve(configPath);
+        if (seen.has(normalizedPath)) {
             return;
         }
-        seen.add(normalized);
-        resolvedChain.push(normalized);
-        const configFile = ts.readConfigFile(normalized, (fileName) => ts.sys.readFile(fileName));
+        seen.add(normalizedPath);
+        resolvedChain.push(normalizedPath);
+        const configFile = ts.readConfigFile(normalizedPath, (fileName) => ts.sys.readFile(fileName));
         if (configFile.error) {
-            throw new Error(`nmr-compile: failed to read ${normalized}.\n${formatDiagnostics([configFile.error])}`);
+            throw new Error(`nmr-compile: failed to read ${normalizedPath}.\n${formatDiagnostics([configFile.error])}`);
         }
         for (const entry of normalizeExtendsField(configFile.config)) {
-            walk(resolveExtendsTarget(entry, normalized));
+            walk(resolveExtendsTarget(entry, normalizedPath));
         }
     }
     walk(path.resolve(packageDir, configFileName));
@@ -84,26 +84,26 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     const emitDir = resolveEmitDir(packageDir, outdir);
     const scratchDirs = resolveScratchDirs(emitDir);
     await removeScratchDirs(scratchDirs);
-    const emitted = new Map();
+    const emittedFiles = new Map();
     function collect(fileName, text, writeByteOrderMark) {
-        emitted.set(fileName, { text, writeByteOrderMark });
+        emittedFiles.set(fileName, { text, writeByteOrderMark });
     }
     const host = createCachingCompilerHost(compilerOptions);
     const scriptProgram = ts.createProgram(rootNames, { ...compilerOptions, declaration: false }, host);
     assertEmitSucceeded(scriptProgram.emit(undefined, collect));
     const declarationProgram = ts.createProgram(rootNames, { ...compilerOptions, emitDeclarationOnly: true, removeComments: false }, host, scriptProgram);
     assertEmitSucceeded(declarationProgram.emit(undefined, collect));
-    const staged = new Map();
-    for (const [fileName, file] of emitted) {
-        staged.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
+    const stagedFiles = new Map();
+    for (const [fileName, file] of emittedFiles) {
+        stagedFiles.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
     }
-    if (staged.size === 0) {
+    if (stagedFiles.size === 0) {
         await rm(emitDir, { force: true, recursive: true });
         return 0;
     }
-    writeStagedOutput(staged, emitDir, scratchDirs.staging);
+    writeStagedOutput(stagedFiles, emitDir, scratchDirs.stagingDir);
     await swapIntoPlace(emitDir, scratchDirs);
-    return staged.size;
+    return stagedFiles.size;
 }
 function assertEmitSucceeded(result) {
     if (result.emitSkipped) {
@@ -112,14 +112,14 @@ function assertEmitSucceeded(result) {
 }
 function createCachingCompilerHost(compilerOptions) {
     const host = ts.createCompilerHost(compilerOptions);
-    const parsed = new Map();
+    const parsedFiles = new Map();
     const readSourceFile = host.getSourceFile.bind(host);
     host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
-        if (parsed.has(fileName)) {
-            return parsed.get(fileName);
+        if (parsedFiles.has(fileName)) {
+            return parsedFiles.get(fileName);
         }
         const sourceFile = readSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
-        parsed.set(fileName, sourceFile);
+        parsedFiles.set(fileName, sourceFile);
         return sourceFile;
     };
     return host;
@@ -132,29 +132,31 @@ async function discardScratchDirs(scratchDirs) {
     }
 }
 async function removeScratchDirs(scratchDirs) {
-    await rm(scratchDirs.previous, { force: true, recursive: true });
-    await rm(scratchDirs.staging, { force: true, recursive: true });
+    await rm(scratchDirs.previousDir, { force: true, recursive: true });
+    await rm(scratchDirs.stagingDir, { force: true, recursive: true });
 }
 function resolveEmitDir(packageDir, outdir) {
-    const resolved = path.resolve(packageDir, outdir);
-    const relative = path.relative(packageDir, resolved);
-    if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
+    const resolvedDir = path.resolve(packageDir, outdir);
+    const relativePathFromPackage = path.relative(packageDir, resolvedDir);
+    if (relativePathFromPackage === '' ||
+        relativePathFromPackage.startsWith('..') ||
+        path.isAbsolute(relativePathFromPackage)) {
         throw new Error(`nmr-compile: refusing to build into '${outdir}', which does not resolve inside the package. ` +
             'The build replaces its output directory on each emit, so the directory must sit below the package root.');
     }
-    return resolved;
+    return resolvedDir;
 }
 async function swapIntoPlace(emitDir, scratchDirs) {
     const hadPreviousOutput = existsSync(emitDir);
     if (hadPreviousOutput) {
-        await rename(emitDir, scratchDirs.previous);
+        await rename(emitDir, scratchDirs.previousDir);
     }
     try {
-        await rename(scratchDirs.staging, emitDir);
+        await rename(scratchDirs.stagingDir, emitDir);
     }
     catch (error) {
         if (hadPreviousOutput && !existsSync(emitDir)) {
-            await rename(scratchDirs.previous, emitDir);
+            await rename(scratchDirs.previousDir, emitDir);
         }
         throw error;
     }
@@ -166,13 +168,13 @@ function synthesizeCompilerOptions(packageDir, outdir) {
     if (configFile.error) {
         throw new Error(`nmr-compile: failed to read ${configPath}.\n${formatDiagnostics([configFile.error])}`);
     }
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
-    if (parsed.errors.length > 0) {
-        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsed.errors)}`);
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
+    if (parsedConfig.errors.length > 0) {
+        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsedConfig.errors)}`);
     }
     const resolvedOutDir = path.resolve(packageDir, outdir);
     return {
-        ...parsed.options,
+        ...parsedConfig.options,
         noEmit: false,
         emitDeclarationOnly: false,
         declaration: true,
@@ -185,8 +187,8 @@ function synthesizeCompilerOptions(packageDir, outdir) {
         noEmitOnError: false,
     };
 }
-function writeStagedOutput(staged, emitDir, stagingDir) {
-    for (const [fileName, file] of staged) {
+function writeStagedOutput(stagedFiles, emitDir, stagingDir) {
+    for (const [fileName, file] of stagedFiles) {
         if (!isWithin(emitDir, fileName)) {
             throw new Error(`nmr-compile: the compiler emitted ${fileName}, which is outside the output directory ${emitDir}. ` +
                 "Verify the resolved tsconfig's 'outDir' and 'declarationDir'.");
@@ -198,57 +200,57 @@ function rewriteSpecifiers(outputFile, text, compilerOptions, sourceRoot) {
     if (!isRewritableOutput(outputFile)) {
         return text;
     }
-    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, scriptKindFor(outputFile));
+    const sourceFile = ts.createSourceFile(outputFile, text, ts.ScriptTarget.Latest, false, resolveScriptKind(outputFile));
     const aliasPrefixes = collectAliasPrefixes(compilerOptions);
     const sourceContainingFile = mapOutputToSource(outputFile, compilerOptions, sourceRoot);
     const edits = [];
-    forEachModuleSpecifier(sourceFile, (literal) => {
+    visitModuleSpecifiers(sourceFile, (literal) => {
         const replacement = resolveSpecifierReplacement(literal.text, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes);
         if (replacement === undefined) {
             return;
         }
-        const start = literal.getStart(sourceFile);
-        const quote = text[start] ?? '"';
-        edits.push({ start, end: literal.getEnd(), text: `${quote}${replacement}${quote}` });
+        const startOffset = literal.getStart(sourceFile);
+        const quote = text[startOffset] ?? '"';
+        edits.push({ startOffset, endOffset: literal.getEnd(), text: `${quote}${replacement}${quote}` });
     });
     if (edits.length === 0) {
         return text;
     }
-    const orderedEdits = [...edits].sort((a, b) => b.start - a.start);
+    const orderedEdits = [...edits].sort((a, b) => b.startOffset - a.startOffset);
     let updatedText = text;
     for (const edit of orderedEdits) {
-        updatedText = updatedText.slice(0, edit.start) + edit.text + updatedText.slice(edit.end);
+        updatedText = updatedText.slice(0, edit.startOffset) + edit.text + updatedText.slice(edit.endOffset);
     }
     return updatedText;
 }
 function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes) {
     if (isRelativeSpecifier(specifier)) {
-        const rewritten = swapTypeScriptExtension(specifier);
-        return rewritten === specifier ? undefined : rewritten;
+        const rewrittenSpecifier = swapTypeScriptExtension(specifier);
+        return rewrittenSpecifier === specifier ? undefined : rewrittenSpecifier;
     }
     if (aliasPrefixes.every((prefix) => !(specifier === prefix || specifier.startsWith(prefix)))) {
         return undefined;
     }
-    const resolved = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
-    if (!resolved) {
+    const resolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
+    if (!resolvedModule) {
         throw new Error(`nmr-compile: could not resolve aliased import '${specifier}' from ${sourceContainingFile}. ` +
             `Verify the tsconfig 'paths' mapping and that the target file exists.`);
     }
-    if (!isWithin(sourceRoot, resolved.resolvedFileName)) {
+    if (!isWithin(sourceRoot, resolvedModule.resolvedFileName)) {
         const { paths: _paths, baseUrl: _baseUrl, rootDirs: _rootDirs, ...nodeResolutionOptions } = compilerOptions;
-        const bareResolved = ts.resolveModuleName(specifier, sourceContainingFile, nodeResolutionOptions, ts.sys).resolvedModule;
-        if (bareResolved) {
+        const bareResolvedModule = ts.resolveModuleName(specifier, sourceContainingFile, nodeResolutionOptions, ts.sys).resolvedModule;
+        if (bareResolvedModule) {
             return undefined;
         }
         throw new Error(`nmr-compile: aliased import '${specifier}' from ${sourceContainingFile} resolves to ` +
-            `${resolved.resolvedFileName}, outside the package source root ${sourceRoot}, and does not resolve ` +
+            `${resolvedModule.resolvedFileName}, outside the package source root ${sourceRoot}, and does not resolve ` +
             `the way Node will at runtime, which ignores tsconfig 'paths', 'baseUrl', and 'rootDirs'. The ` +
             `emitted specifier would fail at runtime; re-anchor the alias inside the package.`);
     }
-    const relative = toRelativeSpecifier(path.dirname(sourceContainingFile), resolved.resolvedFileName);
-    return swapTypeScriptExtension(relative);
+    const relativeSpecifier = buildRelativeSpecifier(path.dirname(sourceContainingFile), resolvedModule.resolvedFileName);
+    return swapTypeScriptExtension(relativeSpecifier);
 }
-function forEachModuleSpecifier(sourceFile, visit) {
+function visitModuleSpecifiers(sourceFile, visit) {
     function walk(node) {
         const specifier = getModuleSpecifier(node);
         if (specifier !== undefined) {
@@ -274,12 +276,12 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent, style) {
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, isOutputPresent, style) {
     const packageName = path.basename(packageDir);
     const previousHash = await readCacheEntry(cachePath);
     const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
     if (previousHash === currentHash) {
-        if (outputPresent) {
+        if (isOutputPresent) {
             console.info(`${STATUS_GLYPHS[style].skipped.text} ${packageName}: No changes detected. Skipping build.`);
             return { changed: false, currentHash };
         }
@@ -346,12 +348,12 @@ function resolveExtendsTarget(extendsEntry, fromConfigPath) {
         }
         throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not exist.`);
     }
-    const resolved = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
+    const resolvedPath = resolvePackageSpecifier(extendsEntry, fromConfigPath) ??
         resolvePackageSpecifier(`${extendsEntry}/tsconfig.json`, fromConfigPath);
-    if (resolved === undefined) {
+    if (resolvedPath === undefined) {
         throw new Error(`nmr-compile: ${fromConfigPath} extends '${extendsEntry}', which does not resolve to a file.`);
     }
-    return resolved;
+    return resolvedPath;
 }
 function resolvePackageSpecifier(specifier, fromConfigPath) {
     const { resolvedModule } = ts.resolveModuleName(specifier, fromConfigPath, { moduleResolution: ts.ModuleResolutionKind.NodeNext, resolveJsonModule: true }, ts.sys);
@@ -361,8 +363,8 @@ function isRelativeSpecifier(specifier) {
     return specifier.startsWith('./') || specifier.startsWith('../');
 }
 function isWithin(parent, child) {
-    const relative = path.relative(parent, child);
-    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+    const relativePath = path.relative(parent, child);
+    return relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
 }
 function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
     const outDir = compilerOptions.outDir ?? path.dirname(outputFile);
@@ -370,11 +372,11 @@ function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
     const withoutExtension = relativeFromOut.replace(/\.d\.ts$|\.js$/, '');
     return path.join(sourceRoot, `${withoutExtension}.ts`);
 }
-function toRelativeSpecifier(fromDir, targetFile) {
-    const relative = path.relative(fromDir, targetFile).split(path.sep).join('/');
-    return relative.startsWith('.') ? relative : `./${relative}`;
+function buildRelativeSpecifier(fromDir, targetFile) {
+    const relativePath = path.relative(fromDir, targetFile).split(path.sep).join('/');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
 }
-function scriptKindFor(file) {
+function resolveScriptKind(file) {
     return file.endsWith('.d.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS;
 }
 function swapTypeScriptExtension(specifier) {

package/dist/esm/commands/clean.js

@@ -42,26 +42,26 @@ async function clearCheckCache(scopeDir, style) {
     await removeCheckCache(scopeDir);
     console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', 'Removed all recorded check results.'));
 }
-function describeSweep(cleaned, skipped) {
-    const packages = cleaned === 1 ? '1 package' : `${cleaned} packages`;
-    const skipClause = skipped === 0 ? '' : `, skipping ${skipped} with an empty clean override`;
+function describeSweep(cleanedCount, skippedCount) {
+    const packages = cleanedCount === 1 ? '1 package' : `${cleanedCount} packages`;
+    const skipClause = skippedCount === 0 ? '' : `, skipping ${skippedCount} with an empty clean override`;
     return `Cleaned ${packages}${skipClause}.`;
 }
 async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
-    let cleaned = 0;
-    let skipped = 0;
+    let cleanedCount = 0;
+    let skippedCount = 0;
     for (const packageDir of workspacePackageDirs) {
-        const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
-        const resolvedCommand = resolved === undefined ? undefined : renderChain(resolved.steps);
+        const resolvedScript = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
+        const resolvedCommand = resolvedScript === undefined ? undefined : renderChain(resolvedScript.steps);
         if (resolvedCommand === undefined || resolvedCommand === '') {
-            skipped++;
+            skippedCount++;
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
             await cleanPackage(packageDir, style);
-            cleaned++;
+            cleanedCount++;
             continue;
         }
         const command = applyDevBin(resolvedCommand, config.devBin, monorepoRoot);
@@ -71,7 +71,7 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
         if (exitCode !== 0) {
             throw new Error(`nmr-clean: \`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }
-        cleaned++;
+        cleanedCount++;
     }
-    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleaned, skipped)));
+    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleanedCount, skippedCount)));
 }

package/dist/esm/commands/ensure-prepublish-hooks.d.ts

@@ -16,8 +16,8 @@ export declare const DEFAULT_HOOK = "npm run build";
  * have a `prepublishOnly` script.
  */
 export declare function ensurePrepublishHooks(monorepoRoot: string, options: {
-    fix: boolean;
-    dryRun: boolean;
+    shouldFix: boolean;
+    isDryRun: boolean;
     command?: string;
 }): EnsurePrepublishHooksResult;
 /**