@loomcli/core 0.6.0 → 0.7.0

package/NOTICE

@@ -0,0 +1,34 @@
+@loomcli/core
+
+This package includes material from uucode and from the Unicode Character
+Database. Its license field reads "MIT AND Unicode-3.0": the Unicode tables
+named below stay under the Unicode License v3, and every other file is under
+the MIT License in LICENSE or, for the ported width iterator, in
+licenses/uucode-LICENSE.md. Neither license asks anything of an application
+that installs this package beyond keeping these notices with the files they
+cover.
+
+Unicode Character Database
+Copyright © 1991-2025 Unicode, Inc.
+Licensed under the Unicode License v3.
+A copy of the License is in licenses/unicode-LICENSE.txt, and at
+https://www.unicode.org/license.txt
+
+uucode
+Copyright (c) 2026 Tim Culverhouse
+Licensed under the MIT License.
+A copy of the License is in licenses/uucode-LICENSE.md.
+Source: @rockorager/uucode 2.2.1 on npm
+
+The Unicode tables core measures text with, in dist/unicode.generated.js, are
+generated by the Loom repository's scripts/generate-unicode-tables.mjs from
+the data files of @rockorager/uucode 2.2.1, which derive from Unicode 17 data.
+The generator writes the same values as a JavaScript module, so a bundle
+carries them.
+
+The grapheme width iterator in dist/style-width.js is ported from the
+@rockorager/uucode 2.2.1 width module. Changes made to it:
+
+- It is written in TypeScript and reads the generated tables module.
+- It yields each grapheme's start, end, and width, and no longer yields the
+  grapheme's text or offers clone, peek, or a standalone string width.

package/dist/application.js

@@ -1,7 +1,9 @@
+import { captureDeclaration, unreadableArgument } from './capture.js';
 import { runInvocation } from './chain.js';
 import { portableName } from './command-rules.js';
 import { attachToRoot, callArguments, childNode, buildGraph, checkDeclaredOptions, collectInputs, commandPlacement, inputPlaces, declareAction, declareExtensions, declareArgument, declareOption, declareResult, declareResultViews, freshState, isPortableName, layerOf, portableNameCorrection, } from './command.js';
 import { escapeControlCharacters } from './controls.js';
+import { elided, spelled } from './diagnostic-text.js';
 import { DeclarationError, exitCodeOf, InternalError, quoted, reasonOf, toFailure, } from './errors.js';
 import { storeCommandLayers } from './extension.js';
 import { checkDescription, checkNoListingFacts, checkVersion, partFinding, slotSite, } from './facts.js';
@@ -12,7 +14,7 @@ import { globalOptionAfterCommand } from './input-rules.js';
 import { inspectGraph } from './inspect.js';
 import { coreViews } from './lanes.js';
 import { Output, reportPlainly } from './output.js';
-import { isPlainObject } from './plain.js';
+import { declaring, isPlainObject, shallowList, shallowRecord } from './plain.js';
 import { invalidPacket, notAnObject, retiredApplicationOption } from './plugin-rules.js';
 import { installPlugins, ownedSignals, pluginViews } from './plugin.js';
 import { renderingPolicy } from './rendering.js';
@@ -133,11 +135,17 @@ class ApplicationBuilder {
     }
     globalOption(name, config) {
         // The plugins' Commands attach at construction, so only the application's own calls close it.
+        // The config is judged after the order, so the finding prints it elided and reads none of it.
         if (this.#config.composed) {
             throw new DeclarationError(globalOptionAfterCommand, {
                 correction: 'Declare global options before attaching Commands or registering an action.',
                 findings: [
-                    { arguments: callArguments(name, config), call: 'globalOption', mark: '0', path: [] },
+                    {
+                        arguments: callArguments(name, config === undefined ? undefined : spelled(elided)),
+                        call: 'globalOption',
+                        mark: '0',
+                        path: [],
+                    },
                 ],
                 sentence: `The Application declares global option ${quoted(name)} after command() or action().`,
             });
@@ -481,7 +489,10 @@ function runRendering(rendering) {
         subject: 'The run',
     };
 }
-/** Reject obsolete wiring before silently losing options that invocations depend on. */
+/**
+ * Reject obsolete wiring before silently losing options that invocations depend on. `options` is the
+ * copy `captureOptions` took, or `undefined` for an Application declared without options.
+ */
 function checkOptions(name, options) {
     const site = {
         at: '1',
@@ -491,13 +502,6 @@ function checkOptions(name, options) {
     if (options === undefined) {
         return { description: undefined, version: checkVersion(site, undefined) };
     }
-    if (!isPlainObject(options)) {
-        throw new DeclarationError(notAnObject, {
-            correction: 'Supply an Application options object.',
-            findings: [{ ...site.declaration, mark: '1' }],
-            sentence: 'The Application declares options that are not an object.',
-        });
-    }
     for (const [key, correction] of retired) {
         if (key in options) {
             const retiredSite = optionSite(name, key, Reflect.get(options, key));
@@ -546,15 +550,43 @@ function readPacket(name, packet) {
         sentence: found,
     });
 }
+/** The parts of the Application options that are lists, each copied with its entries as built. */
+const optionLists = ['plugins', 'views', 'translators', 'extensions'];
+/**
+ * The one copy of the options that `new Application(name, options)` reads: the options object, its
+ * packet and rendering policy, and each list it holds. An entry of a list is what its factory built
+ * and is not copied. A read that throws is the unreadable fault of the options, and a value that is
+ * not a plain object is the not-an-object fault. An Application declared without options has none
+ * to copy.
+ */
+function captureOptions(name, options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    return captureDeclaration(options, (copy, read) => {
+        read.nested(copy, 'packet', shallowRecord);
+        read.nested(copy, 'rendering', shallowRecord);
+        for (const list of optionLists) {
+            read.nested(copy, list, shallowList);
+        }
+    }, {
+        notAnObject: () => new DeclarationError(notAnObject, {
+            correction: 'Supply an Application options object.',
+            findings: [{ arguments: [name, options], call: 'new Application', mark: '1' }],
+            sentence: 'The Application declares options that are not an object.',
+        }),
+        unreadable: unreadableArgument({ call: 'new Application', named: name, subject: 'The Application' }, 'options'),
+    });
+}
 /**
  * Every rule `new Application(name, options)` applies, in the order it reads the slot: the
  * application's own view overrides, its translations, the rendering policy, the options slot and
  * its facts, the installed list and every rule between two plugins, the root's extension values,
  * and then each plugin's Commands, which attach to the root first, in installation order and list
- * order.
+ * order. Each reads the one copy of the options `captureOptions` takes.
  */
-function declareApplication(name, options) {
-    const slot = isPlainObject(options) ? options : undefined;
+function declareApplication(name, declared) {
+    const slot = captureOptions(name, declared);
     const identities = viewIdentities(coreViews);
     const views = buildViews({
         declares: false,
@@ -563,7 +595,7 @@ function declareApplication(name, options) {
     }, slot?.views, identities);
     const translations = readTranslations(optionSite(name, 'translators', slot?.translators), slot?.translators);
     const rendering = renderingPolicy(slot?.rendering, optionSite(name, 'rendering', slot?.rendering));
-    const facts = checkOptions(name, options);
+    const facts = checkOptions(name, slot);
     const development = readPacket(name, slot?.packet);
     const installed = installPlugins(name, slot?.plugins ?? []);
     const { plugins } = installed;
@@ -624,7 +656,7 @@ class ApplicationDeclaration extends ApplicationBuilder {
     constructor(name, options) {
         // The arguments evaluate in order, so the name is checked before any option is read.
         const checked = checkApplicationName(name);
-        super(checked, declareApplication(checked, options));
+        super(checked, declaring(() => declareApplication(checked, options)));
     }
 }
 export const Application = ApplicationDeclaration;

package/dist/capture.d.ts

@@ -0,0 +1,65 @@
+import type { Finding } from './diagnostic-text.js';
+import { DeclarationError } from './errors.js';
+/**
+ * One declaring call's read of the object an author passed it, under way. It remembers the slot it
+ * is reading, so a read that throws names the slot it threw in, or no slot when the object itself
+ * threw.
+ */
+declare class DeclarationRead {
+    /** The top-level key being read, or `undefined` while the object itself is read. */
+    slot: string | undefined;
+    /** The copy of every own string key of one object, each read under its own slot. */
+    record(declared: object): Record<string, unknown>;
+    /**
+     * Replaces the value one key of a copy holds with `copy` of it, read under that key's slot. An
+     * absent key stays absent, so a finding prints the copy with the keys the author wrote.
+     */
+    nested(captured: Record<string, unknown>, key: string, copy: (value: unknown) => unknown): void;
+}
+/** The two faults one declaring call raises when it cannot capture what it was given. */
+interface CaptureFaults {
+    /** The value is not a plain object, so it has no keys for core to read. */
+    readonly notAnObject: () => DeclarationError;
+    /** A read threw the value it receives, in the top-level slot it names, or in the object itself. */
+    readonly unreadable: (thrown: unknown, slot: string | undefined) => DeclarationError;
+}
+/**
+ * Authoring's one read of an object a declaring call receives, inside one try: the verdict on its
+ * prototype, the copy of every own string key, and the copies `nested` takes of the parts it holds,
+ * each judged plain once by `decidePlain`. Every later check, stored value, and finding reads that
+ * copy and never the author's object again, so a getter runs once and a read that threw is never
+ * repeated. A value that is not a plain object is the not-an-object fault, and a read that throws,
+ * from a getter or a proxy trap, is the unreadable fault, named by the slot it threw in.
+ */
+declare function captureDeclaration<Declared>(declared: Declared, nested: (copy: Record<string, unknown>, read: DeclarationRead) => void, faults: CaptureFaults): Declared & Record<string, unknown>;
+/**
+ * What a finding prints for a declaration whose read threw: the slot it threw in, elided, under the
+ * keys that lead to it, or the whole declaration elided. A read that threw is never repeated.
+ */
+declare function elidedRead(slot: string | undefined): {
+    keys: readonly string[];
+    shown: unknown;
+};
+/** What one unreadable declaration is: an input's config, a plugin's definition, or an options object. */
+type Unreadable = 'config' | 'definition' | 'options';
+/**
+ * The fault for a declaration whose read threw, named by `subject` and marked by `findings`. The
+ * thrown value's reason ends the sentence and the value itself is the fault's cause.
+ */
+declare function unreadableFault(report: {
+    readonly declared: Unreadable;
+    readonly findings: readonly Finding[];
+    readonly subject: string;
+}, thrown: unknown): DeclarationError;
+/**
+ * The unreadable fault of the object a `plugin()` call or a constructor receives as its second
+ * argument. Its finding marks the top-level slot whose read threw, or the whole argument when the
+ * object itself threw, and prints that part elided.
+ */
+declare function unreadableArgument(declaration: {
+    readonly call: string;
+    readonly named: unknown;
+    readonly subject: string;
+}, declared: 'definition' | 'options'): (thrown: unknown, slot: string | undefined) => DeclarationError;
+export type { CaptureFaults };
+export { captureDeclaration, elidedRead, unreadableArgument, unreadableFault };

package/dist/capture.js

@@ -0,0 +1,99 @@
+import { elided, spelled } from './diagnostic-text.js';
+import { asSentence, DeclarationError, reasonOf } from './errors.js';
+import { copyOwnKeys, decidePlain } from './plain.js';
+import { unreadableDeclaration } from './plugin-rules.js';
+/**
+ * One declaring call's read of the object an author passed it, under way. It remembers the slot it
+ * is reading, so a read that throws names the slot it threw in, or no slot when the object itself
+ * threw.
+ */
+class DeclarationRead {
+    /** The top-level key being read, or `undefined` while the object itself is read. */
+    slot = undefined;
+    /** The copy of every own string key of one object, each read under its own slot. */
+    record(declared) {
+        const copy = copyOwnKeys(declared, (key) => {
+            this.slot = key;
+        });
+        this.slot = undefined;
+        return copy;
+    }
+    /**
+     * Replaces the value one key of a copy holds with `copy` of it, read under that key's slot. An
+     * absent key stays absent, so a finding prints the copy with the keys the author wrote.
+     */
+    nested(captured, key, copy) {
+        if (Object.hasOwn(captured, key)) {
+            this.slot = key;
+            captured[key] = copy(captured[key]);
+            this.slot = undefined;
+        }
+    }
+}
+/**
+ * Authoring's one read of an object a declaring call receives, inside one try: the verdict on its
+ * prototype, the copy of every own string key, and the copies `nested` takes of the parts it holds,
+ * each judged plain once by `decidePlain`. Every later check, stored value, and finding reads that
+ * copy and never the author's object again, so a getter runs once and a read that threw is never
+ * repeated. A value that is not a plain object is the not-an-object fault, and a read that throws,
+ * from a getter or a proxy trap, is the unreadable fault, named by the slot it threw in.
+ */
+function captureDeclaration(declared, nested, faults) {
+    const read = new DeclarationRead();
+    let copy = undefined;
+    try {
+        if (decidePlain(declared)) {
+            copy = read.record(declared);
+            nested(copy, read);
+        }
+    }
+    catch (error) {
+        throw faults.unreadable(error, read.slot);
+    }
+    if (copy === undefined) {
+        throw faults.notAnObject();
+    }
+    // Last resort: no typed path exists.
+    // The copy is built key by key, so the compiler types it as a record of unknown values.
+    // A spread would keep the declared type, but it reads enumerable keys alone and names no slot.
+    // It holds because the copy holds every own string key of the declared plain object.
+    // Each holds the value read from it once, or that value's copy of the same kind.
+    // No declaration type declares a symbol key, and none reads its prototype.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    return copy;
+}
+/**
+ * What a finding prints for a declaration whose read threw: the slot it threw in, elided, under the
+ * keys that lead to it, or the whole declaration elided. A read that threw is never repeated.
+ */
+function elidedRead(slot) {
+    return slot === undefined
+        ? { keys: [], shown: spelled(elided) }
+        : { keys: [slot], shown: Object.fromEntries([[slot, spelled(elided)]]) };
+}
+/**
+ * The fault for a declaration whose read threw, named by `subject` and marked by `findings`. The
+ * thrown value's reason ends the sentence and the value itself is the fault's cause.
+ */
+function unreadableFault(report, thrown) {
+    const { declared, findings, subject } = report;
+    return new DeclarationError(unreadableDeclaration, {
+        correction: `Declare the ${declared} as a plain object literal whose properties read without throwing.`,
+        findings,
+        sentence: `${subject} ${declared} could not be read: ${asSentence(reasonOf(thrown))}`,
+    }, { cause: thrown });
+}
+/**
+ * The unreadable fault of the object a `plugin()` call or a constructor receives as its second
+ * argument. Its finding marks the top-level slot whose read threw, or the whole argument when the
+ * object itself threw, and prints that part elided.
+ */
+function unreadableArgument(declaration, declared) {
+    const { call, named, subject } = declaration;
+    return (thrown, slot) => {
+        const { keys, shown } = elidedRead(slot);
+        const finding = { arguments: [named, shown], call, mark: ['1', ...keys].join('.') };
+        return unreadableFault({ declared, findings: [finding], subject }, thrown);
+    };
+}
+export { captureDeclaration, elidedRead, unreadableArgument, unreadableFault };

package/dist/command.js

@@ -1,18 +1,19 @@
 var _a, _b;
 import { checkEnvBinding, checkNoArgumentBinding } from './bindings.js';
+import { captureDeclaration, unreadableArgument } from './capture.js';
 import { aliasWithoutNames, argumentDeclaredTwice, argumentsBesideChildren, commandAttachedTwice, commandGlobals, commandWithoutAction, declaredAfterAction, declaredName, groupOption, multipleActions, multipleResults, nestingDepth, notACommand, optionalArgumentLast, portableName, repeatedAlias, resultWithoutAction, resultWithoutViews, rowViewOnValue, siblingNameTaken, unknownDefaultView, variadicArgumentLast, viewName, viewShape, viewsWithoutResult, } from './command-rules.js';
-import { quoteString, spelled } from './diagnostic-text.js';
+import { elided, quoteString, spelled } from './diagnostic-text.js';
 import { asSentence, commandSentence, commandSubject, DeclarationError, NonCallableCommandError, quoted, ResultError, toFailure, UnexpectedArgumentError, UnknownCommandError, reasonOf, } from './errors.js';
 import { buildExtensions, extendStore, publishStore, registerDescriptor, storeCommandLayers, validateLayer, } from './extension.js';
-import { checkDeprecated, checkDescription, checkHidden, checkNoListingFacts, siteFinding, } from './facts.js';
+import { checkDeprecated, checkDescription, checkHidden, checkNoListingFacts, declarerNote, siteFinding, } from './facts.js';
 import { buildGlobals, checkLocalOptions } from './globals.js';
 import { nameSharedAcrossKinds, optionDeclaredTwice, spellingTaken } from './input-rules.js';
-import { graphMismatch, nodeAt, resultNode, snapshot } from './inspect.js';
+import { graphMismatch, nodeAt, resultNode } from './inspect.js';
 import { checkOptionName, compileOptions, copyValues, emptyValues, extractGlobals, isOptionToken, mergeValues, parseInputs, spellingMark, } from './options.js';
-import { isPlainObject } from './plain.js';
+import { declaring, isPlainObject, shallowList, snapshot } from './plain.js';
 import { brokenAttachHook, notAnObject } from './plugin-rules.js';
 import { fillInputs } from './sources.js';
-import { captureConfig, checkInputConfig, checkDeclarations, declaringSite, inputPlace, validateValues, } from './validation.js';
+import { captureInputConfig, configUnread, checkDeclarations, declaringSite, inputPlace, validateValues, } from './validation.js';
 /**
  * The deepest level below the root a Command may sit at, and the word its diagnostic spells it with.
  * A child of the root sits at level 1. Raising the cap relaxes a rule and breaks no application.
@@ -73,16 +74,30 @@ export function commandPlacement(path, child) {
 function constructorFinding(name, options, mark) {
     return { arguments: callArguments(name, options), call: 'new Command', mark };
 }
-/** A named Command's options slot holds a plain options object, and never retired globals wiring. */
-function checkCommandOptions(name, options) {
-    if (options !== undefined && !isPlainObject(options)) {
-        throw new DeclarationError(notAnObject, {
+/**
+ * The one copy of the options that `new Command(name, options)` reads, taken once the name is
+ * judged: the options object and its `extensions` list, whose entries are what their factory built
+ * and are not copied. A read that throws is the unreadable fault of the options, a value that is not
+ * a plain object is the not-an-object fault, and a Command declared without options has none.
+ */
+function captureCommandOptions(name, options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    return captureDeclaration(options, (copy, read) => {
+        read.nested(copy, 'extensions', shallowList);
+    }, {
+        notAnObject: () => new DeclarationError(notAnObject, {
             correction: 'Supply a Command options object.',
             findings: [constructorFinding(name, options, '1')],
             sentence: `${commandSentence(name)} declares options that are not an object.`,
-        });
-    }
-    if (isPlainObject(options) && 'globals' in options) {
+        }),
+        unreadable: unreadableArgument({ call: 'new Command', named: name, subject: commandSentence(name) }, 'options'),
+    });
+}
+/** A named Command's options never carry the retired globals wiring. */
+function checkCommandOptions(name, options) {
+    if ('globals' in options) {
         throw new DeclarationError(commandGlobals, {
             correction: 'Declare globals on the Application and register its environment.',
             findings: [constructorFinding(name, options, '1.globals')],
@@ -149,23 +164,28 @@ export function freshState(declaration) {
     };
 }
 /**
- * A named Command's own declaration, checked before the value exists: the name, the options slot,
- * the core facts, and the extension values the slot carries. A later change to the options object
- * the author passed changes nothing the declaration holds.
+ * A named Command's own declaration, checked before the value exists: the name, then the one copy
+ * of the options slot, its core facts, and the extension values it carries. A later change to the
+ * options object the author passed changes nothing the declaration holds.
  */
 function namedState(name, options) {
     if (!isPortableName(name)) {
+        // The options are read after the name is judged, so the name's finding prints them elided.
         throw new DeclarationError(portableName, {
             correction: portableNameCorrection,
-            findings: [constructorFinding(name, options, '0')],
+            findings: [
+                constructorFinding(name, options === undefined ? undefined : spelled(elided), '0'),
+            ],
             sentence: `Command name ${quoted(name)} is invalid.`,
         });
     }
-    checkCommandOptions(name, options);
-    const slot = isPlainObject(options) ? options : undefined;
+    const slot = captureCommandOptions(name, options);
+    if (slot !== undefined) {
+        checkCommandOptions(name, slot);
+    }
     const site = {
         at: '1',
-        declaration: { arguments: [name, options], call: 'new Command' },
+        declaration: { arguments: [name, slot], call: 'new Command' },
         subject: commandSentence(name),
     };
     // The facts are read in the order their diagnostics have always ranked.
@@ -221,6 +241,14 @@ function inputFinding(path, input, note) {
     const site = declaringSite(input, inputPlace(input, { global: false, path }));
     return siteFinding(site, site.named, note);
 }
+/**
+ * The finding for an input whose name is invalid, marking the name. The config is read after the
+ * name is judged, so it prints elided.
+ */
+function nameFinding(path, input) {
+    const site = configUnread(declaringSite(input, inputPlace(input, { global: false, path })));
+    return siteFinding(site, site.named);
+}
 /** The scope one Command's own options compile under: its subject, and each option's call. */
 function localScope(name, path) {
     return { siteOf: (input) => inputSite(name, path, input), subject: commandSubject(name) };
@@ -297,7 +325,7 @@ function checkArgumentName(command, declared, input) {
     if (!isDeclaredName(input.name)) {
         throw new DeclarationError(declaredName, {
             correction: 'Use a nonempty name without a leading hyphen, whitespace, or "=".',
-            findings: [inputFinding(path, input)],
+            findings: [nameFinding(path, input)],
             sentence: `${commandSentence(command.name)} declares an argument named ${quoted(input.name)}.`,
         });
     }
@@ -317,11 +345,13 @@ function checkArgumentName(command, declared, input) {
 export function declareArgument(state, declared) {
     // The call's own input is judged before the receiver's state, as alias() judges its names.
     // A name of another kind then reports as a declared name instead of failing to print in the order diagnostic.
-    // The config is judged right after its name, and only then captured.
+    // The config is read once right after its name is judged, and every later check reads that copy.
     const { name } = state;
     checkArgumentName({ name, path: pathOf(name), subject: commandSubject(name) }, [], declared);
-    checkInputConfig(declared, { call: 'argument', path: pathOf(name) });
-    const input = { ...declared, config: captureConfig(declared.config) };
+    const input = {
+        ...declared,
+        config: captureInputConfig(declared, { call: 'argument', path: pathOf(name) }),
+    };
     checkOpen(state, {
         arguments: [input.name, input.config],
         call: 'argument',
@@ -350,11 +380,14 @@ const noGlobals = { names: new Map(), options: new Map(), variables: new Map() }
  */
 export function declareOption(state, declared, table = noGlobals) {
     // The call's own input is judged before the receiver's state, as alias() judges its names.
-    // The config is judged right after its name, and only then captured.
-    checkOptionName(declared.name, inputSite(state.name, pathOf(state.name), declared));
-    checkInputConfig(declared, { call: 'option', path: pathOf(state.name) });
-    const input = { ...declared, config: captureConfig(declared.config) };
-    const site = inputSite(state.name, pathOf(state.name), input);
+    // The config is read once right after its name is judged, and every later check reads that copy.
+    const path = pathOf(state.name);
+    checkOptionName(declared.name, configUnread(inputSite(state.name, path, declared)));
+    const input = {
+        ...declared,
+        config: captureInputConfig(declared, { call: 'option', path }),
+    };
+    const site = inputSite(state.name, path, input);
     checkOpen(state, {
         arguments: [input.name, input.config],
         call: 'option',
@@ -632,7 +665,7 @@ function checkGroup(state, place) {
         throw new DeclarationError(groupOption, {
             correction: 'Register an action or remove the option.',
             findings: [inputFinding(place.path, option, 'no action reads it')],
-            sentence: `${commandSentence(name)} declares option "${option.name}" but registers no action to receive it.`,
+            sentence: `${commandSentence(name)} declares option ${quoted(option.name)} but registers no action to receive it.`,
         });
     }
 }
@@ -1045,13 +1078,13 @@ class AttachedCommandValue {
             checkArgumentName({ name, path, subject: commandSubject(name) }, [], raw);
         }
         else {
-            checkOptionName(raw.name, inputSite(declared.name, path, raw));
+            checkOptionName(raw.name, configUnread(inputSite(declared.name, path, raw)));
         }
-        checkInputConfig(raw, { call: raw.kind, path });
         // Each kind captures its own config, so the input keeps the pairing its kind declares.
+        const place = { call: raw.kind, path };
         const input = raw.kind === 'argument'
-            ? { ...raw, config: captureConfig(raw.config) }
-            : { ...raw, config: captureConfig(raw.config) };
+            ? { ...raw, config: captureInputConfig(raw, place) }
+            : { ...raw, config: captureInputConfig(raw, place) };
         return this.#derive({ identity, input, kind: 'input' }, { ...declared, inputs: [...declared.inputs, input] });
     }
     #derive(call, declared) {
@@ -1166,16 +1199,12 @@ function nameCollisionRule(declared, held) {
     }
     return declared === 'option' ? optionDeclaredTwice : argumentDeclaredTwice;
 }
-/** The note a finding for one hook-declared input carries. */
-function hookNote(identity) {
-    return `declared by plugin ${quoted(identity)}`;
-}
 /** The clause and the remedy an input another plugin's hook already declared earns. */
 function hookClause(earlier, path) {
     const { identity, input } = earlier;
     return {
         clause: `an ${input.kind} plugin ${quoted(identity)} declared through onCommandAttach`,
-        held: inputFinding(path, input, hookNote(identity)),
+        held: inputFinding(path, input, declarerNote(identity)),
         kind: input.kind,
         remedy: 'Install one of them.',
     };
@@ -1285,14 +1314,14 @@ function checkAttachedSpelling(declared, named) {
             throw new DeclarationError(spellingTaken, {
                 correction: 'Change one of the two spellings or omit the plugin.',
                 findings: [
-                    spellingPlace(site, option.role, hookNote(identity)),
+                    spellingPlace(site, option.role, declarerNote(identity)),
                     ...(used.finding === undefined ? [] : [used.finding]),
                 ],
                 sentence: `Plugin ${quoted(identity)} declares option ${quoted(input.name)} with spelling ${quoted(spelling)} on ${subject}, which ${quoted(used.form)} already uses.`,
             });
         }
     }
-    readSpellings(table, claimed, (_name, role) => spellingPlace(site, role, hookNote(identity)));
+    readSpellings(table, claimed, (_name, role) => spellingPlace(site, role, declarerNote(identity)));
 }
 /** The declarations of one kind, keyed by name, the first of each name winning. */
 function byName(inputs) {
@@ -1314,7 +1343,7 @@ function tableSpellings(globals) {
         const { owner, site } = entry;
         const note = owner.kind === 'plugin'
             ? `an option of plugin ${quoted(owner.identity)}`
-            : `the global option "${name}"`;
+            : `the global option ${quoted(name)}`;
         return spellingPlace(site, role, note);
     };
 }
@@ -1346,7 +1375,7 @@ function checkAttachedInputs(declared, attached, place) {
         const local = locals.get(name);
         return local === undefined || local.kind !== 'option'
             ? undefined
-            : spellingPlace(scope.siteOf(local), role, `the local option "${name}"`);
+            : spellingPlace(scope.siteOf(local), role, `the local option ${quoted(name)}`);
     });
     for (const entry of attached) {
         const { identity, input } = entry;
@@ -1354,7 +1383,7 @@ function checkAttachedInputs(declared, attached, place) {
         if (collision) {
             throw new DeclarationError(nameCollisionRule(input.kind, collision.kind), {
                 correction: collision.remedy,
-                findings: [inputFinding(path, input, hookNote(identity)), collision.held],
+                findings: [inputFinding(path, input, declarerNote(identity)), collision.held],
                 sentence: `Plugin ${quoted(identity)} declares ${input.kind} ${quoted(input.name)} on ${subject}, which is already declared as ${collision.clause}.`,
             });
         }
@@ -1594,7 +1623,7 @@ _b = CommandBuilder;
  */
 class CommandDeclaration extends CommandBuilder {
     constructor(name, options) {
-        const declared = namedState(name, options);
+        const declared = declaring(() => namedState(name, options));
         super(declared.name, declared.state);
     }
 }

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 };