@williamthorsen/nmr 0.48.0 → 0.49.0

package/dist/esm/config-validation.js

@@ -0,0 +1,236 @@
+import { assertResolvableCheckCacheCommands } from "./config-check-cache.js";
+import { isObject, isStringRecord } from "./helpers/type-guards.js";
+import { findUnexpressibleToken } from "./steps.js";
+import { UserError } from "./UserError.js";
+import { formatVerbosityRejection, isCommandVerbosity } from "./verbosity.js";
+export const CONFIG_TIERS = {
+    root: {
+        label: 'a monorepo-root config',
+        honoredKeys: ['checkCache', 'delegate', 'devBin', 'output', 'rootScripts', 'selfHostedRunner', 'workspaceScripts'],
+        elsewhere: "the package's own config",
+    },
+    workspace: {
+        label: 'a package config',
+        honoredKeys: ['build'],
+        elsewhere: 'the monorepo-root config',
+    },
+};
+const RECOGNIZED_KEYS = [...CONFIG_TIERS.root.honoredKeys, ...CONFIG_TIERS.workspace.honoredKeys];
+const RECOGNIZED_BUILD_KEYS = ['extraIgnorePatterns'];
+const RECOGNIZED_CHECK_CACHE_KEYS = ['enabled', 'excludeCommands', 'extraCommands'];
+const RECOGNIZED_OUTPUT_KEYS = ['commandVerbosity', 'extraAgentEnvVars'];
+const RECOGNIZED_SELF_HOSTED_RUNNER_KEYS = ['exempt'];
+const RECOGNIZED_STEP_KEYS = ['run', 'shouldDeclineArguments', 'shouldRunInBackground'];
+const RETIRED_STEP_KEYS = new Map([['declinesArgs', 'shouldDeclineArguments']]);
+export function assertRecognizedKeys(value, recognizedKeys, configPath, prefix = '') {
+    const unrecognizedKeys = Object.keys(value).filter((key) => !recognizedKeys.includes(key));
+    if (unrecognizedKeys.length === 0) {
+        return;
+    }
+    throw new UserError(`Invalid nmr config at ${configPath}: unrecognized ${unrecognizedKeys.length === 1 ? 'key' : 'keys'} ` +
+        `${formatKeyList(unrecognizedKeys, prefix)}. Recognized: ${formatKeyList(recognizedKeys, prefix)}.`);
+}
+export function validateConfig(value, configPath, baseDir) {
+    if (!isObject(value)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: expected an object, got ${typeof value}`);
+    }
+    assertRecognizedKeys(value, RECOGNIZED_KEYS, configPath);
+    const config = {};
+    const build = validateBuildField(value, configPath);
+    if (build)
+        config.build = build;
+    const checkCache = validateCheckCacheField(value, configPath);
+    if (checkCache)
+        config.checkCache = checkCache;
+    if (value['delegate'] !== undefined)
+        config.delegate = validateDelegateField(value['delegate'], configPath);
+    const devBin = validateStringRecordField(value, 'devBin', configPath);
+    if (devBin)
+        config.devBin = devBin;
+    const output = validateOutputField(value, configPath);
+    if (output)
+        config.output = output;
+    const workspaceScripts = validateScriptField(value, 'workspaceScripts', configPath);
+    if (workspaceScripts)
+        config.workspaceScripts = workspaceScripts;
+    const rootScripts = validateScriptField(value, 'rootScripts', configPath);
+    if (rootScripts)
+        config.rootScripts = rootScripts;
+    const selfHostedRunner = validateSelfHostedRunnerField(value, configPath);
+    if (selfHostedRunner)
+        config.selfHostedRunner = selfHostedRunner;
+    assertResolvableCheckCacheCommands(config, configPath, baseDir);
+    return config;
+}
+function assertNoRetiredKeys(value, retiredKeys, configPath, prefix) {
+    for (const key of Object.keys(value)) {
+        const replacement = retiredKeys.get(key);
+        if (replacement === undefined)
+            continue;
+        throw new UserError(`Invalid nmr config at ${configPath}: \`${prefix}${key}\` was renamed to \`${prefix}${replacement}\`.`);
+    }
+}
+function assertValidElements(scripts, fieldName, configPath) {
+    for (const [command, script] of Object.entries(scripts)) {
+        if (typeof script === 'string')
+            continue;
+        for (const spec of script) {
+            if (typeof spec !== 'string') {
+                assertNoRetiredKeys(spec, RETIRED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
+                assertRecognizedKeys(spec, RECOGNIZED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
+            }
+            const element = typeof spec === 'string' ? spec : spec.run;
+            const token = findUnexpressibleToken(element);
+            if (token === undefined)
+                continue;
+            throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}.${command}\` element \`${element}\` contains ` +
+                `\`${token}\`, which is neither a command name nor an nmr flag. Name it as a script of its own and ` +
+                `reference that name here.`);
+        }
+    }
+}
+function formatKeyList(keys, prefix) {
+    return keys
+        .toSorted()
+        .map((key) => `\`${prefix}${key}\``)
+        .join(', ');
+}
+function isOptionalBoolean(value) {
+    return value === undefined || typeof value === 'boolean';
+}
+function isScriptRecord(value) {
+    if (!isObject(value))
+        return false;
+    for (const v of Object.values(value)) {
+        if (typeof v === 'string')
+            continue;
+        if (!Array.isArray(v) || !v.every(isScriptElement))
+            return false;
+    }
+    return true;
+}
+function isScriptElement(value) {
+    if (typeof value === 'string')
+        return true;
+    if (!isObject(value) || typeof value['run'] !== 'string')
+        return false;
+    return isOptionalBoolean(value['shouldDeclineArguments']) && isOptionalBoolean(value['shouldRunInBackground']);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function validateBuildField(value, configPath) {
+    const build = value['build'];
+    if (build === undefined) {
+        return undefined;
+    }
+    if (!isObject(build)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`build\` must be an object`);
+    }
+    assertRecognizedKeys(build, RECOGNIZED_BUILD_KEYS, configPath, 'build.');
+    const extraIgnorePatterns = build['extraIgnorePatterns'];
+    if (extraIgnorePatterns !== undefined && !isStringArray(extraIgnorePatterns)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`build.extraIgnorePatterns\` must be a string[]`);
+    }
+    return extraIgnorePatterns === undefined ? {} : { extraIgnorePatterns };
+}
+function validateCheckCacheField(value, configPath) {
+    const checkCache = value['checkCache'];
+    if (checkCache === undefined) {
+        return undefined;
+    }
+    if (!isObject(checkCache)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache\` must be an object`);
+    }
+    assertRecognizedKeys(checkCache, RECOGNIZED_CHECK_CACHE_KEYS, configPath, 'checkCache.');
+    const config = {};
+    const enabledValue = checkCache['enabled'];
+    if (enabledValue !== undefined) {
+        if (typeof enabledValue !== 'boolean') {
+            throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.enabled\` must be a boolean`);
+        }
+        config.enabled = enabledValue;
+    }
+    for (const field of ['excludeCommands', 'extraCommands']) {
+        const commands = checkCache[field];
+        if (commands === undefined) {
+            continue;
+        }
+        if (!isStringArray(commands)) {
+            throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${field}\` must be a string[]`);
+        }
+        config[field] = commands;
+    }
+    return config;
+}
+function validateDelegateField(delegate, configPath) {
+    if (delegate === false) {
+        return false;
+    }
+    throw new UserError(`Invalid nmr config at ${configPath}: \`delegate\` accepts only \`false\`, which keeps the repo's checks on the ` +
+        'machine that has the tree. Hosts and `when` belong in the user config, `~/.config/nmr/config.ts`.');
+}
+function validateOutputField(value, configPath) {
+    const output = value['output'];
+    if (output === undefined) {
+        return undefined;
+    }
+    if (!isObject(output)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`output\` must be an object`);
+    }
+    assertRecognizedKeys(output, RECOGNIZED_OUTPUT_KEYS, configPath, 'output.');
+    const config = {};
+    const commandVerbosity = output['commandVerbosity'];
+    if (commandVerbosity !== undefined) {
+        if (typeof commandVerbosity !== 'string' || !isCommandVerbosity(commandVerbosity)) {
+            const renderedValue = typeof commandVerbosity === 'string' ? commandVerbosity : JSON.stringify(commandVerbosity);
+            throw new UserError(`Invalid nmr config at ${configPath}: ${formatVerbosityRejection('`output.commandVerbosity`', renderedValue)}`);
+        }
+        config.commandVerbosity = commandVerbosity;
+    }
+    const extraAgentEnvVars = output['extraAgentEnvVars'];
+    if (extraAgentEnvVars !== undefined) {
+        if (!isStringArray(extraAgentEnvVars)) {
+            throw new UserError(`Invalid nmr config at ${configPath}: \`output.extraAgentEnvVars\` must be a string[]`);
+        }
+        config.extraAgentEnvVars = extraAgentEnvVars;
+    }
+    return config;
+}
+function validateSelfHostedRunnerField(value, configPath) {
+    const selfHostedRunner = value['selfHostedRunner'];
+    if (selfHostedRunner === undefined) {
+        return undefined;
+    }
+    if (!isObject(selfHostedRunner)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`selfHostedRunner\` must be an object`);
+    }
+    assertRecognizedKeys(selfHostedRunner, RECOGNIZED_SELF_HOSTED_RUNNER_KEYS, configPath, 'selfHostedRunner.');
+    const exempt = selfHostedRunner['exempt'];
+    if (typeof exempt !== 'string' || exempt.trim() === '') {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`selfHostedRunner.exempt\` must be a non-empty string giving the reason`);
+    }
+    return { exempt };
+}
+function validateScriptField(value, fieldName, configPath) {
+    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
+        return undefined;
+    }
+    const scripts = value[fieldName];
+    if (!isScriptRecord(scripts)) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | element[]>, ` +
+            'where an element is a command string or ' +
+            '`{ run: string, shouldDeclineArguments?: boolean, shouldRunInBackground?: boolean }`');
+    }
+    assertValidElements(scripts, fieldName, configPath);
+    return scripts;
+}
+function validateStringRecordField(value, fieldName, configPath) {
+    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
+        return undefined;
+    }
+    if (!isStringRecord(value[fieldName])) {
+        throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string>`);
+    }
+    return value[fieldName];
+}

package/dist/esm/config.js

@@ -8,279 +8,19 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
+import { CONFIG_TIERS, validateConfig } from "./config-validation.js";
 import { resolveConfigPath } from "./helpers/config-path.js";
 import { escapeControlCharacters } from "./helpers/escapeControlCharacters.js";
-import { findClosestName } from "./helpers/findClosestName.js";
 import { isHookName } from "./helpers/hook-name.js";
-import { isObject, isStringRecord } from "./helpers/type-guards.js";
+import { isObject } from "./helpers/type-guards.js";
 import { getDefaultRootScripts, getDefaultWorkspaceScripts } from "./resolve-scripts.js";
-import { buildRootRegistry, buildWorkspaceRegistry, describeScript, readPackageJsonScripts } from "./resolver.js";
-import { findUnexpressibleToken, readSelfReference, readStepListSelfReference, } from "./steps.js";
+import { describeScript } from "./resolver.js";
+import { readSelfReference, readStepListSelfReference } from "./steps.js";
 import { UserError } from "./UserError.js";
-import { formatVerbosityRejection, isCommandVerbosity } from "./verbosity.js";
-import { getWorkspacePackageDirs, isMonorepoRoot } from "./workspace.js";
-const CONFIG_TIERS = {
-    root: {
-        label: 'a monorepo-root config',
-        honoredKeys: ['checkCache', 'devBin', 'output', 'rootScripts', 'selfHostedRunner', 'workspaceScripts'],
-        elsewhere: "the package's own config",
-    },
-    workspace: {
-        label: 'a package config',
-        honoredKeys: ['build'],
-        elsewhere: 'the monorepo-root config',
-    },
-};
-const RECOGNIZED_KEYS = [...CONFIG_TIERS.root.honoredKeys, ...CONFIG_TIERS.workspace.honoredKeys];
-const RECOGNIZED_BUILD_KEYS = ['extraIgnorePatterns'];
-const RECOGNIZED_CHECK_CACHE_KEYS = ['enabled', 'excludeCommands', 'extraCommands'];
-const RECOGNIZED_OUTPUT_KEYS = ['commandVerbosity', 'extraAgentEnvVars'];
-const RECOGNIZED_SELF_HOSTED_RUNNER_KEYS = ['exempt'];
-const RECOGNIZED_STEP_KEYS = ['run', 'shouldDeclineArguments', 'shouldRunInBackground'];
 const SCRIPT_FIELDS = [
     { field: 'rootScripts', scope: 'root' },
     { field: 'workspaceScripts', scope: 'workspaceRegistry' },
 ];
-const RETIRED_STEP_KEYS = new Map([['declinesArgs', 'shouldDeclineArguments']]);
-function isScriptRecord(value) {
-    if (!isObject(value))
-        return false;
-    for (const v of Object.values(value)) {
-        if (typeof v === 'string')
-            continue;
-        if (!Array.isArray(v) || !v.every(isScriptElement))
-            return false;
-    }
-    return true;
-}
-function isScriptElement(value) {
-    if (typeof value === 'string')
-        return true;
-    if (!isObject(value) || typeof value['run'] !== 'string')
-        return false;
-    return isOptionalBoolean(value['shouldDeclineArguments']) && isOptionalBoolean(value['shouldRunInBackground']);
-}
-function validateScriptField(value, fieldName, configPath) {
-    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
-        return undefined;
-    }
-    const scripts = value[fieldName];
-    if (!isScriptRecord(scripts)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | element[]>, ` +
-            'where an element is a command string or ' +
-            '`{ run: string, shouldDeclineArguments?: boolean, shouldRunInBackground?: boolean }`');
-    }
-    assertValidElements(scripts, fieldName, configPath);
-    return scripts;
-}
-function assertValidElements(scripts, fieldName, configPath) {
-    for (const [command, script] of Object.entries(scripts)) {
-        if (typeof script === 'string')
-            continue;
-        for (const spec of script) {
-            if (typeof spec !== 'string') {
-                assertNoRetiredKeys(spec, RETIRED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
-                assertRecognizedKeys(spec, RECOGNIZED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
-            }
-            const element = typeof spec === 'string' ? spec : spec.run;
-            const token = findUnexpressibleToken(element);
-            if (token === undefined)
-                continue;
-            throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}.${command}\` element \`${element}\` contains ` +
-                `\`${token}\`, which is neither a command name nor an nmr flag. Name it as a script of its own and ` +
-                `reference that name here.`);
-        }
-    }
-}
-function isOptionalBoolean(value) {
-    return value === undefined || typeof value === 'boolean';
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === 'string');
-}
-function validateBuildField(value, configPath) {
-    const build = value['build'];
-    if (build === undefined) {
-        return undefined;
-    }
-    if (!isObject(build)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`build\` must be an object`);
-    }
-    assertRecognizedKeys(build, RECOGNIZED_BUILD_KEYS, configPath, 'build.');
-    const extraIgnorePatterns = build['extraIgnorePatterns'];
-    if (extraIgnorePatterns !== undefined && !isStringArray(extraIgnorePatterns)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`build.extraIgnorePatterns\` must be a string[]`);
-    }
-    return extraIgnorePatterns === undefined ? {} : { extraIgnorePatterns };
-}
-function validateCheckCacheField(value, configPath) {
-    const checkCache = value['checkCache'];
-    if (checkCache === undefined) {
-        return undefined;
-    }
-    if (!isObject(checkCache)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache\` must be an object`);
-    }
-    assertRecognizedKeys(checkCache, RECOGNIZED_CHECK_CACHE_KEYS, configPath, 'checkCache.');
-    const config = {};
-    const enabledValue = checkCache['enabled'];
-    if (enabledValue !== undefined) {
-        if (typeof enabledValue !== 'boolean') {
-            throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.enabled\` must be a boolean`);
-        }
-        config.enabled = enabledValue;
-    }
-    for (const field of ['excludeCommands', 'extraCommands']) {
-        const commands = checkCache[field];
-        if (commands === undefined) {
-            continue;
-        }
-        if (!isStringArray(commands)) {
-            throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${field}\` must be a string[]`);
-        }
-        config[field] = commands;
-    }
-    return config;
-}
-function validateSelfHostedRunnerField(value, configPath) {
-    const selfHostedRunner = value['selfHostedRunner'];
-    if (selfHostedRunner === undefined) {
-        return undefined;
-    }
-    if (!isObject(selfHostedRunner)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`selfHostedRunner\` must be an object`);
-    }
-    assertRecognizedKeys(selfHostedRunner, RECOGNIZED_SELF_HOSTED_RUNNER_KEYS, configPath, 'selfHostedRunner.');
-    const exempt = selfHostedRunner['exempt'];
-    if (typeof exempt !== 'string' || exempt.trim() === '') {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`selfHostedRunner.exempt\` must be a non-empty string giving the reason`);
-    }
-    return { exempt };
-}
-function assertResolvableCheckCacheCommands(config, configPath, baseDir) {
-    const { checkCache } = config;
-    if (checkCache === undefined || !isMonorepoRoot(baseDir)) {
-        return;
-    }
-    const fields = ['excludeCommands', 'extraCommands'];
-    const entries = fields.flatMap((field) => (checkCache[field] ?? []).map((command) => ({ command, field })));
-    const hook = entries.find(({ command }) => isHookName(command));
-    if (hook !== undefined) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${hook.field}\` names the hook \`${hook.command}\`, ` +
-            'which is never gated on its own: It runs as part of the chain of the command that it wraps.');
-    }
-    const registeredNames = new Set([
-        ...Object.keys(buildRootRegistry(config, baseDir)),
-        ...Object.keys(buildWorkspaceRegistry(config)),
-    ]);
-    const missingEntries = entries.filter(({ command }) => !registeredNames.has(command));
-    if (missingEntries.length === 0) {
-        return;
-    }
-    const declaredNames = readDeclaredScriptNames(baseDir);
-    const unresolvableEntry = missingEntries.find(({ command }) => !declaredNames.has(command));
-    if (unresolvableEntry === undefined) {
-        return;
-    }
-    const closestName = findClosestName(unresolvableEntry.command, [...registeredNames, ...declaredNames]);
-    throw new UserError(`Invalid nmr config at ${configPath}: \`checkCache.${unresolvableEntry.field}\` does not name any command: ` +
-        `\`${unresolvableEntry.command}\`.${closestName === undefined ? '' : ` Did you mean \`${closestName}\`?`}`);
-}
-function readDeclaredScriptNames(monorepoRoot) {
-    let packageDirs;
-    try {
-        packageDirs = getWorkspacePackageDirs(monorepoRoot);
-    }
-    catch {
-        packageDirs = [];
-    }
-    const names = new Set();
-    const dirs = [monorepoRoot, ...packageDirs];
-    for (const dir of dirs) {
-        const scripts = readPackageScripts(dir);
-        for (const name of Object.keys(scripts)) {
-            names.add(name);
-        }
-    }
-    return names;
-}
-function readPackageScripts(packageDir) {
-    try {
-        return readPackageJsonScripts(packageDir) ?? {};
-    }
-    catch (error) {
-        if (error instanceof UserError) {
-            return {};
-        }
-        throw error;
-    }
-}
-function validateOutputField(value, configPath) {
-    const output = value['output'];
-    if (output === undefined) {
-        return undefined;
-    }
-    if (!isObject(output)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`output\` must be an object`);
-    }
-    assertRecognizedKeys(output, RECOGNIZED_OUTPUT_KEYS, configPath, 'output.');
-    const config = {};
-    const commandVerbosity = output['commandVerbosity'];
-    if (commandVerbosity !== undefined) {
-        if (typeof commandVerbosity !== 'string' || !isCommandVerbosity(commandVerbosity)) {
-            const renderedValue = typeof commandVerbosity === 'string' ? commandVerbosity : JSON.stringify(commandVerbosity);
-            throw new UserError(`Invalid nmr config at ${configPath}: ${formatVerbosityRejection('`output.commandVerbosity`', renderedValue)}`);
-        }
-        config.commandVerbosity = commandVerbosity;
-    }
-    const extraAgentEnvVars = output['extraAgentEnvVars'];
-    if (extraAgentEnvVars !== undefined) {
-        if (!isStringArray(extraAgentEnvVars)) {
-            throw new UserError(`Invalid nmr config at ${configPath}: \`output.extraAgentEnvVars\` must be a string[]`);
-        }
-        config.extraAgentEnvVars = extraAgentEnvVars;
-    }
-    return config;
-}
-function validateStringRecordField(value, fieldName, configPath) {
-    if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
-        return undefined;
-    }
-    if (!isStringRecord(value[fieldName])) {
-        throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string>`);
-    }
-    return value[fieldName];
-}
-function validateConfig(value, configPath, baseDir) {
-    if (!isObject(value)) {
-        throw new UserError(`Invalid nmr config at ${configPath}: expected an object, got ${typeof value}`);
-    }
-    assertRecognizedKeys(value, RECOGNIZED_KEYS, configPath);
-    const config = {};
-    const build = validateBuildField(value, configPath);
-    if (build)
-        config.build = build;
-    const checkCache = validateCheckCacheField(value, configPath);
-    if (checkCache)
-        config.checkCache = checkCache;
-    const devBin = validateStringRecordField(value, 'devBin', configPath);
-    if (devBin)
-        config.devBin = devBin;
-    const output = validateOutputField(value, configPath);
-    if (output)
-        config.output = output;
-    const workspaceScripts = validateScriptField(value, 'workspaceScripts', configPath);
-    if (workspaceScripts)
-        config.workspaceScripts = workspaceScripts;
-    const rootScripts = validateScriptField(value, 'rootScripts', configPath);
-    if (rootScripts)
-        config.rootScripts = rootScripts;
-    const selfHostedRunner = validateSelfHostedRunnerField(value, configPath);
-    if (selfHostedRunner)
-        config.selfHostedRunner = selfHostedRunner;
-    assertResolvableCheckCacheCommands(config, configPath, baseDir);
-    return config;
-}
 export async function loadConfig(baseDir) {
     const configPath = resolveConfigPath(baseDir);
     if (!existsSync(configPath)) {
@@ -302,14 +42,6 @@ export async function loadWorkspaceConfig(packageDir) {
     assertTierKeys(config, CONFIG_TIERS.workspace, resolveConfigPath(packageDir));
     return config;
 }
-function assertNoRetiredKeys(value, retiredKeys, configPath, prefix) {
-    for (const key of Object.keys(value)) {
-        const replacement = retiredKeys.get(key);
-        if (replacement === undefined)
-            continue;
-        throw new UserError(`Invalid nmr config at ${configPath}: \`${prefix}${key}\` was renamed to \`${prefix}${replacement}\`.`);
-    }
-}
 function assertNoSelfReferences(config, configPath, monorepoRoot) {
     for (const { field, scope } of SCRIPT_FIELDS) {
         const scripts = config[field] ?? {};
@@ -334,14 +66,6 @@ function assertNoSelfReferences(config, configPath, monorepoRoot) {
         }
     }
 }
-function assertRecognizedKeys(value, recognizedKeys, configPath, prefix = '') {
-    const unrecognizedKeys = Object.keys(value).filter((key) => !recognizedKeys.includes(key));
-    if (unrecognizedKeys.length === 0) {
-        return;
-    }
-    throw new UserError(`Invalid nmr config at ${configPath}: unrecognized ${unrecognizedKeys.length === 1 ? 'key' : 'keys'} ` +
-        `${formatKeyList(unrecognizedKeys, prefix)}. Recognized: ${formatKeyList(recognizedKeys, prefix)}.`);
-}
 function assertTierKeys(config, tier, configPath) {
     const unsupportedKeys = Object.keys(config).filter((key) => !tier.honoredKeys.includes(key));
     if (unsupportedKeys.length === 0) {
@@ -350,12 +74,6 @@ function assertTierKeys(config, tier, configPath) {
     throw new UserError(`Invalid nmr config at ${configPath}: ${tier.label} honors ${tier.honoredKeys.toSorted().join(', ')} alone, ` +
         `not ${unsupportedKeys.toSorted().join(', ')}. Move those keys to ${tier.elsewhere}.`);
 }
-function formatKeyList(keys, prefix) {
-    return keys
-        .toSorted()
-        .map((key) => `\`${prefix}${key}\``)
-        .join(', ');
-}
 function formatSelfReferenceRemedy(options) {
     const { isDefault, key, selfReference } = options;
     if (isDefault) {

package/dist/esm/crossing-diagnostics.d.ts

@@ -0,0 +1,39 @@
+import type { Writable } from 'node:stream';
+import { type OutputStyle } from '@williamthorsen/nmr-core';
+import type { ScriptRegistry } from './resolve-scripts.js';
+import { type ResolvedScript } from './resolver.js';
+import type { NmrConfig } from './types.js';
+/**
+ * Throws a `UserError` for a `package.json` entry that chains steps onto a re-invocation of its own command,
+ * which resolution discards, leaving those steps to run nowhere. Accepts every other entry in silence.
+ *
+ * Runs ahead of resolution, so that a command that the registry does not define reports the declaration that
+ * names it rather than the name that resolution could not find. A `--log` rejects none, running nothing whose
+ * steps could go missing.
+ */
+export declare function assertNoSelfReference(options: {
+    anchorDir: string;
+    command: string;
+    isReading: boolean;
+    isWorkspaceRoot: boolean;
+    monorepoRoot: string;
+    registry: ScriptRegistry;
+}): void;
+/**
+ * Reports a step that reaches nmr through a shell, when the resolved script contains one.
+ *
+ * Ahead of the gate, so that a command that usually skips still reports its crossing. A `--log` reports
+ * none, running nothing that could cross. Reads the resolved steps rather than the full chain: the line names
+ * a declaration to edit, and a hook, a passthrough, and a `devBin` substitution are none.
+ */
+export declare function reportNmrCrossing(options: {
+    config: NmrConfig;
+    isReading: boolean;
+    isWorkspaceRoot: boolean;
+    monorepoRoot: string;
+    registry: ScriptRegistry;
+    resolvedScript: ResolvedScript;
+    shouldUseRoot: boolean;
+    stderr: Writable;
+    style: OutputStyle;
+}): void;