@gobing-ai/ts-infra 0.3.5 → 0.3.7

package/src/application/index.ts

@@ -14,10 +14,11 @@ import { attachDefaultObservers, createLifecycleBus } from '../event-bus/default
 import { EventBus } from '../event-bus/event-bus';
 import type { BusLifecycleEvents, EventMap } from '../event-bus/types';
 import type { InfraEvents } from '../events';
-import { getLogger, initializeLogger, type Logger } from '../logger';
-import { initScheduler, setSchedulerAdapter } from '../scheduler/factory';
+import { getLogger, type Logger } from '../logger';
+import { initScheduler } from '../scheduler/factory';
 import type { SchedulerAdapter } from '../scheduler/types';
-import { initTelemetry, shutdownTelemetry } from '../telemetry/sdk';
+import { loggerPlugin, schedulerPlugin, telemetryPlugin, userCallbackPlugin } from './plugins/builtins';
+import { PluginHost } from './plugins/host';
 import type {
     ApplicationBootstrapConfig,
     ApplicationBootstrapOptions,
@@ -30,11 +31,7 @@ import type {
 
 interface RuntimeState<TAppConfig, TEvents extends EventMap> {
     app: ApplicationRuntime<TAppConfig, TEvents> | undefined;
-    userStop?: (app: ApplicationRuntime<TAppConfig, TEvents>, reason: ApplicationStopReason) => Promise<void> | void;
-    schedulerAdapter?: SchedulerAdapter;
-    schedulerStarted: boolean;
-    loggerInitialized: boolean;
-    telemetryInitialized: boolean;
+    pluginHost: PluginHost;
     stopped: boolean;
 }
 
@@ -50,31 +47,13 @@ async function performShutdown<TAppConfig, TEvents extends EventMap>(
     const app = state.app;
     if (!app) return;
 
-    // 1. User stop callback
-    if (state.userStop) {
-        await state.userStop(app, reason);
-    }
-
-    // 2. Stop scheduler
-    if (state.schedulerStarted && state.schedulerAdapter) {
-        await state.schedulerAdapter.stop().catch(() => {});
-        state.schedulerStarted = false;
-    }
-
-    // 3. Close DB adapter
-    if (app.db) {
-        try {
-            app.db.close();
-        } catch {
-            /* best-effort */
-        }
-    }
-
-    // 4. Shutdown telemetry
-    if (state.telemetryInitialized) {
-        await shutdownTelemetry();
-        state.telemetryInitialized = false;
-    }
+    // 1. Stop + unload plugins in reverse registration order (fail-soft).
+    //    Scheduler stop and telemetry shutdown run here via their onStop hooks.
+    await state.pluginHost.stopAll(reason);
+    await state.pluginHost.unloadAll(reason);
+    // Shutdown is complete — the host's stopAll/unloadAll calls every plugin's
+    // onStop/onUnload in reverse registration order, including user callback,
+    // scheduler, and service teardown. No inline steps.
 }
 
 // ── Public API ────────────────────────────────────────────────────────────
@@ -86,24 +65,20 @@ async function performShutdown<TAppConfig, TEvents extends EventMap>(
  * Accepts injected dependencies; never opens files, reads config from disk,
  * or wires runtime-specific exporters.
  *
- * Startup order (deterministic, per R5):
- * 1. Resolve bootstrap config + app config
- * 2. Initialize logger
- * 3. Initialize telemetry
- * 4. Create lifecycle bus + application EventBus
- * 5. Register DB adapter (injected only)
- * 6. Initialize scheduler + register entries
- * 7. Call user `start(app)` callback
- * 8. Start scheduler if `autoStart`
+ * Startup is plugin-driven. Built-in service plugins are registered in dependency
+ * order, then `loadAll()` + `startAll()` run them forward:
+ * 1. Resolve bootstrap config; build EventBus + PluginHost
+ * 2. Register built-ins in order: logger → telemetry → [caller plugins] →
+ *    user-callback → scheduler (scheduler last so autoStart runs after user start)
+ * 3. `loadAll()` then `startAll()` — `failFast` plugins abort boot on failure
  *
- * Shutdown order (reverse, per R5):
- * 1. User `stop(app, reason)` callback
- * 2. Stop scheduler
- * 3. Close DB adapter
- * 4. Shut down telemetry
+ * Shutdown is the reverse fan-out: `stopAll(reason)` → `unloadAll(reason)` calls
+ * every plugin's `onStop`/`onUnload` in reverse registration order (scheduler stop,
+ * user `stop(app, reason)`, telemetry shutdown, owned-DB close). Caller-injected
+ * `services.db` is caller-owned and never closed here.
  *
- * If any startup step fails, already-started services are cleaned up in reverse
- * order before rethrowing. `stop()` is idempotent.
+ * If startup fails, the host's reverse-order `stopAll('error')`/`unloadAll('error')`
+ * tears down whatever started before rethrowing. `stop()` is idempotent.
  *
  * @example
  * ```ts
@@ -151,41 +126,14 @@ export async function runApplication<TAppConfig = unknown, TEvents extends Event
 
     const state: RuntimeState<TAppConfig, TEvents> = {
         app: undefined,
-        userStop: options.stop,
-        schedulerAdapter: undefined,
-        schedulerStarted: false,
-        loggerInitialized: false,
-        telemetryInitialized: false,
         stopped: false,
+        pluginHost: undefined as unknown as PluginHost,
     };
 
     try {
-        // ── 1. Initialize logger ────────────────────────────────────────
-        let logger: Logger;
-        if (options.services?.logger) {
-            logger = options.services.logger;
-        } else if (loggingConfig.enabled) {
-            await initializeLogger({
-                level: loggingConfig.level,
-                console: loggingConfig.console,
-                fileSink: loggingConfig.fileSink,
-                json: loggingConfig.json,
-            });
-            logger = getLogger('bootstrap');
-        } else {
-            logger = getLogger('bootstrap');
-        }
-
-        // ── 2. Initialize telemetry ────────────────────────────────────
-        if (telemetryConfig.enabled) {
-            initTelemetry({
-                enabled: telemetryConfig.enabled,
-                serviceName: telemetryConfig.serviceName,
-                environment: telemetryConfig.environment,
-                dbStatementDebug: telemetryConfig.dbStatementDebug,
-            });
-            state.telemetryInitialized = true;
-        }
+        // ── 1. Resolve logger (init deferred to loggerPlugin) ───────────
+        const logger: Logger = options.services?.logger ?? getLogger('bootstrap');
+        const loggerInjected = !!options.services?.logger;
 
         // ── 3. Create lifecycle bus + EventBus ─────────────────────────
         const lifecycleBus =
@@ -206,14 +154,22 @@ export async function runApplication<TAppConfig = unknown, TEvents extends Event
         let scheduler: SchedulerAdapter | undefined;
         if (schedulerConfig.enabled) {
             const adapter = options.services?.scheduler ?? schedOpts?.adapter;
-            if (adapter) {
-                setSchedulerAdapter(adapter);
-            }
-            scheduler = initScheduler(schedOpts?.entries);
-            state.schedulerAdapter = scheduler;
+            scheduler = initScheduler(adapter, schedOpts?.entries);
         }
 
-        // ── Build resolved config ──────────────────────────────────────
+        // ── 5.5 Plugin host + built-in service plugins ─────────────────
+        const pluginHost: PluginHost =
+            options.services?.pluginHost ?? new PluginHost(events as unknown as EventBus<EventMap>);
+        state.pluginHost = pluginHost;
+
+        // Register built-in service plugins in dependency order: logger -> telemetry.
+        pluginHost.register(loggerPlugin(loggingConfig, loggerInjected));
+        pluginHost.register(telemetryPlugin(telemetryConfig));
+        // Caller-injected `services.db` is NOT closed by the portable layer — it is
+        // caller-owned (task 0028). Only adapters the bootstrap CREATES (the Node
+        // subpath) are wrapped in a `dbPlugin` whose onStop closes them.
+
+        // ── Build runtime handle (before startAll so plugins can capture it) ─
         const resolvedConfig: ApplicationBootstrapConfig = {
             logging: loggingConfig,
             events: { enabled: eventsEnabled, lifecycle: eventsLifecycle, defaultObservers: eventsDefaultObservers },
@@ -221,7 +177,6 @@ export async function runApplication<TAppConfig = unknown, TEvents extends Event
             scheduler: schedulerConfig,
         };
 
-        // ── Build runtime handle ───────────────────────────────────────
         const app: ApplicationRuntime<TAppConfig, TEvents> = {
             config: resolvedConfig,
             appConfig: options.appConfig as TAppConfig,
@@ -230,36 +185,51 @@ export async function runApplication<TAppConfig = unknown, TEvents extends Event
             lifecycleBus,
             db,
             scheduler,
+            pluginHost,
             stop: (reason?: ApplicationStopReason) => performShutdown(state, reason ?? 'manual'),
         };
         state.app = app;
 
-        // ── 6. User start callback ─────────────────────────────────────
-        await options.start(app);
+        // ── Register caller-provided plugins (before user callback) ─────────
+        if (options.plugins) {
+            for (const p of options.plugins) {
+                pluginHost.register(p);
+            }
+        }
 
-        // ── 7. Start scheduler ─────────────────────────────────────────
-        if (schedulerConfig.enabled && schedulerConfig.autoStart && scheduler) {
-            await scheduler.start();
-            state.schedulerStarted = true;
+        // ── Register user-callback plugin (after services, before scheduler) ─
+        pluginHost.register(
+            userCallbackPlugin(
+                options.start,
+                options.stop as ((app: ApplicationRuntime<TAppConfig, TEvents>, reason: string) => void) | undefined,
+                app,
+            ),
+        );
+
+        // ── Register scheduler plugin (LAST — autoStart after user callback) ─
+        if (schedulerConfig.enabled && scheduler) {
+            pluginHost.register(schedulerPlugin(scheduler, schedulerConfig.autoStart));
         }
 
+        // ── Load + start (built-in failFast=rethrow on critical failure) ─
+        await pluginHost.loadAll();
+        await pluginHost.startAll();
         return app;
     } catch (error) {
-        // Reverse-order cleanup of services this bootstrap owns.
-        // Scheduler: start() is the last async op before return; if it throws,
-        // schedulerStarted is still false, so there is nothing started to stop.
-        // DB: injected by the caller (portable bootstrap never creates one), so
-        // its lifecycle is caller-owned and not closed here.
-        // Telemetry: owned by the bootstrap — shut it down if it was initialized.
-        if (state.telemetryInitialized) {
-            await shutdownTelemetry();
-        }
+        // Startup failed: tear down whatever started, in reverse registration
+        // order, via the host. Each plugin's onStop/onUnload is best-effort, so a
+        // partially-started ring still releases its resources (telemetry, scheduler,
+        // owned DB). Caller-injected services.db is caller-owned and not touched.
+        await state.pluginHost.stopAll('error');
+        await state.pluginHost.unloadAll('error');
         throw error;
     }
 }
 
 export type { BusLifecycleEvents, EventMap } from '../event-bus/types';
 export type { InfraEvents } from '../events';
+export type { PluginHost } from './plugins/host';
+export type { Plugin, PluginSummary } from './plugins/types';
 // Re-export types
 export type {
     ApplicationBootstrapConfig,

package/src/application/plugins/builtins.ts

@@ -0,0 +1,178 @@
+/**
+ * Built-in service plugins for the application bootstrap.
+ *
+ * Each factory returns a `Plugin` that maps an existing init/shutdown pair onto
+ * the PluginHost lifecycle: `onStart` = init, `onStop` = teardown. Absent
+ * hooks are omitted (no-op by absence, not by stub).
+ *
+ * @module application/plugins
+ */
+
+import type { LogLevel } from '../../logger';
+import { initializeLogger } from '../../logger';
+import { initMetrics, shutdownMetrics } from '../../telemetry/metrics';
+import { initTelemetry, shutdownTelemetry } from '../../telemetry/sdk';
+import type { ApplicationBootstrapConfig, DbAdapterLike } from '../types';
+import type { Plugin } from './types';
+
+// ── Telemetry ──────────────────────────────────────────────────────────────
+
+/**
+ * Built-in plugin for telemetry + metrics.
+ *
+ * `onStart`: `initTelemetry` + `initMetrics` (pre-warm instruments).
+ * `onStop`:  `shutdownMetrics` + `shutdownTelemetry` (reverse of init).
+ * `failFast: true` — a failing telemetry init aborts the bootstrap.
+ */
+export function telemetryPlugin(config: ApplicationBootstrapConfig['telemetry']): Plugin {
+    return {
+        name: 'builtin:telemetry',
+        version: '0.0.0',
+        failFast: true,
+        onLoad: async () => {},
+        onStart: async () => {
+            if (config.enabled) {
+                initTelemetry({
+                    enabled: config.enabled,
+                    serviceName: config.serviceName,
+                    environment: config.environment,
+                    dbStatementDebug: config.dbStatementDebug,
+                });
+                initMetrics();
+            }
+        },
+        onStop: async () => {
+            if (config.enabled) {
+                shutdownMetrics();
+                await shutdownTelemetry();
+            }
+        },
+    };
+}
+
+// ── Logger ─────────────────────────────────────────────────────────────────
+
+/**
+ * Built-in plugin for the structured logger.
+ *
+ * `onStart`: `initializeLogger` (skipped when an injected logger is present).
+ * No `onStop` — the logger has no teardown.
+ * `failFast: true` — a failing logger init aborts the bootstrap.
+ */
+export function loggerPlugin(
+    config: {
+        enabled: boolean;
+        level: LogLevel;
+        console: boolean;
+        json: boolean;
+        fileSink?: ((line: string) => void) | undefined;
+    },
+    injected?: boolean,
+): Plugin {
+    return {
+        name: 'builtin:logger',
+        version: '0.0.0',
+        failFast: true,
+        onLoad: async () => {},
+        onStart: async () => {
+            if (config.enabled && !injected) {
+                await initializeLogger({
+                    level: config.level,
+                    console: config.console,
+                    json: config.json,
+                    fileSink: config.fileSink,
+                });
+            }
+        },
+    };
+}
+
+// ── User callback ──────────────────────────────────────────────────────────
+
+import type { EventMap } from '../../event-bus/types';
+import type { ApplicationRuntime } from '../types';
+
+/**
+ * Built-in plugin that wraps the user's `start`/`stop` callbacks.
+ *
+ * `onStart`: calls `options.start(app)`. `failFast: true`.
+ * `onStop`:  calls `options.stop(app, reason)`. Registered after services,
+ *            before scheduler, so stopAll/reverse-order places it after
+ *            scheduler.stop and before service teardown.
+ */
+export function userCallbackPlugin<TAppConfig, TEvents extends EventMap>(
+    start: (app: ApplicationRuntime<TAppConfig, TEvents>) => Promise<void> | void,
+    stop: ((app: ApplicationRuntime<TAppConfig, TEvents>, reason: string) => Promise<void> | void) | undefined,
+    app?: ApplicationRuntime<TAppConfig, TEvents>,
+): Plugin {
+    return {
+        name: 'builtin:user-callback',
+        version: '0.0.0',
+        failFast: true,
+        onLoad: async () => {},
+        onStart: async () => {
+            if (app) await start(app);
+        },
+        onStop:
+            stop && app
+                ? async (_host, reason) => {
+                      await stop(app, reason ?? 'manual');
+                  }
+                : undefined,
+    };
+}
+
+// ── Scheduler ──────────────────────────────────────────────────────────────
+import type { SchedulerAdapter } from '../../scheduler/types';
+
+/**
+ * Built-in plugin for the scheduler.
+ *
+ * `onStart`: `adapter.start()` when `autoStart` is true.
+ * `onStop`:  `adapter.stop()` — fail-soft.
+ *
+ * Registered LAST so autoStart always runs after the user callback.
+ */
+export function schedulerPlugin(adapter: SchedulerAdapter, autoStart: boolean): Plugin {
+    return {
+        name: 'builtin:scheduler',
+        version: '0.0.0',
+        failFast: true,
+        onLoad: async () => {},
+        onStart: async () => {
+            if (autoStart) {
+                await adapter.start();
+            }
+        },
+        onStop: async () => {
+            // Fail-soft — the host always catches stop/unload errors
+            await adapter.stop();
+        },
+    };
+}
+
+// ── DB (reason-aware, for owned adapters only) ────────────────────────────
+
+/**
+ * Built-in plugin for a DB adapter the bootstrap OWNS.
+ *
+ * `onStop(reason)`: `db.close()` — best-effort.
+ * Register ONLY when the bootstrap creates the adapter (Node subpath).
+ * Do NOT register for caller-injected `services.db` — those are caller-owned.
+ */
+export function dbPlugin(db: DbAdapterLike): Plugin {
+    return {
+        name: 'builtin:db',
+        version: '0.0.0',
+        failFast: false,
+        onLoad: async () => {},
+        onStart: async () => {},
+        onStop: async () => {
+            try {
+                db.close();
+            } catch {
+                /* best-effort */
+            }
+        },
+    };
+}

package/src/application/plugins/host.ts

@@ -0,0 +1,143 @@
+/**
+ * Bare `PluginHost` — owns an insertion-ordered set of plugins and drives
+ * lifecycle fan-out (load → start → stop → unload) with fail-soft semantics
+ * for start/stop/unload and fail-fast for load.
+ *
+ * This is a runtime concern: it needs a logger and event bus, both provided
+ * by the application bootstrap. No capabilities, no trust ladder.
+ *
+ * @module application/plugins
+ */
+
+import type { EventBus } from '../../event-bus/event-bus';
+import type { EventMap } from '../../event-bus/types';
+import { getLogger, type Logger } from '../../logger';
+import type { Plugin, PluginSummary } from './types';
+
+// ── PluginHost ─────────────────────────────────────────────────────────────
+
+/**
+ * Plugin host: registers plugins in insertion order and drives their lifecycle
+ * fan-out (load → start → stop → unload).
+ *
+ * The host stores `EventBus<EventMap>` (the base event contract) rather than
+ * a narrower `TEvents` subtype, because `EventBus` is invariant in its type
+ * parameter and plugins only need the base contract.
+ */
+export class PluginHost {
+    readonly logger: Logger;
+    readonly events: EventBus<EventMap>;
+
+    private readonly _plugins = new Map<string, Plugin>();
+
+    constructor(events: EventBus<EventMap>, opts?: { logger?: Logger }) {
+        this.events = events;
+        this.logger = opts?.logger ?? getLogger('plugin-host');
+    }
+
+    // ── Registration ────────────────────────────────────────────────────
+
+    /** Register a plugin. Throws on duplicate name. */
+    register(plugin: Plugin): void {
+        if (this._plugins.has(plugin.name)) {
+            throw new Error(`Plugin already registered: ${plugin.name}`);
+        }
+        this._plugins.set(plugin.name, plugin);
+    }
+
+    /** Remove a plugin by name. No-op if absent. */
+    unregister(name: string): void {
+        this._plugins.delete(name);
+    }
+
+    /** Check whether a plugin is registered. */
+    has(name: string): boolean {
+        return this._plugins.has(name);
+    }
+
+    /** List registered plugins in registration order. */
+    list(): readonly PluginSummary[] {
+        const result: PluginSummary[] = [];
+        for (const p of this._plugins.values()) {
+            result.push({ name: p.name, version: p.version });
+        }
+        return result;
+    }
+
+    // ── Lifecycle fan-out ───────────────────────────────────────────────
+
+    /**
+     * Fail-fast: calls `onLoad` on every plugin in registration order.
+     * A throwing hook aborts the bootstrap.
+     */
+    async loadAll(): Promise<void> {
+        for (const plugin of this._plugins.values()) {
+            this.logger.debug(`Loading plugin: ${plugin.name}`, { name: plugin.name });
+            await plugin.onLoad(this);
+        }
+    }
+
+    /**
+     * Calls `onStart` on every plugin in registration order.
+     * Plugins with `failFast: true` rethrow (aborting boot); others log + skip.
+     */
+    async startAll(): Promise<void> {
+        for (const plugin of this._plugins.values()) {
+            if (!plugin.onStart) continue;
+            try {
+                this.logger.debug(`Starting plugin: ${plugin.name}`, { name: plugin.name });
+                await plugin.onStart(this);
+            } catch (err) {
+                if (plugin.failFast) {
+                    throw err;
+                }
+                this.logger.error(`Plugin start hook failed: ${plugin.name}`, {
+                    name: plugin.name,
+                    error: (err as Error).message,
+                });
+            }
+        }
+    }
+
+    /**
+     * Fail-soft: calls `onStop` on every plugin in **reverse** registration order.
+     * A throwing hook is logged + skipped.
+     * `reason` is forwarded to each plugin's `onStop(host, reason?)`.
+     */
+    async stopAll(reason?: string): Promise<void> {
+        const reversed = [...this._plugins.values()].reverse();
+        for (const plugin of reversed) {
+            if (!plugin.onStop) continue;
+            try {
+                this.logger.debug(`Stopping plugin: ${plugin.name}`, { name: plugin.name, reason });
+                await plugin.onStop(this, reason);
+            } catch (err) {
+                this.logger.error(`Plugin stop hook failed: ${plugin.name}`, {
+                    name: plugin.name,
+                    error: (err as Error).message,
+                });
+            }
+        }
+    }
+
+    /**
+     * Fail-soft: calls `onUnload` on every plugin in **reverse** registration order.
+     * A throwing hook is logged + skipped.
+     * `reason` is forwarded to each plugin's `onUnload(host, reason?)`.
+     */
+    async unloadAll(reason?: string): Promise<void> {
+        const reversed = [...this._plugins.values()].reverse();
+        for (const plugin of reversed) {
+            if (!plugin.onUnload) continue;
+            try {
+                this.logger.debug(`Unloading plugin: ${plugin.name}`, { name: plugin.name, reason });
+                await plugin.onUnload(this, reason);
+            } catch (err) {
+                this.logger.error(`Plugin unload hook failed: ${plugin.name}`, {
+                    name: plugin.name,
+                    error: (err as Error).message,
+                });
+            }
+        }
+    }
+}

package/src/application/plugins/index.ts

@@ -0,0 +1,3 @@
+// PluginHost class doubles as the type (same contract)
+export { PluginHost } from './host';
+export type { Plugin, PluginSummary } from './types';

package/src/application/plugins/types.ts

@@ -0,0 +1,86 @@
+/**
+ * Portable plugin lifecycle contract.
+ *
+ * The `Plugin` interface is a minimal runtime-neutral lifecycle contract:
+ * no capabilities, no trust ladder, no manifest schema — just `onLoad` / `onUnload`
+ * and `onStart` / `onStop` hooks. Names are deliberately runtime-neutral so
+ * CLI and long-lived server apps share the same semantics.
+ *
+ * @module application/plugins
+ */
+
+import type { EventBus } from '../../event-bus/event-bus';
+import type { EventMap } from '../../event-bus/types';
+import type { Logger } from '../../logger';
+
+// ── Plugin contract ────────────────────────────────────────────────────────
+
+/**
+ * Minimal plugin lifecycle contract.
+ *
+ * All hooks receive the host reference so a plugin can access the runtime
+ * logger, event bus, and other plugins.
+ */
+export interface Plugin {
+    /** Unique name. Used for dedup and lookup in the host. */
+    readonly name: string;
+
+    /** Semver-compatible version string. Informational only in this cut. */
+    readonly version: string;
+
+    /**
+     * When `true`, a throwing `onStart` aborts the bootstrap (fail-fast).
+     * When absent/false, a throwing `onStart` is logged and skipped (fail-soft).
+     * Has no effect on `loadAll` (always fail-fast) or `stopAll`/`unloadAll`
+     * (always fail-soft — teardown is best-effort).
+     */
+    readonly failFast?: boolean;
+
+    /**
+     * Called during `PluginHost.loadAll()` — fail-fast.
+     * A throwing `onLoad` aborts the bootstrap.
+     */
+    onLoad(host: PluginHost): void | Promise<void>;
+
+    /** Called during `PluginHost.unloadAll()` — fail-soft. */
+    onUnload?(host: PluginHost, reason?: string): void | Promise<void>;
+
+    /** Called during `PluginHost.startAll()` — fail-soft. */
+    onStart?(host: PluginHost): void | Promise<void>;
+
+    /** Called during `PluginHost.stopAll()` — fail-soft. */
+    onStop?(host: PluginHost, reason?: string): void | Promise<void>;
+}
+
+// ── Plugin host public shape ───────────────────────────────────────────────
+
+/**
+ * Summary view of a registered plugin (no references, just metadata).
+ */
+export interface PluginSummary {
+    readonly name: string;
+    readonly version: string;
+}
+
+// ── PluginHost structural interface ────────────────────────────────────────
+
+/**
+ * Structural contract for the plugin host.
+ *
+ * This is the shape exposed on `ApplicationRuntime.pluginHost`. Consumers
+ * that need to register/unregister plugins at runtime use this interface.
+ */
+export interface PluginHost {
+    readonly logger: Logger;
+    readonly events: EventBus<EventMap>;
+
+    register(plugin: Plugin): void;
+    unregister(name: string): void;
+    has(name: string): boolean;
+    list(): readonly PluginSummary[];
+
+    loadAll(): Promise<void>;
+    startAll(): Promise<void>;
+    stopAll(reason?: string): Promise<void>;
+    unloadAll(reason?: string): Promise<void>;
+}