@sous-io/plugin-api 0.0.0-stage → 1.0.1

package/dist/outputs.js

@@ -0,0 +1,286 @@
+/**
+ * What an intent returns: `IntentOutputs`, one or more `IntentOutput`s in the order they are shown.
+ * Each output carries a result as a payload type a reporter knows how to show (`VariableSet`,
+ * `Table`, ...), and converts to plain values for machines (`--json`, MCP, a calling intent).
+ *
+ * A payload is also what a reporter is given to show a structure while an intent runs:
+ * `reporter.variables(...)` reports a `VariableSet`.
+ */
+/** Marks a payload, so a reporter recognizes one even from another copy of this package. */
+const PAYLOAD = Symbol.for("sous.payload");
+/** Marks an `IntentOutputs`, for the same reason. */
+const OUTPUTS = Symbol.for("sous.intent-outputs");
+/**
+ * A structure a reporter knows how to show. Each payload holds plain values only, and converts to
+ * them: `toPlain()` gives a plain object, and each type adds its own conversion (`toObject()`,
+ * `toRows()`, ...). `toText()` is the payload as plain text, for a reporter that draws nothing.
+ */
+export class Payload {
+    [PAYLOAD] = true;
+    /** Whether a value is a payload, from any copy of plugin-api. */
+    static is(value) {
+        return typeof value === "object" && value !== null && value[PAYLOAD] === true;
+    }
+}
+/** A value as text: nothing for `undefined` and `null`, JSON for an object. */
+function textOf(value) {
+    if (value === undefined || value === null) {
+        return "";
+    }
+    if (typeof value !== "object") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** Labels and values, read as one block: `Repository: /work/recipes`. */
+export class VariableSet extends Payload {
+    kind = "variable-set";
+    entries;
+    title;
+    /** @param entries - The pairs, or a record read as label and value pairs in its key order. */
+    constructor(entries, options = {}) {
+        super();
+        this.entries = Array.isArray(entries) ? [...entries] : Object.entries(entries).map(([label, value]) => ({ label, value }));
+        this.title = options.title;
+    }
+    /** The pairs as one object: `{ Repository: "/work/recipes" }`. A label used twice keeps its last value. */
+    toObject() {
+        return Object.fromEntries(this.entries.filter((entry) => entry.label !== "").map((entry) => [entry.label, entry.value]));
+    }
+    toPlain() {
+        return this.toObject();
+    }
+    toText() {
+        const lines = this.entries.map((entry) => `${entry.label}: ${textOf(entry.value)}${entry.detail === undefined ? "" : ` (${entry.detail})`}`);
+        return [...(this.title === undefined ? [] : [this.title]), ...lines].join("\n");
+    }
+}
+/** Rows under columns. */
+export class Table extends Payload {
+    kind = "table";
+    columns;
+    rows;
+    title;
+    /** What to say instead of the table when there are no rows. */
+    empty;
+    /** A note shown under a row, by the row's index; `undefined` for a row with none. */
+    rowNotes;
+    constructor(columns, rows, options = {}) {
+        super();
+        this.columns = columns;
+        this.rows = rows;
+        this.title = options.title;
+        this.empty = options.empty;
+        this.rowNotes = options.rowNotes;
+    }
+    /** The rows. */
+    toRows() {
+        return [...this.rows];
+    }
+    toPlain() {
+        return { rows: this.toRows() };
+    }
+    toText() {
+        if (this.rows.length === 0 && this.empty !== undefined) {
+            return this.empty;
+        }
+        const lines = this.rows.map((row) => this.columns.map((column) => textOf(row[column.key])).join("  "));
+        return [...(this.title === undefined ? [] : [this.title]), ...lines].join("\n");
+    }
+}
+/** A list of items, with an optional title before it and an optional sentence after it. */
+export class ItemList extends Payload {
+    kind = "item-list";
+    items;
+    title;
+    footer;
+    constructor(items, options = {}) {
+        super();
+        this.items = items;
+        this.title = options.title;
+        this.footer = options.footer;
+    }
+    /** The items. */
+    toArray() {
+        return [...this.items];
+    }
+    toPlain() {
+        return { items: this.toArray() };
+    }
+    toText() {
+        return [...(this.title === undefined ? [] : [this.title]), ...this.items.map((item) => `- ${item}`), ...(this.footer === undefined ? [] : [this.footer])].join("\n");
+    }
+}
+/** Items nested under other items. */
+export class Tree extends Payload {
+    kind = "tree";
+    nodes;
+    title;
+    constructor(nodes, options = {}) {
+        super();
+        this.nodes = nodes;
+        this.title = options.title;
+    }
+    toPlain() {
+        return { nodes: this.nodes };
+    }
+    toText() {
+        const lines = (nodes, depth) => nodes.flatMap((node) => [`${"  ".repeat(depth)}${node.label}${node.detail === undefined ? "" : ` (${node.detail})`}`, ...lines(node.children ?? [], depth + 1)]);
+        return [...(this.title === undefined ? [] : [this.title]), ...lines(this.nodes, 0)].join("\n");
+    }
+}
+/**
+ * Text. A paragraph a reporter may wrap, or, with `verbatim`, text shown exactly as given (a value
+ * a script reads, `--help`).
+ */
+export class TextBlock extends Payload {
+    kind = "text-block";
+    text;
+    verbatim;
+    constructor(text, options = {}) {
+        super();
+        this.text = text;
+        this.verbatim = options.verbatim === true;
+    }
+    toString() {
+        return this.text;
+    }
+    toPlain() {
+        return { text: this.text };
+    }
+    toText() {
+        return this.text;
+    }
+}
+/** A structured value shown as data (a config as JSON). */
+export class DataValue extends Payload {
+    kind = "data-value";
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    /** The value itself. */
+    toValue() {
+        return this.value;
+    }
+    /** The value when it is a plain object, else `{ value }`. */
+    toPlain() {
+        return typeof this.value === "object" && this.value !== null && !Array.isArray(this.value) ? this.value : { value: this.value };
+    }
+    toText() {
+        try {
+            return JSON.stringify(this.value, null, 2) ?? String(this.value);
+        }
+        catch {
+            return String(this.value);
+        }
+    }
+}
+/** One part of what an intent returns. */
+export class IntentOutput {
+    title;
+    summary;
+    result;
+    data;
+    style;
+    constructor(init) {
+        this.title = init.title;
+        this.summary = init.summary;
+        this.result = init.result;
+        this.data = init.data;
+        this.style = init.style;
+    }
+    /** What machines get: `data`, else the result as a plain object, else `{}`. */
+    toPlain() {
+        return (this.data ?? this.result?.toPlain() ?? {});
+    }
+    /** The output as plain text: title, summary, then the result. */
+    toText() {
+        return [this.title, this.summary, this.result?.toText()].filter((part) => part !== undefined && part !== "").join("\n");
+    }
+}
+/**
+ * What an intent returns: its outputs, in the order they are shown.
+ *
+ * ```ts
+ * return new IntentOutputs(new IntentOutput({ summary: "Subscribed to acme/git.", result: new VariableSet({ Recipe: "acme/git" }) }));
+ *
+ * const prepared = (await ctx.run("build.prepare", {})).toPlain();   // the last output's plain object
+ * ```
+ */
+export class IntentOutputs {
+    [OUTPUTS] = true;
+    #outputs;
+    /** The exit code the command ends with (a build with errors ends with 1). Default: none, so 0. */
+    exitCode;
+    constructor(outputs = [], options = {}) {
+        this.#outputs = Array.isArray(outputs) ? [...outputs] : [outputs];
+        this.exitCode = options.exitCode;
+    }
+    /** Outputs holding one plain value and nothing to show beyond it. */
+    static of(data, init = {}) {
+        return new IntentOutputs(new IntentOutput({ ...init, data }));
+    }
+    /** Whether a value is an `IntentOutputs`, from any copy of plugin-api. */
+    static is(value) {
+        return typeof value === "object" && value !== null && value[OUTPUTS] === true;
+    }
+    /** How many outputs there are. */
+    get length() {
+        return this.#outputs.length;
+    }
+    /** The outputs, in order. */
+    toArray() {
+        return [...this.#outputs];
+    }
+    /** The first output, or `undefined`. */
+    first() {
+        return this.#outputs[0];
+    }
+    /** The last output, or `undefined`. */
+    last() {
+        return this.#outputs[this.#outputs.length - 1];
+    }
+    /** The last output's plain object (`{}` with none). Never an array. */
+    toPlain() {
+        return (this.last()?.toPlain() ?? {});
+    }
+    /** Every output as plain text, separated by a blank line. */
+    toText() {
+        return this.#outputs.map((output) => output.toText()).filter((text) => text !== "").join("\n\n");
+    }
+    /** New outputs with more appended, keeping the exit code (for a wrapper or an `after` listener). */
+    with(...more) {
+        return new IntentOutputs([...this.#outputs, ...more], this.exitCode === undefined ? {} : { exitCode: this.exitCode });
+    }
+    /**
+     * The same outputs with `data` as what machines get: set on the last output, or as one output
+     * holding only data when there is none. Use it when the last output shows something built from
+     * a larger result.
+     *
+     * ```ts
+     * return new IntentOutputs([commandVariables(ctx), table]).withData({ subscriptions });
+     * ```
+     */
+    withData(data) {
+        const outputs = [...this.#outputs];
+        const last = outputs.pop();
+        const replaced = last === undefined
+            ? new IntentOutput({ data })
+            : new IntentOutput({ ...(last.title === undefined ? {} : { title: last.title }), ...(last.summary === undefined ? {} : { summary: last.summary }), ...(last.result === undefined ? {} : { result: last.result }), ...(last.style === undefined ? {} : { style: last.style }), data });
+        return new IntentOutputs([...outputs, replaced], this.exitCode === undefined ? {} : { exitCode: this.exitCode });
+    }
+    /** The same outputs with another exit code. */
+    withExitCode(exitCode) {
+        return new IntentOutputs([...this.#outputs], { exitCode });
+    }
+    [Symbol.iterator]() {
+        return this.#outputs[Symbol.iterator]();
+    }
+}

package/dist/plugin.d.ts

@@ -0,0 +1,144 @@
+import type { ContributorDefinition } from "./config.js";
+import type { Environment, EngineHandle, ProjectInfo } from "./context.js";
+import type { EntityKindOptions, EntityReader } from "./entities.js";
+import type { EventFor, EventForPattern, EventPattern, EventPayload, Listener, ListenerOptions } from "./events.js";
+import type { IntentDefinition, IntentWrapper, IntentInputOf } from "./intents.js";
+import type { EntityKind, EntityType, IntentReturn, ServiceName, ServiceType } from "./registry.js";
+import type { Reporter } from "./reporter.js";
+import type { SousSchema } from "./schema.js";
+import type { ServiceFactory, ServiceOptions, ServiceReader, ServiceWrapper } from "./services.js";
+/**
+ * A plugin: a module that registers contributors, intents, listeners, services and entities. Its module's default export is the definition.
+ */
+export interface PluginDefinition {
+    /** The package name: `sous-plugin-diagrams`, `@sous-io/plugin-skills`. */
+    name: string;
+    /** Its version, checked against other plugins' `dependsOn`. */
+    version?: string;
+    /** One sentence saying what it adds. */
+    description?: string;
+    /** Plugins this one needs, with semver ranges. Sous stops before any intent runs when one is missing. */
+    dependsOn?: Readonly<Record<string, string>>;
+    /** The default `before` of every contributor it adds. */
+    before?: readonly string[];
+    /** The default `after` of every contributor it adds. */
+    after?: readonly string[];
+    /**
+     * Service and intent names this plugin's contract declares for other plugins to implement
+     * (`compiler.namespace-resolver`). Another plugin registering one is expected, so sous does not
+     * warn that it starts with this plugin's prefix.
+     */
+    implementable?: readonly string[];
+    /** Runs once, when the plugin loads during config building. */
+    register(sous: Sous): void | Promise<void>;
+}
+/**
+ * Declares a plugin. It only gives the definition its type.
+ *
+ * ```ts
+ * export default definePlugin({
+ *     name: "sous-plugin-diagrams",
+ *     version: "1.0.0",
+ *     dependsOn: { "@sous-io/plugin-skills": "^1.0.0" },
+ *
+ *     register(sous) {
+ *         sous.intents.add({ intent: "diagrams.render", handle: async () => ({ rendered: 0 }) });
+ *     },
+ * });
+ * ```
+ */
+export declare function definePlugin<const T extends PluginDefinition>(definition: T): T;
+/** A front end: the CLI, the MCP server, a web GUI. */
+export interface FrontEndDefinition {
+    /** `cli`, `mcp`, `web`. */
+    id: string;
+    /** Takes over after the config is built: turns its input into submitted chains. */
+    start(engine: EngineHandle, argv: readonly string[]): void | Promise<void>;
+    /**
+     * Whether `argv` needs the built config (`boolean = true`). It is asked on the config of the
+     * built-in plugins' registrations alone; `false` lets the application start the front end without
+     * building the config when the project loads no further plugin.
+     */
+    needsConfig?(engine: EngineHandle, argv: readonly string[]): boolean;
+}
+/** `sous.intents`. */
+export interface IntentRegistry {
+    /** Adds an intent. Two plugins adding one name is an error naming both, unless `intents.replace` picks one. */
+    add<const N extends string, S extends SousSchema = SousSchema>(definition: IntentDefinition<N, S>): void;
+    /** Wraps an intent's handler. */
+    wrap<N extends string>(intent: N, wrapper: IntentWrapper<IntentInputOf<N, unknown>, IntentReturn<N>>): void;
+}
+/** `sous.services`. */
+export interface ServiceRegistry extends ServiceReader {
+    /** Adds a service with a lifetime. */
+    add<N extends ServiceName>(name: N, factory: ServiceFactory<ServiceType<N>>, options?: ServiceOptions): void;
+    /** Wraps a service. Wrappers stack in plugin order. */
+    wrap<N extends ServiceName>(name: N, wrapper: ServiceWrapper<ServiceType<N>>): void;
+    /**
+     * Replaces a service. Two plugins replacing one is an error, unless the config picks one
+     * (`services.replace."<name>": "<plugin>"`); sous then warns on every run.
+     */
+    replace<N extends ServiceName>(name: N, factory: ServiceFactory<ServiceType<N>>, options?: ServiceOptions): void;
+}
+/** `sous.entities`. */
+export interface EntityRegistry extends EntityReader {
+    /** Defines a kind, with the schema every entry is checked against. */
+    define(kind: string, schema: SousSchema, options?: EntityKindOptions): void;
+    /**
+     * Adds an entity whose existence does not depend on the config.
+ *
+ * An entity's methods must not use `this`: the engine stores a copy of each entry (its schema
+ * check and its method timing make one), so `this` is not the object the plugin made. Close over
+ * what a method needs instead:
+ *
+ * ```ts
+ * const root = ".codex";
+ *
+ * sous.entities.add("skill-target", {
+ *     id: "codex",
+ *     directory: () => root,          // not `() => this.root`
+ * });
+ * ```
+     */
+    add<K extends EntityKind>(kind: K, entry: EntityType<K>): void;
+}
+/**
+ * What `register(sous)` receives: everything a plugin uses, scoped to that plugin, so every
+ * registration is recorded with it.
+ */
+export interface Sous {
+    /** The plugin registering. */
+    readonly plugin: {
+        readonly name: string;
+        readonly version: string | undefined;
+    };
+    readonly project: ProjectInfo | undefined;
+    readonly env: Environment;
+    /** The engine's reporter, for messages outside any chain. */
+    readonly reporter: Reporter;
+    /** The engine, as front ends and background intents use it. */
+    readonly engine: EngineHandle;
+    readonly config: {
+        /** Adds a contributor. */
+        contribute(definition: ContributorDefinition): void;
+    };
+    readonly intents: IntentRegistry;
+    readonly services: ServiceRegistry;
+    readonly entities: EntityRegistry;
+    readonly plugins: {
+        /** Brings in another plugin as this one's own dependency; users may still disable it by name. */
+        add(plugin: PluginDefinition | string): Promise<void>;
+    };
+    readonly frontEnds: {
+        /** Adds a front end. */
+        add(definition: FrontEndDefinition): void;
+    };
+    /** Listens for an event by name, wildcard or regular expression. */
+    on<const P extends EventPattern>(pattern: P, listener: Listener<EventForPattern<P>>, options?: ListenerOptions): void;
+    /** Listens once, then removes itself. */
+    once<const P extends EventPattern>(pattern: P, listener: Listener<EventForPattern<P>>, options?: ListenerOptions): void;
+    /** Removes a listener added with the same pattern. */
+    off(pattern: EventPattern, listener: Listener<never>): void;
+    /** Fires an event and waits for every listener. */
+    emit<N extends string>(name: N, payload?: EventPayload<N>): Promise<EventFor<N>>;
+}

package/dist/plugin.js

@@ -0,0 +1,18 @@
+/**
+ * Declares a plugin. It only gives the definition its type.
+ *
+ * ```ts
+ * export default definePlugin({
+ *     name: "sous-plugin-diagrams",
+ *     version: "1.0.0",
+ *     dependsOn: { "@sous-io/plugin-skills": "^1.0.0" },
+ *
+ *     register(sous) {
+ *         sous.intents.add({ intent: "diagrams.render", handle: async () => ({ rendered: 0 }) });
+ *     },
+ * });
+ * ```
+ */
+export function definePlugin(definition) {
+    return definition;
+}

package/dist/prompter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Asking questions. Services never prompt: they ask through the `Prompter` the front end
+ * handed over with the chain (`ctx.prompter`). Every question names the flag or argument that
+ * answers it without a prompt, so an agent can do everything a person can.
+ */
+/** What every question carries. */
+export interface QuestionBase {
+    /** The question, as a person would read it: `Remove the 3 files listed above?` */
+    message: string;
+    /**
+     * The flag or argument that answers this question ahead of time (`--yes`, `--harness <id>`).
+     * A prompter that cannot ask names it in its error.
+     */
+    answeredBy?: string;
+}
+/** A question answered with free text. */
+export interface ValueQuestion extends QuestionBase {
+    /** The answer used when the person just presses enter. */
+    default?: string;
+    /** Returns a message when the answer is not acceptable, so the prompter asks again. */
+    validate?: (answer: string) => string | undefined;
+    /** Hides what is typed, for secrets. */
+    secret?: boolean;
+}
+/** One option of a {@link ChoiceQuestion}. */
+export interface Choice<T> {
+    /** What the person sees. */
+    label: string;
+    value: T;
+    /** One more line about the option. */
+    description?: string;
+}
+/** A question answered by picking one option. */
+export interface ChoiceQuestion<T> extends QuestionBase {
+    choices: ReadonlyArray<Choice<T>>;
+    /** The index of the option picked when the person just presses enter. */
+    defaultIndex?: number;
+}
+/** A yes-or-no question. */
+export interface ConfirmQuestion extends QuestionBase {
+    /** The answer used when the person just presses enter. */
+    default?: boolean;
+}
+/** Where a chain's questions go. Each front end supplies its own. */
+export interface Prompter {
+    /** Whether this prompter can ask anything at all in this run. */
+    readonly interactive: boolean;
+    /** Asks for free text. Throws `NonInteractiveError` naming `answeredBy` when it cannot ask. */
+    askValue(question: ValueQuestion): Promise<string>;
+    /** Asks the person to pick one option. */
+    askChoice<T>(question: ChoiceQuestion<T>): Promise<T>;
+    /** Asks a yes-or-no question. */
+    confirm(question: ConfirmQuestion): Promise<boolean>;
+}
+/**
+ * A prompter that never asks: every question fails with a `NonInteractiveError` naming the flag that
+ * answers it. Used when nothing can answer, such as in CI or a background intent.
+ */
+export declare const nonInteractivePrompter: Prompter;
+/**
+ * A prompter that answers from a list of prepared answers, in order, for tests and for front ends
+ * that collect answers up front. Running out of answers fails like {@link nonInteractivePrompter}.
+ */
+export declare function scriptedPrompter(answers: unknown[]): Prompter & {
+    readonly asked: string[];
+};

package/dist/prompter.js

@@ -0,0 +1,32 @@
+import { NonInteractiveError } from "./errors.js";
+/**
+ * A prompter that never asks: every question fails with a `NonInteractiveError` naming the flag that
+ * answers it. Used when nothing can answer, such as in CI or a background intent.
+ */
+export const nonInteractivePrompter = {
+    interactive: false,
+    askValue: (question) => Promise.reject(new NonInteractiveError(question.message, question.answeredBy)),
+    askChoice: (question) => Promise.reject(new NonInteractiveError(question.message, question.answeredBy)),
+    confirm: (question) => Promise.reject(new NonInteractiveError(question.message, question.answeredBy)),
+};
+/**
+ * A prompter that answers from a list of prepared answers, in order, for tests and for front ends
+ * that collect answers up front. Running out of answers fails like {@link nonInteractivePrompter}.
+ */
+export function scriptedPrompter(answers) {
+    const asked = [];
+    const next = (question) => {
+        asked.push(question.message);
+        if (answers.length === 0) {
+            return Promise.reject(new NonInteractiveError(question.message, question.answeredBy));
+        }
+        return Promise.resolve(answers.shift());
+    };
+    return {
+        interactive: true,
+        asked,
+        askValue: (question) => next(question),
+        askChoice: (question) => next(question),
+        confirm: (question) => next(question),
+    };
+}

package/dist/registry.d.ts

@@ -0,0 +1,91 @@
+import type { IntentOutputs, PlainObject } from "./outputs.js";
+import type { ConfigKeyEntity, PluginLocatorEntity } from "./entities.js";
+import type { ConfigBuiltPayload } from "./events.js";
+/**
+ * The interfaces plugins add their own types to, through TypeScript declaration merging. At run time everything is looked up by its string name; these only
+ * give the names their types.
+ *
+ * ```ts
+ * declare module "@sous-io/plugin-api" {
+ *     interface SousServices {
+ *         "diagrams.renderer": Renderer;
+ *     }
+ *
+ *     interface SousIntents {
+ *         "diagrams.render": { input: { only?: string }; result: { rendered: number } };
+ *     }
+ *
+ *     interface SousEvents {
+ *         "diagrams.rendered": { files: RenderResult[] };
+ *     }
+ *
+ *     interface SousEntities {
+ *         "harness": HarnessEntity;
+ *     }
+ * }
+ * ```
+ */
+export interface SousServices {
+}
+/** Each intent's input and result: `"name": { input: ...; result: ... }`. */
+export interface SousIntents {
+}
+/** Each custom event's payload: `"diagrams.rendered": { files: RenderResult[] }`. */
+export interface SousEvents {
+}
+/** Each entity kind's entry type: `"harness": HarnessEntity`. */
+export interface SousEntities {
+}
+/**
+ * The type of each top-level config key, for `ctx.config.get("diagrams")`. Optional: a key with no
+ * entry here reads as `unknown`. (Added beside the four interfaces core names; it follows the same
+ * pattern for the keys plugins add as `config-key` entities.)
+ */
+export interface SousConfig {
+}
+/** The entity kinds core itself defines. */
+export interface CoreEntities {
+    /** A key the config may hold, with its schema. */
+    "config-key": ConfigKeyEntity;
+    /** A way to find a plugin's module from the specifier in `plugins.load`. */
+    "plugin-locator": PluginLocatorEntity;
+}
+/** The events core itself fires. */
+export interface CoreEvents {
+    /** Fired once each time the config has been built (never for "what if" builds). */
+    "config.built": ConfigBuiltPayload;
+}
+/** A name any of these registries accepts: a known one, or any string. */
+export type AnyName<Known> = (Known & string) | (string & {});
+/** Every known service name, plus any string. */
+export type ServiceName = AnyName<keyof SousServices>;
+/** The type of a service, or `unknown` when nothing declares it. */
+export type ServiceType<N extends string> = N extends keyof SousServices ? SousServices[N] : unknown;
+/** Every known intent name, plus any string. */
+export type IntentName = AnyName<keyof SousIntents>;
+/** The input type an intent declared, or `unknown`. */
+export type IntentInput<N extends string> = N extends keyof SousIntents ? SousIntents[N] extends {
+    input: infer I;
+} ? I : unknown : unknown;
+/** The result type an intent declared, or `unknown`. */
+export type IntentResult<N extends string> = N extends keyof SousIntents ? SousIntents[N] extends {
+    result: infer R;
+} ? R : unknown : unknown;
+/**
+ * What an intent's handler returns: its outputs, whose `toPlain()` is the declared result (or a plain
+ * object when the intent declares none).
+ */
+export type IntentReturn<N extends string> = IntentOutputs<IntentResult<N> extends object ? IntentResult<N> : PlainObject>;
+/** Every entity kind, core's and the plugins'. */
+export type AllEntities = CoreEntities & SousEntities;
+/** Every known entity kind, plus any string. */
+export type EntityKind = AnyName<keyof AllEntities>;
+/** What every entity has. */
+export interface EntityBase {
+    /** Unique within its kind. */
+    id: string;
+}
+/** The entry type of an entity kind, or {@link EntityBase} when nothing declares it. */
+export type EntityType<K extends string> = K extends keyof AllEntities ? AllEntities[K] : EntityBase & Record<string, unknown>;
+/** The type of a top-level config key, or `unknown`. */
+export type ConfigKeyType<K extends string> = K extends keyof SousConfig ? SousConfig[K] : unknown;

package/dist/registry.js

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