@loomcli/core 0.7.0 → 0.8.0

package/dist/errors.js

@@ -50,10 +50,16 @@ function nonCallableMessage(command, candidates) {
         ? `A command is required.${offering(candidates, 'command')}`
         : `${routedSentence(command)} requires a subcommand.${offering(candidates, 'subcommand')}`;
 }
-function shortGroupMessage(fault) {
-    return fault.reason === 'value-position'
-        ? `Value option ${quoted(fault.token)} must be last in its short group. Supply its value in the next token.`
-        : `A short group mixes the global option ${quoted(`-${fault.global}`)} with ${quoted(`-${fault.other}`)}, which is not a global option. Supply global options as separate tokens, and local options after their command name.`;
+/**
+ * The sentence for an option word the routed Command's table does not hold, while visible Commands
+ * below it declare it. Each Command reads as its path from the root.
+ */
+function misplacedMessage(spelling, commands) {
+    const names = commands.map((path) => path.join(' '));
+    const [only] = names;
+    return names.length === 1 && only !== undefined
+        ? `Option ${quoted(spelling)} belongs to command ${quoted(only)}. Supply it after ${quoted(only)}.`
+        : `Option ${quoted(spelling)} belongs to commands ${names.join(', ')}. Supply it after the command name.`;
 }
 /**
  * The sentence for a class whose declared code no failure may exit with. The class is named by its
@@ -248,18 +254,26 @@ export class UnknownOptionError extends UsageError {
 }
 export class MissingValueError extends UsageError {
     spelling;
-    constructor(spelling) {
-        super(`Option ${quoted(spelling)} requires a value. Supply a value after ${quoted(spelling)}.`);
+    constructor(spelling, form = 'separate') {
+        super(form === 'attached'
+            ? `Option ${quoted(spelling)} requires a value. Supply a value after ${quoted(spelling)}, or attach one that starts with a hyphen as ${quoted(`${spelling}=<value>`)}.`
+            : `Option ${quoted(spelling)} requires a value. Supply a value after ${quoted(spelling)}.`);
         this.name = 'MissingValueError';
         this.spelling = spelling;
     }
 }
-/** A Boolean spelling takes no value, so the token carried one the declaration cannot accept. */
+/**
+ * A Boolean or counted spelling takes no value, so the token carried one the declaration cannot
+ * accept. A counted option's sentence tells the operator to repeat the spelling instead, and `kind`
+ * chooses the sentence alone.
+ */
 export class UnexpectedValueError extends UsageError {
     spelling;
     value;
-    constructor(spelling, value) {
-        super(`Boolean option ${quoted(spelling)} does not accept a value. Supply the flag alone.`);
+    constructor(spelling, value, kind = 'boolean') {
+        super(kind === 'count'
+            ? `Counted option ${quoted(spelling)} does not accept a value. Repeat ${quoted(spelling)} to raise its count.`
+            : `Boolean option ${quoted(spelling)} does not accept a value. Supply the flag alone.`);
         this.name = 'UnexpectedValueError';
         this.spelling = spelling;
         this.value = value;
@@ -273,14 +287,20 @@ export class RepeatedOptionError extends UsageError {
         this.spelling = spelling;
     }
 }
-export class ShortGroupError extends UsageError {
-    token;
-    reason;
-    constructor(fault) {
-        super(shortGroupMessage(fault));
-        this.name = 'ShortGroupError';
-        this.reason = fault.reason;
-        this.token = fault.token;
+/**
+ * An option word the Command routing reached does not declare, while a visible Command below it
+ * does, such as a Command's own option typed before its name, or a parent's own option the routed
+ * Command declares with another value class. `commands` holds each such Command's path from the
+ * root, in authoring order.
+ */
+export class MisplacedOptionError extends UsageError {
+    spelling;
+    commands;
+    constructor(spelling, commands) {
+        super(misplacedMessage(spelling, commands));
+        this.commands = commands;
+        this.name = 'MisplacedOptionError';
+        this.spelling = spelling;
     }
 }
 /** The platform's error options one value carries, read without trusting its shape. */
@@ -498,7 +518,7 @@ for (const Class of [
     MissingValueError,
     UnexpectedValueError,
     RepeatedOptionError,
-    ShortGroupError,
+    MisplacedOptionError,
     DeclarationError,
     FatalError,
     InternalError,

package/dist/globals.d.ts

@@ -1,10 +1,10 @@
 import type { BoundOption } from './bindings.js';
 import type { DescriptorRegistry } from './extension.js';
-import type { InputSite } from './facts.js';
+import type { FactSite, InputSite } from './facts.js';
 import { compileOptions } from './options.js';
-import type { CompileScope } from './options.js';
+import type { CompileScope, SpellingTable } from './options.js';
 import type { BuiltPlugin } from './plugin.js';
-import type { OptionConfig, OptionValue } from './types.js';
+import type { OptionConfig } from './types.js';
 import type { InputDeclaration, OptionInput, ValidatedInputs } from './validation.js';
 /**
  * Who declared one option that shares the globals table, or the Command that declares a local
@@ -27,10 +27,10 @@ interface TableEntry {
     site: InputSite;
 }
 /**
- * The globals table the pre-scan reads, with every rule that pairs two of its options settled: one
- * spelling map, the scope that owns each key and where it was declared, and the variable each
- * option binds. It holds the application's global options and every installed plugin's options,
- * because the pre-scan reads one table.
+ * The globals table, with every rule that pairs two of its options settled: one spelling map, the
+ * scope that owns each key and where it was declared, and the variable each option binds. It holds
+ * the application's global options and every installed plugin's options, because both are global
+ * options that routing reads and every Command's table holds.
  */
 interface GlobalTable {
     names: ReadonlyMap<string, TableEntry>;
@@ -39,26 +39,33 @@ interface GlobalTable {
     variables: ReadonlyMap<string, BoundOption>;
 }
 /**
- * The compiled table one graph build shares. `inputs` holds the application's declarations alone,
- * because a plugin option is never validated and never reaches an action.
+ * The compiled table one graph build shares. `inputs` holds every global option, the application's
+ * in authoring order and then each installed plugin's in installation order, which is the order
+ * the input-source stage fills them, validation checks them, and `inspect()` lists them. `sites`
+ * holds the call that declared each of them, which a fault about one rebuilds. `bind` reads every
+ * global option's validated value, keyed by declared name, as every action receives it. `table`
+ * holds the global options alone as parser entries, which routing reads at a Command without its
+ * own options to offer and every Command's table joins.
  */
 interface BuiltGlobals extends GlobalTable {
     bind: (values: ValidatedInputs) => unknown;
     inputs: readonly OptionInput[];
     plugins: readonly BuiltPlugin[];
+    sites: ReadonlyMap<InputDeclaration, InputSite>;
+    table: SpellingTable;
 }
 /** The validated extension record of each declaration, keyed by the declaration itself. */
 type InputRecords = ReadonlyMap<InputDeclaration, Readonly<Record<string, unknown>>>;
 /**
- * The Application's private global declarations, their schema-derived value binder, and the
- * extension record each declaration's own call validated.
+ * The Application's private global declarations and the extension record each declaration's own
+ * call validated. The global options' value types live on the Application's type, and the action
+ * reads every global option's value through the built table's binder.
  */
-interface GlobalsState<Globals = unknown> {
-    bind: (values: ValidatedInputs) => Globals;
+interface GlobalsState {
     inputs: readonly OptionInput[];
     records: InputRecords;
 }
-declare function emptyGlobals(): GlobalsState<{}>;
+declare function emptyGlobals(): GlobalsState;
 /** Where one global option was declared: its `globalOption()` call on the Application. */
 declare function globalSite(input: OptionInput): InputSite;
 /**
@@ -66,26 +73,45 @@ declare function globalSite(input: OptionInput): InputSite;
  * plugin's `plugin()` call, which is rebuilt from every option the plugin holds.
  */
 declare function pluginSites(identity: string, inputs: readonly OptionInput[]): (input: OptionInput) => InputSite;
+/**
+ * A global option declares no presence rule, whether the application or a plugin declares it, and
+ * whatever the key's value. The fault marks the key on the call that declared the option.
+ */
+declare function checkNoPresenceRule(site: FactSite, config: OptionConfig): void;
 /**
  * One global option's own facts, binding, and extension values, checked at its `globalOption()`
  * call against the Application's descriptors. The rules that pair it with another option belong to
  * the table, which the caller rebuilds with it.
  */
-declare function declareGlobalOption<Globals, Name extends string, Config extends OptionConfig>(state: GlobalsState<Globals>, declared: OptionInput<Name, Config>, descriptors: DescriptorRegistry): {
+declare function declareGlobalOption<Name extends string, Config extends OptionConfig>(state: GlobalsState, declared: OptionInput<Name, Config>, descriptors: DescriptorRegistry): {
     readonly input: OptionInput<Name, Config>;
-    readonly state: GlobalsState<Globals & Record<Name, OptionValue<Config>>>;
+    readonly state: GlobalsState;
 };
 /**
- * The one table the pre-scan reads: the application's global options in authoring order, then each
- * installed plugin's options in installation order. Every collision between the two scopes, by key
- * or by spelling, is reported here, so the pre-scan meets a table with one owner per name.
+ * The globals table: the application's global options in authoring order, then each installed
+ * plugin's options in installation order. Every collision between the two scopes, by key or by
+ * spelling, is reported here, so the parser meets a table with one owner per name.
  */
 declare function globalTable(inputs: readonly OptionInput[], plugins: readonly BuiltPlugin[]): GlobalTable;
-/** The table one graph build shares, which every earlier call already proved free of collisions. */
+/**
+ * The validated value of each listed option, keyed by declared name. Entries become own keys even
+ * for a name such as `__proto__`, which assignment would not.
+ */
+declare function optionValues(inputs: readonly OptionInput[], values: ValidatedInputs): Record<string, unknown>;
+/**
+ * The validated value of each listed option, keyed by declared name, as a plugin reads it: each
+ * value a plain-data copy frozen to every depth, as the request's values are, so a plugin that
+ * reaches into one contributes nothing to what another plugin or the action receives.
+ */
+declare function frozenValues(inputs: readonly OptionInput[], values: ValidatedInputs): Readonly<Record<string, unknown>>;
+/**
+ * The table one graph build shares, which every earlier call already proved free of collisions.
+ * A plugin's options are global options, so they join the application's in every reading.
+ */
 declare function buildGlobals(node: GlobalsState, plugins: readonly BuiltPlugin[]): BuiltGlobals;
 /**
  * One Command's own options against the globals table, compiled for dispatch. The table holds the
- * application's globals and every plugin option, so a local collision reads the same sentence
+ * application's global options and every plugin's, so a local collision reads the same sentence
  * whichever scope on the other side claimed the name, the spelling, or the variable. One
  * invocation's scope is this Command's own options and the table, so a variable binds one option
  * there, while a sibling Command may bind it again. `scope` names the Command and places each of
@@ -95,4 +121,4 @@ declare function checkLocalOptions(declarations: readonly OptionInput[], table:
 /** The options in one list that bind a variable, each named and placed by its scope. */
 declare function boundOptions(inputs: readonly OptionInput[], describe: (input: OptionInput) => Omit<BoundOption, 'variable'>): BoundOption[];
 export type { BuiltGlobals, GlobalsState, GlobalTable, InputRecords, OptionOwner, TableEntry };
-export { boundOptions, buildGlobals, checkLocalOptions, declareGlobalOption, emptyGlobals, globalSite, globalTable, pluginSites, };
+export { boundOptions, buildGlobals, checkLocalOptions, checkNoPresenceRule, declareGlobalOption, emptyGlobals, frozenValues, globalSite, globalTable, optionValues, pluginSites, };

package/dist/globals.js

@@ -3,7 +3,8 @@ import { DeclarationError, quoted } from './errors.js';
 import { buildExtensions } from './extension.js';
 import { callSite, checkDeprecated, checkDescription, checkHidden, factFault, pluginOptionSite, siteFinding, } from './facts.js';
 import { globalPresenceRule, optionDeclaredTwice, spellingTaken } from './input-rules.js';
-import { checkOptionName, compileOptions, spellingMark } from './options.js';
+import { checkOptionName, compileOptions, spellingMark, tableEntries } from './options.js';
+import { snapshot } from './plain.js';
 import { captureInputConfig, configUnread } from './validation.js';
 const globalSubject = 'the global options';
 /**
@@ -59,7 +60,7 @@ function correction(first, second) {
 const sideNotes = {
     application: 'the global option',
     local: 'the local option',
-    plugin: 'the plugin option',
+    plugin: "the plugin's global option",
 };
 /** One key claimed twice, whichever two scopes claimed it. */
 function keyCollision(first, second) {
@@ -77,12 +78,12 @@ function spellingCollision(spelling, first, second) {
     const [leading, trailing] = pair;
     return new DeclarationError(spellingTaken, {
         correction: 'Change one declaration.',
-        findings: pair.map(({ owner, role, site }) => siteFinding(site, spellingMark(site, role), sideNotes[owner.kind])),
+        findings: pair.map(({ origin, owner, site }) => siteFinding(site, spellingMark(site, origin), sideNotes[owner.kind])),
         sentence: `Option spelling ${quoted(spelling)} is used by ${usedBy(leading)} and ${usedBy(trailing)}.`,
     });
 }
 function emptyGlobals() {
-    return { bind: () => ({}), inputs: [], records: new Map() };
+    return { inputs: [], records: new Map() };
 }
 /** Where one global option was declared: its `globalOption()` call on the Application. */
 function globalSite(input) {
@@ -101,6 +102,20 @@ function pluginSites(identity, inputs) {
     const options = Object.fromEntries(inputs.map(({ config, name }) => [name, config]));
     return (input) => pluginOptionSite({ identity, options }, input.name, `Plugin ${quoted(identity)} option ${quoted(input.name)}`);
 }
+/**
+ * A global option declares no presence rule, whether the application or a plugin declares it, and
+ * whatever the key's value. The fault marks the key on the call that declared the option.
+ */
+function checkNoPresenceRule(site, config) {
+    const rejected = omissionRules.find((key) => key in config);
+    if (rejected !== undefined) {
+        throw factFault(globalPresenceRule, site, {
+            correction: `Remove ${rejected}, and check for the value in each Command that needs it.`,
+            fact: rejected,
+            sentence: `${site.subject} declares ${rejected}.`,
+        });
+    }
+}
 /**
  * One global option's own facts, binding, and extension values, checked at its `globalOption()`
  * call against the Application's descriptors. The rules that pair it with another option belong to
@@ -115,14 +130,7 @@ function declareGlobalOption(state, declared, descriptors) {
     };
     const site = globalSite(input);
     const sentence = site.subject;
-    const rejected = omissionRules.find((key) => key in input.config);
-    if (rejected !== undefined) {
-        throw factFault(globalPresenceRule, site, {
-            correction: `Remove ${rejected}, and check for the value in each Command that needs it.`,
-            fact: rejected,
-            sentence: `${sentence} declares ${rejected}.`,
-        });
-    }
+    checkNoPresenceRule(site, input.config);
     checkDescription(site, input.config.description);
     checkHidden(site, input.config.hidden);
     checkDeprecated(site, input.config.deprecated);
@@ -138,16 +146,15 @@ function declareGlobalOption(state, declared, descriptors) {
     return {
         input,
         state: {
-            bind: (values) => ({ ...state.bind(values), ...values.option(input) }),
             inputs: [...state.inputs, input],
             records: new Map([...state.records, [input, record]]),
         },
     };
 }
 /**
- * The one table the pre-scan reads: the application's global options in authoring order, then each
- * installed plugin's options in installation order. Every collision between the two scopes, by key
- * or by spelling, is reported here, so the pre-scan meets a table with one owner per name.
+ * The globals table: the application's global options in authoring order, then each installed
+ * plugin's options in installation order. Every collision between the two scopes, by key or by
+ * spelling, is reported here, so the parser meets a table with one owner per name.
  */
 function globalTable(inputs, plugins) {
     const names = new Map();
@@ -177,13 +184,47 @@ function globalTable(inputs, plugins) {
     ]);
     return { names, options, variables };
 }
-/** The table one graph build shares, which every earlier call already proved free of collisions. */
+/**
+ * The validated value of each listed option, keyed by declared name. Entries become own keys even
+ * for a name such as `__proto__`, which assignment would not.
+ */
+function optionValues(inputs, values) {
+    return Object.fromEntries(inputs.map((input) => [input.name, values.read(input)]));
+}
+/**
+ * The validated value of each listed option, keyed by declared name, as a plugin reads it: each
+ * value a plain-data copy frozen to every depth, as the request's values are, so a plugin that
+ * reaches into one contributes nothing to what another plugin or the action receives.
+ */
+function frozenValues(inputs, values) {
+    return Object.freeze(Object.fromEntries(inputs.map((input) => [input.name, snapshot(values.read(input))])));
+}
+/**
+ * The table one graph build shares, which every earlier call already proved free of collisions.
+ * A plugin's options are global options, so they join the application's in every reading.
+ */
 function buildGlobals(node, plugins) {
-    return { ...globalTable(node.inputs, plugins), bind: node.bind, inputs: node.inputs, plugins };
+    const inputs = [...node.inputs, ...plugins.flatMap((installed) => installed.inputs)];
+    const sites = new Map(node.inputs.map((input) => [input, globalSite(input)]));
+    for (const installed of plugins) {
+        const siteOf = pluginSites(installed.identity, installed.inputs);
+        for (const input of installed.inputs) {
+            sites.set(input, siteOf(input));
+        }
+    }
+    const table = globalTable(node.inputs, plugins);
+    return {
+        ...table,
+        bind: (values) => optionValues(inputs, values),
+        inputs,
+        plugins,
+        sites,
+        table: new Map(tableEntries(table.options, true)),
+    };
 }
 /**
  * One Command's own options against the globals table, compiled for dispatch. The table holds the
- * application's globals and every plugin option, so a local collision reads the same sentence
+ * application's global options and every plugin's, so a local collision reads the same sentence
  * whichever scope on the other side claimed the name, the spelling, or the variable. One
  * invocation's scope is this Command's own options and the table, so a variable binds one option
  * there, while a sibling Command may bind it again. `scope` names the Command and places each of
@@ -204,7 +245,7 @@ function checkLocalOptions(declarations, table, scope) {
         const claimed = global && table.names.get(global.name);
         const declaration = declarations.find((input) => input.name === option.name);
         if (global && claimed && declaration) {
-            throw spellingCollision(spelling, { ...claimed, name: global.name, role: global.role }, { name: option.name, owner: local, role: option.role, site: siteOf(declaration) });
+            throw spellingCollision(spelling, { ...claimed, name: global.name, origin: global }, { name: option.name, origin: option, owner: local, site: siteOf(declaration) });
         }
     }
     claimVariables(boundOptions(declarations, (input) => ({
@@ -236,9 +277,9 @@ function join(owner, inputs, table) {
         const claimed = existing && names.get(existing.name);
         const own = names.get(option.name);
         if (existing && claimed && own) {
-            throw spellingCollision(spelling, { ...own, name: option.name, role: option.role }, { ...claimed, name: existing.name, role: existing.role });
+            throw spellingCollision(spelling, { ...own, name: option.name, origin: option }, { ...claimed, name: existing.name, origin: existing });
         }
         options.set(spelling, option);
     }
 }
-export { boundOptions, buildGlobals, checkLocalOptions, declareGlobalOption, emptyGlobals, globalSite, globalTable, pluginSites, };
+export { boundOptions, buildGlobals, checkLocalOptions, checkNoPresenceRule, declareGlobalOption, emptyGlobals, frozenValues, globalSite, globalTable, optionValues, pluginSites, };

package/dist/index.d.ts

@@ -5,7 +5,7 @@ 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 { DeclarationError, FatalError, InputError, InternalError, LoomError, MisplacedOptionError, MissingValueError, NonCallableCommandError, RepeatedOptionError, ResultError, 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';
@@ -19,6 +19,7 @@ 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 { reportedSpelling } from './inspect.js';
 export { issuePath } from './validation.js';
 export type { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/spec';
 export type { ApplicationMethod, ApplicationOptions, Packet } from './application.js';
@@ -34,6 +35,6 @@ export type { WordPosition } from './locate.js';
 export type { AnyDeclaredView, AnyOverrideKey, DeclaredRowView, DeclaredView, DeclaredViewBrand, FailureClass, FailureView, FailureViewContext, ReplacementView, ViewContribution, ViewOverride, } from './view.js';
 export type { ArgumentNode, CommandGraph, CommandNode, OptionNode, ResultNode } from './inspect.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 { Action, ActionArgs, ActionContext, ActionHandler, ActionOptions, ArgumentConfig, AttachedCommand, BooleanOption, CommandAttachHook, CountOption, 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, ContextualStyle, Style, ThemeMapping, ThemeConstraint, } from './style.js';

package/dist/index.js

@@ -4,7 +4,7 @@ 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 { DeclarationError, FatalError, InputError, InternalError, LoomError, MisplacedOptionError, MissingValueError, NonCallableCommandError, RepeatedOptionError, ResultError, 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';
@@ -15,4 +15,5 @@ export { checkShortSetting } from './plugin-settings.js';
 export { translate } from './translators.js';
 export { glyph } from './glyphs.generated.js';
 export { pad, style } from './style.js';
+export { reportedSpelling } from './inspect.js';
 export { issuePath } from './validation.js';

package/dist/input-rules.d.ts

@@ -1,4 +1,4 @@
-/** An option declared with a type other than string or Boolean. */
+/** An option declared with a type other than string, Boolean, or count. */
 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;
@@ -9,8 +9,18 @@ declare const shortAlias: import("./diagnostic-text.js").DiagnosticRule;
 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;
+/** `aliases` on an option that declares `shortOnly`. */
+declare const shortOnlyWithAliases: import("./diagnostic-text.js").DiagnosticRule;
 /** `multiple` on a Boolean option. */
 declare const booleanOptionMultiple: import("./diagnostic-text.js").DiagnosticRule;
+/** `multiple` on a counted option. */
+declare const countOptionMultiple: import("./diagnostic-text.js").DiagnosticRule;
+/** `polarity` on a counted option. */
+declare const polarityOnCount: import("./diagnostic-text.js").DiagnosticRule;
+/** `implied` on a Boolean or counted option. */
+declare const impliedOnBooleanOrCount: import("./diagnostic-text.js").DiagnosticRule;
+/** An `implied` value that is not a string. */
+declare const impliedNotAString: import("./diagnostic-text.js").DiagnosticRule;
 /** `polarity` on a string option. */
 declare const polarityOnString: import("./diagnostic-text.js").DiagnosticRule;
 /** A polarity outside the three settings. */
@@ -51,6 +61,8 @@ declare const omissionAlreadyDecided: import("./diagnostic-text.js").DiagnosticR
 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;
+/** `validate`, `default`, `required`, or `validateOmitted` on a counted option. */
+declare const countOptionValueRule: 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. */
@@ -63,6 +75,8 @@ declare const defaultLevels = 10;
 declare const defaultDepth: import("./diagnostic-text.js").DiagnosticRule;
 /** A declared default its validator rejected. */
 declare const invalidDefault: import("./diagnostic-text.js").DiagnosticRule;
+/** A declared implied value its validator rejected. */
+declare const invalidImplied: 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, defaultDepth, defaultLevels, defaultShape, envName, envOnArgument, envOnMultiple, flagNotBoolean, globalOptionAfterCommand, globalPresenceRule, invalidDefault, notAValidator, omissionAlreadyDecided, nameSharedAcrossKinds, omissionWithoutValidator, optionDeclaredTwice, optionPolarity, optionType, polarityOnString, requiredWithDefault, schemaConverterFailed, shortAlias, shortOnlyBothPolarities, shortOnlyWithoutShort, spellingTaken, variableBoundTwice, };
+export { booleanOptionMultiple, booleanOptionValueRule, countOptionMultiple, countOptionValueRule, defaultDepth, defaultLevels, defaultShape, envName, envOnArgument, envOnMultiple, flagNotBoolean, globalOptionAfterCommand, globalPresenceRule, impliedNotAString, impliedOnBooleanOrCount, invalidDefault, invalidImplied, notAValidator, omissionAlreadyDecided, nameSharedAcrossKinds, omissionWithoutValidator, optionDeclaredTwice, optionPolarity, optionType, polarityOnCount, polarityOnString, requiredWithDefault, schemaConverterFailed, shortAlias, shortOnlyBothPolarities, shortOnlyWithAliases, shortOnlyWithoutShort, spellingTaken, variableBoundTwice, };

package/dist/input-rules.js

@@ -4,9 +4,9 @@ import { registerRule } from './diagnostic-text.js';
  * options, and environment bindings. Each is declared once here and shared by every site that
  * raises it, as a plugin's rules are.
  */
-/** An option declared with a type other than string or Boolean. */
+/** An option declared with a type other than string, Boolean, or count. */
 const optionType = registerRule('@loomcli/core/option-type', {
-    explanation: 'The type decides how the parser reads an option: a string option consumes a value, and a Boolean option consumes none. Core reads no other kind.',
+    explanation: 'The type decides how the parser reads an option: a string option consumes a value, a Boolean option consumes none, and a counted option consumes none and counts its occurrences. Core reads no other kind.',
     headline: 'Invalid option type',
 });
 /** A short alias that is not one ASCII letter. */
@@ -27,11 +27,36 @@ const shortOnlyWithoutShort = registerRule('@loomcli/core/short-only-without-sho
     explanation: 'shortOnly removes every long spelling of an option, so an option with no short alias would leave an operator no spelling to type.',
     headline: 'Short only with no short alias',
 });
+/** `aliases` on an option that declares `shortOnly`. */
+const shortOnlyWithAliases = registerRule('@loomcli/core/short-only-with-aliases', {
+    explanation: 'shortOnly removes every long spelling of an option, and each alias adds a long spelling, so an option cannot declare both.',
+    headline: 'Short only with aliases',
+});
 /** `multiple` on a Boolean option. */
 const booleanOptionMultiple = registerRule('@loomcli/core/boolean-option-multiple', {
     explanation: 'A Boolean option reports whether its spelling was supplied, so a repeat has no second value to collect. multiple collects each occurrence of a string option into an array.',
     headline: 'Boolean option takes one value',
 });
+/** `multiple` on a counted option. */
+const countOptionMultiple = registerRule('@loomcli/core/count-option-multiple', {
+    explanation: 'A counted option already counts every occurrence of every spelling, so it has no values to collect. multiple collects each occurrence of a string option into an array.',
+    headline: 'Counted option takes no values',
+});
+/** `polarity` on a counted option. */
+const polarityOnCount = registerRule('@loomcli/core/polarity-on-count', {
+    explanation: 'Polarity chooses which long forms a Boolean option accepts and what its absence means. A counted option reads how many times it was supplied, so it has no negative form and no polarity.',
+    headline: 'Polarity on a counted option',
+});
+/** `implied` on a Boolean or counted option. */
+const impliedOnBooleanOrCount = registerRule('@loomcli/core/implied-on-boolean-or-count', {
+    explanation: 'An implied value is the value a bare spelling of a string option supplies. A Boolean option and a counted option take no value, so a bare spelling already says everything they read.',
+    headline: 'Implied on a valueless option',
+});
+/** An `implied` value that is not a string. */
+const impliedNotAString = registerRule('@loomcli/core/implied-not-a-string', {
+    explanation: "An implied value stands in for the string an operator would otherwise attach to the spelling, so it is a string, in the validator's input type.",
+    headline: 'Implied value not a string',
+});
 /** `polarity` on a string option. */
 const polarityOnString = registerRule('@loomcli/core/polarity-on-string', {
     explanation: 'Polarity chooses which long forms a Boolean option accepts and what its absence means. A string option takes its value from the operator, so it has no polarity.',
@@ -52,7 +77,7 @@ const shortOnlyBothPolarities = registerRule('@loomcli/core/short-only-both-pola
  * plugin's hook declared.
  */
 const spellingTaken = registerRule('@loomcli/core/spelling-taken', {
-    explanation: "The parser reads each spelling as one option, and a Command's own options share one invocation with the global options and every installed plugin's options. A spelling two options claim, a short alias or a generated negative form included, would reach only one of them.",
+    explanation: "The parser reads each spelling as one option, and a Command's own options share one invocation with the global options and every installed plugin's options. A spelling two options claim, a short alias, an alias, or a generated negative form included, would reach only one of them.",
     headline: 'Spelling used twice',
 });
 /**
@@ -60,7 +85,7 @@ const spellingTaken = registerRule('@loomcli/core/spelling-taken', {
  * plugin's hook declared.
  */
 const optionDeclaredTwice = registerRule('@loomcli/core/option-declared-twice', {
-    explanation: "An action reads the global options and its Command's own options from one options object, each under its declared name, and the pre-scan reads the global options and every installed plugin's options from one table. Two options with one name in either leave one of them unreadable.",
+    explanation: "An action reads the global options and its Command's own options from one options object, each under its declared name, and the global options, the application's and every installed plugin's, share every Command's one table of spellings. Two options with one name in either leave one of them unreadable.",
     headline: 'Option declared twice',
 });
 /**
@@ -117,6 +142,11 @@ const booleanOptionValueRule = registerRule('@loomcli/core/boolean-option-value-
     explanation: 'A Boolean option consumes no value, so there is nothing to validate, and its polarity decides the value an absent option reads. validate, default, required, and validateOmitted belong to inputs that take a value.',
     headline: 'Value rule on a Boolean option',
 });
+/** `validate`, `default`, `required`, or `validateOmitted` on a counted option. */
+const countOptionValueRule = registerRule('@loomcli/core/count-option-value-rule', {
+    explanation: 'A counted option consumes no value and reads how many times it was supplied, 0 when nothing supplied it, so there is nothing to validate and no absence to decide. validate, default, required, and validateOmitted belong to inputs that take a value.',
+    headline: 'Value rule on a counted option',
+});
 /** A required input that also declares a default. */
 const requiredWithDefault = registerRule('@loomcli/core/required-with-default', {
     explanation: 'A default fills an omitted value, and a required input fails when it is omitted, so a required input never reads its default.',
@@ -144,9 +174,14 @@ const invalidDefault = registerRule('@loomcli/core/invalid-default', {
     explanation: 'Each run passes every declared default through its validator before it reads a token, because a default reaches the action as a validated value. A default the validator rejects would reach no action, whatever the operator supplies.',
     headline: 'Default rejected',
 });
+/** A declared implied value its validator rejected. */
+const invalidImplied = registerRule('@loomcli/core/invalid-implied', {
+    explanation: 'Each run passes every implied value through its validator before it reads a token, because a bare spelling supplies it to the action as a validated value. An implied value the validator rejects is the declaration at fault, whatever the operator supplies, so the run reports it whether or not a bare spelling was typed.',
+    headline: 'Implied value rejected',
+});
 /** A validator's JSON Schema converter that threw or returned a value that is not a plain object. */
 const schemaConverterFailed = registerRule('@loomcli/core/schema-converter-failed', {
     explanation: "Help, the manifest, and completion read what an input accepts from the JSON Schema its validator publishes. A converter that throws or returns anything but a plain object publishes no shape, so a distributed build reads the input's schema as null.",
     headline: 'Schema converter failed',
 });
-export { booleanOptionMultiple, booleanOptionValueRule, defaultDepth, defaultLevels, defaultShape, envName, envOnArgument, envOnMultiple, flagNotBoolean, globalOptionAfterCommand, globalPresenceRule, invalidDefault, notAValidator, omissionAlreadyDecided, nameSharedAcrossKinds, omissionWithoutValidator, optionDeclaredTwice, optionPolarity, optionType, polarityOnString, requiredWithDefault, schemaConverterFailed, shortAlias, shortOnlyBothPolarities, shortOnlyWithoutShort, spellingTaken, variableBoundTwice, };
+export { booleanOptionMultiple, booleanOptionValueRule, countOptionMultiple, countOptionValueRule, defaultDepth, defaultLevels, defaultShape, envName, envOnArgument, envOnMultiple, flagNotBoolean, globalOptionAfterCommand, globalPresenceRule, impliedNotAString, impliedOnBooleanOrCount, invalidDefault, invalidImplied, notAValidator, omissionAlreadyDecided, nameSharedAcrossKinds, omissionWithoutValidator, optionDeclaredTwice, optionPolarity, optionType, polarityOnCount, polarityOnString, requiredWithDefault, schemaConverterFailed, shortAlias, shortOnlyBothPolarities, shortOnlyWithAliases, shortOnlyWithoutShort, spellingTaken, variableBoundTwice, };