@loomcli/core 0.6.0 → 0.8.0

package/dist/errors.d.ts

@@ -10,20 +10,6 @@ import type { InputIdentity } from './types.js';
  * keeps the raw value.
  */
 export declare function quoted(value: unknown): string;
-/**
- * The two short-group faults. A value option that is not last in its group names that option's
- * spelling; a group that mixes scopes names only the two letters that disagree, because the rest
- * of the group may hold an inline value. `token` keeps the whole group as the reported fact.
- */
-type ShortGroupFault = {
-    reason: 'value-position';
-    token: string;
-} | {
-    reason: 'mixed-scope';
-    token: string;
-    global: string;
-    other: string;
-};
 /**
  * The one message a distributed build shows an operator for a defect or a declaration fault: the
  * application name and a fixed phrase, with no reason, class name, code, or path.
@@ -123,24 +109,39 @@ export declare class UnknownOptionError extends UsageError {
     readonly spelling: string;
     constructor(spelling: string);
 }
+/**
+ * Where a missing value should have been: the words ran out, or the next word was an option word or
+ * the bare `--`, which is never a separate value, so the sentence names the attached form too.
+ */
+type MissingValueForm = 'attached' | 'separate';
 export declare class MissingValueError extends UsageError {
     readonly spelling: string;
-    constructor(spelling: string);
+    constructor(spelling: string, form?: MissingValueForm);
 }
-/** 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 declare class UnexpectedValueError extends UsageError {
     readonly spelling: string;
     readonly value: string;
-    constructor(spelling: string, value: string);
+    constructor(spelling: string, value: string, kind?: 'boolean' | 'count');
 }
 export declare class RepeatedOptionError extends UsageError {
     readonly spelling: string;
     constructor(spelling: string);
 }
-export declare class ShortGroupError extends UsageError {
-    readonly token: string;
-    readonly reason: 'value-position' | 'mixed-scope';
-    constructor(fault: ShortGroupFault);
+/**
+ * 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 declare class MisplacedOptionError extends UsageError {
+    readonly spelling: string;
+    readonly commands: readonly (readonly string[])[];
+    constructor(spelling: string, commands: readonly (readonly string[])[]);
 }
 /**
  * Exit 1: the declaration is wrong, so the author reads its Developer Diagnostic. A rule and the

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

@@ -9,6 +9,11 @@ export interface FactSite {
     readonly declaration: Omit<Finding, 'mark' | 'note'>;
     readonly at: string;
 }
+/**
+ * The note a finding carries for what a plugin declared on the author's behalf, such as an input
+ * its hook declares or the settings its factory takes, so the diagnostic names the declarer.
+ */
+export declare function declarerNote(identity: string): string;
 /** The finding for the call one site holds, marking one part of it, with a note when given. */
 export declare function siteFinding(site: FactSite, mark: string, note?: string): Finding;
 /**

package/dist/facts.js

@@ -1,5 +1,5 @@
 import { misplacedListingFact, notOneLine } from './command-rules.js';
-import { DeclarationError } from './errors.js';
+import { DeclarationError, quoted } from './errors.js';
 import { flagNotBoolean } from './input-rules.js';
 /**
  * One character outside Unicode `White_Space`, so a fact holds prose and not only spacing.
@@ -12,6 +12,13 @@ const prose = /\P{White_Space}/u;
  * The seven are LF, VT, FF, CR, NEL, LS, and PS, each of them `White_Space` too.
  */
 const lineTerminator = /[\n\v\f\r\u0085\u2028\u2029]/u;
+/**
+ * The note a finding carries for what a plugin declared on the author's behalf, such as an input
+ * its hook declares or the settings its factory takes, so the diagnostic names the declarer.
+ */
+export function declarerNote(identity) {
+    return `declared by plugin ${quoted(identity)}`;
+}
 /** The finding for the call one site holds, marking one part of it, with a note when given. */
 export function siteFinding(site, mark, note) {
     const finding = { ...site.declaration, mark };

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,8 +3,9 @@ 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 { captureConfig, checkInputConfig } from './validation.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';
 /**
  * The presence keys a global option may not declare, in the order its diagnostic names them. A
@@ -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) {
@@ -99,7 +100,21 @@ function globalSite(input) {
  */
 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 "${input.name}"`);
+    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()`
@@ -108,19 +123,14 @@ function pluginSites(identity, inputs) {
  */
 function declareGlobalOption(state, declared, descriptors) {
     // The name is judged before the config, as every other declaration judges its own name first.
-    checkOptionName(declared.name, globalSite(declared));
-    checkInputConfig(declared, { call: 'globalOption', path: [] });
-    const input = { ...declared, config: captureConfig(declared.config) };
+    checkOptionName(declared.name, configUnread(globalSite(declared)));
+    const input = {
+        ...declared,
+        config: captureInputConfig(declared, { call: 'globalOption', path: [] }),
+    };
     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);
@@ -136,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();
@@ -168,20 +177,54 @@ function globalTable(inputs, plugins) {
         ...plugins.flatMap((installed) => {
             const siteOf = pluginSites(installed.identity, installed.inputs);
             return boundOptions(installed.inputs, (input) => ({
-                phrase: `plugin ${quoted(installed.identity)} option "${input.name}"`,
+                phrase: `plugin ${quoted(installed.identity)} option ${quoted(input.name)}`,
                 site: siteOf(input),
             }));
         }),
     ]);
     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
@@ -202,11 +245,11 @@ 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) => ({
-        phrase: `${subject} option "${input.name}"`,
+        phrase: `${subject} option ${quoted(input.name)}`,
         site: siteOf(input),
     })), table.variables);
     return options;
@@ -234,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/glyphs.generated.js

@@ -1,5 +1,5 @@
 // Generated by scripts/check-glyph-catalog.py from Inquirer a446ea9e273864a3653a26943f59b4fbe8003796.
-/*
+/*!
 Copyright (c) 2025 Simon Boudrias
 
 Permission is hereby granted, free of charge, to any person

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';
@@ -13,11 +13,13 @@ export { locate } from './locate.js';
 export { incompleteResult, lanes } from './lanes.js';
 export { override, view } from './view.js';
 export { plugin } from './plugin.js';
+export { checkShortSetting } from './plugin-settings.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 { 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';
@@ -30,9 +32,9 @@ export type { CancellationReason } from './signals.js';
 export type { ErrorClass, Translation, Translator } from './translators.js';
 export type { IncompleteResult } from './lanes.js';
 export type { WordPosition } from './locate.js';
-export type { AnyDeclaredView, DeclaredRowView, DeclaredView, DeclaredViewBrand, FailureClass, FailureView, FailureViewContext, ViewContribution, ViewOverride, } from './view.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,14 +4,16 @@ 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';
 export { incompleteResult, lanes } from './lanes.js';
 export { override, view } from './view.js';
 export { plugin } from './plugin.js';
+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,14 +61,22 @@ 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. */
 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;
+/** The most arrays and plain objects any path through a declared default may hold. */
+declare const defaultLevels = 10;
+/** A declared default nested deeper than `defaultLevels`. */
+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, 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, };