@sous-io/plugin-api 0.0.1 → 1.0.1

package/dist/context.d.ts

@@ -0,0 +1,159 @@
+import type { BuildOptions, BuiltConfig } from "./config.js";
+import type { EntityReader } from "./entities.js";
+import type { EventFor, EventPayload } from "./events.js";
+import type { IntentCatalog, IntentRequest, SubmitOptions } from "./intents.js";
+import type { JsonObject } from "./json.js";
+import type { Prompter } from "./prompter.js";
+import type { IntentInput, IntentName, IntentReturn } from "./registry.js";
+import type { Reporter } from "./reporter.js";
+import type { ServiceReader } from "./services.js";
+import type { Timings } from "./timing.js";
+/**
+ * The project a sous process serves: the one found from its working directory. Its root is the
+ * directory holding the `.sous/` directory the config file was found in.
+ */
+export interface ProjectInfo {
+    /** The project root. */
+    readonly root: string;
+    /** The `.sous/` directory. */
+    readonly sousDir: string;
+    /** The config file, when one was found. */
+    readonly configPath: string | undefined;
+    /** The `conf.d` directory. */
+    readonly confDir: string;
+}
+/** The environment variables sous was started with. Read them here, never from `process.env`. */
+export type Environment = Readonly<Record<string, string | undefined>>;
+/** The application the engine runs: sous itself, or another tool built on the engine. */
+export interface AppInfo {
+    readonly name: string;
+    readonly version: string;
+}
+/** The chain a context belongs to. */
+export interface ChainInfo {
+    /** Counts chains in this process. */
+    readonly id: number;
+    /** The intent the chain was submitted with. */
+    readonly intent: string;
+    readonly parallel: boolean;
+}
+/** One loaded plugin, as front ends and `plugins show` see it. */
+export interface PluginInfo {
+    readonly name: string;
+    readonly version: string | undefined;
+    /** Whether it is active in the current config. */
+    readonly active: boolean;
+    readonly builtIn: boolean;
+    /** The plugin that brought it in, or `plugins.load`. */
+    readonly loadedBy: string | undefined;
+    /** What it registered, for `plugins show`. */
+    readonly registrations: ReadonlyArray<{
+        readonly kind: string;
+        readonly name: string;
+    }>;
+    /** Its options from `plugins.options` in the current config, if any. */
+    readonly options: JsonObject | undefined;
+}
+/**
+ * The engine, as plugins see it: what front ends and background intents use.
+ */
+export interface EngineHandle {
+    /** The config as of the latest rebuild. */
+    readonly config: BuiltConfig;
+    /** The application name and version. */
+    readonly app: AppInfo;
+    /** The intents front ends generate commands and tools from. */
+    readonly intents: IntentCatalog;
+    /** Every timing so far (`--timings`). */
+    readonly timings: Timings;
+    /** Where engine-level messages go (budget warnings, build warnings). */
+    readonly reporter: Reporter;
+    /**
+     * The error of the latest config build, when it failed (`undefined` once one succeeds). The
+     * config is then the partial one that build reached; only intents that declare
+     * `toleratesConfigErrors` run, and a front end should report this error for anything else.
+     */
+    readonly configError: unknown;
+    /** Sets where engine-level messages go; messages kept so far are sent there first. */
+    setReporter(reporter: Reporter): void;
+    /** Submits a chain; resolves with the intent's outputs. */
+    submit<N extends IntentName>(request: IntentRequest<N>, options?: SubmitOptions): Promise<IntentReturn<N>>;
+    /** Builds a separate "what if" config, never replacing the real one. */
+    buildConfig(options?: BuildOptions): Promise<BuiltConfig>;
+    /** Every loaded plugin. */
+    plugins(): PluginInfo[];
+    /** Resolves when every background intent has returned. */
+    whenBackgroundIntentsReturn(): Promise<void>;
+}
+/**
+ * What a handler, a listener or an entity method gets (`ctx`). Inside a chain, `run` starts another
+ * intent as part of the same chain.
+ */
+export interface Context {
+    /** The plugin whose code was given this context. */
+    readonly plugin: string;
+    /** The config this chain started with (for a background intent, the latest). */
+    readonly config: BuiltConfig;
+    readonly entities: EntityReader;
+    readonly services: ServiceReader;
+    /** Where this chain's output goes: the front end that submitted it. */
+    readonly reporter: Reporter;
+    /** Where this chain's questions go: the front end that submitted it. */
+    readonly prompter: Prompter;
+    readonly project: ProjectInfo | undefined;
+    readonly env: Environment;
+    /** The front end's global argument values (`debug`, `logLevel`, plugin-added ones). */
+    readonly globals: Readonly<Record<string, unknown>>;
+    /**
+     * The working directory the front end gave the chain: the CLI gives the process's, the MCP
+     * server the project root. Use it instead of `process.cwd()`. Default: the engine's.
+     */
+    readonly cwd: string;
+    /** The chain, or `undefined` outside one (a background intent). */
+    readonly chain: ChainInfo | undefined;
+    readonly engine: EngineHandle;
+    /** This plugin's own options from `plugins.options`. */
+    options<T = JsonObject>(): T | undefined;
+    /**
+     * Runs an intent as part of this chain, immediately, and returns its outputs; `toPlain()` gives
+     * its result as a plain object. Outside a chain it submits a new chain instead.
+     */
+    run<N extends IntentName>(intent: N, input?: IntentInput<N> | Record<string, unknown>): Promise<IntentReturn<N>>;
+    /** Fires an event and waits for every listener. */
+    emit<N extends string>(name: N, payload?: EventPayload<N>): Promise<EventFor<N>>;
+    /** Says this chain changed the config, so it is rebuilt before the next chain starts. */
+    configChanged(): void;
+    /**
+     * Rebuilds the config now, for the rest of this chain: later `ctx.config`, `ctx.services`
+     * (`config` services are made again), `ctx.entities` and `ctx.run` calls see the new one. The
+     * new config becomes the engine's, and `config.built` fires, as for any rebuild. Resolves with
+     * it; a failed build rejects, and the chain keeps its old config.
+     *
+     * Only a series chain may do this: a parallel chain, a background intent, a `config.built`
+     * listener or code outside any chain gets a `SousError`.
+     *
+     * ```ts
+     * async handle(input, ctx) {
+     *     await writeSubscription(ctx, input);       // changes a config file
+     *     await ctx.refreshConfig();                 // the build below sees it
+     *
+     *     return ctx.run("build", {});      // the build's outputs become this intent's
+     * }
+     * ```
+     */
+    refreshConfig(options?: RefreshConfigOptions): Promise<BuiltConfig>;
+}
+/** Options for `ctx.refreshConfig()`. */
+export interface RefreshConfigOptions {
+    /**
+     * Where to look for the project before rebuilding, for an intent that has just set one up
+     * (`sous init`). The engine takes the project found at or above this directory when it differs
+     * from the one it serves; without a project there, nothing changes.
+     *
+     * ```ts
+     * await writeProjectFiles(root);
+     * await ctx.refreshConfig({ locateProjectFrom: root });   // the build below serves `root`
+     * ```
+     */
+    locateProjectFrom?: string;
+}

package/dist/context.js

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

package/dist/entities.d.ts

@@ -0,0 +1,60 @@
+import type { ProjectInfo } from "./context.js";
+import type { PluginDefinition } from "./plugin.js";
+import type { EntityKind, EntityType } from "./registry.js";
+import type { SousSchema } from "./schema.js";
+/** Options for defining an entity kind. */
+export interface EntityKindOptions {
+    /** What the kind is, for `plugins show`. */
+    description?: string;
+}
+/**
+ * One entity, with where it came from.
+ *
+ * The engine compares entities by id, source and a hash of their fields that are not functions,
+ * so a contributor that read an entity re-runs when it appears, disappears or its data changes.
+ */
+export interface EntityRecord<E = unknown> {
+    readonly kind: string;
+    readonly id: string;
+    readonly entry: E;
+    /** The plugin that added it. */
+    readonly plugin: string;
+    /** The contributor that added it, when the config created it. */
+    readonly contributor?: string;
+}
+/** Reading entities, after the config is built. */
+export interface EntityReader {
+    /** One entity, or `undefined`. */
+    get<K extends EntityKind>(kind: K, id: string): EntityType<K> | undefined;
+    /** Every entity of a kind, in the order they were added. */
+    list<K extends EntityKind>(kind: K): EntityType<K>[];
+    /** Whether an entity exists. */
+    has(kind: string, id: string): boolean;
+    /** Every entity of a kind, with where each came from. */
+    describe<K extends EntityKind>(kind: K): EntityRecord<EntityType<K>>[];
+    /** Every kind defined so far. */
+    kinds(): string[];
+}
+/** A `config-key` entity: a key the config may hold, with its schema and defaults. */
+export interface ConfigKeyEntity {
+    /** The key, as a path: `diagrams`, or `tools.claude` for a key inside another plugin's. */
+    id: string;
+    /** Checks the value and fills in its defaults when the finished config is checked. */
+    schema: SousSchema;
+    /** What the key is for. */
+    description?: string;
+}
+/** What a plugin locator is told. */
+export interface PluginLocateContext {
+    readonly project: ProjectInfo | undefined;
+}
+/**
+ * A `plugin-locator` entity: turns a specifier from `plugins.load` into a module to import, such as
+ * a recipe's downloaded bundle, or a Yarn Plug'n'Play location. Locators are asked in plugin order;
+ * the first answer wins, and when none answers, Node's own resolution from the project is used.
+ */
+export interface PluginLocatorEntity {
+    id: string;
+    /** A path or URL to import, a plugin definition, or `undefined` to pass. */
+    locate(specifier: string, context: PluginLocateContext): string | URL | PluginDefinition | undefined | Promise<string | URL | PluginDefinition | undefined>;
+}

package/dist/entities.js

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

package/dist/errors.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The error classes every plugin throws and every front end recognizes.
+ *
+ * A front end turns an error into a message and an exit code. Errors are recognized by their
+ * `sousErrorKind` as well as by class, so two copies of this package never confuse a front end.
+ */
+/** The kind of a sous error, one per class. */
+export type SousErrorKind = "sous" | "config" | "input" | "non-interactive" | "cancelled" | "loop" | "plugin" | "conflict" | "not-found" | "budget";
+/** Options every sous error accepts. */
+export interface SousErrorOptions {
+    /** The error that caused this one. */
+    cause?: unknown;
+    /** More lines that explain it or say how to fix it, shown under the message. */
+    details?: readonly string[];
+    /** The exit code a CLI should use. Default 1. */
+    exitCode?: number;
+}
+/** The base of every error sous and its plugins throw on purpose. */
+export declare class SousError extends Error {
+    /** Identifies sous errors across copies of this package. */
+    readonly sousErrorKind: SousErrorKind;
+    /** More lines that explain the error or say how to fix it. */
+    readonly details: readonly string[];
+    /** The exit code a CLI should use. */
+    readonly exitCode: number;
+    constructor(message: string, options?: SousErrorOptions);
+}
+/** The config could not be built, or is not valid. */
+export declare class ConfigError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+}
+/** One problem with an intent's input, or a config value: where, and what. */
+export interface InputIssue {
+    /** Where, as a path string (`ref`, `targets[2].id`); `""` for the value itself. */
+    path: string;
+    message: string;
+}
+/** An intent's input did not match its schema. */
+export declare class InputError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** The intent whose input was wrong. */
+    readonly intent: string;
+    /** Every problem found. */
+    readonly issues: readonly InputIssue[];
+    constructor(intent: string, issues: readonly InputIssue[], options?: SousErrorOptions);
+}
+/**
+ * A question could not be asked, because nothing can answer it in this run. The message
+ * names the question and the flag or argument that answers it ahead of time.
+ */
+export declare class NonInteractiveError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** The question that could not be asked. */
+    readonly question: string;
+    /** The flag or argument that answers it, such as `--yes`. */
+    readonly answeredBy: string | undefined;
+    constructor(question: string, answeredBy: string | undefined, options?: SousErrorOptions);
+}
+/** A listener cancelled an intent or an event on purpose; `reason` says why. */
+export declare class CancelledError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** What was cancelled: an intent or an event name. */
+    readonly target: string;
+    /** The reason the listener gave. */
+    readonly reason: string;
+    /** The plugin whose listener cancelled it. */
+    readonly cancelledBy: string | undefined;
+    constructor(target: string, reason: string, cancelledBy?: string, options?: SousErrorOptions);
+}
+/** The engine found a loop: the config did not settle, or calls nested past a limit. */
+export declare class LoopError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** Which limit was passed, as named under the `limits` config key. */
+    readonly limit: string;
+    constructor(limit: string, message: string, options?: SousErrorOptions);
+}
+/** A plugin could not be found, loaded or registered, or a plugin it depends on is missing. */
+export declare class PluginError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** The plugin, by name or by the specifier it was asked for under. */
+    readonly plugin: string;
+    constructor(plugin: string, message: string, options?: SousErrorOptions);
+}
+/**
+ * Two plugins claim the same thing (a service replacement, an intent, a CLI command) and the
+ * config does not pick one. The message names both and the config key that picks one.
+ */
+export declare class ConflictError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** What is claimed twice. */
+    readonly subject: string;
+    /** The plugins claiming it. */
+    readonly plugins: readonly string[];
+    constructor(subject: string, plugins: readonly string[], message: string, options?: SousErrorOptions);
+}
+/** No plugin provides the intent, service, entity or front end asked for. */
+export declare class NotFoundError extends SousError {
+    readonly sousErrorKind: SousErrorKind;
+    /** What kind of thing was asked for: `intent`, `service`, `entity`, `front end`. */
+    readonly thing: string;
+    /** Its name or id. */
+    readonly id: string;
+    constructor(thing: string, id: string, message?: string, options?: SousErrorOptions);
+}
+/**
+ * Whether a value is a sous error, by class or by its `sousErrorKind` (so a second copy of this
+ * package is still recognized).
+ */
+export declare function isSousError(value: unknown): value is SousError;
+/** Whether a value is a sous error of one kind. */
+export declare function isSousErrorOfKind(value: unknown, kind: SousErrorKind): value is SousError;

package/dist/errors.js

@@ -0,0 +1,138 @@
+/**
+ * The error classes every plugin throws and every front end recognizes.
+ *
+ * A front end turns an error into a message and an exit code. Errors are recognized by their
+ * `sousErrorKind` as well as by class, so two copies of this package never confuse a front end.
+ */
+/** The base of every error sous and its plugins throw on purpose. */
+export class SousError extends Error {
+    /** Identifies sous errors across copies of this package. */
+    sousErrorKind = "sous";
+    /** More lines that explain the error or say how to fix it. */
+    details;
+    /** The exit code a CLI should use. */
+    exitCode;
+    constructor(message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = new.target.name;
+        this.details = options.details ?? [];
+        this.exitCode = options.exitCode ?? 1;
+    }
+}
+/** The config could not be built, or is not valid. */
+export class ConfigError extends SousError {
+    sousErrorKind = "config";
+}
+/** An intent's input did not match its schema. */
+export class InputError extends SousError {
+    sousErrorKind = "input";
+    /** The intent whose input was wrong. */
+    intent;
+    /** Every problem found. */
+    issues;
+    constructor(intent, issues, options = {}) {
+        super(`The input to "${intent}" is not valid.`, {
+            exitCode: 2,
+            ...options,
+            details: options.details ?? issues.map((issue) => (issue.path ? `${issue.path}: ${issue.message}` : issue.message)),
+        });
+        this.intent = intent;
+        this.issues = issues;
+    }
+}
+/**
+ * A question could not be asked, because nothing can answer it in this run. The message
+ * names the question and the flag or argument that answers it ahead of time.
+ */
+export class NonInteractiveError extends SousError {
+    sousErrorKind = "non-interactive";
+    /** The question that could not be asked. */
+    question;
+    /** The flag or argument that answers it, such as `--yes`. */
+    answeredBy;
+    constructor(question, answeredBy, options = {}) {
+        const fix = answeredBy ? ` Pass ${answeredBy} to answer it ahead of time.` : "";
+        // Exit code 1, as before the refactor: only a command line the CLI could not parse exits 2.
+        super(`sous needed to ask "${question}" but cannot ask questions in this run.${fix}`, options);
+        this.question = question;
+        this.answeredBy = answeredBy;
+    }
+}
+/** A listener cancelled an intent or an event on purpose; `reason` says why. */
+export class CancelledError extends SousError {
+    sousErrorKind = "cancelled";
+    /** What was cancelled: an intent or an event name. */
+    target;
+    /** The reason the listener gave. */
+    reason;
+    /** The plugin whose listener cancelled it. */
+    cancelledBy;
+    constructor(target, reason, cancelledBy, options = {}) {
+        const by = cancelledBy ? ` (cancelled by ${cancelledBy})` : "";
+        super(`"${target}" was cancelled: ${reason}${by}`, options);
+        this.target = target;
+        this.reason = reason;
+        this.cancelledBy = cancelledBy;
+    }
+}
+/** The engine found a loop: the config did not settle, or calls nested past a limit. */
+export class LoopError extends SousError {
+    sousErrorKind = "loop";
+    /** Which limit was passed, as named under the `limits` config key. */
+    limit;
+    constructor(limit, message, options = {}) {
+        super(message, options);
+        this.limit = limit;
+    }
+}
+/** A plugin could not be found, loaded or registered, or a plugin it depends on is missing. */
+export class PluginError extends SousError {
+    sousErrorKind = "plugin";
+    /** The plugin, by name or by the specifier it was asked for under. */
+    plugin;
+    constructor(plugin, message, options = {}) {
+        super(message, options);
+        this.plugin = plugin;
+    }
+}
+/**
+ * Two plugins claim the same thing (a service replacement, an intent, a CLI command) and the
+ * config does not pick one. The message names both and the config key that picks one.
+ */
+export class ConflictError extends SousError {
+    sousErrorKind = "conflict";
+    /** What is claimed twice. */
+    subject;
+    /** The plugins claiming it. */
+    plugins;
+    constructor(subject, plugins, message, options = {}) {
+        super(message, options);
+        this.subject = subject;
+        this.plugins = plugins;
+    }
+}
+/** No plugin provides the intent, service, entity or front end asked for. */
+export class NotFoundError extends SousError {
+    sousErrorKind = "not-found";
+    /** What kind of thing was asked for: `intent`, `service`, `entity`, `front end`. */
+    thing;
+    /** Its name or id. */
+    id;
+    constructor(thing, id, message, options = {}) {
+        super(message ?? `No plugin provides the ${thing} "${id}".`, options);
+        this.thing = thing;
+        this.id = id;
+    }
+}
+/**
+ * Whether a value is a sous error, by class or by its `sousErrorKind` (so a second copy of this
+ * package is still recognized).
+ */
+export function isSousError(value) {
+    return (value instanceof SousError ||
+        (value instanceof Error && typeof value.sousErrorKind === "string"));
+}
+/** Whether a value is a sous error of one kind. */
+export function isSousErrorOfKind(value, kind) {
+    return isSousError(value) && value.sousErrorKind === kind;
+}

package/dist/events.d.ts

@@ -0,0 +1,90 @@
+import type { Context } from "./context.js";
+import type { BuiltConfig } from "./config.js";
+import type { CoreEvents, IntentInput, IntentReturn, SousEvents, SousIntents } from "./registry.js";
+/** What every event has. */
+export interface EventBase {
+    /** The event's name: `build.before`, `diagrams.rendered`. */
+    readonly name: string;
+    /** Shared with later listeners, and from an intent's `before` event to its `after` event. */
+    readonly data: Map<string, unknown>;
+    /** Stops the intent (or tells the emitter of a custom event to stop); the reason is reported. */
+    cancel(reason: string): void;
+    /** Whether a listener cancelled it. */
+    readonly cancelled: boolean;
+    /** The reason given to {@link cancel}. */
+    readonly cancelReason: string | undefined;
+    /** The plugin whose listener cancelled it. */
+    readonly cancelledBy: string | undefined;
+    /** Later listeners don't see this event. An intent still runs. */
+    stopPropagation(): void;
+    /** Whether a listener stopped propagation. */
+    readonly propagationStopped: boolean;
+}
+/** A custom event, fired with `emit`. */
+export interface CustomEvent<P = unknown> extends EventBase {
+    readonly kind: "custom";
+    payload: P;
+}
+/** `<intent>.before`: fired before the handler runs. Listeners may change `input`. */
+export interface IntentBeforeEvent<I extends string = string, In = IntentInput<I>> extends EventBase {
+    readonly kind: "before";
+    readonly intent: I;
+    input: In;
+}
+/** `<intent>.after`: fired after the handler returned. Listeners may replace `result`, its outputs. */
+export interface IntentAfterEvent<I extends string = string, In = IntentInput<I>, R = IntentReturn<I>> extends EventBase {
+    readonly kind: "after";
+    readonly intent: I;
+    readonly input: In;
+    result: R;
+}
+/** `<intent>.error`: fired when the handler threw. A listener may turn the failure into outputs. */
+export interface IntentErrorEvent<I extends string = string, In = IntentInput<I>, R = IntentReturn<I>> extends EventBase {
+    readonly kind: "error";
+    readonly intent: I;
+    readonly input: In;
+    readonly error: unknown;
+    /** Turns the failure into these outputs; the intent then succeeds and `after` fires. */
+    recover(result: R): void;
+    /** Whether a listener recovered. */
+    readonly recovered: boolean;
+}
+/** Any event, for regular expression listeners, which narrow by `event.name` or `event.kind`. */
+export type AnyEvent = CustomEvent<unknown> | IntentBeforeEvent | IntentAfterEvent | IntentErrorEvent;
+/** The payload of `config.built`. */
+export interface ConfigBuiltPayload {
+    /** The config that was just built. */
+    config: BuiltConfig;
+}
+/** Every custom event TypeScript knows about. */
+export type AllEvents = CoreEvents & SousEvents;
+type KnownIntent = keyof SousIntents & string;
+/** Every event name TypeScript knows about: custom events, and every intent's three events. */
+export type KnownEventName = (keyof AllEvents & string) | `${KnownIntent}.${"before" | "after" | "error"}`;
+type CustomOrAny<N extends string> = N extends keyof AllEvents ? CustomEvent<AllEvents[N]> : AnyEvent;
+/**
+ * The event object a listener for one exact name receives. An intent's three events are typed from
+ * `SousIntents`; for an intent no plugin declared, the input and result are `unknown`.
+ */
+export type EventFor<N extends string> = N extends keyof AllEvents ? CustomEvent<AllEvents[N]> : N extends `${infer I}.before` ? I extends KnownIntent ? IntentBeforeEvent<I> : IntentBeforeEvent<I, unknown> : N extends `${infer I}.after` ? I extends KnownIntent ? IntentAfterEvent<I> : IntentAfterEvent<I, unknown, unknown> : N extends `${infer I}.error` ? I extends KnownIntent ? IntentErrorEvent<I> : IntentErrorEvent<I, unknown, unknown> : CustomOrAny<N>;
+/** Turns a wildcard pattern into a template literal type: `build.*` becomes `build.${string}`. */
+export type PatternTemplate<P extends string> = P extends `${infer A}*${infer B}` ? `${A}${string}${PatternTemplate<B>}` : P;
+/** The event names a pattern matches, among those TypeScript knows. */
+export type MatchingEventNames<P extends string> = Extract<KnownEventName, PatternTemplate<P>>;
+/**
+ * The event a listener receives for a pattern: an exact name gives that event, a wildcard the union
+ * of every matching known event, and a regular expression {@link AnyEvent}.
+ */
+export type EventForPattern<P extends EventPattern> = P extends RegExp ? AnyEvent : P extends `${string}*${string}` ? [MatchingEventNames<P & string>] extends [never] ? AnyEvent : EventFor<MatchingEventNames<P & string>> : EventFor<P & string>;
+/** What a listener subscribes to: an exact name, a wildcard (`build.*`, `*.before`) or a regular expression. */
+export type EventPattern = string | RegExp;
+/** A listener. It gets a `ctx` like a handler's, so it can run intents, read the config and report. */
+export type Listener<E = AnyEvent> = (event: E, ctx: Context) => void | Promise<void>;
+/** Options for `on` and `once`. */
+export interface ListenerOptions {
+    /** Higher runs first. Default `0`. */
+    priority?: number;
+}
+/** The payload type of a custom event. */
+export type EventPayload<N extends string> = N extends keyof AllEvents ? AllEvents[N] : unknown;
+export {};

package/dist/events.js

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

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The plugin interface of sous: the one promise sous makes outside its
+ * monorepo. It holds `definePlugin`, the interfaces plugins add their types to, every public
+ * type, the `Reporter` and `Prompter` interfaces and the error classes. Everything else a plugin
+ * uses is handed to it in `register(sous)` and in each `ctx`.
+ */
+export type * from "./config.js";
+export type * from "./context.js";
+export type * from "./entities.js";
+export type * from "./events.js";
+export type * from "./intents.js";
+export type * from "./json.js";
+export type * from "./node.js";
+export type * from "./registry.js";
+export type * from "./services.js";
+export { definePlugin } from "./plugin.js";
+export type * from "./plugin.js";
+export { CancelledError, ConfigError, ConflictError, InputError, isSousError, isSousErrorOfKind, LoopError, NonInteractiveError, NotFoundError, PluginError, SousError, } from "./errors.js";
+export type { InputIssue, SousErrorKind, SousErrorOptions } from "./errors.js";
+export { nonInteractivePrompter, scriptedPrompter } from "./prompter.js";
+export type * from "./prompter.js";
+export { BaseReporter, BufferedReporter, createReporter, isLevelShown, isLogLevel, LOG_LEVELS, errorChain, LogLevel, messageText, nullReporter, ReportEntryStyle, Reporting, } from "./reporter.js";
+export type * from "./reporter.js";
+export { commandVariables } from "./command-variables.js";
+export { DataValue, IntentOutput, IntentOutputs, ItemList, Payload, Table, TextBlock, Tree, VariableSet } from "./outputs.js";
+export type * from "./outputs.js";
+export { formatIssuePath, isSchema, jsonSchema, toJsonSchema, validateWith, validateWithSync } from "./schema.js";
+export type * from "./schema.js";
+export { TIMING_CATEGORIES } from "./timing.js";
+export type * from "./timing.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * The plugin interface of sous: the one promise sous makes outside its
+ * monorepo. It holds `definePlugin`, the interfaces plugins add their types to, every public
+ * type, the `Reporter` and `Prompter` interfaces and the error classes. Everything else a plugin
+ * uses is handed to it in `register(sous)` and in each `ctx`.
+ */
+export { definePlugin } from "./plugin.js";
+export { CancelledError, ConfigError, ConflictError, InputError, isSousError, isSousErrorOfKind, LoopError, NonInteractiveError, NotFoundError, PluginError, SousError, } from "./errors.js";
+export { nonInteractivePrompter, scriptedPrompter } from "./prompter.js";
+export { BaseReporter, BufferedReporter, createReporter, isLevelShown, isLogLevel, LOG_LEVELS, errorChain, LogLevel, messageText, nullReporter, ReportEntryStyle, Reporting, } from "./reporter.js";
+export { commandVariables } from "./command-variables.js";
+export { DataValue, IntentOutput, IntentOutputs, ItemList, Payload, Table, TextBlock, Tree, VariableSet } from "./outputs.js";
+export { formatIssuePath, isSchema, jsonSchema, toJsonSchema, validateWith, validateWithSync } from "./schema.js";
+export { TIMING_CATEGORIES } from "./timing.js";