@loomcli/core 0.2.0 → 0.4.0

package/dist/environment.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from './plugin.js';
+/** The shallow type information an Application supplies before its Command graph is composed. */
+interface ApplicationEnvironment<Globals = {}, Plugins extends readonly Plugin[] = readonly []> {
+    readonly globals: Globals;
+    readonly plugins: Plugins;
+}
+interface RegistrationShape {
+    environment?: ApplicationEnvironment<unknown, readonly Plugin[]>;
+}
+/** The Application augments this interface once in its own TypeScript compilation context. */
+interface Register extends RegistrationShape {
+}
+type RegisteredEnvironment = Register extends {
+    environment: infer Environment;
+} ? Environment extends ApplicationEnvironment<unknown, readonly Plugin[]> ? Environment : never : ApplicationEnvironment;
+type RegisteredGlobals = RegisteredEnvironment['globals'];
+/** A private type marker avoids pretending parsed global values exist before an invocation. */
+declare const applicationEnvironment: unique symbol;
+type EnvironmentOf<Value extends {
+    readonly [applicationEnvironment]: ApplicationEnvironment<unknown, readonly Plugin[]>;
+}> = Value[typeof applicationEnvironment];
+export type { ApplicationEnvironment, EnvironmentOf, Register, RegisteredEnvironment, RegisteredGlobals, applicationEnvironment, };

package/dist/environment.js

@@ -0,0 +1 @@
+export {};

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { InputIdentity, Renderer } from './types.js';
+import type { InputIdentity } from './types.js';
 /**
  * The two short-group faults. A value option that is not last in its group names that option's
  * spelling; a group that mixes scopes names the whole group and the two letters that disagree.
@@ -14,28 +14,25 @@ type ShortGroupFault = {
     global: string;
     other: string;
 };
-/** One registration: the class it names, read as the prototype and the name that class holds. */
-interface Registration {
-    name: string;
-    prototype: unknown;
-    render: (failure: LoomError) => unknown;
-}
-/** Phantom key. It marks a failure registration and holds no runtime value. */
-declare const failureRegistration: unique symbol;
-/** The runtime value `renderFailure` returns. Its pair lives in the registry above. */
-declare class RegisteredFailure {
-    readonly [failureRegistration]: true;
-    constructor(registration: Registration);
-}
+/**
+ * Core's own text for one failure: its message under the category prefix its class carries, with
+ * the trailing newline every view's text carries. The four categories are disjoint branches of the
+ * hierarchy, so one ordered test reads every class, and a class without a prefix of its own writes
+ * the sentence alone. It is the default view of every failure class and the text the plain
+ * fallback path writes, so it runs no application code and nothing downstream composes its newline.
+ */
+export declare function defaultText(failure: LoomError): string;
 /** How a diagnostic names one Command inside a sentence: by name, or as the unnamed root. */
 export declare function commandSubject(name: string | null): string;
+/** The routed path names the Command a sentence speaks of; an empty path is the root. */
+export declare function routedSubject(command: readonly string[]): string;
 /** The same subject at the start of a sentence. */
 export declare function commandSentence(name: string | null): string;
 /**
  * Every failure `run()` reports is an instance of a public class. Each class carries the facts its
- * sentence interpolates, so a renderer reads them instead of parsing prose, and the exit status is
+ * sentence interpolates, so a view reads them instead of parsing prose, and the exit status is
  * a field of the base, so a subclass inherits it. `message` never carries a category prefix; the
- * default renderers add it.
+ * default views add it.
  */
 export declare abstract class LoomError extends Error {
     readonly exitCode: 1 | 2;
@@ -109,58 +106,33 @@ export declare class DeclarationError extends LoomError {
 export declare class FatalError extends LoomError {
     constructor(message: string);
 }
-/** Exit 1: an unexpected exception, a non-error throw, or a renderer that could not answer. */
+/** Exit 1: an unexpected exception, a non-error throw, or a view that could not answer. */
 export declare class InternalError extends LoomError {
     readonly cause: unknown;
     constructor(message: string, cause: unknown);
 }
+/** The four ways the results lane is broken, each named where core meets it. */
+export type ResultFault = 'missing' | 'repeated' | 'undeclared' | 'middleware';
+/**
+ * Exit 1: the promise a declared result makes was not kept. It wraps no thrown value, so its
+ * `cause` is `undefined`, and it extends `InternalError`, so an override of that class brands it
+ * and its default text carries the same prefix, while an override keyed by this class reaches it
+ * alone.
+ */
+export declare class ResultError extends InternalError {
+    readonly path: readonly string[];
+    readonly kind: ResultFault;
+    readonly cause: undefined;
+    constructor(kind: ResultFault, path: readonly string[]);
+}
 /** What a diagnostic says about an unexpected value, whether or not it was an Error. */
 export declare function reasonOf(thrown: unknown): string;
 /**
- * Why a returned value is not the text a renderer owes. A renderer is synchronous, so a returned
- * promise is a non-string return like any other, and its rejection is adopted and swallowed here:
- * an unobserved rejection would end the process before the invocation could report anything.
+ * Why a returned value is not the text a view owes. A view is synchronous, so a returned promise is
+ * a non-string return like any other, and its rejection is adopted and swallowed here: an
+ * unobserved rejection would end the process before the invocation could report anything.
  */
 export declare function notTextReason(value: unknown): string;
 /** Every thrown value reaches reporting as a failure class; anything else is internal. */
 export declare function toFailure(thrown: unknown): LoomError;
-/** An opaque registration pairing one failure class with a renderer for its instances. */
-export type FailureRenderer = Pick<RegisteredFailure, typeof failureRegistration>;
-/**
- * A registration pairing one failure class with a renderer for its instances. The helper is the
- * typed path for a class-keyed list, because an array literal cannot carry a different type
- * parameter per element.
- */
-export declare function renderFailure<Failure extends LoomError>(type: abstract new (...args: never[]) => Failure, renderer: Renderer<Failure>): FailureRenderer;
-/** The renderers one application registered, keyed by the class each one names. */
-export type FailureRegistry = ReadonlyMap<unknown, Registration>;
-/**
- * One class answers to one renderer inside one contributor, so a second registration for it is a
- * declaration fault. The subject names the contributor: the Application, or an installed plugin.
- */
-export declare function buildFailures(failures: readonly FailureRenderer[], subject?: string): FailureRegistry;
-/**
- * One registry from every contributor's own, resolving first-in-wins: the application's
- * registrations, then each installed plugin's in installation order, then core's text.
- */
-export declare function mergeFailures(registries: readonly FailureRegistry[]): FailureRegistry;
-/**
- * The report of one failure: the text core writes, and whether a registered renderer produced it.
- * An unrendered report carries core's own text, which the plain fallback path writes beside the
- * diagnostic naming the renderer that could not answer.
- */
-export type FailureReport = {
-    kind: 'rendered';
-    text: string;
-} | {
-    kind: 'unrendered';
-    text: string;
-    reason: string;
-};
-/**
- * The text core writes for one failure. Resolution walks the failure's prototype chain most
- * derived first through the application's registrations, then falls to core's own text, so a
- * registration for a base class brands every failure below it.
- */
-export declare function describeFailure(registry: FailureRegistry, failure: LoomError): FailureReport;
 export {};

package/dist/errors.js

@@ -1,7 +1,20 @@
-/** The routed path names the Command a token fault belongs to; an empty path is the root. */
+/** The same subject at the start of a sentence, where a token fault names its Command. */
 function routedSentence(command) {
-    const name = command.at(-1);
-    return name === undefined ? 'The root Command' : commandSentence(name);
+    const subject = routedSubject(command);
+    return `${subject.slice(0, 1).toUpperCase()}${subject.slice(1)}`;
+}
+/** The sentence one results-lane fault reports, which names the Command that holds it. */
+function resultMessage(kind, command) {
+    if (kind === 'missing') {
+        return `${routedSentence(command)} declares a result and its action returned without emitting one. Call out.results() once.`;
+    }
+    if (kind === 'repeated') {
+        return `${routedSentence(command)} emitted its result twice. Call out.results() once.`;
+    }
+    if (kind === 'undeclared') {
+        return `${routedSentence(command)} declares no result. Declare one with result() or rows() before action().`;
+    }
+    return `A middleware called out.results() on ${routedSubject(command)}. Only the action emits a result.`;
 }
 /**
  * The clause that offers the candidates, which is absent when there are none: every child of the
@@ -17,12 +30,12 @@ function shortGroupMessage(fault) {
 }
 /**
  * Core's own text for one failure: its message under the category prefix its class carries, with
- * the trailing newline every renderer's text carries. The four categories are disjoint branches of
- * the hierarchy, so one ordered test reads every class, and a class without a prefix of its own
- * writes the sentence alone. A default rendering is the same kind of value as a custom one, so
- * nothing downstream composes the newline for it.
+ * the trailing newline every view's text carries. The four categories are disjoint branches of the
+ * hierarchy, so one ordered test reads every class, and a class without a prefix of its own writes
+ * the sentence alone. It is the default view of every failure class and the text the plain
+ * fallback path writes, so it runs no application code and nothing downstream composes its newline.
  */
-function defaultText(failure) {
+export function defaultText(failure) {
     if (failure instanceof UsageError) {
         return `Invalid input: ${failure.message}\n`;
     }
@@ -34,36 +47,15 @@ function defaultText(failure) {
     }
     return `${failure.message}\n`;
 }
-/** Every prototype in a failure's chain, most derived first, so one walk reads the registry. */
-function chainOf(failure) {
-    const chain = [];
-    let prototype = Object.getPrototypeOf(failure);
-    while (prototype !== null) {
-        chain.push(prototype);
-        prototype = Object.getPrototypeOf(prototype);
-    }
-    return chain;
-}
-/** Authored registrations register here, so the public type publishes nothing to reach. */
-const nodes = new WeakMap();
-/** The runtime value `renderFailure` returns. Its pair lives in the registry above. */
-class RegisteredFailure {
-    constructor(registration) {
-        nodes.set(this, registration);
-    }
-}
-/** Reads the pair behind a registered value; anything else is a declaration error. */
-function nodeOf(value, subject) {
-    const registration = nodes.get(value);
-    if (!registration) {
-        throw new DeclarationError(`${subject} holds a value that is not a failure renderer. Supply the value returned by renderFailure(type, renderer).`);
-    }
-    return registration;
-}
 /** How a diagnostic names one Command inside a sentence: by name, or as the unnamed root. */
 export function commandSubject(name) {
     return name === null ? 'the root Command' : `Command "${name}"`;
 }
+/** The routed path names the Command a sentence speaks of; an empty path is the root. */
+export function routedSubject(command) {
+    const name = command.at(-1);
+    return name === undefined ? 'the root Command' : commandSubject(name);
+}
 /** The same subject at the start of a sentence. */
 export function commandSentence(name) {
     const subject = commandSubject(name);
@@ -71,9 +63,9 @@ export function commandSentence(name) {
 }
 /**
  * Every failure `run()` reports is an instance of a public class. Each class carries the facts its
- * sentence interpolates, so a renderer reads them instead of parsing prose, and the exit status is
+ * sentence interpolates, so a view reads them instead of parsing prose, and the exit status is
  * a field of the base, so a subclass inherits it. `message` never carries a category prefix; the
- * default renderers add it.
+ * default views add it.
  */
 export class LoomError extends Error {
     exitCode;
@@ -193,7 +185,7 @@ export class FatalError extends LoomError {
         this.name = 'FatalError';
     }
 }
-/** Exit 1: an unexpected exception, a non-error throw, or a renderer that could not answer. */
+/** Exit 1: an unexpected exception, a non-error throw, or a view that could not answer. */
 export class InternalError extends LoomError {
     cause;
     constructor(message, cause) {
@@ -202,85 +194,36 @@ export class InternalError extends LoomError {
         this.name = 'InternalError';
     }
 }
+/**
+ * Exit 1: the promise a declared result makes was not kept. It wraps no thrown value, so its
+ * `cause` is `undefined`, and it extends `InternalError`, so an override of that class brands it
+ * and its default text carries the same prefix, while an override keyed by this class reaches it
+ * alone.
+ */
+export class ResultError extends InternalError {
+    path;
+    kind;
+    constructor(kind, path) {
+        super(resultMessage(kind, path), undefined);
+        this.kind = kind;
+        this.name = 'ResultError';
+        this.path = path;
+    }
+}
 /** What a diagnostic says about an unexpected value, whether or not it was an Error. */
 export function reasonOf(thrown) {
     return thrown instanceof Error ? thrown.message : 'An unknown error occurred.';
 }
 /**
- * Why a returned value is not the text a renderer owes. A renderer is synchronous, so a returned
- * promise is a non-string return like any other, and its rejection is adopted and swallowed here:
- * an unobserved rejection would end the process before the invocation could report anything.
+ * Why a returned value is not the text a view owes. A view is synchronous, so a returned promise is
+ * a non-string return like any other, and its rejection is adopted and swallowed here: an
+ * unobserved rejection would end the process before the invocation could report anything.
  */
 export function notTextReason(value) {
     void Promise.resolve(value).catch(() => undefined);
-    return `The renderer returned ${typeof value} instead of a string.`;
+    return `The view returned ${typeof value} instead of a string.`;
 }
 /** Every thrown value reaches reporting as a failure class; anything else is internal. */
 export function toFailure(thrown) {
     return thrown instanceof LoomError ? thrown : new InternalError(reasonOf(thrown), thrown);
 }
-/**
- * A registration pairing one failure class with a renderer for its instances. The helper is the
- * typed path for a class-keyed list, because an array literal cannot carry a different type
- * parameter per element.
- */
-export function renderFailure(type, renderer) {
-    return new RegisteredFailure({
-        name: 'name' in type && typeof type.name === 'string' ? type.name : 'a failure class',
-        prototype: 'prototype' in type ? type.prototype : undefined,
-        // Resolution reaches this registration through the same class, so the test always holds.
-        render: (failure) => (failure instanceof type ? renderer.render(failure) : undefined),
-    });
-}
-/**
- * One class answers to one renderer inside one contributor, so a second registration for it is a
- * declaration fault. The subject names the contributor: the Application, or an installed plugin.
- */
-export function buildFailures(failures, subject = 'The Application') {
-    const registry = new Map();
-    for (const failure of failures) {
-        const registration = nodeOf(failure, subject);
-        if (registry.has(registration.prototype)) {
-            throw new DeclarationError(`${subject} registers two failure renderers for "${registration.name}". Remove one registration.`);
-        }
-        registry.set(registration.prototype, registration);
-    }
-    return registry;
-}
-/**
- * One registry from every contributor's own, resolving first-in-wins: the application's
- * registrations, then each installed plugin's in installation order, then core's text.
- */
-export function mergeFailures(registries) {
-    const merged = new Map();
-    for (const registry of registries) {
-        for (const [type, registration] of registry) {
-            if (!merged.has(type)) {
-                merged.set(type, registration);
-            }
-        }
-    }
-    return merged;
-}
-/**
- * The text core writes for one failure. Resolution walks the failure's prototype chain most
- * derived first through the application's registrations, then falls to core's own text, so a
- * registration for a base class brands every failure below it.
- */
-export function describeFailure(registry, failure) {
-    const registration = chainOf(failure)
-        .map((prototype) => registry.get(prototype))
-        .find((entry) => entry !== undefined);
-    if (!registration) {
-        return { kind: 'rendered', text: defaultText(failure) };
-    }
-    try {
-        const text = registration.render(failure);
-        return typeof text === 'string'
-            ? { kind: 'rendered', text }
-            : { kind: 'unrendered', reason: notTextReason(text), text: defaultText(failure) };
-    }
-    catch (error) {
-        return { kind: 'unrendered', reason: reasonOf(error), text: defaultText(failure) };
-    }
-}

package/dist/extension.d.ts

@@ -1,17 +1,22 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { ArgumentNode, CommandNode, OptionNode } from './inspect.js';
+import type { AttachedCommand } from './types.js';
 /** The three declaration kinds an extension can name, each with its own node in the graph. */
 type ExtensionTarget = 'argument' | 'command' | 'option';
 /**
- * The descriptor supertype a plugin's `extensions` list uses. It publishes the identity and the
- * target and erases both the schema and the factory call signature, because a schema-typed call
- * signature relates only by schema identity and a list cannot name one schema per element. A
- * descriptor is assignable to it; an extension value, which publishes its brand alone, is not.
+ * The descriptor supertype a plugin's `extensions` list uses. It publishes the identity, the
+ * target, and whether the extension collects, and erases both the schema and the factory call
+ * signature, because a schema-typed call signature relates only by schema identity and a list
+ * cannot name one schema per element. A descriptor is assignable to it; an extension value, which
+ * publishes its brand alone, is not.
  */
 interface AnyExtension {
     readonly identity: string;
     readonly target: ExtensionTarget;
+    readonly collect: boolean;
 }
+/** What a value must show to be taken for a descriptor before its `collect` flag is checked. */
+type DescriptorShape = Pick<AnyExtension, 'identity' | 'target'>;
 /** One carried value: the input its author supplied and the descriptor that produced it. */
 interface CarriedValue {
     descriptor: AnyExtension;
@@ -32,33 +37,52 @@ declare class ExtensionCarrier<Target extends ExtensionTarget> {
 type ExtensionValue<Target extends ExtensionTarget> = Pick<ExtensionCarrier<Target>, typeof extensionTarget>;
 /**
  * A descriptor that is also a factory: calling it with the schema's input returns the branded value
- * a declaration carries. The schema is public so a typed read recovers the output type.
+ * a declaration carries. The schema is public so a typed read recovers the output type, and
+ * `collect` says whether the values a declaration carries accumulate or replace each other.
  */
-interface Extension<Target extends ExtensionTarget = ExtensionTarget, Schema extends StandardSchemaV1 = StandardSchemaV1> extends AnyExtension {
+interface Extension<Target extends ExtensionTarget = ExtensionTarget, Schema extends StandardSchemaV1 = StandardSchemaV1, Collect extends boolean = false> extends AnyExtension {
     (input: StandardSchemaV1.InferInput<Schema>): ExtensionValue<Target>;
     readonly schema: Schema;
     readonly target: Target;
+    readonly collect: Collect;
 }
 /**
  * One typed fact a plugin defines for one target. The descriptor is compared by reference wherever
- * it appears, so one identity means one descriptor and a duplicated package copy is visible.
+ * it appears, so one identity means one descriptor and a duplicated package copy is visible. With
+ * `collect: true` it is a collecting extension, whose values accumulate on a declaration in order.
  */
 declare function extension<Target extends ExtensionTarget, Schema extends StandardSchemaV1>(identity: string, config: {
     schema: Schema;
     target: Target;
+    collect?: false | undefined;
 }): Extension<Target, Schema>;
-/** The node kind one descriptor's target names, so a read against another kind cannot compile. */
-type NodeFor<Target extends ExtensionTarget> = Target extends 'command' ? CommandNode : Target extends 'option' ? OptionNode : ArgumentNode;
+declare function extension<Target extends ExtensionTarget, Schema extends StandardSchemaV1>(identity: string, config: {
+    schema: Schema;
+    target: Target;
+    collect: true;
+}): Extension<Target, Schema, true>;
+/**
+ * The node kind one descriptor's target names, so a read against another kind cannot compile. A
+ * Command-target read also takes the value a lifecycle hook receives, which publishes the record
+ * as it stands at that hook.
+ */
+type NodeFor<Target extends ExtensionTarget> = Target extends 'command' ? CommandNode | AttachedCommand : Target extends 'option' ? OptionNode : ArgumentNode;
 /** Stored output is plain data the graph froze, so every read of it is read-only to any depth. */
 type DeepReadonly<Value> = Value extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : Value extends object ? {
     readonly [Key in keyof Value]: DeepReadonly<Value[Key]>;
 } : Value;
+/**
+ * What one read answers, decided by the descriptor's own `collect` type: a collecting extension's
+ * outputs as a read-only list, or an ordinary extension's output or nothing.
+ */
+type ExtensionRead<Schema extends StandardSchemaV1, Collect extends boolean> = Collect extends true ? readonly DeepReadonly<StandardSchemaV1.InferOutput<Schema>>[] : DeepReadonly<StandardSchemaV1.InferOutput<Schema>> | undefined;
 /**
  * The typed read of one extension value. It takes the node kind the descriptor targets, returns the
  * stored output or `undefined`, compares the descriptor by reference with the one that produced the
- * value, and runs no schema.
+ * value, and runs no schema. Through a collecting descriptor it returns every collected output in
+ * collection order, and an empty list where the node carries none.
  */
-declare function readExtension<Target extends ExtensionTarget, Schema extends StandardSchemaV1>(node: NodeFor<Target>, descriptor: Extension<Target, Schema>): DeepReadonly<StandardSchemaV1.InferOutput<Schema>> | undefined;
+declare function readExtension<Target extends ExtensionTarget, Schema extends StandardSchemaV1, Collect extends boolean = false>(node: NodeFor<Target>, descriptor: Extension<Target, Schema, Collect>): ExtensionRead<Schema, Collect>;
 /** The declaration one `extensions` slot belongs to, as its own diagnostics name it. */
 interface ExtensionSubject {
     /** The subject after a preposition, such as `on Command "get"`. */
@@ -74,10 +98,13 @@ type DescriptorRegistry = Map<string, AnyExtension>;
  * build alone and inspection reads them back with the nodes it renders.
  */
 type ExtensionRecords = Map<object, Readonly<Record<string, unknown>>>;
-/** Whether a value is a descriptor: a callable object carrying an identity and a declared target. */
-declare function isDescriptor(value: unknown): value is AnyExtension;
-/** One identity means one descriptor, wherever on the graph that descriptor appears. */
-declare function registerDescriptor(descriptors: DescriptorRegistry, descriptor: AnyExtension): void;
+/**
+ * Whether a value has a descriptor's shape: a callable object carrying an identity and a declared
+ * target. Its `collect` flag is checked where a build registers it.
+ */
+declare function isDescriptor(value: unknown): value is DescriptorShape;
+/** Admits one descriptor and records it, so a later descriptor of its identity is compared to it. */
+declare function registerDescriptor(descriptors: DescriptorRegistry, descriptor: DescriptorShape): void;
 /** Everything one `extensions` slot needs to answer: whose it is, and what it may carry. */
 interface ExtensionSlot {
     declared: unknown;
@@ -85,11 +112,44 @@ interface ExtensionSlot {
     subject: ExtensionSubject;
     target: ExtensionTarget;
 }
+/** One carried value, validated against its descriptor's schema and ready to store. */
+interface ValidatedValue {
+    descriptor: AnyExtension;
+    output: unknown;
+}
+/**
+ * One layer's values, each validated once, synchronously, in authoring order. A layer holds at
+ * most one value of an extension, collecting or not, so a second one is a declaration fault.
+ */
+declare function validateLayer(slot: ExtensionSlot): readonly ValidatedValue[];
+/**
+ * The values one declaration has validated so far, by identity in the order each first appeared:
+ * an ordinary extension's latest output alone, and a collecting extension's every output in
+ * collection order. A store is never changed; adding a layer answers a new one.
+ */
+interface ExtensionStore {
+    readonly entries: ReadonlyMap<string, {
+        readonly descriptor: AnyExtension;
+        readonly outputs: readonly unknown[];
+    }>;
+}
+/**
+ * The store with one more validated layer. An ordinary value replaces the earlier one in place, so
+ * a key keeps its first position, and a collecting value joins the values before it.
+ */
+declare function extendStore(store: ExtensionStore, layer: readonly ValidatedValue[]): ExtensionStore;
 /**
- * The frozen record one declaration publishes: each carried value validated once, synchronously,
- * and stored under its extension's identity. The descriptors that produced them are recorded beside
- * the record, so a typed read compares by reference without the graph carrying a reference.
+ * The frozen record a store publishes: each ordinary extension's output, and each collecting
+ * extension's frozen list of outputs, under its identity. The descriptors that produced them are
+ * recorded beside the record, so a typed read compares by reference without the graph carrying a
+ * reference.
  */
+declare function publishStore(store: ExtensionStore): Readonly<Record<string, unknown>>;
+/** The frozen record of one `extensions` slot, which is one layer. */
 declare function buildExtensions(slot: ExtensionSlot): Readonly<Record<string, unknown>>;
-export type { AnyExtension, DeepReadonly, DescriptorRegistry, Extension, ExtensionRecords, ExtensionSubject, ExtensionTarget, ExtensionValue, };
-export { buildExtensions, extension, isDescriptor, readExtension, registerDescriptor };
+/** A Command's author layers, validated in authoring order into the store its hooks extend. */
+declare function storeCommandLayers(slot: Omit<ExtensionSlot, 'declared' | 'target'> & {
+    layers: readonly unknown[];
+}): ExtensionStore;
+export type { AnyExtension, DeepReadonly, DescriptorRegistry, Extension, ExtensionRecords, ExtensionStore, ExtensionSubject, ExtensionTarget, ExtensionValue, };
+export { buildExtensions, extendStore, extension, isDescriptor, publishStore, readExtension, registerDescriptor, storeCommandLayers, validateLayer, };