@williamthorsen/nmr 0.38.0 → 0.39.0

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

@@ -25,14 +25,14 @@ 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.
  */
-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
  * 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.
  *

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

@@ -16,7 +16,7 @@ export declare const TRANSCRIPT_LIMIT_BYTES = 262144;
  * stderr on failure is the command's own output going to a stream that may be a terminal, and stripping its
  * color there would be a loss.
  */
-export declare function cleanTranscript(raw: string): string;
+export declare function cleanTranscript(rawText: string): string;
 /**
  * Composes what a pass persists from what its command wrote, or `undefined` where it wrote nothing worth
  * keeping.
@@ -25,6 +25,6 @@ export declare function cleanTranscript(raw: string): string;
  * failure: nmr reads each through a pipe of its own, so their true interleaving is not among the facts it
  * holds. A stream carrying nothing contributes neither content nor marker.
  */
-export declare function composeTranscript(retained: RetainedOutput): string | undefined;
+export declare function composeTranscript(retainedOutput: RetainedOutput): string | undefined;
 /** Renders the line that stands in for dropped bytes, in nmr's voice so it is not mistaken for the tool's. */
 export declare function formatElisionMarker(byteCount: number): string;

package/dist/esm/helpers/transcript.js

@@ -2,15 +2,15 @@ export const TRANSCRIPT_LIMIT_BYTES = 262_144;
 const ANSI_PATTERN = /\u{1B}(?:\[[\u{30}-\u{3F}]*[\u{20}-\u{2F}]*[\u{40}-\u{7E}]|\][^\u{7}\u{1B}]*(?:\u{7}|\u{1B}\\))/gu;
 const END_LIMIT_BYTES = TRANSCRIPT_LIMIT_BYTES / 2;
 const STREAM_MARKER = '\n… nmr: stderr …\n';
-export function cleanTranscript(raw) {
-    return raw
+export function cleanTranscript(rawText) {
+    return rawText
         .replaceAll(ANSI_PATTERN, '')
         .split('\n')
         .map((line) => renderCarriageReturns(line))
         .join('\n');
 }
-export function composeTranscript(retained) {
-    const streams = [retained.stdout, retained.stderr]
+export function composeTranscript(retainedOutput) {
+    const streams = [retainedOutput.stdout, retainedOutput.stderr]
         .map((stream) => cleanTranscript(stream.toString('utf8')))
         .filter((stream) => stream.trim() !== '');
     if (streams.length === 0) {
@@ -22,19 +22,19 @@ export function formatElisionMarker(byteCount) {
     const unit = byteCount === 1 ? 'byte' : 'bytes';
     return `\n… nmr elided ${byteCount.toLocaleString('en-US')} ${unit} …\n`;
 }
-function alignEnd(buffer, end) {
-    let aligned = Math.min(buffer.length, end);
-    while (aligned > 0 && isContinuationByte(buffer[aligned])) {
-        aligned--;
+function alignEnd(buffer, endOffset) {
+    let alignedOffset = Math.min(buffer.length, endOffset);
+    while (alignedOffset > 0 && isContinuationByte(buffer[alignedOffset])) {
+        alignedOffset--;
     }
-    return aligned;
+    return alignedOffset;
 }
-function alignStart(buffer, start) {
-    let aligned = Math.max(0, start);
-    while (aligned < buffer.length && isContinuationByte(buffer[aligned])) {
-        aligned++;
+function alignStart(buffer, startOffset) {
+    let alignedOffset = Math.max(0, startOffset);
+    while (alignedOffset < buffer.length && isContinuationByte(buffer[alignedOffset])) {
+        alignedOffset++;
     }
-    return aligned;
+    return alignedOffset;
 }
 function clampTranscript(transcript) {
     const buffer = Buffer.from(transcript, 'utf8');

package/dist/esm/prettier.js

@@ -57,23 +57,23 @@ export function definePrettierConfig(options = {}) {
 function buildShellPlugin() {
     return {
         ...shPlugin,
-        languages: shPlugin.languages.filter(isInferredLanguage).map(withoutExcludedFilenames),
+        languages: shPlugin.languages.filter(isInferredLanguage).map(dropExcludedFilenames),
     };
 }
 function isInferredLanguage(language) {
     return INFERRED_LANGUAGES.has(language.name);
 }
-function withoutExcludedFilenames(language) {
+function dropExcludedFilenames(language) {
     if (language.filenames === undefined)
         return language;
     return { ...language, filenames: language.filenames.filter((name) => !EXCLUDED_FILENAMES.has(name)) };
 }
 function assertNoReplacement(options) {
     if ('overrides' in options)
-        throw ownedKeyError('overrides', 'additionalOverrides');
+        throw buildOwnedKeyError('overrides', 'additionalOverrides');
     if ('plugins' in options)
-        throw ownedKeyError('plugins', 'additionalPlugins');
+        throw buildOwnedKeyError('plugins', 'additionalPlugins');
 }
-function ownedKeyError(key, seam) {
+function buildOwnedKeyError(key, seam) {
     return new TypeError(`definePrettierConfig: \`${key}\` is owned by this config. Use \`${seam}\` to append to it.`);
 }

package/dist/esm/recording.d.ts

@@ -28,12 +28,12 @@ export type KeyDifference = {
     ingredient: 'command-string';
 } | {
     ingredient: 'nmr-version';
-    current: string;
-    recorded: string;
+    currentVersion: string;
+    recordedVersion: string;
 } | {
     ingredient: 'node-version';
-    current: string;
-    recorded: string;
+    currentVersion: string;
+    recordedVersion: string;
 } | {
     ingredient: 'other';
 };
@@ -99,7 +99,7 @@ export declare function renderRefusal(options: {
 export declare function resolveRecording(options: {
     anchorDir: string;
     command: string;
-    current: RunIdentity;
+    currentIdentity: RunIdentity;
     isCacheable: boolean;
     key: string | undefined;
     monorepoRoot: string;

package/dist/esm/recording.js

@@ -27,7 +27,10 @@ export async function resolveRecording(options) {
     }
     const ageMs = Math.max(0, Date.now() - Date.parse(entry.recordedAt));
     if (entry.key !== options.key) {
-        return { ok: false, refusal: { kind: 'mismatched', ageMs, difference: findKeyDifference(entry, options.current) } };
+        return {
+            ok: false,
+            refusal: { kind: 'mismatched', ageMs, difference: findKeyDifference(entry, options.currentIdentity) },
+        };
     }
     const transcript = await readTranscript({ anchorDir, command, monorepoRoot });
     if (transcript === undefined && (entry.retention?.replay.length ?? 0) === 0) {
@@ -45,14 +48,14 @@ function describeDifference(difference) {
         case 'command-string':
             return 'over a command chain this is not';
         case 'nmr-version':
-            return `under nmr ${difference.recorded}, not ${difference.current}`;
+            return `under nmr ${difference.recordedVersion}, not ${difference.currentVersion}`;
         case 'node-version':
-            return `under Node ${difference.recorded}, not ${difference.current}`;
+            return `under Node ${difference.recordedVersion}, not ${difference.currentVersion}`;
         case 'other':
             return 'under an install or environment this run does not share';
         default: {
-            const unhandled = difference;
-            throw new Error(`Unhandled key difference: ${JSON.stringify(unhandled)}`);
+            const unhandledDifference = difference;
+            throw new Error(`Unhandled key difference: ${JSON.stringify(unhandledDifference)}`);
         }
     }
 }
@@ -69,23 +72,27 @@ function describeRefusal(command, refusal) {
         case 'no-output':
             return `the pass ${formatDuration(refusal.ageMs)} ago retained none, as a run printing nothing or writing to a terminal does`;
         default: {
-            const unhandled = refusal;
-            throw new Error(`Unhandled refusal: ${JSON.stringify(unhandled)}`);
+            const unhandledRefusal = refusal;
+            throw new Error(`Unhandled refusal: ${JSON.stringify(unhandledRefusal)}`);
         }
     }
 }
-function findKeyDifference(entry, current) {
-    if (current.treeHash !== undefined && entry.treeHash !== current.treeHash) {
+function findKeyDifference(entry, currentIdentity) {
+    if (currentIdentity.treeHash !== undefined && entry.treeHash !== currentIdentity.treeHash) {
         return { ingredient: 'tree' };
     }
-    if (entry.commandString !== current.commandString) {
+    if (entry.commandString !== currentIdentity.commandString) {
         return { ingredient: 'command-string' };
     }
-    if (entry.nmrVersion !== current.nmrVersion) {
-        return { ingredient: 'nmr-version', current: current.nmrVersion, recorded: entry.nmrVersion };
+    if (entry.nmrVersion !== currentIdentity.nmrVersion) {
+        return { ingredient: 'nmr-version', currentVersion: currentIdentity.nmrVersion, recordedVersion: entry.nmrVersion };
     }
-    if (entry.nodeVersion !== current.nodeVersion) {
-        return { ingredient: 'node-version', current: current.nodeVersion, recorded: entry.nodeVersion };
+    if (entry.nodeVersion !== currentIdentity.nodeVersion) {
+        return {
+            ingredient: 'node-version',
+            currentVersion: currentIdentity.nodeVersion,
+            recordedVersion: entry.nodeVersion,
+        };
     }
     return { ingredient: 'other' };
 }

package/dist/esm/report-format.d.ts

@@ -47,5 +47,5 @@ export type ReportFormatRead = {
 export declare function resolveReportFormat(options: ResolveReportFormatOptions): ReportFormat;
 export interface ResolveReportFormatOptions {
     envFormat: ReportFormat | undefined;
-    jsonFlag: boolean;
+    hasJsonFlag: boolean;
 }

package/dist/esm/report-format.js

@@ -6,20 +6,20 @@ export function isReportFormat(value) {
     return names.includes(value);
 }
 export function readReportFormatEnv(env) {
-    const raw = env[REPORT_FORMAT_ENV_VAR];
-    if (raw === undefined || raw === '') {
+    const rawValue = env[REPORT_FORMAT_ENV_VAR];
+    if (rawValue === undefined || rawValue === '') {
         return { ok: true };
     }
-    if (!isReportFormat(raw)) {
-        return { ok: false, error: formatReportFormatRejection(REPORT_FORMAT_ENV_VAR, raw) };
+    if (!isReportFormat(rawValue)) {
+        return { ok: false, error: formatReportFormatRejection(REPORT_FORMAT_ENV_VAR, rawValue) };
     }
-    return { ok: true, format: raw };
+    return { ok: true, format: rawValue };
 }
 export const REPORT_FORMAT_ENV_VAR = 'NMR_REPORT_FORMAT';
 export const REPORT_FORMATS = ['text', 'json'];
 export function resolveReportFormat(options) {
-    const { envFormat, jsonFlag } = options;
-    if (jsonFlag)
+    const { envFormat, hasJsonFlag } = options;
+    if (hasJsonFlag)
         return 'json';
     return envFormat ?? 'text';
 }

package/dist/esm/resolveBinStyles.js

@@ -3,14 +3,14 @@ import { describeInvalidOutputStyle } from '@williamthorsen/nmr-core';
 import { resolveOutputStyles } from "./output-style.js";
 import { UserError } from "./UserError.js";
 export function resolveBinStyles() {
-    const { invalid, styles } = resolveOutputStyles({
+    const { invalid: invalidStyle, styles } = resolveOutputStyles({
         env: process.env,
         flagValue: undefined,
         stderrIsTty: process.stderr.isTTY,
         stdoutIsTty: process.stdout.isTTY,
     });
-    if (invalid !== undefined) {
-        throw new UserError(describeInvalidOutputStyle(invalid));
+    if (invalidStyle !== undefined) {
+        throw new UserError(describeInvalidOutputStyle(invalidStyle));
     }
     return styles;
 }

package/dist/esm/resolver.d.ts

@@ -38,7 +38,7 @@ export interface ResolvedScript {
  * A bare string element and the `{ run }` spec compose the same step. The spec's only addition is the
  * declaration of what the step does with the invocation's trailing arguments, which position cannot carry.
  */
-export declare function expandScript(script: ScriptValue, workspaceRoot: boolean): readonly Step[];
+export declare function expandScript(script: ScriptValue, isWorkspaceRoot: boolean): readonly Step[];
 /**
  * Returns a description of a script for help output.
  */
@@ -87,4 +87,4 @@ export declare function isSelfReferential(script: string, commandName: string, p
  * Returns undefined if the command is not found in the registry. A package.json override of `""` (indicating
  * skip) resolves to a single opaque step carrying it, which renders back to the empty string.
  */
-export declare function resolveScript(commandName: string, registry: ScriptRegistry, packageDir: string | undefined, workspaceRoot: boolean): ResolvedScript | undefined;
+export declare function resolveScript(commandName: string, registry: ScriptRegistry, packageDir: string | undefined, isWorkspaceRoot: boolean): ResolvedScript | undefined;

package/dist/esm/resolver.js

@@ -12,13 +12,13 @@ export function applyDevBin(command, devBin, monorepoRoot) {
     }
     const spaceIndex = command.indexOf(' ');
     const firstToken = spaceIndex === -1 ? command : command.slice(0, spaceIndex);
-    const rest = spaceIndex === -1 ? '' : command.slice(spaceIndex);
+    const restOfCommand = spaceIndex === -1 ? '' : command.slice(spaceIndex);
     const replacement = devBin[firstToken];
     if (replacement === undefined) {
         return command;
     }
     const resolvedReplacement = resolveReplacementPaths(replacement, monorepoRoot);
-    return resolvedReplacement + rest;
+    return resolvedReplacement + restOfCommand;
 }
 export function applyDevBinToSteps(steps, devBin, monorepoRoot) {
     if (!devBin) {
@@ -40,13 +40,13 @@ function resolveReplacementPaths(replacement, monorepoRoot) {
     })
         .join(' ');
 }
-export function expandScript(script, workspaceRoot) {
+export function expandScript(script, isWorkspaceRoot) {
     if (typeof script === 'string') {
         return [{ kind: 'opaque', command: script }];
     }
     return script.map((element) => typeof element === 'string'
-        ? composeNmrStep(element, workspaceRoot)
-        : composeNmrStep(element.run, workspaceRoot, element.shouldDeclineArguments));
+        ? composeNmrStep(element, isWorkspaceRoot)
+        : composeNmrStep(element.run, isWorkspaceRoot, element.shouldDeclineArguments));
 }
 export function describeScript(script) {
     return typeof script === 'string' ? script : `[${script.map(describeElement).join(', ')}]`;
@@ -59,9 +59,9 @@ function describeElement(element) {
 }
 export function readPackageJsonScripts(packageDir) {
     const file = resolvePackageJsonPath(packageDir);
-    let raw;
+    let rawText;
     try {
-        raw = readFileSync(file, 'utf8');
+        rawText = readFileSync(file, 'utf8');
     }
     catch (error) {
         if (hasErrnoCode(error, 'ENOENT')) {
@@ -69,10 +69,10 @@ export function readPackageJsonScripts(packageDir) {
         }
         throw error;
     }
-    const parsed = parsePackageJson(raw, file);
-    if (!isObject(parsed))
+    const parsedManifest = parsePackageJson(rawText, file);
+    if (!isObject(parsedManifest))
         return undefined;
-    const scripts = parsed['scripts'];
+    const scripts = parsedManifest['scripts'];
     if (!isObject(scripts))
         return undefined;
     return readScriptRecord(packageDir, scripts);
@@ -108,15 +108,15 @@ export function findChainedSelfReference(packageDir, commandName) {
 export function isSelfReferential(script, commandName, packageDir) {
     return readSelfReference({ anchoredAtRoot: isMonorepoRoot(packageDir), commandName, script }) !== undefined;
 }
-export function resolveScript(commandName, registry, packageDir, workspaceRoot) {
+export function resolveScript(commandName, registry, packageDir, isWorkspaceRoot) {
     if (packageDir) {
         const pkgScripts = readPackageJsonScripts(packageDir);
         if (pkgScripts && Object.hasOwn(pkgScripts, commandName)) {
-            const override = pkgScripts[commandName];
-            if (override !== undefined && !isSelfReferential(override, commandName, packageDir)) {
+            const overrideCommand = pkgScripts[commandName];
+            if (overrideCommand !== undefined && !isSelfReferential(overrideCommand, commandName, packageDir)) {
                 return {
                     origin: { tier: 'package', file: resolvePackageJsonPath(packageDir), key: commandName },
-                    steps: [{ kind: 'opaque', command: override }],
+                    steps: [{ kind: 'opaque', command: overrideCommand }],
                 };
             }
         }
@@ -128,5 +128,5 @@ export function resolveScript(commandName, registry, packageDir, workspaceRoot)
     if (registryEntry === undefined) {
         return undefined;
     }
-    return { origin: { tier: 'registry', key: commandName }, steps: expandScript(registryEntry, workspaceRoot) };
+    return { origin: { tier: 'registry', key: commandName }, steps: expandScript(registryEntry, isWorkspaceRoot) };
 }