@loomcli/core 0.5.0 → 0.6.0

package/dist/options.js

@@ -1,52 +1,123 @@
-import { DeclarationError, MissingValueError, RepeatedOptionError, ShortGroupError, UnexpectedValueError, UnknownOptionError, } from './errors.js';
+import { declaredName } from './command-rules.js';
+import { valueCode } from './diagnostic-text.js';
+import { DeclarationError, MissingValueError, quoted, RepeatedOptionError, ShortGroupError, UnexpectedValueError, UnknownOptionError, } from './errors.js';
+import { factFault, flagFault, siteFinding } from './facts.js';
+import { booleanOptionMultiple, optionDeclaredTwice, optionPolarity, optionType, polarityOnString, shortAlias, shortOnlyBothPolarities, shortOnlyWithoutShort, spellingTaken, } from './input-rules.js';
 /** Every parsed value lands in one of these maps; `lists` holds the repeated string options. */
 export function emptyValues() {
     return { booleans: new Map(), lists: new Map(), spellings: new Map(), strings: new Map() };
 }
-function validateDeclaration({ name, config }) {
+/**
+ * The part of one declaration that yields a spelling of the given role, which a spelling fault
+ * marks: the declared name for the long form, `short` for the short alias, and the `polarity` that
+ * generates a negative form.
+ */
+export function spellingMark(site, role) {
+    if (role === 'long') {
+        return site.named;
+    }
+    return `${site.at}.${role === 'short' ? 'short' : 'polarity'}`;
+}
+/** The declared name answers the declared-name rule an argument's name answers. */
+export function checkOptionName(name, site) {
+    const findings = [siteFinding(site, site.named)];
     if (typeof name !== 'string') {
-        throw new DeclarationError('Option names must be strings. Supply a string name.');
+        throw new DeclarationError(declaredName, {
+            correction: 'Supply a string name.',
+            findings,
+            sentence: `Option name ${valueCode(name)} is not a string.`,
+        });
     }
     if (!name || name.startsWith('-') || /[\s=]/u.test(name)) {
-        throw new DeclarationError(`Option name "${name}" is invalid. Use a nonempty name without a leading hyphen, whitespace, or "=".`);
-    }
-    if (!['string', 'boolean'].includes(config.type)) {
-        throw new DeclarationError(`Option "${name}" has an invalid type. Use "string" or "boolean".`);
+        throw new DeclarationError(declaredName, {
+            correction: 'Use a nonempty name without a leading hyphen, whitespace, or "=".',
+            findings,
+            sentence: `Option name ${quoted(name)} is invalid.`,
+        });
     }
+}
+/** The short alias, and `shortOnly`, which leaves the option that alias alone. */
+function checkShortForms(config, site, subject) {
     if (config.short !== undefined &&
         (typeof config.short !== 'string' || !/^[A-Za-z]$/u.test(config.short))) {
-        throw new DeclarationError(`Option "${name}" requires a short alias of one ASCII letter.`);
+        throw factFault(shortAlias, site, {
+            correction: 'Supply one ASCII letter.',
+            fact: 'short',
+            sentence: `${subject} declares a short alias that is not one ASCII letter.`,
+        });
     }
     if (config.shortOnly !== undefined && typeof config.shortOnly !== 'boolean') {
-        throw new DeclarationError(`Option "${name}" shortOnly must be Boolean. Use true or false.`);
+        throw flagFault(site, 'shortOnly');
     }
     if (config.shortOnly && config.short === undefined) {
-        throw new DeclarationError(`Option "${name}" with shortOnly requires a short alias.`);
+        throw factFault(shortOnlyWithoutShort, site, {
+            correction: 'Add short or remove shortOnly.',
+            fact: 'shortOnly',
+            sentence: `${subject} declares shortOnly and no short alias.`,
+        });
     }
+}
+/** A Boolean option's polarity, which a string option does not declare. */
+function checkPolarity(config, site, subject) {
+    if (config.polarity === undefined) {
+        return;
+    }
+    if (config.type !== 'boolean') {
+        throw factFault(polarityOnString, site, {
+            correction: 'Remove polarity or use type "boolean".',
+            fact: 'polarity',
+            sentence: `${subject} declares polarity but is not Boolean.`,
+        });
+    }
+    if (!['positive', 'both', 'negative'].includes(config.polarity)) {
+        throw factFault(optionPolarity, site, {
+            correction: 'Use "positive", "both", or "negative".',
+            fact: 'polarity',
+            sentence: `${subject} has an invalid polarity.`,
+        });
+    }
+    if (config.polarity === 'both' && config.shortOnly) {
+        throw factFault(shortOnlyBothPolarities, site, {
+            correction: 'Enable long forms or select one polarity.',
+            fact: 'shortOnly',
+            sentence: `${subject} cannot express both polarities with shortOnly.`,
+        });
+    }
+}
+/** Every rule one option declaration answers alone, before the table meets it. */
+function validateDeclaration({ name, config }, site) {
+    checkOptionName(name, site);
+    const subject = `Option ${quoted(name)}`;
+    if (!['string', 'boolean'].includes(config.type)) {
+        throw factFault(optionType, site, {
+            correction: 'Use "string" or "boolean".',
+            fact: 'type',
+            sentence: `${subject} has an invalid type.`,
+        });
+    }
+    checkShortForms(config, site, subject);
     if (config.type === 'boolean' && config.multiple !== undefined) {
-        throw new DeclarationError(`Option "${name}" is a boolean option and declares multiple. Remove multiple or declare a string option.`);
+        throw factFault(booleanOptionMultiple, site, {
+            correction: 'Remove multiple or declare a string option.',
+            fact: 'multiple',
+            sentence: `${subject} is a boolean option and declares multiple.`,
+        });
     }
     if (config.multiple !== undefined && typeof config.multiple !== 'boolean') {
-        throw new DeclarationError(`Option "${name}" multiple must be Boolean. Use true or false.`);
-    }
-    if (config.polarity !== undefined) {
-        if (config.type !== 'boolean') {
-            throw new DeclarationError(`Option "${name}" declares polarity but is not Boolean. Remove polarity or use type "boolean".`);
-        }
-        if (!['positive', 'both', 'negative'].includes(config.polarity)) {
-            throw new DeclarationError(`Option "${name}" has an invalid polarity. Use "positive", "both", or "negative".`);
-        }
-        if (config.polarity === 'both' && config.shortOnly) {
-            throw new DeclarationError(`Option "${name}" cannot express both polarities with shortOnly. Enable long forms or select one polarity.`);
-        }
+        throw flagFault(site, 'multiple');
     }
+    checkPolarity(config, site, subject);
 }
-function addSpelling(spellings, spelling, option) {
-    const existing = spellings.get(spelling);
+function addSpelling(claims, spelling, claim) {
+    const existing = claims.get(spelling);
     if (existing) {
-        throw new DeclarationError(`Option spelling "${spelling}" is used by both "${existing.name}" and "${option.name}". Change one declaration.`);
+        throw new DeclarationError(spellingTaken, {
+            correction: 'Change one declaration.',
+            findings: [existing, claim].map(({ option, site }) => siteFinding(site, spellingMark(site, option.role))),
+            sentence: `Option spelling ${quoted(spelling)} is used by both ${quoted(existing.option.name)} and ${quoted(claim.option.name)}.`,
+        });
     }
-    spellings.set(spelling, option);
+    claims.set(spelling, claim);
 }
 /**
  * One Boolean option's value for one invocation: the value the parser consumed, or the value its
@@ -57,37 +128,50 @@ function addSpelling(spellings, spelling, option) {
 export function booleanValue(values, name, config) {
     return values.booleans.get(name) ?? config.polarity === 'negative';
 }
-export function compileOptions(declarations, subject) {
-    const spellings = new Map();
-    const names = new Set();
-    for (const { name, config } of declarations) {
-        validateDeclaration({ config, name });
-        if (names.has(name)) {
-            throw new DeclarationError(`Option "${name}" is declared more than once on ${subject}. Remove or rename the duplicate.`);
+/**
+ * One scope's options compiled into the spelling table the parser reads, with every rule one
+ * declaration answers alone and every rule two of them answer together.
+ */
+export function compileOptions(declarations, scope) {
+    const claims = new Map();
+    const names = new Map();
+    for (const declaration of declarations) {
+        const { name, config } = declaration;
+        const site = scope.siteOf(declaration);
+        validateDeclaration({ config, name }, site);
+        const first = names.get(name);
+        if (first) {
+            const earlier = scope.siteOf(first);
+            throw new DeclarationError(optionDeclaredTwice, {
+                correction: 'Remove or rename the duplicate.',
+                findings: [
+                    siteFinding(earlier, earlier.named, 'the first declaration'),
+                    siteFinding(site, site.named, 'the second declaration'),
+                ],
+                sentence: `Option ${quoted(name)} is declared more than once on ${scope.subject}.`,
+            });
         }
-        names.add(name);
+        names.set(name, declaration);
         const positive = config.type === 'string'
             ? { multiple: config.multiple === true, name, type: 'string' }
             : { name, type: 'boolean', value: config.polarity !== 'negative' };
         if (!config.shortOnly) {
             if (config.type === 'string' || config.polarity !== 'negative') {
-                addSpelling(spellings, `--${name}`, { ...positive, role: 'long' });
+                addSpelling(claims, `--${name}`, { option: { ...positive, role: 'long' }, site });
             }
             if (config.type === 'boolean' &&
                 (config.polarity === 'both' || config.polarity === 'negative')) {
-                addSpelling(spellings, `--no-${name}`, {
-                    name,
-                    role: 'negative',
-                    type: 'boolean',
-                    value: false,
+                addSpelling(claims, `--no-${name}`, {
+                    option: { name, role: 'negative', type: 'boolean', value: false },
+                    site,
                 });
             }
         }
         if (config.short !== undefined) {
-            addSpelling(spellings, `-${config.short}`, { ...positive, role: 'short' });
+            addSpelling(claims, `-${config.short}`, { option: { ...positive, role: 'short' }, site });
         }
     }
-    return spellings;
+    return new Map([...claims].map(([spelling, { option }]) => [spelling, option]));
 }
 /**
  * Whether a token reads as an option: it starts with a hyphen. Routing stops at one, and a
@@ -199,6 +283,9 @@ function readOption(spellings, input, state) {
 /**
  * A hyphen token belongs to the globals when its long spelling or every short letter does. The
  * pre-scan reads the globals alone, so a letter it does not own is only "not a global option".
+ * The scan stops at a global value option, because the letters after it may be the value the
+ * operator meant to pass: the token then belongs to the globals, and parsing reports the
+ * value-position fault that names that option alone.
  */
 function isGlobalToken(spellings, token) {
     const long = longToken(token);
@@ -210,8 +297,12 @@ function isGlobalToken(spellings, token) {
     let other = '';
     for (let index = 0; index < group.length; index += 1) {
         const letter = group.charAt(index);
-        if (spellings.has(`-${letter}`)) {
+        const option = spellings.get(`-${letter}`);
+        if (option) {
             global = global === '' ? letter : global;
+            if (option.type === 'string') {
+                break;
+            }
         }
         else {
             other = other === '' ? letter : other;

package/dist/output.d.ts

@@ -4,7 +4,7 @@ import type { RenderingPolicy } from './rendering.js';
 import type { Palette } from './style-state.js';
 import type { ActionChannel, Host, OpenResult, Out, ResultBinding, ViewContext } from './types.js';
 import type { ViewRegistry } from './view.js';
-type WriteState = {
+export type WriteState = {
     kind: 'ok';
 } | {
     kind: 'failed';
@@ -19,6 +19,7 @@ export declare class Output {
     private readonly signal;
     private readonly destinations;
     private renderFault;
+    private readonly viewFaults;
     private readonly stops;
     private route;
     /**
@@ -56,7 +57,7 @@ export declare class Output {
     private resultFault;
     /** The registry one invocation resolves through, republished as each contributor is read. */
     useViews(registry: ViewRegistry): void;
-    /** The routed path, published once routing resolved it, which an incomplete sequence names. */
+    /** The path routing walked, updated as each name routes, which an incomplete sequence names. */
     useRoute(path: readonly string[]): void;
     /** What this invocation's output raised beside its calls, in the order it was raised. */
     get stopped(): readonly unknown[];
@@ -112,6 +113,12 @@ export declare class Output {
      * awaits the call must not end the process with an unhandled rejection.
      */
     private renderFailed;
+    /**
+     * Whether one value is what a view or a message check failed with during this invocation. A
+     * broken view is a defect in the code that broke the view contract, so an action or a source that
+     * lets its rejection propagate reports it as that defect.
+     */
+    raisedByView(value: unknown): boolean;
     /** What a view failed with during this invocation, if one did. */
     get fault(): {
         cause: unknown;

package/dist/output.js

@@ -145,10 +145,13 @@ export class Output {
     signal;
     destinations = new Map();
     renderFault = undefined;
+    // Every value a view failed with.
+    // A caller that lets one propagate never offers it to a translator.
+    viewFaults = new WeakSet();
     // Every fault the output path raised beside its calls, reported after the primary outcome.
     // A source a sequence stopped on and a results-lane fault are both such faults.
     stops = [];
-    // The routed Command an incomplete sequence names, published once routing resolved it.
+    // The path routing walked, which an incomplete sequence names, updated as each name routes.
     route = [];
     /**
      * The channel every caller writes through. It is typed with the result left open, because the
@@ -263,7 +266,7 @@ export class Output {
     useViews(registry) {
         this.registry = registry;
     }
-    /** The routed path, published once routing resolved it, which an incomplete sequence names. */
+    /** The path routing walked, updated as each name routes, which an incomplete sequence names. */
     useRoute(path) {
         this.route = path;
     }
@@ -395,10 +398,23 @@ export class Output {
      */
     renderFailed(cause) {
         this.renderFault ??= { cause };
+        if ((typeof cause === 'object' || typeof cause === 'function') && cause !== null) {
+            this.viewFaults.add(cause);
+        }
         const rejection = Promise.reject(cause);
         void rejection.catch(() => undefined);
         return rejection;
     }
+    /**
+     * Whether one value is what a view or a message check failed with during this invocation. A
+     * broken view is a defect in the code that broke the view contract, so an action or a source that
+     * lets its rejection propagate reports it as that defect.
+     */
+    raisedByView(value) {
+        return ((typeof value === 'object' || typeof value === 'function') &&
+            value !== null &&
+            this.viewFaults.has(value));
+    }
     /** What a view failed with during this invocation, if one did. */
     get fault() {
         return this.renderFault;

package/dist/plain.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A structural value core reads as plain data: an object literal, and never a declaration that
+ * carries state of its own. The options slots read it to reject a value that is not an options
+ * object, and inspection reads it to copy a declared value faithfully.
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/plain.js

@@ -0,0 +1,12 @@
+/**
+ * A structural value core reads as plain data: an object literal, and never a declaration that
+ * carries state of its own. The options slots read it to reject a value that is not an options
+ * object, and inspection reads it to copy a declared value faithfully.
+ */
+export function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/plugin-rules.d.ts

@@ -0,0 +1,62 @@
+/** 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 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, };

package/dist/plugin-rules.js

@@ -0,0 +1,155 @@
+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, and the config of an argument or option by their keys. A value of any other kind has no keys to read.",
+    headline: 'Not an object',
+});
+/** 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, };