@williamthorsen/nmr 2.0.0 → 2.0.2

package/dist/esm/commands/build.js

@@ -1,30 +1,24 @@
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { readFile, rename, rm } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { formatGlyphLine, readCacheEntry, startTimer, STATUS_GLYPHS, UserError, writeCacheEntry, } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
-import { glob } from 'glob';
-import { NMR_GLYPHS } from "../glyphs.js";
+import { readCacheEntry, startTimer, UserError, writeCacheEntry } from '@williamthorsen/nmr-core';
 import { resolveConfigPath } from "../helpers/config-path.js";
-import { formatSaving } from "../helpers/duration.js";
 import { writeStatedOutcome } from "../stated-outcome.js";
-import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, readEmitDuration, resolveBuildCachePath, resolveScratchDirs, resolveToolchainFingerprint, writeEmitDuration, } from "./build-output.js";
+import { DEFAULT_OUTDIR, hasExpectedBuildOutput, readEmitDuration, resolveBuildCachePath, resolveEntryPoints, resolveToolchainFingerprint, writeEmitDuration, } from "./build-output.js";
 import { assertSupportedTypeScript, formatDiagnostics, getCompiler, loadCompiler } from "./compiler.js";
-import { isWithin, rewriteSpecifiers } from "./rewrite-specifiers.js";
+import { discardScratchDirs, publishOutput, removeScratchDirs } from "./publish-output.js";
+import { rewriteSpecifiers } from "./rewrite-specifiers.js";
 import { resolveTsconfigChain } from "./tsconfig-chain.js";
 const SOURCE_ROOT = 'src';
-export async function buildPackage(packageDir, options) {
+export async function buildPackage(packageDir, options = {}) {
     await loadCompiler(options.loadTypeScript);
     assertSupportedTypeScript();
     const cachePath = resolveBuildCachePath(packageDir);
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
     const emitDir = resolveEmitDir(packageDir, outdir);
     const emitConfig = { outdir, declaration: true, rewriteRelativeImportExtensions: true };
-    const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
-        cwd: packageDir,
-        ignore: [...(options.ignorePatterns ?? DEFAULT_IGNORE_PATTERNS), ...(options.extraIgnorePatterns ?? [])],
-    });
+    const entryPoints = await resolveEntryPoints(packageDir, options);
     const configPath = resolveConfigPath(packageDir);
     const dependencies = [
         'package.json',
@@ -35,17 +29,19 @@ export async function buildPackage(packageDir, options) {
         compilerVersion: getCompiler().version,
         fingerprint: await resolveToolchainFingerprint(packageDir),
     };
-    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints), options.style);
-    if (!changed) {
-        await discardScratchDirs(resolveScratchDirs(emitDir));
-        return;
+    const { reason, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
+    if (reason === 'unchanged') {
+        await discardScratchDirs(emitDir);
+        const savedMs = await recordUnchangedBuild(packageDir, currentHash, process.env);
+        return { kind: 'unchanged', ...(savedMs !== undefined && { savedMs }) };
     }
+    options.onProgress?.({ kind: reason });
     const readEmitMs = startTimer();
     const emittedFileCount = await emitPackage(packageDir, entryPoints, outdir);
     const emitMs = readEmitMs();
     await writeCacheEntry(cachePath, currentHash);
     await writeEmitDuration(packageDir, currentHash, emitMs);
-    console.info(formatGlyphLine(NMR_GLYPHS, options.style, 'package', `${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`));
+    return { kind: 'emitted', fileCount: emittedFileCount, outdir };
 }
 export async function computeBuildHash(packageDir, files, emitConfig, toolchain) {
     const hash = createHash('sha256');
@@ -67,8 +63,7 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     const rootNames = entryPoints.map((entry) => path.resolve(packageDir, entry));
     const sourceRoot = path.resolve(packageDir, SOURCE_ROOT);
     const emitDir = resolveEmitDir(packageDir, outdir);
-    const scratchDirs = resolveScratchDirs(emitDir);
-    await removeScratchDirs(scratchDirs);
+    await removeScratchDirs(emitDir);
     const emittedFiles = new Map();
     function collect(fileName, text, writeByteOrderMark) {
         emittedFiles.set(fileName, { text, writeByteOrderMark });
@@ -82,13 +77,7 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     for (const [fileName, file] of emittedFiles) {
         stagedFiles.set(fileName, { ...file, text: rewriteSpecifiers(fileName, file.text, compilerOptions, sourceRoot) });
     }
-    if (stagedFiles.size === 0) {
-        await rm(emitDir, { force: true, recursive: true });
-        return 0;
-    }
-    writeStagedOutput(stagedFiles, emitDir, scratchDirs.stagingDir);
-    await swapIntoPlace(emitDir, scratchDirs);
-    return stagedFiles.size;
+    return publishOutput(emitDir, stagedFiles);
 }
 function assertEmitSucceeded(result) {
     if (result.emitSkipped) {
@@ -110,17 +99,6 @@ function createCachingCompilerHost(compilerOptions) {
     };
     return host;
 }
-async function discardScratchDirs(scratchDirs) {
-    try {
-        await removeScratchDirs(scratchDirs);
-    }
-    catch {
-    }
-}
-async function removeScratchDirs(scratchDirs) {
-    await rm(scratchDirs.previousDir, { force: true, recursive: true });
-    await rm(scratchDirs.stagingDir, { force: true, recursive: true });
-}
 function resolveEmitDir(packageDir, outdir) {
     const resolvedDir = path.resolve(packageDir, outdir);
     const relativePathFromPackage = path.relative(packageDir, resolvedDir);
@@ -132,24 +110,6 @@ function resolveEmitDir(packageDir, outdir) {
     }
     return resolvedDir;
 }
-async function swapIntoPlace(emitDir, scratchDirs) {
-    const hadPreviousOutput = existsSync(emitDir);
-    if (hadPreviousOutput) {
-        await rename(emitDir, scratchDirs.previousDir);
-    }
-    try {
-        await rename(scratchDirs.stagingDir, emitDir);
-    }
-    catch (error) {
-        if (hadPreviousOutput && !existsSync(emitDir)) {
-            await rename(scratchDirs.previousDir, emitDir);
-        }
-        throw new UserError(`failed to move the built output into ${emitDir}: ${describeError(error)}`, {
-            cause: error,
-        });
-    }
-    await discardScratchDirs(scratchDirs);
-}
 function synthesizeCompilerOptions(packageDir, outdir) {
     const ts = getCompiler();
     const configPath = path.join(packageDir, 'tsconfig.json');
@@ -176,38 +136,16 @@ function synthesizeCompilerOptions(packageDir, outdir) {
         noEmitOnError: false,
     };
 }
-function writeStagedOutput(stagedFiles, emitDir, stagingDir) {
-    const ts = getCompiler();
-    for (const [fileName, file] of stagedFiles) {
-        if (!isWithin(emitDir, fileName)) {
-            throw new Error(`the compiler emitted ${fileName}, which is outside the output directory ${emitDir}. ` +
-                "Verify the resolved tsconfig's 'outDir' and 'declarationDir'.");
-        }
-        ts.sys.writeFile(path.join(stagingDir, path.relative(emitDir, fileName)), file.text, file.writeByteOrderMark);
-    }
-}
-async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, isOutputPresent, style) {
-    const packageName = path.basename(packageDir);
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, isOutputPresent) {
     const previousHash = await readCacheEntry(cachePath);
     const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
-    if (previousHash === currentHash) {
-        if (isOutputPresent) {
-            const savedMs = await readEmitDuration(packageDir, currentHash);
-            await writeStatedOutcome(process.env, { kind: 'build-unchanged', ...(savedMs !== undefined && { savedMs }) });
-            const saving = formatSaving(savedMs ?? 0);
-            const savingClause = saving === undefined ? '' : `, ${saving}`;
-            console.info(`${STATUS_GLYPHS[style].skipped.text} ${packageName}: No changes detected. Skipping build${savingClause}.`);
-            return { changed: false, currentHash };
-        }
-        console.info(formatGlyphLine(NMR_GLYPHS, style, 'package', `${packageName}: Build output is missing. Rebuilding.`));
-        return { changed: true, currentHash };
+    if (previousHash !== currentHash) {
+        return { reason: 'inputs-changed', currentHash };
     }
-    console.info(formatGlyphLine(NMR_GLYPHS, style, 'package', `${packageName}: Changes detected.`));
-    return { changed: true, currentHash };
+    return { reason: isOutputPresent ? 'unchanged' : 'output-missing', currentHash };
 }
-function describeEmit(fileCount, outdir) {
-    if (fileCount === 0) {
-        return 'Did not emit any output.';
-    }
-    return `Compiled ${fileCount} files to ${outdir.replace(/\/+$/u, '')}.`;
+export async function recordUnchangedBuild(packageDir, digest, env) {
+    const savedMs = await readEmitDuration(packageDir, digest);
+    await writeStatedOutcome(env, { kind: 'build-unchanged', ...(savedMs !== undefined && { savedMs }) });
+    return savedMs;
 }

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

@@ -0,0 +1,6 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
+import type { CleanOutcome, CleanProgress } from './clean.js';
+/** Renders the line that closes a sweep, or `undefined` for a one-package clean, whose own line concludes it. */
+export declare function renderCleanOutcome(outcome: CleanOutcome, style: OutputStyle): string | undefined;
+/** Renders the line that reports a completed step of a clean. */
+export declare function renderCleanProgress(progress: CleanProgress, style: OutputStyle): string;

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

@@ -0,0 +1,20 @@
+import path from 'node:path';
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
+import { NMR_GLYPHS } from "../glyphs.js";
+export function renderCleanOutcome(outcome, style) {
+    if (outcome.kind === 'package') {
+        return undefined;
+    }
+    return formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(outcome.cleanedDirs.length, outcome.skippedCount));
+}
+export function renderCleanProgress(progress, style) {
+    const message = progress.kind === 'check-results-removed'
+        ? 'Removed all recorded check results.'
+        : `${path.basename(progress.packageDir)}: Removed build output and cache.`;
+    return formatGlyphLine(NMR_GLYPHS, style, 'clean', message);
+}
+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}.`;
+}

package/dist/esm/commands/clean.d.ts

@@ -1,18 +1,50 @@
-import { type OutputStyle } from '@williamthorsen/nmr-core';
+import type { Writable } from 'node:stream';
+/** What a clean did: one package's clean, or a sweep of every workspace package. */
+export type CleanOutcome = {
+    kind: 'package';
+    checkResultsDir: string;
+    packageDir: string;
+} | {
+    kind: 'sweep';
+    checkResultsDir: string;
+    cleanedDirs: string[];
+    skippedCount: number;
+};
+/** A step of a clean, reported as soon as it completes. */
+export type CleanProgress = {
+    kind: 'check-results-removed';
+} | {
+    kind: 'package-cleaned';
+    packageDir: string;
+};
+/** What a clean needs from its caller: a listener for its progress, and the streams for an override's output. */
+export interface CleanOptions {
+    /** Called after each step completes, so that a caller can report it before a later override runs or fails. */
+    onProgress?: (progress: CleanProgress) => void;
+    /** The stream to which a package's own `clean` override writes its errors. */
+    stderr: Writable;
+    /** The stream to which a package's own `clean` override writes its output. */
+    stdout: Writable;
+}
+/**
+ * Cleans the package containing `cwd`, or every workspace package when run from the monorepo root.
+ *
+ * From within a package this is the built-in clean itself: `nmr` has already resolved `clean` to `nmr-clean`
+ * before invoking it, so resolving again would apply the package's own override twice.
+ */
+export declare function cleanFrom(cwd: string, options: CleanOptions): Promise<CleanOutcome>;
 /**
  * Removes a package's build output and the build-cache entries that describe it, so the package does not keep
  * any state that would make the next build skip. Removal is idempotent: An already-clean package is a silent
  * no-op.
  */
-export declare function cleanPackage(packageDir: string, style: OutputStyle): Promise<void>;
+export declare function cleanPackage(packageDir: string): Promise<void>;
 /**
- * Cleans the package containing `cwd`, or every workspace package when run from the monorepo root.
- *
- * From within a package this is the built-in clean itself: `nmr` has already resolved `clean` to this bin
- * before invoking it, so resolving again would apply the package's own override twice.
+ * Runs `nmr-clean` against `argv` from `cwd` and returns the exit code to report. The command takes neither an
+ * option nor an operand, so anything but `--help` is a usage error and removes nothing.
  *
  * This is the default `clean` script, and it is published as a bin because, under pnpm's isolated layout,
  * `pnpm exec` resolves only the bins of the consuming project's direct dependencies: pnpm links nmr's own bins
  * into the consumer's `node_modules/.bin`, but not the bins of nmr's dependencies.
  */
-export declare function runClean(cwd: string, style: OutputStyle): Promise<void>;
+export declare function runClean(argv: string[], cwd: string): Promise<number>;

package/dist/esm/commands/clean.js

@@ -1,59 +1,81 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
-import { formatGlyphLine, UserError } from '@williamthorsen/nmr-core';
+import process from 'node:process';
+import { UserError } from '@williamthorsen/nmr-core';
+import { defineCommand, runCli } from '@williamthorsen/nmr-core/cli';
 import { NMR_CLEAN_BIN } from "../bins.js";
-import { removeCheckCache } from "../check-cache-entries.js";
+import { removeCheckCache } from "../check-cache/check-cache-entries.js";
 import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
-import { NMR_GLYPHS } from "../glyphs.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { resolveChannel } from "../output-channel.js";
+import { resolveBinStyles } from "../resolveBinStyles.js";
 import { buildWorkspaceRegistry, resolveScript } from "../resolver.js";
 import { runCommand } from "../runner.js";
 import { renderChain } from "../steps.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
 import { resolveBuildCachePath, resolveEmitDurationPath } from "./build-output.js";
+import { renderCleanOutcome, renderCleanProgress } from "./clean-report.js";
 const CLEAN_COMMAND = 'clean';
 const BUILT_IN_CLEAN = 'nmr-clean';
 const OUTPUT_ROOT = 'dist';
-export async function cleanPackage(packageDir, style) {
-    await rm(path.resolve(packageDir, OUTPUT_ROOT), { recursive: true, force: true });
-    await rm(resolveBuildCachePath(packageDir), { force: true });
-    await rm(resolveEmitDurationPath(packageDir), { force: true });
-    console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', `${path.basename(packageDir)}: Removed build output and cache.`));
-}
-export async function runClean(cwd, style) {
+export async function cleanFrom(cwd, options) {
     let monorepoRoot;
     try {
         monorepoRoot = findMonorepoRoot(cwd);
     }
     catch {
-        await clearCheckCache(cwd, style);
-        await cleanPackage(cwd, style);
-        return;
+        await clearCheckCache(cwd, options);
+        await cleanReportedPackage(cwd, options);
+        return { kind: 'package', checkResultsDir: cwd, packageDir: cwd };
     }
-    await clearCheckCache(monorepoRoot, style);
+    await clearCheckCache(monorepoRoot, options);
     const workspacePackageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packageDir = findContainingPackageDir(cwd, workspacePackageDirs);
     if (packageDir !== undefined) {
-        await cleanPackage(packageDir, style);
-        return;
+        await cleanReportedPackage(packageDir, options);
+        return { kind: 'package', checkResultsDir: monorepoRoot, packageDir };
     }
-    await sweepWorkspace(monorepoRoot, workspacePackageDirs, style);
+    return sweepWorkspace(monorepoRoot, workspacePackageDirs, options);
 }
-async function clearCheckCache(scopeDir, style) {
-    await removeCheckCache(scopeDir);
-    console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', 'Removed all recorded check results.'));
+export async function cleanPackage(packageDir) {
+    await rm(path.resolve(packageDir, OUTPUT_ROOT), { recursive: true, force: true });
+    await rm(resolveBuildCachePath(packageDir), { force: true });
+    await rm(resolveEmitDurationPath(packageDir), { force: true });
+}
+export async function runClean(argv, cwd) {
+    const command = defineCommand({
+        summary: 'Remove the build output and build cache of this package, or of every package from the monorepo root',
+        run: async () => {
+            const style = resolveBinStyles().stdout;
+            const outcome = await cleanFrom(cwd, {
+                onProgress: (progress) => {
+                    console.info(renderCleanProgress(progress, style));
+                },
+                stderr: process.stderr,
+                stdout: process.stdout,
+            });
+            const closing = renderCleanOutcome(outcome, style);
+            if (closing !== undefined) {
+                reportClosing(closing);
+            }
+            return 0;
+        },
+    });
+    return runCli(argv, command, { name: NMR_CLEAN_BIN, stdout: process.stdout, stderr: process.stderr, baseDir: cwd });
 }
-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 cleanReportedPackage(packageDir, options) {
+    await cleanPackage(packageDir);
+    options.onProgress?.({ kind: 'package-cleaned', packageDir });
+}
+async function clearCheckCache(scopeDir, options) {
+    await removeCheckCache(scopeDir);
+    options.onProgress?.({ kind: 'check-results-removed' });
 }
-async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
+async function sweepWorkspace(monorepoRoot, workspacePackageDirs, options) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
-    let cleanedCount = 0;
+    const cleanedDirs = [];
     let skippedCount = 0;
     for (const packageDir of workspacePackageDirs) {
         const resolvedScript = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
@@ -63,18 +85,20 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
-            await cleanPackage(packageDir, style);
-            cleanedCount++;
+            await cleanReportedPackage(packageDir, options);
+            cleanedDirs.push(packageDir);
             continue;
         }
         const { exitCode } = await runCommand(resolvedCommand, packageDir, {
             bin: NMR_CLEAN_BIN,
-            channels: { stderr: resolveChannel(process.stderr, false), stdout: resolveChannel(process.stdout, false) },
+            channels: { stderr: resolveChannel(options.stderr, false), stdout: resolveChannel(options.stdout, false) },
+            stderr: options.stderr,
+            stdout: options.stdout,
         });
         if (exitCode !== 0) {
             throw new UserError(`\`${resolvedCommand}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }
-        cleanedCount++;
+        cleanedDirs.push(packageDir);
     }
-    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleanedCount, skippedCount)));
+    return { kind: 'sweep', checkResultsDir: monorepoRoot, cleanedDirs, skippedCount };
 }

package/dist/esm/commands/compile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runs `nmr-compile` against `argv` for the package at `packageDir` and returns the exit code to report. The command
+ * takes neither an option nor an operand, so anything but `--help` is a usage error and compiles nothing.
+ */
+export declare function runCompile(argv: string[], packageDir: string): Promise<number>;

package/dist/esm/commands/compile.js

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import process from 'node:process';
+import { defineCommand, runCli } from '@williamthorsen/nmr-core/cli';
+import { NMR_COMPILE_BIN } from "../bins.js";
+import { loadWorkspaceConfig } from "../config.js";
+import { resolveBinStyles } from "../resolveBinStyles.js";
+import { buildPackage } from "./build.js";
+import { renderBuildOutcome, renderBuildProgress } from "./build-report.js";
+export async function runCompile(argv, packageDir) {
+    const command = defineCommand({
+        summary: "Compile the package's src tree to dist/esm",
+        run: async () => {
+            const { stdout } = resolveBinStyles();
+            const { build } = await loadWorkspaceConfig(packageDir);
+            const packageName = path.basename(packageDir);
+            const outcome = await buildPackage(packageDir, {
+                onProgress: (progress) => {
+                    console.info(renderBuildProgress(progress, packageName, stdout));
+                },
+                ...(build?.extraIgnorePatterns !== undefined && { extraIgnorePatterns: build.extraIgnorePatterns }),
+            });
+            console.info(renderBuildOutcome(outcome, packageName, stdout));
+            return 0;
+        },
+    });
+    return runCli(argv, command, {
+        name: NMR_COMPILE_BIN,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        baseDir: packageDir,
+    });
+}

package/dist/esm/commands/fmt-cache.js

@@ -2,7 +2,8 @@ import { createHash } from 'node:crypto';
 import { mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { NO_CACHE_ENV_VAR } from "../check-cache.js";
+import { NO_CACHE_ENV_VAR } from "../check-cache/check-cache.js";
+import { isEnvSwitchOn } from "../env-switch.js";
 export const FMT_CACHE_DIRECTORY = path.join('node_modules', '.cache', 'prettier', 'nmr-fmt');
 const LOCKFILE_NAMES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'bun.lock', 'bun.lockb'];
 const NO_LOCKFILE_MARKER = 'nolock';
@@ -10,7 +11,7 @@ const HASH_LENGTH = 16;
 const CACHE_FILE_PATTERN = /^([0-9a-f]{16})\.([0-9a-f]{16}|nolock)\.json$/;
 export function prepareFmtCache(options) {
     const { cwd, env, repositoryRoot, shouldBypassCache } = options;
-    if (shouldBypassCache || env[NO_CACHE_ENV_VAR] === '1')
+    if (shouldBypassCache || isEnvSwitchOn(env, NO_CACHE_ENV_VAR))
         return { kind: 'uncached' };
     try {
         if (statSync(path.join(repositoryRoot, 'node_modules'), { throwIfNoEntry: false })?.isDirectory() !== true) {

package/dist/esm/commands/fmt.d.ts

@@ -1,15 +1,17 @@
+import { type SpawnInherited } from './spawn-inherited.js';
 export type FormatMode = 'check' | 'write';
 /**
  * Runs `nmr-fmt` against `argv` and returns the exit code to report: It formats or checks the files that git
  * reports for `cwd`. A repository without a Prettier config of its own is formatted with the house config. The run
- * uses Prettier's content-keyed cache unless `--no-cache` or `NMR_NO_CACHE=1` bypasses it.
+ * uses Prettier's content-keyed cache unless `--no-cache` or `NMR_NO_CACHE=1` bypasses it, and an `NMR_NO_CACHE`
+ * that is neither on nor off is rejected as a usage error.
  *
  * Trailing arguments are git pathspecs, not Prettier flags; an unrecognized option is rejected rather
  * than passed along, since git would read it as a pathspec matching nothing and the run would report
  * success over an empty selection. Every argument after `--` is a pathspec, even one that starts
  * with `-`.
  */
-export declare function runFmt(argv: string[], cwd?: string): Promise<number>;
+export declare function runFmt(argv: string[], cwd?: string, env?: NodeJS.ProcessEnv): Promise<number>;
 /** @internal */
 export interface RunPrettierOptions {
     cliPath: string;
@@ -23,6 +25,8 @@ export interface RunPrettierOptions {
     cwd: string;
     /** Overridable so that the multi-batch path is reachable without a fixture that hits the real ceiling. */
     budgetBytes?: number;
+    /** Runs the Prettier CLI on the caller's stdio. */
+    spawn?: SpawnInherited;
 }
 /**
  * Runs Prettier over the selection, returning the first non-zero exit code. Every batch runs even after

package/dist/esm/commands/fmt.js

@@ -1,6 +1,4 @@
 import { Buffer } from 'node:buffer';
-import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import process from 'node:process';
@@ -9,8 +7,12 @@ import { isRecord, reportError } from '@williamthorsen/nmr-core';
 import { defineCommand, runCli, UsageError } from '@williamthorsen/nmr-core/cli';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { NMR_FMT_BIN } from "../bins.js";
+import { NO_CACHE_ENV_VAR } from "../check-cache/check-cache.js";
+import { readEnvSwitch } from "../env-switch.js";
 import { prepareFmtCache } from "./fmt-cache.js";
 import { resolveFormatTargets } from "./format-targets.js";
+import { BROKEN_MANIFEST_FIX, findPackageManifest, resolveDeclaredCli, } from "./package-manifest.js";
+import { resolveInheritedExitCode, spawnInherited } from "./spawn-inherited.js";
 const PRETTIER_PACKAGE = 'prettier';
 const DEFAULT_CONFIG_PATH = fileURLToPath(new URL(`../prettier-default.config${path.extname(fileURLToPath(import.meta.url))}`, import.meta.url));
 const ARGUMENT_BUDGET_BYTES = 100_000;
@@ -18,7 +20,7 @@ const MODE_ARGS = {
     check: ['--check'],
     write: ['--list-different', '--write'],
 };
-export async function runFmt(argv, cwd = process.cwd()) {
+export async function runFmt(argv, cwd = process.cwd(), env = process.env) {
     const command = defineCommand({
         summary: 'Format or check the files that git lists',
         flags: {
@@ -31,12 +33,20 @@ export async function runFmt(argv, cwd = process.cwd()) {
             if (flags.check === flags.write) {
                 throw new UsageError(flags.check ? 'Pass --check or --write, not both.' : 'Pass --check or --write.');
             }
-            return formatFiles({ mode: flags.check ? 'check' : 'write', pathspecs: operands.pathspec, shouldBypassCache: flags.noCache }, cwd);
+            const noCache = readEnvSwitch(env, NO_CACHE_ENV_VAR);
+            if (!noCache.ok) {
+                throw new UsageError(noCache.error);
+            }
+            return formatFiles({
+                mode: flags.check ? 'check' : 'write',
+                pathspecs: operands.pathspec,
+                shouldBypassCache: flags.noCache || noCache.isOn,
+            }, cwd, env);
         },
     });
     return runCli(argv, command, { name: NMR_FMT_BIN, stdout: process.stdout, stderr: process.stderr, baseDir: cwd });
 }
-async function formatFiles(request, cwd) {
+async function formatFiles(request, cwd, env) {
     const resolvedTargets = resolveFormatTargets(cwd, request.pathspecs);
     if (!resolvedTargets.ok) {
         reportError(NMR_FMT_BIN, resolvedTargets.error);
@@ -70,7 +80,7 @@ async function formatFiles(request, cwd) {
     }
     const cache = prepareFmtCache({
         cwd,
-        env: process.env,
+        env,
         repositoryRoot,
         shouldBypassCache: request.shouldBypassCache,
     });
@@ -92,17 +102,36 @@ function resolvePrettierCli(cwd) {
         ok: false,
         error: `\`${PRETTIER_PACKAGE}\` could not be resolved from this repository or from nmr's own installation, which declares it as a dependency. Reinstall \`@williamthorsen/nmr\`.`,
     };
-    const manifestPath = resolveFrom(path.join(cwd, 'package.json'), `${PRETTIER_PACKAGE}/package.json`) ??
-        resolveFrom(import.meta.url, `${PRETTIER_PACKAGE}/package.json`);
-    if (manifestPath === undefined)
-        return missingResult;
-    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    if (!isRecord(manifest))
-        return missingResult;
-    const bin = isRecord(manifest['bin']) ? manifest['bin'][PRETTIER_PACKAGE] : manifest['bin'];
-    if (typeof bin !== 'string')
+    const repositoryLookup = findPackageManifest(path.join(cwd, 'package.json'), PRETTIER_PACKAGE);
+    const copy = repositoryLookup.kind === 'absent'
+        ? {
+            lookup: findPackageManifest(import.meta.url, PRETTIER_PACKAGE),
+            origin: "nmr's installation",
+            reinstallStep: 'Reinstall `@williamthorsen/nmr`.',
+        }
+        : {
+            lookup: repositoryLookup,
+            origin: 'this repository',
+            reinstallStep: `Reinstall this repository's \`${PRETTIER_PACKAGE}\` dependency.`,
+        };
+    const { lookup } = copy;
+    if (lookup.kind === 'absent')
         return missingResult;
-    return { ok: true, cliPath: path.resolve(path.dirname(manifestPath), bin), manifestPath };
+    if (lookup.kind === 'broken') {
+        return {
+            ok: false,
+            error: `\`${PRETTIER_PACKAGE}\` could not be loaded from ${copy.origin}: ${lookup.cause}. ${BROKEN_MANIFEST_FIX}`,
+        };
+    }
+    const { manifest, manifestPath } = lookup;
+    const cliPath = resolveDeclaredCli(manifest, manifestPath, PRETTIER_PACKAGE);
+    if (cliPath === undefined) {
+        return {
+            ok: false,
+            error: `\`${PRETTIER_PACKAGE}\` at ${path.dirname(manifestPath)} does not declare a CLI. ${copy.reinstallStep}`,
+        };
+    }
+    return { ok: true, cliPath, manifestPath };
 }
 async function findRepositoryConfig(manifestPath, cwd) {
     try {
@@ -122,7 +151,7 @@ async function findRepositoryConfig(manifestPath, cwd) {
     }
 }
 export function runPrettier(options) {
-    const { cacheLocation, cliPath, configPath, mode, files, ignorePaths, cwd, budgetBytes = ARGUMENT_BUDGET_BYTES, } = options;
+    const { cacheLocation, cliPath, configPath, mode, files, ignorePaths, cwd, budgetBytes = ARGUMENT_BUDGET_BYTES, spawn = spawnInherited, } = options;
     const prettierArgs = [
         cliPath,
         ...(configPath === undefined ? [] : ['--config', configPath]),
@@ -136,12 +165,12 @@ export function runPrettier(options) {
     ];
     let firstFailureStatus = 0;
     for (const batch of batchWithinBudget(files, budgetBytes)) {
-        const result = spawnSync(process.execPath, [...prettierArgs, ...batch], { cwd, stdio: 'inherit' });
+        const result = spawn(process.execPath, [...prettierArgs, ...batch], { cwd });
         if (result.error) {
             reportError(NMR_FMT_BIN, `could not run \`${PRETTIER_PACKAGE}\` (${result.error.message}).`);
             return 1;
         }
-        const status = result.status ?? 1;
+        const status = resolveInheritedExitCode(result);
         if (status !== 0 && firstFailureStatus === 0) {
             firstFailureStatus = status;
         }
@@ -166,11 +195,3 @@ function batchWithinBudget(files, budgetBytes) {
         batches.push(batch);
     return batches;
 }
-function resolveFrom(parent, specifier) {
-    try {
-        return createRequire(parent).resolve(specifier);
-    }
-    catch {
-        return undefined;
-    }
-}