@loomcli/core 0.4.0 → 0.6.0

package/dist/hints.js

@@ -0,0 +1,247 @@
+import { developerPlainText, developerText } from './developer.js';
+import { genericDefectText, InternalError, isAuthorFault, reasonOf } from './errors.js';
+import { nodeAt } from './inspect.js';
+import { reportPlainly } from './output.js';
+import { pluginSentence } from './plugin.js';
+import { brokenDestination, brokenFailureHook, brokenFailureView, viewCorrection, } from './rules.js';
+import { ignoreRejection, isThenable } from './thenable.js';
+import { describeFailure } from './view.js';
+/** The generic defect message the first time a run writes it, and nothing after that. */
+function genericOnce(build, application) {
+    if (build.generic) {
+        return '';
+    }
+    build.generic = true;
+    return genericDefectText(application);
+}
+/** The string one index of a returned list holds, read once, or `undefined` for a hole or a non-string. */
+function heldString(listed, index) {
+    if (!Object.hasOwn(listed, index)) {
+        return undefined;
+    }
+    const held = listed[index];
+    return typeof held === 'string' ? held : undefined;
+}
+/** The first `length` strings a list holds, copied into a frozen array, or `undefined` at a gap. */
+function copiedHints(listed, length) {
+    const hints = [];
+    for (let index = 0; index < length; index += 1) {
+        const hint = heldString(listed, index);
+        if (hint === undefined) {
+            return undefined;
+        }
+        hints.push(hint);
+    }
+    return Object.freeze(hints);
+}
+/**
+ * Every hint a returned list holds, copied by index into a fresh frozen array, or `undefined` for a
+ * value that is not a list of strings alone. The copy calls no method on the returned value, so an
+ * array subclass or a proxy cannot answer a list other than the one it holds. A hole is not a hint.
+ * The length is read once, so a getter cannot grow the list while it is copied.
+ */
+function listedHints(returned) {
+    if (!Array.isArray(returned)) {
+        return undefined;
+    }
+    const listed = returned;
+    // A proxy answers its own length, so a length no array can hold is not a list.
+    const { length } = listed;
+    if (!Number.isSafeInteger(length) || length < 0) {
+        return undefined;
+    }
+    return copiedHints(listed, length);
+}
+/**
+ * The hints one returned value holds. A hook is synchronous, so a returned promise is a broken
+ * answer: it receives a rejection handler and is otherwise ignored, as a failure view's is.
+ */
+function readHints(returned) {
+    if (returned === undefined) {
+        return { hints: [], kind: 'hints' };
+    }
+    if (typeof returned === 'string') {
+        return { hints: [returned], kind: 'hints' };
+    }
+    if (isThenable(returned)) {
+        ignoreRejection(returned);
+        return {
+            cause: undefined,
+            kind: 'broken',
+            reason: 'The hook returned a promise instead of hints.',
+        };
+    }
+    const hints = listedHints(returned);
+    return hints === undefined
+        ? {
+            cause: undefined,
+            kind: 'broken',
+            reason: 'The hook returned a value that is not a string or an array of strings.',
+        }
+        : { hints, kind: 'hints' };
+}
+/** One hook's call, with a throw read as a broken answer. */
+function callHook(hook, failure, context) {
+    try {
+        return readHints(hook(failure, context));
+    }
+    catch (error) {
+        return { cause: error, kind: 'broken', reason: reasonOf(error) };
+    }
+}
+/**
+ * The context every hook for one failure shares. `graph` and `command` stay getters, so a run
+ * whose hooks read neither builds no graph for them.
+ */
+function hookContext(scene, style) {
+    const { application, built, path } = scene;
+    let command = undefined;
+    return Object.freeze({
+        application,
+        get command() {
+            command ??= nodeAt(built.inspected(), path);
+            return command;
+        },
+        get graph() {
+            return built.inspected();
+        },
+        path,
+        style,
+    });
+}
+/**
+ * Every installed plugin's hints for one failure, in installation order, and each hook that broke.
+ * Each hook receives the failure and its context alone, so hints accumulate and no hook sees
+ * another's.
+ */
+function collectHints(scene, failure, style) {
+    const { built } = scene;
+    if (built === undefined) {
+        return { broken: [], hints: Object.freeze([]) };
+    }
+    const context = hookContext({ ...scene, built }, style);
+    // Every hook runs here, in installation order, before any answer is read.
+    const answers = built.plugins.flatMap(({ identity, onFailure }) => onFailure === undefined ? [] : [{ answer: callHook(onFailure, failure, context), identity }]);
+    const hints = answers.flatMap(({ answer }) => (answer.kind === 'hints' ? answer.hints : []));
+    const broken = answers.flatMap(({ answer, identity }) => answer.kind === 'broken' ? [{ cause: answer.cause, identity, reason: answer.reason }] : []);
+    return { broken, hints: Object.freeze(hints) };
+}
+/** The defect one broken hook reports in a development build. */
+function hookDefect({ cause, identity, reason }) {
+    return new InternalError(brokenFailureHook, {
+        cause,
+        correction: 'Return a string, an array of strings, or undefined from onFailure, synchronously.',
+        sentence: `${pluginSentence(identity)} failed in onFailure: ${reason}`,
+    });
+}
+/** The defect a broken failure view reports in a development build. */
+function viewDefect(report) {
+    return new InternalError(brokenFailureView, {
+        cause: report.cause,
+        correction: viewCorrection,
+        sentence: `Rendering the failure failed: ${report.reason}`,
+    });
+}
+/**
+ * What one broken contract reports on the plain fallback path. A development build writes its
+ * Developer Diagnostic after a blank line; a distributed build writes the generic defect message
+ * at most once per run.
+ */
+function brokenContract(defect, build, scene) {
+    return build.development
+        ? `\n${developerPlainText(defect, scene)}`
+        : genericOnce(build, scene.application);
+}
+/**
+ * What the plain fallback path writes after one failure's diagnostic: core's default text when the
+ * view broke, then what each broken contract reports, the view first and each hook in installation
+ * order. Nothing here resolves markup or runs a plugin's code.
+ */
+function plainLines(report, broken, reporting) {
+    const { build, failure, scene } = reporting;
+    if (report.kind === 'rendered') {
+        return broken.map((hook) => brokenContract(hookDefect(hook), build, scene)).join('');
+    }
+    // `report.text` is core's default text, which already ends in `\n`; for a defect it is generic.
+    const own = isAuthorFault(failure) ? genericOnce(build, scene.application) : report.text;
+    return [viewDefect(report), ...broken.map(hookDefect)].reduce((text, defect) => `${text}${brokenContract(defect, build, scene)}`, own);
+}
+/**
+ * Renders one failure as the run's build decides. A development build renders a fault only the
+ * author can fix as its Developer Diagnostic, ahead of every override, with the hints under it,
+ * and after an earlier report of the run it opens with one blank line. Every other failure, and
+ * every failure in a distributed build, resolves through the view registry. Core's default text
+ * for a defect is the generic message, which the run writes at most once, so a later defect that
+ * core's own view renders writes nothing.
+ */
+async function renderFailure(sink, failure, scene) {
+    const { build } = sink;
+    if (build.development && isAuthorFault(failure)) {
+        const { style } = sink.output.context('stderr');
+        const text = developerText(failure, { ...scene.developer, hints: scene.hints, style });
+        await sink.output.report(build.reported ? `\n${text}` : text);
+        return { core: false, kind: 'rendered', text: '' };
+    }
+    const report = describeFailure(sink.registry, failure, failureContext(sink.output, scene));
+    if (report.kind === 'rendered' && !repeatsGeneric(build, report, failure)) {
+        // The view owns the trailing newline; output resolves its marked text.
+        await sink.output.report(report.text);
+    }
+    return report;
+}
+/**
+ * Whether a rendered report is the generic defect message a run wrote already, which it writes
+ * nothing for. Core's own view writes the generic message for a fault only the author can fix, and
+ * the first such report counts it.
+ */
+function repeatsGeneric(build, report, failure) {
+    if (report.kind !== 'rendered' || !report.core || !isAuthorFault(failure)) {
+        return false;
+    }
+    const repeated = build.generic;
+    build.generic = true;
+    return repeated;
+}
+/** The context a failure view reads: the stderr view context, where the run was, and the hints. */
+function failureContext(output, scene) {
+    return Object.freeze({
+        ...output.context('stderr'),
+        application: scene.developer.application,
+        hints: scene.hints,
+        path: scene.path,
+    });
+}
+/**
+ * Reports one failure. The hooks run first, so the diagnostic or the view receives their hints. A
+ * view that breaks leaves core's default text without hints on the plain fallback path, and each
+ * broken contract's report follows that whole diagnostic. It answers whether a view or a hook
+ * broke, which forces the run's code to 1 outside a cancelled run.
+ */
+async function reportFailure(sink, failure, scene) {
+    const { broken, hints } = collectHints(scene, failure, sink.output.context('stderr').style);
+    const developer = { application: scene.application, host: scene.host };
+    const report = await renderFailure(sink, failure, { developer, hints, path: scene.path });
+    const plain = plainLines(report, broken, { build: sink.build, failure, scene: developer });
+    if (plain !== '') {
+        await reportPlainly(sink.stderr, plain);
+    }
+    sink.build.reported = true;
+    return report.kind !== 'rendered' || broken.length > 0;
+}
+/**
+ * What a run writes on the plain fallback path when a destination failed a write or reporting
+ * itself failed: the Developer Diagnostic of the broken destination in a development build, and
+ * the generic defect message, at most once per run, in a distributed one.
+ */
+function destinationReport(build, cause, scene) {
+    if (!build.development) {
+        return genericOnce(build, scene.application);
+    }
+    const defect = new InternalError(brokenDestination, {
+        cause,
+        correction: 'Give run() host streams that accept every write until the run resolves.',
+        sentence: 'Could not write invocation output.',
+    });
+    return `${build.reported ? '\n' : ''}${developerPlainText(defect, scene)}`;
+}
+export { destinationReport, reportFailure };

package/dist/host.d.ts

@@ -1,3 +1,16 @@
 import type { Writable } from 'node:stream';
 import type { Host, RunOptions } from './types.js';
+/**
+ * The reader process capture supplies: one UTF-8 file, read synchronously, whose path lies under
+ * the working directory once both resolve through symbolic links. A stack can be forged, so a file
+ * outside `cwd`, a link that leaves it, a path that is not a regular file, such as a FIFO or a
+ * device, a file larger than 1 MiB, and any failure answer `undefined`.
+ */
+export declare function readSourceFile(path: string, cwd: string): string | undefined;
+/**
+ * The roots a defect's frame may lie under: the working directory as the host names it, and the
+ * path it resolves to through symbolic links, because a runtime names a module by its resolved
+ * path. A directory that cannot be resolved is its own one root.
+ */
+export declare function sourceRoots(cwd: string): readonly string[];
 export declare function captureHost(overrides: RunOptions['host'], stderr: Writable): Host;

package/dist/host.js

@@ -1,3 +1,5 @@
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, relative, sep } from 'node:path';
 // Process stream declarations assume a terminal, but pipes omit isTTY at runtime.
 function isTerminal(stream) {
     return stream.isTTY === true;
@@ -5,13 +7,53 @@ function isTerminal(stream) {
 function dimension(value) {
     return value === 0 ? undefined : value;
 }
+/** The largest source file the captured reader reads, so a frame cannot make it read without end. */
+const sourceLimit = 1_048_576;
+/**
+ * The reader process capture supplies: one UTF-8 file, read synchronously, whose path lies under
+ * the working directory once both resolve through symbolic links. A stack can be forged, so a file
+ * outside `cwd`, a link that leaves it, a path that is not a regular file, such as a FIFO or a
+ * device, a file larger than 1 MiB, and any failure answer `undefined`.
+ */
+export function readSourceFile(path, cwd) {
+    try {
+        const file = realpathSync(path);
+        const within = relative(realpathSync(cwd), file);
+        if (within === '' || within === '..' || within.startsWith(`..${sep}`) || isAbsolute(within)) {
+            return undefined;
+        }
+        const stats = statSync(file);
+        if (!stats.isFile() || stats.size > sourceLimit) {
+            return undefined;
+        }
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The roots a defect's frame may lie under: the working directory as the host names it, and the
+ * path it resolves to through symbolic links, because a runtime names a module by its resolved
+ * path. A directory that cannot be resolved is its own one root.
+ */
+export function sourceRoots(cwd) {
+    try {
+        const resolved = realpathSync(cwd);
+        return resolved === cwd ? [cwd] : [cwd, resolved];
+    }
+    catch {
+        return [cwd];
+    }
+}
 export function captureHost(overrides, stderr) {
-    const { argv, cwd, env, platform, stdin, stdout, terminal } = overrides ?? {};
+    const { argv, cwd, env, platform, readSource, stdin, stdout, terminal } = overrides ?? {};
     return {
         argv: [...(argv ?? process.argv.slice(2))],
         cwd: cwd ?? process.cwd(),
         env: { ...(env ?? process.env) },
         platform: platform ?? process.platform,
+        readSource: readSource ?? readSourceFile,
         stderr,
         stdin: stdin ?? process.stdin,
         stdout: stdout ?? process.stdout,

package/dist/identity.d.ts

@@ -0,0 +1,19 @@
+import type { Finding } from './diagnostic-text.js';
+import { DeclarationError } from './errors.js';
+/** The calls that declare an identity. */
+type IdentityCall = 'extension' | 'plugin' | 'view';
+/** Whether a value is a plugin, extension, or view identity. */
+declare function isIdentity(value: unknown): value is string;
+/** Whether a value is a diagnostic rule identity: an identity and a kebab-case rule name. */
+declare function isRuleIdentity(value: unknown): value is string;
+/**
+ * The fault for one identity outside the grammar. `subject` opens the sentence and says who
+ * declares or holds it, such as `A plugin declares the identity`.
+ */
+declare function identityFault(subject: string, identity: unknown, findings: readonly Finding[]): DeclarationError;
+/**
+ * Checks the identity one `plugin()`, `extension()`, or `view()` call declares, at the call, so a
+ * fault throws before the value exists. The finding marks the identity on the rebuilt call.
+ */
+declare function checkIdentity(call: IdentityCall, identity: unknown): asserts identity is string;
+export { checkIdentity, identityFault, isIdentity, isRuleIdentity };

package/dist/identity.js

@@ -0,0 +1,72 @@
+import { elided, spelled } from './diagnostic-text.js';
+import { DeclarationError, quoted } from './errors.js';
+import { invalidIdentity } from './plugin-rules.js';
+/*
+ * The identity grammar plugins, extensions, views, and diagnostic rules share. Both grammars are
+ * built here from one source, so every rule identity's prefix is a valid plugin identity.
+ */
+/**
+ * A package name as npm spells one, scoped or not: `help` or `@acme/config`. The group captures it,
+ * scope included, so its length is checked against npm's limit.
+ */
+const packageName = String.raw `(?<package>(?:@[a-z0-9-][a-z0-9._-]*\/)?[a-z0-9-][a-z0-9._-]*)`;
+/** The longest package name npm accepts, scope included. */
+const packageNameLimit = 214;
+/** One segment after a `/`, of lowercase letters and digits in words joined by single hyphens. */
+const kebabSegment = String.raw `\/[a-z0-9]+(?:-[a-z0-9]+)*`;
+/**
+ * A package name, then zero or more kebab-case subpath segments: `@acme/config` or
+ * `@loomcli/plugins/help/page`. It is the grammar of a plugin, extension, or view identity.
+ */
+const identityGrammar = new RegExp(`^${packageName}(?:${kebabSegment})*$`, 'u');
+/**
+ * An identity, then a mandatory kebab-case rule name: `@loomcli/core/spelling-taken` or
+ * `@loomcli/plugins/manifest/failure-name-conflict`. It is the grammar of a diagnostic rule's
+ * identity and of a validator package's issue codes.
+ */
+const ruleGrammar = new RegExp(`^${packageName}(?:${kebabSegment})+$`, 'u');
+/** How a sentence names the declarer of each call. */
+const declarers = {
+    extension: 'An extension',
+    plugin: 'A plugin',
+    view: 'A view',
+};
+/** Whether a value is a string one grammar matches, with a package name within npm's limit. */
+function matches(grammar, value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const name = grammar.exec(value)?.groups?.package;
+    return name !== undefined && name.length <= packageNameLimit;
+}
+/** Whether a value is a plugin, extension, or view identity. */
+function isIdentity(value) {
+    return matches(identityGrammar, value);
+}
+/** Whether a value is a diagnostic rule identity: an identity and a kebab-case rule name. */
+function isRuleIdentity(value) {
+    return matches(ruleGrammar, value);
+}
+/**
+ * The fault for one identity outside the grammar. `subject` opens the sentence and says who
+ * declares or holds it, such as `A plugin declares the identity`.
+ */
+function identityFault(subject, identity, findings) {
+    return new DeclarationError(invalidIdentity, {
+        correction: 'Name it <package>[/<subpath>...], such as "@acme/notes" or "@acme/notes/page".',
+        findings,
+        sentence: `${subject} ${quoted(identity)}, which is not a package name with optional kebab-case subpath segments.`,
+    });
+}
+/**
+ * Checks the identity one `plugin()`, `extension()`, or `view()` call declares, at the call, so a
+ * fault throws before the value exists. The finding marks the identity on the rebuilt call.
+ */
+function checkIdentity(call, identity) {
+    if (!isIdentity(identity)) {
+        throw identityFault(`${declarers[call]} declares the identity`, identity, [
+            { arguments: [identity, spelled(elided)], call, mark: '0' },
+        ]);
+    }
+}
+export { checkIdentity, identityFault, isIdentity, isRuleIdentity };

package/dist/index.d.ts

@@ -1,27 +1,38 @@
 export { Application } from './application.js';
 export { Command } from './command.js';
+export { escapeControlCharacters } from './controls.js';
 export { validationContext, validationContextKey } from './context.js';
+export { diagnosticRule } from './diagnostic.js';
+export { isRuleIdentity } from './identity.js';
+export type { DiagnosticParts, DiagnosticRule, Finding } from './diagnostic-text.js';
 export { DeclarationError, FatalError, InputError, InternalError, LoomError, MissingValueError, NonCallableCommandError, RepeatedOptionError, ResultError, ShortGroupError, UnexpectedArgumentError, UnexpectedValueError, UnknownCommandError, UnknownOptionError, UsageError, } from './errors.js';
+export { EX_CANTCREAT, EX_CONFIG, EX_DATAERR, EX_IOERR, EX_NOHOST, EX_NOINPUT, EX_NOPERM, EX_NOUSER, EX_OSERR, EX_OSFILE, EX_PROTOCOL, EX_SOFTWARE, EX_TEMPFAIL, EX_UNAVAILABLE, EX_USAGE, } from './exit-codes.js';
+export type { FailureExitCode } from './exit-codes.js';
 export { extension, readExtension } from './extension.js';
+export { locate } from './locate.js';
 export { incompleteResult, lanes } from './lanes.js';
 export { override, view } from './view.js';
 export { plugin } from './plugin.js';
+export { translate } from './translators.js';
 export { glyph } from './glyphs.generated.js';
 export type { RenderingPolicy } from './rendering.js';
 export type { ViewContext } from './types.js';
 export { pad, style } from './style.js';
 export { issuePath } from './validation.js';
 export type { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/spec';
-export type { ApplicationMethod, ApplicationOptions } from './application.js';
+export type { ApplicationMethod, ApplicationOptions, Packet } from './application.js';
 export type { ChainOutcome, MiddlewareContext } from './chain.js';
 export type { InputProblem, ResultFault } from './errors.js';
 export type { AnyExtension, Extension, ExtensionValue } from './extension.js';
+export type { FailureHook, FailureHookContext } from './hints.js';
 export type { CommandMethod, CommandOptions } from './command.js';
 export type { CancellationReason } from './signals.js';
+export type { ErrorClass, Translation, Translator } from './translators.js';
 export type { IncompleteResult } from './lanes.js';
-export type { AnyDeclaredView, DeclaredRowView, DeclaredView, DeclaredViewBrand, FailureClass, ViewContribution, ViewOverride, } from './view.js';
+export type { WordPosition } from './locate.js';
+export type { AnyDeclaredView, DeclaredRowView, DeclaredView, DeclaredViewBrand, FailureClass, FailureView, FailureViewContext, ViewContribution, ViewOverride, } from './view.js';
 export type { ArgumentNode, CommandGraph, CommandNode, OptionNode, ResultNode } from './inspect.js';
-export type { Middleware, OptionsOf, Plugin, PluginDefinition, PluginOptions, PluginOptionValues, } from './plugin.js';
+export type { Middleware, OptionsOf, Plugin, PluginDefinition, PluginOptions, PluginOptionSpellings, PluginOptionValues, SourceAnswer, SourceContext, SourceResolver, } from './plugin.js';
 export type { Action, ActionArgs, ActionContext, ActionHandler, ActionOptions, ArgumentConfig, AttachedCommand, BooleanOption, CommandAttachHook, ExitCode, Host, InputIdentity, InputTerminal, Out, OptionConfig, OutputTerminal, Request, ResultInput, ResultView, ResultViews, RunOptions, ScalarArgument, StringOption, SuppliedInputs, RowView, RowViews, ValidationContext, VariadicArgument, View, } from './types.js';
 export type { ApplicationEnvironment, EnvironmentOf, Register, RegisteredEnvironment, } from './environment.js';
-export type { Ansi16Color, Ansi256Fallbacks, ColorFallbacks, ConcreteStyle, Style, ThemeMapping, ThemeConstraint, } from './style.js';
+export type { Ansi16Color, Ansi256Fallbacks, ColorFallbacks, ConcreteStyle, ContextualStyle, Style, ThemeMapping, ThemeConstraint, } from './style.js';

package/dist/index.js

@@ -1,11 +1,17 @@
 export { Application } from './application.js';
 export { Command } from './command.js';
+export { escapeControlCharacters } from './controls.js';
 export { validationContext, validationContextKey } from './context.js';
+export { diagnosticRule } from './diagnostic.js';
+export { isRuleIdentity } from './identity.js';
 export { DeclarationError, FatalError, InputError, InternalError, LoomError, MissingValueError, NonCallableCommandError, RepeatedOptionError, ResultError, ShortGroupError, UnexpectedArgumentError, UnexpectedValueError, UnknownCommandError, UnknownOptionError, UsageError, } from './errors.js';
+export { EX_CANTCREAT, EX_CONFIG, EX_DATAERR, EX_IOERR, EX_NOHOST, EX_NOINPUT, EX_NOPERM, EX_NOUSER, EX_OSERR, EX_OSFILE, EX_PROTOCOL, EX_SOFTWARE, EX_TEMPFAIL, EX_UNAVAILABLE, EX_USAGE, } from './exit-codes.js';
 export { extension, readExtension } from './extension.js';
+export { locate } from './locate.js';
 export { incompleteResult, lanes } from './lanes.js';
 export { override, view } from './view.js';
 export { plugin } from './plugin.js';
+export { translate } from './translators.js';
 export { glyph } from './glyphs.generated.js';
 export { pad, style } from './style.js';
 export { issuePath } from './validation.js';

package/dist/input-rules.d.ts

@@ -0,0 +1,64 @@
+/** An option declared with a type other than string or Boolean. */
+declare const optionType: import("./diagnostic-text.js").DiagnosticRule;
+/** A short alias that is not one ASCII letter. */
+declare const shortAlias: import("./diagnostic-text.js").DiagnosticRule;
+/**
+ * A yes-or-no declaration key, such as `required`, `hidden`, or an extension descriptor's
+ * `collect`, that holds a value other than a Boolean.
+ */
+declare const flagNotBoolean: import("./diagnostic-text.js").DiagnosticRule;
+/** `shortOnly` on an option that declares no short alias. */
+declare const shortOnlyWithoutShort: import("./diagnostic-text.js").DiagnosticRule;
+/** `multiple` on a Boolean option. */
+declare const booleanOptionMultiple: import("./diagnostic-text.js").DiagnosticRule;
+/** `polarity` on a string option. */
+declare const polarityOnString: import("./diagnostic-text.js").DiagnosticRule;
+/** A polarity outside the three settings. */
+declare const optionPolarity: import("./diagnostic-text.js").DiagnosticRule;
+/** `polarity: 'both'` beside `shortOnly`. */
+declare const shortOnlyBothPolarities: import("./diagnostic-text.js").DiagnosticRule;
+/**
+ * One spelling that two options in one scope claim, the application's, a plugin's, or one a
+ * plugin's hook declared.
+ */
+declare const spellingTaken: import("./diagnostic-text.js").DiagnosticRule;
+/**
+ * Two options with one declared name in one scope, the application's, a plugin's, or one a
+ * plugin's hook declared.
+ */
+declare const optionDeclaredTwice: import("./diagnostic-text.js").DiagnosticRule;
+/**
+ * An input a plugin's `onCommandAttach` hook declares under a name that an input of the other kind
+ * already holds in the Command's scope: an argument under an option's name, or an option under an
+ * argument's name.
+ */
+declare const nameSharedAcrossKinds: import("./diagnostic-text.js").DiagnosticRule;
+/** `required` or `validateOmitted` on a global option. */
+declare const globalPresenceRule: import("./diagnostic-text.js").DiagnosticRule;
+/** `globalOption()` after the application's own `command()` or `action()`. */
+declare const globalOptionAfterCommand: import("./diagnostic-text.js").DiagnosticRule;
+/** An environment binding on a multiple option. */
+declare const envOnMultiple: import("./diagnostic-text.js").DiagnosticRule;
+/** An environment binding whose name is outside the variable name grammar. */
+declare const envName: import("./diagnostic-text.js").DiagnosticRule;
+/** An environment binding on an argument. */
+declare const envOnArgument: import("./diagnostic-text.js").DiagnosticRule;
+/** One variable that two options in one invocation's scope bind. */
+declare const variableBoundTwice: import("./diagnostic-text.js").DiagnosticRule;
+/** `validateOmitted` on a declaration whose absence another rule already decides. */
+declare const omissionAlreadyDecided: import("./diagnostic-text.js").DiagnosticRule;
+/** `validateOmitted` on a declaration with no validator. */
+declare const omissionWithoutValidator: import("./diagnostic-text.js").DiagnosticRule;
+/** `validate`, `default`, `required`, or `validateOmitted` on a Boolean option. */
+declare const booleanOptionValueRule: import("./diagnostic-text.js").DiagnosticRule;
+/** A required input that also declares a default. */
+declare const requiredWithDefault: import("./diagnostic-text.js").DiagnosticRule;
+/** A `validate` value that is not a Standard Schema v1 object. */
+declare const notAValidator: import("./diagnostic-text.js").DiagnosticRule;
+/** A default of the wrong raw shape for its declaration. */
+declare const defaultShape: import("./diagnostic-text.js").DiagnosticRule;
+/** A declared default its validator rejected. */
+declare const invalidDefault: import("./diagnostic-text.js").DiagnosticRule;
+/** A validator's JSON Schema converter that threw or returned a value that is not a plain object. */
+declare const schemaConverterFailed: import("./diagnostic-text.js").DiagnosticRule;
+export { booleanOptionMultiple, booleanOptionValueRule, defaultShape, envName, envOnArgument, envOnMultiple, flagNotBoolean, globalOptionAfterCommand, globalPresenceRule, invalidDefault, notAValidator, omissionAlreadyDecided, nameSharedAcrossKinds, omissionWithoutValidator, optionDeclaredTwice, optionPolarity, optionType, polarityOnString, requiredWithDefault, schemaConverterFailed, shortAlias, shortOnlyBothPolarities, shortOnlyWithoutShort, spellingTaken, variableBoundTwice, };