@loomcli/core 0.5.0 → 0.7.0

package/dist/plugin-rules.d.ts

@@ -0,0 +1,68 @@
+/** A slot that holds a list, such as `plugins` or `commands`, holding a value of another kind. */
+declare const notAList: import("./diagnostic-text.js").DiagnosticRule;
+/**
+ * A declaration core reads by its keys, such as a plugin's middleware or a constructor's options,
+ * that is not an object.
+ */
+declare const notAnObject: import("./diagnostic-text.js").DiagnosticRule;
+/**
+ * A declaration whose read throws while core takes its one copy, such as a getter that throws or a
+ * proxy whose trap throws: the config of an argument or option, a plugin's definition and each of
+ * its option declarations, and the options of a Command or of the Application.
+ */
+declare const unreadableDeclaration: import("./diagnostic-text.js").DiagnosticRule;
+/** A list entry that its factory did not build, such as a hand-made plugin or translation. */
+declare const foreignValue: import("./diagnostic-text.js").DiagnosticRule;
+/** One plugin identity installed twice. */
+declare const pluginInstalledTwice: import("./diagnostic-text.js").DiagnosticRule;
+/** A second plugin claiming the theme, the signals, or the configuration source slot. */
+declare const slotTaken: import("./diagnostic-text.js").DiagnosticRule;
+/** A plugin, extension, or view identity outside the identity grammar. */
+declare const invalidIdentity: import("./diagnostic-text.js").DiagnosticRule;
+/** A validator or a presence rule on a plugin option. */
+declare const pluginOptionRule: import("./diagnostic-text.js").DiagnosticRule;
+/** A middleware activation that is missing, empty, or names an option the plugin lacks. */
+declare const middlewareActivation: import("./diagnostic-text.js").DiagnosticRule;
+/** A loader, a hook, or a translator that core cannot call. */
+declare const notAFunction: import("./diagnostic-text.js").DiagnosticRule;
+/** A claimed signal outside SIGINT and SIGTERM. */
+declare const unknownSignal: import("./diagnostic-text.js").DiagnosticRule;
+/** One signal claimed twice by one plugin. */
+declare const signalClaimedTwice: import("./diagnostic-text.js").DiagnosticRule;
+/** A configuration source binding that is not one of the plugin's option extensions. */
+declare const sourceBinding: import("./diagnostic-text.js").DiagnosticRule;
+/** A plugin option that carries its own plugin's source binding. */
+declare const sourceBoundOwnOption: import("./diagnostic-text.js").DiagnosticRule;
+/** Two distinct objects under one extension or declared-view identity. */
+declare const twoPackageCopies: import("./diagnostic-text.js").DiagnosticRule;
+/** A descriptor with no Standard Schema. */
+declare const extensionWithoutSchema: import("./diagnostic-text.js").DiagnosticRule;
+/** An extension value on a declaration its descriptor does not target. */
+declare const extensionTarget: import("./diagnostic-text.js").DiagnosticRule;
+/** Two values of one extension in one layer. */
+declare const extensionValueTwice: import("./diagnostic-text.js").DiagnosticRule;
+/** An extension value its schema rejects, by an issue or by a throw. */
+declare const invalidExtensionValue: import("./diagnostic-text.js").DiagnosticRule;
+/** An extension schema that answers with a promise. */
+declare const asyncExtensionSchema: import("./diagnostic-text.js").DiagnosticRule;
+/** An extension output that is not plain data. */
+declare const extensionOutput: import("./diagnostic-text.js").DiagnosticRule;
+/** An override whose key is neither a declared view nor a failure class. */
+declare const overrideKey: import("./diagnostic-text.js").DiagnosticRule;
+/** One key overridden twice inside one contributor. */
+declare const overrideTwice: import("./diagnostic-text.js").DiagnosticRule;
+/** A `translate()` key that is not a class, or that is a failure class. */
+declare const translationKey: import("./diagnostic-text.js").DiagnosticRule;
+/** An `onCommandAttach` hook that threw or returned a value that is not the attached Command. */
+declare const brokenAttachHook: import("./diagnostic-text.js").DiagnosticRule;
+/** The retired `globals` or `failures` Application option. */
+declare const retiredApplicationOption: import("./diagnostic-text.js").DiagnosticRule;
+/** A packet that is not an object, or whose build is neither value. */
+declare const invalidPacket: import("./diagnostic-text.js").DiagnosticRule;
+/** A rendering policy that is not an object, or holds a setting outside its closed set. */
+declare const renderingPolicyRule: import("./diagnostic-text.js").DiagnosticRule;
+/** A plugin theme that is not a mapping of names to unapplied concrete style chains. */
+declare const themeMapping: import("./diagnostic-text.js").DiagnosticRule;
+/** A theme name that a built-in style member already holds. */
+declare const themeNameTaken: import("./diagnostic-text.js").DiagnosticRule;
+export { asyncExtensionSchema, brokenAttachHook, extensionOutput, extensionTarget, extensionValueTwice, extensionWithoutSchema, foreignValue, invalidExtensionValue, invalidIdentity, invalidPacket, middlewareActivation, notAFunction, notAList, notAnObject, overrideKey, overrideTwice, pluginInstalledTwice, pluginOptionRule, renderingPolicyRule, retiredApplicationOption, signalClaimedTwice, slotTaken, sourceBinding, sourceBoundOwnOption, themeMapping, themeNameTaken, translationKey, twoPackageCopies, unknownSignal, unreadableDeclaration, };

package/dist/plugin-rules.js

@@ -0,0 +1,164 @@
+import { registerRule } from './diagnostic-text.js';
+/*
+ * Core's rules for the declaration faults of plugins, extensions, views, translators, lifecycle
+ * hooks, and the Application options that install them. Each is declared once here and shared by
+ * every site that raises it, as a plugin's rules are.
+ */
+/** A slot that holds a list, such as `plugins` or `commands`, holding a value of another kind. */
+const notAList = registerRule('@loomcli/core/not-a-list', {
+    explanation: 'Core reads plugins, commands, extensions, views, translators, and signals each as a list, in order. A value of any other kind has no entries to read.',
+    headline: 'Not a list',
+});
+/**
+ * A declaration core reads by its keys, such as a plugin's middleware or a constructor's options,
+ * that is not an object.
+ */
+const notAnObject = registerRule('@loomcli/core/not-an-object', {
+    explanation: "Core reads the options of a Command and of the Application, a plugin's definition, its options record, each of its option declarations, its middleware, its source, the config of an argument or option, and the settings a plugin factory takes by their keys. A value of any other kind has no keys to read.",
+    headline: 'Not an object',
+});
+/**
+ * A declaration whose read throws while core takes its one copy, such as a getter that throws or a
+ * proxy whose trap throws: the config of an argument or option, a plugin's definition and each of
+ * its option declarations, and the options of a Command or of the Application.
+ */
+const unreadableDeclaration = registerRule('@loomcli/core/unreadable-declaration', {
+    explanation: 'Core reads a declaration by its keys, and each list in it by index, once, at the call that declares it, and checks and records the copy it takes. A read that throws, such as a throwing getter or proxy trap, leaves core nothing to check or record.',
+    headline: 'Declaration could not be read',
+});
+/** A list entry that its factory did not build, such as a hand-made plugin or translation. */
+const foreignValue = registerRule('@loomcli/core/foreign-value', {
+    explanation: 'Core reads a plugin, an extension, an extension value, a declared view, a view override, and a translation through facts its factory recorded when it built the value. Any other value carries none, even one of the same shape.',
+    headline: 'Value not from its factory',
+});
+/** One plugin identity installed twice. */
+const pluginInstalledTwice = registerRule('@loomcli/core/plugin-installed-twice', {
+    explanation: 'Core keys each plugin by its identity, and a plugin contributes its options, middleware, hooks, and views once, so a second installation would contribute each of them again.',
+    headline: 'Plugin installed twice',
+});
+/** A second plugin claiming the theme, the signals, or the configuration source slot. */
+const slotTaken = registerRule('@loomcli/core/slot-taken', {
+    explanation: 'A slot is a position exactly one plugin claims: the theme, the process signals, and the configuration source. A second claim would leave two plugins answering where core asks one.',
+    headline: 'Slot already claimed',
+});
+/** A plugin, extension, or view identity outside the identity grammar. */
+const invalidIdentity = registerRule('@loomcli/core/invalid-identity', {
+    explanation: 'An identity keys what a plugin, an extension, or a view contributes, names it in every diagnostic, and prefixes the identities of the rules its package declares, so it is a package name as npm spells one, scoped or not, then any subpath segments, each after a / and each of lowercase letters and digits in words joined by single hyphens.',
+    headline: 'Invalid identity',
+});
+/** A validator or a presence rule on a plugin option. */
+const pluginOptionRule = registerRule('@loomcli/core/plugin-option-rule', {
+    explanation: "A plugin's middleware interprets its own options' values, so a plugin option declares how it parses and nothing more: no validator and no presence rule.",
+    headline: 'Rule on a plugin option',
+});
+/** A middleware activation that is missing, empty, or names an option the plugin lacks. */
+const middlewareActivation = registerRule('@loomcli/core/middleware-activation', {
+    explanation: "Activation decides when core loads a plugin's middleware: on every run with 'always', or only when an invocation supplies one of the plugin's own options the list names, so a middleware no invocation needs costs it nothing.",
+    headline: 'Invalid middleware activation',
+});
+/** A loader, a hook, or a translator that core cannot call. */
+const notAFunction = registerRule('@loomcli/core/not-a-function', {
+    explanation: 'Core calls each of these values at a point of its own: load when a run first reaches a middleware or a source, onCommandAttach at graph build, onFailure when a failure renders, and a translator when a foreign throw reaches it. A value core cannot call leaves it nothing to run.',
+    headline: 'Not a function',
+});
+/** A claimed signal outside SIGINT and SIGTERM. */
+const unknownSignal = registerRule('@loomcli/core/unknown-signal', {
+    explanation: 'Core installs listeners for SIGINT and SIGTERM alone, the two signals that ask a command-line program to stop, so a plugin claims one of those.',
+    headline: 'Unknown signal',
+});
+/** One signal claimed twice by one plugin. */
+const signalClaimedTwice = registerRule('@loomcli/core/signal-claimed-twice', {
+    explanation: 'Core installs one listener for each signal a plugin claims, and a second listener on one signal would take the forced path on the first signal the run receives.',
+    headline: 'Signal claimed twice',
+});
+/** A configuration source binding that is not one of the plugin's option extensions. */
+const sourceBinding = registerRule('@loomcli/core/source-binding', {
+    explanation: 'A configuration source answers the options that carry its binding, an extension the plugin lists under extensions that applies to options. Core asks the source about those options without knowing what the binding means.',
+    headline: 'Invalid source binding',
+});
+/** A plugin option that carries its own plugin's source binding. */
+const sourceBoundOwnOption = registerRule('@loomcli/core/source-bound-own-option', {
+    explanation: "A plugin's own options resolve before its configuration source loads, because the source reads them, so none of them can take a value from that source.",
+    headline: 'Source bound to its own option',
+});
+/** Two distinct objects under one extension or declared-view identity. */
+const twoPackageCopies = registerRule('@loomcli/core/two-package-copies', {
+    explanation: 'Core keys each extension and each declared view by its identity and compares it by reference. Two distinct objects under one identity mean two copies of the package that defines it are installed, and a value one copy made cannot be read through the other.',
+    headline: 'Two copies of one package',
+});
+/** A descriptor with no Standard Schema. */
+const extensionWithoutSchema = registerRule('@loomcli/core/extension-without-schema', {
+    explanation: "Core validates each extension value against its descriptor's Standard Schema at the call that carries it, so a descriptor with no schema leaves the value unchecked.",
+    headline: 'Extension without a schema',
+});
+/** An extension value on a declaration its descriptor does not target. */
+const extensionTarget = registerRule('@loomcli/core/extension-target', {
+    explanation: 'An extension is defined for one target, Commands, options, or arguments, and a typed read takes that kind of node alone, so a value on another kind would never be read.',
+    headline: 'Extension on the wrong target',
+});
+/** Two values of one extension in one layer. */
+const extensionValueTwice = registerRule('@loomcli/core/extension-value-twice', {
+    explanation: 'One extensions list or one extend() call sets each extension once, collecting or not, so two values of one extension leave it unclear which the author meant.',
+    headline: 'Extension value twice',
+});
+/** An extension value its schema rejects, by an issue or by a throw. */
+const invalidExtensionValue = registerRule('@loomcli/core/invalid-extension-value', {
+    explanation: "An extension value passes its descriptor's schema at the call that carries it, so every plugin that reads it reads a value the schema accepted.",
+    headline: 'Invalid extension value',
+});
+/** An extension schema that answers with a promise. */
+const asyncExtensionSchema = registerRule('@loomcli/core/async-extension-schema', {
+    explanation: 'Core validates extension values synchronously while it builds the declaration, so a schema that answers with a promise leaves it no verdict to read.',
+    headline: 'Asynchronous extension schema',
+});
+/** An extension output that is not plain data. */
+const extensionOutput = registerRule('@loomcli/core/extension-output', {
+    explanation: "Every projection, the manifest included, reads an extension's output as frozen plain data: strings, finite numbers, Booleans, null, arrays, and plain objects.",
+    headline: 'Extension output not plain data',
+});
+/** An override whose key is neither a declared view nor a failure class. */
+const overrideKey = registerRule('@loomcli/core/override-key', {
+    explanation: 'An override replaces the view of a declared view or of a failure class, so its key is one of them.',
+    headline: 'Invalid override key',
+});
+/** One key overridden twice inside one contributor. */
+const overrideTwice = registerRule('@loomcli/core/override-twice', {
+    explanation: 'Within one contributor, one key answers to one override, so two leave it unclear which the author meant. The same key overridden by two contributors resolves to the first installed.',
+    headline: 'Key overridden twice',
+});
+/** A `translate()` key that is not a class, or that is a failure class. */
+const translationKey = registerRule('@loomcli/core/translation-key', {
+    explanation: 'A translation keys on the foreign error class it replaces. Core offers a translator only a thrown value no failure class made, so the key is a class and never a failure class.',
+    headline: 'Invalid translation key',
+});
+/** An `onCommandAttach` hook that threw or returned a value that is not the attached Command. */
+const brokenAttachHook = registerRule('@loomcli/core/broken-attach-hook', {
+    explanation: "onCommandAttach receives each Command's declaration at graph build and returns it, or a value derived from it, synchronously and without throwing. Core builds the Command the hook returns, so a throw or any other value leaves it nothing to build.",
+    headline: 'Broken attach hook',
+});
+/** The retired `globals` or `failures` Application option. */
+const retiredApplicationOption = registerRule('@loomcli/core/retired-application-option', {
+    explanation: 'The Application no longer reads globals or failures. A global option is declared with globalOption(), so its type reaches every action, and a failure view is an override under views.',
+    headline: 'Retired Application option',
+});
+/** A packet that is not an object, or whose build is neither value. */
+const invalidPacket = registerRule('@loomcli/core/invalid-packet', {
+    explanation: 'The packet says whether the application was built for development, which decides whether a defect shows the author its Developer Diagnostic or the operator one generic message. Its build reads development or distributed.',
+    headline: 'Invalid packet',
+});
+/** A rendering policy that is not an object, or holds a setting outside its closed set. */
+const renderingPolicyRule = registerRule('@loomcli/core/rendering-policy', {
+    explanation: 'The rendering policy decides whether output carries color, modifiers, hyperlinks, and terminal controls. color, modifiers, and hyperlinks each read auto, always, or never, and terminalControls reads strip or preserve.',
+    headline: 'Invalid rendering policy',
+});
+/** A plugin theme that is not a mapping of names to unapplied concrete style chains. */
+const themeMapping = registerRule('@loomcli/core/theme-mapping', {
+    explanation: "A plugin's theme maps each name to an unapplied chain of concrete styles. A semantic token reads the theme itself, so a chain that holds one has no concrete style to resolve to.",
+    headline: 'Invalid theme mapping',
+});
+/** A theme name that a built-in style member already holds. */
+const themeNameTaken = registerRule('@loomcli/core/theme-name-taken', {
+    explanation: 'Each theme name becomes a member of the style object beside the built-in members, so a name a built-in already holds would hide it.',
+    headline: 'Theme name taken',
+});
+export { asyncExtensionSchema, brokenAttachHook, extensionOutput, extensionTarget, extensionValueTwice, extensionWithoutSchema, foreignValue, invalidExtensionValue, invalidIdentity, invalidPacket, middlewareActivation, notAFunction, notAList, notAnObject, overrideKey, overrideTwice, pluginInstalledTwice, pluginOptionRule, renderingPolicyRule, retiredApplicationOption, signalClaimedTwice, slotTaken, sourceBinding, sourceBoundOwnOption, themeMapping, themeNameTaken, translationKey, twoPackageCopies, unknownSignal, unreadableDeclaration, };

package/dist/plugin-settings.d.ts

@@ -0,0 +1,18 @@
+/** The plugin factory whose settings `checkShortSetting` judges, and the option `short` spells. */
+interface ShortSettingDeclarer {
+    /** The plugin's identity, which the sentence and each finding's note name. */
+    readonly plugin: string;
+    /** The factory's name, the call each finding quotes, such as `'format'`. */
+    readonly call: string;
+    /** The name of the option the setting gives a short spelling, such as `'format'`. */
+    readonly option: string;
+}
+/**
+ * Judges a plugin factory's settings at its call, under core's own rules: settings that are neither
+ * undefined nor a plain object are the not-an-object fault, and a `short` that is not one ASCII
+ * letter is the short-alias fault every option's short spelling answers, in the same sentence. Each
+ * finding quotes the factory's call and names the plugin, so a first-party plugin that takes a short
+ * spelling as `{ short }` reports it where the author wrote it.
+ */
+export declare function checkShortSetting(settings: unknown, declarer: ShortSettingDeclarer): void;
+export {};

package/dist/plugin-settings.js

@@ -0,0 +1,38 @@
+import { DeclarationError, quoted } from './errors.js';
+import { declarerNote } from './facts.js';
+import { shortAlias } from './input-rules.js';
+import { shortAliasText, isShortAlias } from './options.js';
+import { isPlainObject } from './plain.js';
+import { notAnObject } from './plugin-rules.js';
+/**
+ * Judges a plugin factory's settings at its call, under core's own rules: settings that are neither
+ * undefined nor a plain object are the not-an-object fault, and a `short` that is not one ASCII
+ * letter is the short-alias fault every option's short spelling answers, in the same sentence. Each
+ * finding quotes the factory's call and names the plugin, so a first-party plugin that takes a short
+ * spelling as `{ short }` reports it where the author wrote it.
+ */
+export function checkShortSetting(settings, declarer) {
+    if (settings === undefined) {
+        return;
+    }
+    const { call, option, plugin } = declarer;
+    const finding = (mark) => ({
+        arguments: [settings],
+        call,
+        mark,
+        note: declarerNote(plugin),
+    });
+    if (!isPlainObject(settings)) {
+        throw new DeclarationError(notAnObject, {
+            correction: 'Supply a settings object, or omit the settings.',
+            findings: [finding('0')],
+            sentence: `Plugin ${quoted(plugin)} declares settings that are not an object.`,
+        });
+    }
+    if (settings.short !== undefined && !isShortAlias(settings.short)) {
+        throw new DeclarationError(shortAlias, {
+            ...shortAliasText(`Option ${quoted(option)}`),
+            findings: [finding('0.short')],
+        });
+    }
+}

package/dist/plugin.d.ts

@@ -1,15 +1,17 @@
 import type { MiddlewareContext } from './chain.js';
 import type { AttachedChild, Command } from './command.js';
-import type { AnyExtension, DescriptorRegistry } from './extension.js';
+import type { AdmittedDescriptor, AnyExtension, DescriptorRegistry } from './extension.js';
 import type { InputRecords } from './globals.js';
+import type { FailureHook } from './hints.js';
 import type { CommandGraph, OptionNode } from './inspect.js';
 import type { OptionValues } from './options.js';
 import type { ProcessSignal } from './signals.js';
 import type { Palette } from './style-state.js';
 import type { ContextualStyle, ThemeConstraint, ThemeMapping } from './style.js';
+import type { Translation, TranslationContributor } from './translators.js';
 import type { CommandAttachHook, Host, OptionValue, Out, PluginOptionConfig } from './types.js';
 import type { OptionInput } from './validation.js';
-import type { ViewContribution } from './view.js';
+import type { ViewContribution, ViewSubject } from './view.js';
 /**
  * The declaration record a plugin contributes its options under: the parsing part of an option
  * config, keyed by option name. A plugin option carries no schema and no presence rule, so the
@@ -78,9 +80,10 @@ interface SourceAnswer {
 type SourceResolver<Contributor extends Plugin | ((...args: never[]) => Plugin)> = (context: SourceContext<OptionsOf<Contributor>>) => Promise<Readonly<Record<string, SourceAnswer>>>;
 /**
  * Everything a plugin declares. `plugin()` checks every rule the definition carries on its own, and
- * creating and installing the value runs none of its code: a hook runs at graph build, the
- * middleware runs inside an invocation, and the configuration source runs in the input-source
- * stage when an unfilled option carries its binding.
+ * creating and installing the value runs none of its code: `onCommandAttach` runs at graph build,
+ * `onFailure` runs when `run()` renders a failure, the middleware runs inside an invocation, the
+ * configuration source runs in the input-source stage when an unfilled option carries its binding,
+ * and a translator runs when a foreign throw its key matches leaves the application's work.
  */
 interface PluginDefinition<Options extends PluginOptions = PluginOptions, Theme extends ThemeMapping = ThemeMapping> {
     theme?: Theme & ThemeConstraint<Theme>;
@@ -92,8 +95,10 @@ interface PluginDefinition<Options extends PluginOptions = PluginOptions, Theme
         }>;
     };
     onCommandAttach?: CommandAttachHook;
+    onFailure?: FailureHook;
     extensions?: readonly AnyExtension[];
     views?: readonly ViewContribution[];
+    translators?: readonly Translation[];
     signals?: readonly ('SIGINT' | 'SIGTERM')[];
     source?: {
         binding: AnyExtension & {
@@ -107,13 +112,16 @@ interface PluginDefinition<Options extends PluginOptions = PluginOptions, Theme
 }
 /**
  * One plugin: an identity and the contributions it carries. Creating and installing the value runs
- * none of its code: a hook runs at graph build, and the middleware runs inside an invocation, so an
- * installed plugin an invocation never reaches costs that invocation its hooks alone. Every rule
- * that one definition carries on its own throws here, before the value exists.
+ * none of its code: `onCommandAttach` runs at graph build, `onFailure` runs when `run()` renders a
+ * failure, and the middleware runs inside an invocation, so an installed plugin an invocation never
+ * reaches costs that invocation its hooks alone. The definition is read once, after the identity,
+ * and every rule that one definition carries on its own throws here, before the value exists.
  */
 declare function plugin<Options extends PluginOptions = {}, const Theme extends ThemeMapping = {}>(identity: string, definition: PluginDefinition<Options, Theme>): Plugin<NoInfer<Options>, NoInfer<Theme>>;
 /** How every plugin diagnostic names one plugin at the start of a sentence. */
 declare function pluginSentence(identity: string): string;
+/** The subject a plugin's `views` list reports under, and the call that declared it. */
+declare function pluginViews(identity: string): ViewSubject;
 /** What the installed list resolves to: the plugins in order, and every descriptor they define. */
 interface InstalledPlugins {
     descriptors: DescriptorRegistry;
@@ -122,11 +130,11 @@ interface InstalledPlugins {
 /**
  * The installed list in composition order, with every rule that reads two plugins together: an
  * identity installed twice, a second claim on the theme slot, the signals slot, or the
- * configuration source, and two distinct descriptors under one identity. The slot is read
- * defensively, because a JavaScript author reaches it with any value. Each plugin's own rules
- * already ran at its `plugin()` call.
+ * configuration source, and two distinct descriptors under one identity. The slot is the copy the
+ * Application's constructor took, which a JavaScript author fills with any value. Each plugin's own
+ * rules already ran at its `plugin()` call.
  */
-declare function installPlugins(plugins: unknown): InstalledPlugins;
+declare function installPlugins(application: string, plugins: unknown): InstalledPlugins;
 /**
  * The default export one plugin loader resolves to, checked by the guard its caller supplies. A
  * loader that throws where it is called and one that rejects later are one failure, and a module
@@ -154,8 +162,12 @@ interface BuiltPlugin {
     theme: Palette | undefined;
     /** The hook core calls once per Command at graph build, or nothing where none is declared. */
     onCommandAttach: CommandAttachHook | undefined;
-    /** The plugin's own `views` slot, read once the validated theme is in place. */
+    /** The hook core calls for each failure `run()` renders after graph build, or nothing. */
+    onFailure: FailureHook | undefined;
+    /** The copy of the plugin's own `views` list, which the Application reads again. */
     views: unknown;
+    /** The translations the plugin registers, which resolve after the application's. */
+    translators: TranslationContributor;
     identity: string;
     inputs: readonly OptionInput[];
     middleware: BuiltMiddleware | undefined;
@@ -164,7 +176,7 @@ interface BuiltPlugin {
     /** The Commands the plugin attaches to the root, in list order. */
     commands: readonly AttachedChild[];
     /** Every descriptor the plugin defines or its options' values name, by identity. */
-    descriptors: ReadonlyMap<string, AnyExtension>;
+    descriptors: ReadonlyMap<string, AdmittedDescriptor>;
     /** The extension record each of the plugin's own options carries. */
     records: InputRecords;
 }
@@ -183,4 +195,4 @@ declare function pluginValues(inputs: readonly OptionInput[], values: OptionValu
 declare function pluginSpellings(inputs: readonly OptionInput[], values: OptionValues): Readonly<Record<string, string>>;
 type ThemeOf<Contributor> = [Contributor] extends [never] ? {} : Contributor extends Plugin<PluginOptions, infer Theme> ? Theme : {};
 export type { ThemeOf, BuiltPlugin, BuiltSource, PluginValues, SourceAnswer, SourceContext, SourceResolver, Middleware, OptionsOf, Plugin, PluginDefinition, PluginOptions, PluginOptionSpellings, PluginOptionValues, };
-export { installPlugins, loadDefault, ownedSignals, plugin, pluginSentence, pluginSpellings, pluginValues, };
+export { installPlugins, loadDefault, ownedSignals, plugin, pluginSentence, pluginSpellings, pluginViews, pluginValues, };