@williamthorsen/nmr 0.38.0 → 0.40.0

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.d.ts

@@ -1,14 +1,13 @@
-/** Marks a value that was cut, so a reader can tell a truncated one from a complete one. */
+/** Marks a value that was cut, so that a reader can tell a truncated one from a complete one. */
 export declare const TRUNCATION_MARK = "\u2026";
 /**
  * Cuts a string that would overrun a byte budget, marking the cut. What comes back is at most `budgetBytes`
  * long, the mark included.
  *
  * Cuts between code points rather than between bytes, so a multi-byte character is never left in halves.
- * Graphemes are left unconsidered, which can separate an emoji from a modifier following it -- a cost paid
- * only at a budget no caller here comes near.
+ * Graphemes are left unconsidered, which can separate an emoji from a modifier following it -- a risk only
+ * at a budget that the callers here never come near.
  *
- * A budget too small to hold the mark yields nothing at all, rather than a return that overruns what the
- * caller asked for.
+ * The return never exceeds the budget: A budget too small to hold the mark yields an empty string.
  */
 export declare function clampToBytes(value: string, budgetBytes: number): string;

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/config-path.d.ts

@@ -2,7 +2,5 @@
 export declare const CONFIG_RELATIVE_PATH: string;
 /**
  * Resolves the config-file path for a directory, whether that is the monorepo root or a package.
- * Callers that only need to know whether a config exists -- the build, which folds it into its cache digest -- go
- * through this rather than spelling the path again, so that the two cannot drift into hashing a file nothing reads.
  */
 export declare function resolveConfigPath(baseDir: string): string;

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

@@ -6,11 +6,11 @@ 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.
- * Both ends are kept because a failing command's first error and its trailing summary each carry signal
+ * Creates an accumulator that retains the first and last bytes that it is fed and drops the middle.
+ * Both ends are kept because a failing command's first error and its trailing summary each contain information
  * that the other end does not.
  */
 export declare function createBoundedBuffer(options?: BoundedBufferOptions): BoundedBuffer;

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/deriveExcerpt.d.ts

@@ -1,11 +1,10 @@
 /**
- * Reduces a transcript to the one line a verdict's detail slot carries, or `undefined` when it held nothing.
+ * Reduces a transcript to the one line shown in a verdict's detail slot, or `undefined` when it contained nothing.
  *
  * The excerpt is the last blank-line-delimited block: a tool that prints progress separates its closing
- * statement with a blank line, so the blank line is the tool naming where its summary starts. A fixed count of
- * trailing lines fits vitest's four-line summary and v8's six-line coverage summary only by coincidence.
+ * statement with a blank line, and that blank line is the tool's own mark of where its summary starts.
  *
- * The line carries a byte bound of its own, so what a caller persists is bounded. The 512-byte ceiling a
- * verdict line is held to is not applied here, which leaves that line's grammar with the module that owns it.
+ * The line is bounded by `MAX_EXCERPT_BYTES` alone; the ceiling on a verdict line is applied where that line is
+ * composed.
  */
 export declare function deriveExcerpt(transcript: string): string | undefined;

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

@@ -1,17 +1,16 @@
 /**
- * Renders a duration at the two coarsest units that say something, for a line a reader skims.
+ * Renders a duration at the two coarsest units that say something, for a line that a reader skims.
  *
- * Truncates at every unit rather than rounding, so a value never reads as more time than elapsed: 90 seconds is
- * `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`.
+ * Truncates at every unit rather than rounding, so that a value never reads as more time than elapsed: 119.9
+ * seconds is `1m 59s`, whereas 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 is rendered without the `.0`, as
+ * `12s` rather than `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
- * rather than printing a saving of `~0s`.
+ * Renders the clause stating the time that a skip saved, or `undefined` for a saving under a second.
  *
- * 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`.
+ * A non-finite duration also returns `undefined`: It compares false against the threshold and would otherwise
+ * render as `saved ~NaNs`.
  */
-export declare function formatSaving(milliseconds: number): string | undefined;
+export declare function formatSaving(durationMs: number): string | undefined;

package/dist/esm/helpers/duration.js

@@ -1,5 +1,5 @@
-export function formatDuration(milliseconds) {
-    const total = Math.max(0, milliseconds);
+export function formatDuration(durationMs) {
+    const total = Math.max(0, durationMs);
     if (total < MILLISECONDS_PER_MINUTE) {
         return `${truncateToTenth(total)}s`;
     }
@@ -10,11 +10,11 @@ export function formatDuration(milliseconds) {
     }
     return joinUnits(`${Math.floor(totalMinutes / MINUTES_PER_HOUR)}h`, totalMinutes % MINUTES_PER_HOUR, 'm');
 }
-export function formatSaving(milliseconds) {
-    if (!Number.isFinite(milliseconds) || milliseconds < MILLISECONDS_PER_SECOND) {
+export function formatSaving(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < MILLISECONDS_PER_SECOND) {
         return undefined;
     }
-    return `saved ~${formatDuration(milliseconds)}`;
+    return `saved ~${formatDuration(durationMs)}`;
 }
 const MILLISECONDS_PER_MINUTE = 60_000;
 const MILLISECONDS_PER_SECOND = 1_000;
@@ -23,6 +23,6 @@ const SECONDS_PER_MINUTE = 60;
 function joinUnits(major, minor, minorUnit) {
     return minor === 0 ? major : `${major} ${minor}${minorUnit}`;
 }
-function truncateToTenth(milliseconds) {
-    return Math.floor(milliseconds / 100) / 10;
+function truncateToTenth(durationMs) {
+    return Math.floor(durationMs / 100) / 10;
 }

package/dist/esm/helpers/filter-selection.d.ts

@@ -1,40 +1,40 @@
 /**
- * Asks pnpm what a `-F` pattern selects, so an invocation that would select nothing is caught before it
- * delegates, and one selecting several packages is told from one selecting a single package.
+ * Asks pnpm what a `-F` pattern selects, so that an invocation that would select nothing is caught before it
+ * delegates, and one selecting several packages is distinguished from one selecting a single package.
  *
- * pnpm's own selector answers rather than a matcher of nmr's: `-F` means the whole selector language, names
- * and globs alongside `./path`, `{dir}`, `pkg...`, `!negation`, and `[since]`, and a matcher here would leave
- * every form but the simplest silently unchecked.
+ * pnpm answers because `-F` accepts pnpm's whole selector language: names and globs alongside `./path`, `{dir}`,
+ * `pkg...`, `!negation`, and `[since]`.
  *
- * Runs from the monorepo root, where the delegate runs, so a path pattern resolves against the same directory
- * in the probe as in the run it stands in for.
+ * Runs from the monorepo root, where the delegate runs, so that a path pattern resolves against the same
+ * directory in the probe as in the run that it stands in for.
  *
- * The listing counts the root project wherever the filter leaves it standing, while the `exec` a delegation
- * composes runs there only where the pattern selects the root positively: `-F '!./packages/*'` lists the root
- * and executes nowhere. A listing of the root alone is therefore the one reading the listing cannot settle,
- * and it is put to `exec` itself. Every other listing settles on its own, and counts the packages beside the
- * root: two of them run in two scopes, while one beside the root may run in that package alone.
+ * The listing counts the root project wherever the filter does not exclude it, while the `exec` that a
+ * delegation composes runs there only when the pattern selects the root positively: `-F '!./packages/*'` lists
+ * the root and executes nowhere. A listing of the root alone is therefore the one reading that the listing
+ * cannot settle, and that reading is checked against `exec` itself. Every other listing settles on its own, and
+ * counts the packages beside the root: two of them run in two scopes, while one beside the root may run in that
+ * package alone.
  */
 export declare function readFilterSelection(pattern: string, monorepoRoot: string): FilterSelection;
 /**
  * Reduces a listing to what it proves about the selection.
  *
- * Every outcome the probe cannot read resolves to `unresolved`, which claims nothing about the selection, and the
- * invocation delegates as it would have. A pattern pnpm rejects rather than resolves, such as a bad git ref in
- * a changed-since selector, is pnpm's to report, and reporting it here as a match failure would name a
- * different fault than the one the user has.
+ * Every outcome that the probe cannot read resolves to `unresolved`, which claims nothing about the selection,
+ * and the invocation delegates as it would have. A pattern that pnpm rejects rather than resolves, such as a bad
+ * git ref in a changed-since selector, is pnpm's to report, and reporting it here as a match failure would name a
+ * different fault than the one that the user has.
  */
 export declare function interpretSelectionProbe(probe: SelectionProbe, monorepoRoot: string): ProbeReading;
 /**
- * Reduces a marked delegate run to what it proves: a scope that wrote the marker is a scope the run reached. The
- * run is made only for a listing of the root alone, so that scope is the only one.
+ * Reduces a marked delegate run to what it proves: a scope that wrote the marker is a scope that the run
+ * reached. Because the run is made only for a listing of the root alone, that scope is the only one.
  */
 export declare function interpretDelegateProbe(probe: SelectionProbe): FilterSelection;
 /** What a `-F` pattern selected, as far as pnpm could be asked. `multiple` is two or more packages beside the root. */
 export type FilterSelection = 'empty' | 'multiple' | 'single' | 'unresolved';
 /** What a listing proves, `root-only` being the reading that only the delegate can settle. */
 export type ProbeReading = FilterSelection | 'root-only';
-/** The part of a probe's completion a selection is read from. */
+/** The part of a probe's completion from which a selection is read. */
 export interface SelectionProbe {
     error: Error | undefined;
     status: number | null;

package/dist/esm/helpers/filter-selection.js

@@ -5,31 +5,31 @@ import process from 'node:process';
 import { isObject } from "./type-guards.js";
 const SELECTION_MARKER = 'nmr-selected-scope';
 export function readFilterSelection(pattern, monorepoRoot) {
-    const listing = spawnSync('pnpm', ['ls', '--filter', pattern, '--depth', '-1', '--json'], {
+    const listingRun = spawnSync('pnpm', ['ls', '--filter', pattern, '--depth', '-1', '--json'], {
         cwd: monorepoRoot,
         encoding: 'utf8',
     });
-    const reading = interpretSelectionProbe({ error: listing.error, status: listing.status, stdout: listing.stdout }, monorepoRoot);
-    return reading === 'root-only' ? readDelegateSelection(pattern, monorepoRoot) : reading;
+    const probeReading = interpretSelectionProbe({ error: listingRun.error, status: listingRun.status, stdout: listingRun.stdout }, monorepoRoot);
+    return probeReading === 'root-only' ? readDelegateSelection(pattern, monorepoRoot) : probeReading;
 }
 export function interpretSelectionProbe(probe, monorepoRoot) {
     if (probe.error !== undefined || probe.status !== 0) {
         return 'unresolved';
     }
-    let parsed;
+    let parsedListing;
     try {
-        parsed = JSON.parse(probe.stdout);
+        parsedListing = JSON.parse(probe.stdout);
     }
     catch {
         return 'unresolved';
     }
-    if (!Array.isArray(parsed)) {
+    if (!Array.isArray(parsedListing)) {
         return 'unresolved';
     }
-    if (parsed.length === 0) {
+    if (parsedListing.length === 0) {
         return 'empty';
     }
-    const packageCount = parsed.filter((entry) => !isRootEntry(entry, monorepoRoot)).length;
+    const packageCount = parsedListing.filter((entry) => !isRootEntry(entry, monorepoRoot)).length;
     if (packageCount === 0) {
         return 'root-only';
     }
@@ -45,9 +45,9 @@ function isRootEntry(entry, monorepoRoot) {
     if (!isObject(entry) || typeof entry['path'] !== 'string') {
         return false;
     }
-    return readRealPath(entry['path']) === readRealPath(monorepoRoot);
+    return resolveRealPath(entry['path']) === resolveRealPath(monorepoRoot);
 }
-function readRealPath(target) {
+function resolveRealPath(target) {
     try {
         return realpathSync(target);
     }
@@ -56,6 +56,6 @@ function readRealPath(target) {
     }
 }
 function readDelegateSelection(pattern, monorepoRoot) {
-    const probe = spawnSync('pnpm', ['--filter', pattern, 'exec', process.execPath, '--eval', `process.stdout.write('${SELECTION_MARKER}')`], { cwd: monorepoRoot, encoding: 'utf8' });
-    return interpretDelegateProbe({ error: probe.error, status: probe.status, stdout: probe.stdout });
+    const probeRun = spawnSync('pnpm', ['--filter', pattern, 'exec', process.execPath, '--eval', `process.stdout.write('${SELECTION_MARKER}')`], { cwd: monorepoRoot, encoding: 'utf8' });
+    return interpretDelegateProbe({ error: probeRun.error, status: probeRun.status, stdout: probeRun.stdout });
 }

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

@@ -1,5 +1,5 @@
 /**
- * Finds the candidate closest to a name, or `undefined` where none is near enough to be worth naming.
+ * Finds the candidate closest to a name, or `undefined` when none is near enough to be worth naming.
  *
  * The ceiling scales with the name's length, so a short name admits one slip and a long one a few. A fixed
  * ceiling would either miss a typo in `root:test:coverage` or offer `fix` for `ci`.

package/dist/esm/helpers/findClosestName.js

@@ -1,33 +1,33 @@
 export function findClosestName(name, candidates) {
     const ceiling = Math.max(1, Math.floor(name.length / 4));
-    let closest;
-    let shortest = Infinity;
+    let closestName;
+    let shortestDistance = Infinity;
     for (const candidate of candidates) {
         const distance = measureDistance(name, candidate);
-        if (distance < shortest) {
-            shortest = distance;
-            closest = candidate;
+        if (distance < shortestDistance) {
+            shortestDistance = distance;
+            closestName = candidate;
         }
     }
-    return shortest <= ceiling ? closest : undefined;
+    return shortestDistance <= ceiling ? closestName : undefined;
 }
 function measureDistance(first, second) {
     if (first.length === 0 || second.length === 0) {
         return Math.max(first.length, second.length);
     }
-    let previous = Array.from({ length: second.length + 1 }, (_unused, column) => column);
-    let current = Array.from({ length: second.length + 1 }, () => 0);
+    let previousRow = Array.from({ length: second.length + 1 }, (_unused, column) => column);
+    let currentRow = Array.from({ length: second.length + 1 }, () => 0);
     for (let row = 1; row <= first.length; row += 1) {
-        current[0] = row;
+        currentRow[0] = row;
         for (let column = 1; column <= second.length; column += 1) {
-            const substitution = readCell(previous, column - 1) + (first[row - 1] === second[column - 1] ? 0 : 1);
-            current[column] = Math.min(readCell(current, column - 1) + 1, readCell(previous, column) + 1, substitution);
+            const substitution = readCell(previousRow, column - 1) + (first[row - 1] === second[column - 1] ? 0 : 1);
+            currentRow[column] = Math.min(readCell(currentRow, column - 1) + 1, readCell(previousRow, column) + 1, substitution);
         }
-        const completed = current;
-        current = previous;
-        previous = completed;
+        const completedRow = currentRow;
+        currentRow = previousRow;
+        previousRow = completedRow;
     }
-    return readCell(previous, second.length);
+    return readCell(previousRow, second.length);
 }
 function readCell(row, index) {
     const value = row[index];

package/dist/esm/helpers/hook-name.d.ts

@@ -1,9 +1,6 @@
 /**
- * Returns true when `key` is a hook script name — that is, ends with the
- * `:pre` or `:post` suffix preceded by at least one character.
+ * Reports whether `key` is a hook script name: a `:pre` or `:post` suffix preceded by at least one character.
  *
- * Bare `:pre` and `:post` (no parent name) return false. The predicate is
- * purely about suffix shape; it does not consult the registry or care
- * whether the parent command exists.
+ * Reads the suffix alone, without consulting the registry for the parent command.
  */
 export declare function isHookName(key: string): boolean;

package/dist/esm/helpers/package-json.d.ts

@@ -1,8 +1,8 @@
 /**
- * The `package.json` fields that carry a dependency's version specifier.
+ * The `package.json` fields that contain a dependency's version specifier.
  *
  * pnpm accepts the `catalog:` protocol in all four, so a reader looking for catalogued dependencies has to
- * sweep the whole set rather than the two that carry most of them.
+ * sweep the whole set rather than the two that contain most of them.
  */
 export declare const DEPENDENCY_FIELDS: readonly ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
 export type DependencyField = (typeof DEPENDENCY_FIELDS)[number];
@@ -19,26 +19,27 @@ export type PackageJson = {
     [K in DependencyField]?: Record<string, string>;
 };
 /**
- * Reads and parses the package.json at the given directory, keeping only the fields nmr reads.
+ * Reads and parses the package.json at the given directory, keeping only the fields that nmr reads.
  */
 export declare function readPackageJson(dir: string): PackageJson;
 /**
- * Returns the `pnpm.overrides` block a package.json declares, every key it holds and each value as written.
+ * Returns the `pnpm.overrides` block declared by a package.json, every key that it contains and each value as
+ * written.
  */
-export declare function getPnpmOverrides(pkg: PackageJson): Record<string, unknown> | undefined;
+export declare function getPnpmOverrides(packageJson: PackageJson): Record<string, unknown> | undefined;
 /**
  * Parses a `package.json`'s text, rejecting what does not parse.
  *
- * A file the user wrote by hand is theirs to fix, so the failure names it rather than reporting the parser's
+ * A file that the user wrote by hand is theirs to fix, so the failure names it rather than reporting the parser's
  * own stack.
  */
-export declare function parsePackageJson(raw: string, file: string): unknown;
+export declare function parsePackageJson(rawText: string, file: string): unknown;
 /**
  * Narrows a `scripts` record to strings, rejecting any value that is not one.
  *
- * npm and pnpm read a script as a string too, so a value of any other type is malformed however it got there.
- * Dropping one silently would let a caller run something else in its place and report nothing.
+ * A value of any other type is malformed however it got there, because npm and pnpm read a script as a string
+ * too. Dropping one silently would let a caller run something else in its place and report nothing.
  */
 export declare function readScriptRecord(dir: string, scripts: Record<string, unknown>): Record<string, string>;
-/** Resolves the `package.json` path for a directory: the file tier-3 scripts are read from. */
+/** Resolves the `package.json` path for a directory: the file from which tier-3 scripts are read. */
 export declare function resolvePackageJsonPath(dir: string): string;

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

@@ -14,45 +14,46 @@ export const DEPENDENCY_FIELDS = [
 ];
 export function readPackageJson(dir) {
     const file = resolvePackageJsonPath(dir);
-    const parsed = parsePackageJson(readFileSync(file, 'utf8'), file);
-    if (!isObject(parsed)) {
+    const parsedManifest = parsePackageJson(readFileSync(file, 'utf8'), file);
+    if (!isObject(parsedManifest)) {
         throw new UserError(`Invalid package.json in ${dir}: expected an object`);
     }
-    const pkg = {};
-    if (typeof parsed['name'] === 'string')
-        pkg.name = parsed['name'];
-    if (parsed['private'] === true)
-        pkg.private = true;
-    if (typeof parsed['version'] === 'string')
-        pkg.version = parsed['version'];
-    if (typeof parsed['packageManager'] === 'string')
-        pkg.packageManager = parsed['packageManager'];
-    if (isObject(parsed['scripts'])) {
-        pkg.scripts = readScriptRecord(dir, parsed['scripts']);
+    const packageJson = {};
+    if (typeof parsedManifest['name'] === 'string')
+        packageJson.name = parsedManifest['name'];
+    if (parsedManifest['private'] === true)
+        packageJson.private = true;
+    if (typeof parsedManifest['version'] === 'string')
+        packageJson.version = parsedManifest['version'];
+    if (typeof parsedManifest['packageManager'] === 'string') {
+        packageJson.packageManager = parsedManifest['packageManager'];
     }
-    if (isObject(parsed['pnpm'])) {
-        const pnpm = parsed['pnpm'];
+    if (isObject(parsedManifest['scripts'])) {
+        packageJson.scripts = readScriptRecord(dir, parsedManifest['scripts']);
+    }
+    if (isObject(parsedManifest['pnpm'])) {
+        const pnpm = parsedManifest['pnpm'];
         if (isObject(pnpm['overrides'])) {
-            pkg.pnpm = { overrides: pnpm['overrides'] };
+            packageJson.pnpm = { overrides: pnpm['overrides'] };
         }
     }
     for (const field of DEPENDENCY_FIELDS) {
-        const declared = parsed[field];
-        if (isObject(declared)) {
-            pkg[field] = readStringValues(declared);
+        const declaredDependencies = parsedManifest[field];
+        if (isObject(declaredDependencies)) {
+            packageJson[field] = readStringValues(declaredDependencies);
         }
     }
-    return pkg;
+    return packageJson;
 }
-export function getPnpmOverrides(pkg) {
-    if (!isObject(pkg.pnpm))
+export function getPnpmOverrides(packageJson) {
+    if (!isObject(packageJson.pnpm))
         return undefined;
-    const overrides = pkg.pnpm.overrides;
+    const overrides = packageJson.pnpm.overrides;
     return isObject(overrides) ? overrides : undefined;
 }
-export function parsePackageJson(raw, file) {
+export function parsePackageJson(rawText, file) {
     try {
-        return JSON.parse(raw);
+        return JSON.parse(rawText);
     }
     catch (error) {
         throw new UserError(`Invalid package.json at ${file}: ${describeError(error)}`);

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

@@ -1,8 +1,7 @@
 /**
  * Keeps the entries whose value is a string, dropping the rest.
  *
- * A manifest reader that rejected the whole record over one bad value would report nothing about the entries
- * beside it, which for a reporter is silence where there is something to say. YAML's implicit typing makes
- * that easy to reach without malformed intent: an unquoted `18` parses as a number.
+ * Drops rather than rejects, so that one malformed value does not hide the entries beside it. YAML's implicit
+ * typing makes such a value easy to write: An unquoted `18` parses as a number.
  */
 export declare function readStringValues(record: Record<string, unknown>): Record<string, string>;

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

@@ -1,16 +1,15 @@
 /**
  * Reports the line that closes a bin's output, separated from the items above it by a blank line.
  *
- * A bin that prints one line per item leaves a reader who reaches the end holding whichever item happened to
- * be last. The convention this writes: the header says what the list is, and the closing statement says what
- * the run came to, so the count and the remedy live here rather than in the header. The blank line is what
- * makes the statement findable once the lines are flattened.
+ * When a bin prints one line per item, the last line that a reader sees is whichever item happened to be last.
+ * The convention that this implements: The header says what the list is, and the closing statement says what
+ * the run concluded, so the count and the remedy are stated here rather than in the header. The blank line makes
+ * the statement findable once the lines are flattened.
  *
- * The blank line rides in the same call as the statement, so the closer is one write and cannot be
- * interleaved. `log` is what puts the closer on the stream its items went to: a bin reporting to stderr
- * passes `console.warn`.
+ * The closer is one write and cannot be interleaved: The blank line goes in the same call as the statement.
+ * `log` writes the closer to the stream that its items went to: A bin reporting to stderr passes `console.warn`.
  *
- * A bin whose whole output is one or two statements about one subject has no items to be separated from, and
- * closes by printing plainly rather than through here.
+ * A bin whose whole output is one or two statements about one subject does not have any items to be separated
+ * from, and closes by printing plainly rather than through here.
  */
 export declare function reportClosing(message: string, log?: (line: string) => void): void;