seyfert 4.5.0 → 5.0.0

package/lib/client/plugins.d.ts

@@ -0,0 +1,78 @@
+import type { Awaitable } from '../common/types/util';
+import type { GatewayDispatchPayload } from '../types';
+import type { BaseClient, BaseClientOptions, ContextScope, ContextScopeContext } from './base';
+import { type GatewayIntentInput } from './intents';
+import { type PluginRuntimeRegistry } from './plugins/registry';
+export type { SeyfertPluginErrorCode } from './plugins/errors';
+export { SeyfertPluginAggregateError, SeyfertPluginError } from './plugins/errors';
+export { createSharedKey } from './plugins/shared';
+export { PluginOrder } from './plugins/types';
+import type { AnySeyfertPlugin, ExtendOf, PluginAutocompleteNext, PluginAutocompletePayload, PluginClientMap, PluginCommandObserver, PluginContextMap, PluginGatewaySendPayload, PluginHookName, PluginHookPayload, PluginMiddlewareMap, PluginRequirementInput, ResolvedPluginList, SeyfertPlugin, SeyfertPluginApi, SeyfertPluginClient, SeyfertPluginOptions, SeyfertPluginTeardownApi } from './plugins/types';
+export type { AnySeyfertPlugin, ContextOf, ExtendOf, HandleableComponent, HandleableModal, MiddlewaresOf, PluginAutocompleteNext, PluginAutocompletePayload, PluginAutocompleteWrapper, PluginCacheResourceConstructor, PluginCacheResourceOptions, PluginClientMap, PluginCommandContributionOptions, PluginCommandLoadable, PluginCommandObserver, PluginCommandObserverCommand, PluginCommandObserverContext, PluginContextInteraction, PluginContextMap, PluginContextMapOf, PluginContextOf, PluginContributionOptions, PluginDiagnosticCode, PluginDiagnosticMessage, PluginDiagnosticSeverity, PluginDiagnostics, PluginDisposer, PluginEventErrorHandler, PluginExtensionOf, PluginGatewayDispatchInterceptor, PluginGatewayDispatchMeta, PluginGatewayDispatchNext, PluginGatewaySendPayload, PluginGatewaySendPayloadWrapper, PluginHandlerConstructor, PluginHandlerCreator, PluginHandlerInstance, PluginHandlerKind, PluginHandlerMetadata, PluginHandlerOptions, PluginHandlerTransformer, PluginHookHandler, PluginHookName, PluginHookPayload, PluginHookPayloadFor, PluginIntentResolvable, PluginLangOptions, PluginLifecyclePhase, PluginLifecycleStatus, PluginLoadedMetadata, PluginMiddlewareDenialMetadata, PluginMiddlewareMap, PluginMiddlewareOptions, PluginMiddlewaresMapOf, PluginMiddlewaresOf, PluginOrderOpt, PluginRequirement, PluginRequirementDiagnostic, PluginRequirementInput, PluginRestFailPayload, PluginRestObserver, PluginRestRatelimitPayload, PluginRestRequestPayload, PluginRestSuccessPayload, PluginSharedOptions, PluginSharedRegistry, PluginUploadCommandsMetadata, PluginUsingClient, RegisteredPluginContext, RegisteredPluginExtension, RegisteredPluginMiddlewares, RegisteredPluginShared, RegisteredPlugins, ResolvedPluginList, SemverRange, SeyfertCommandDefaults, SeyfertComponentDefaults, SeyfertModalDefaults, SeyfertPlugin, SeyfertPluginApi, SeyfertPluginClient, SeyfertPluginHooks, SeyfertPluginOptions, SeyfertPluginTeardownApi, SeyfertRegistry, SharedKey, SharedValue, } from './plugins/types';
+type CreatePluginInputBase<Name extends string, I extends readonly AnySeyfertPlugin[], E extends object, C extends object, M extends PluginMiddlewareMap> = {
+    readonly name: Name;
+    readonly instanceId?: string;
+    readonly imports?: I;
+    readonly requires?: readonly PluginRequirementInput[];
+    readonly client?: PluginClientMap<E, I>;
+    readonly ctx?: PluginContextMap<C, I, E>;
+    readonly middlewares?: M;
+    readonly globalMiddlewares?: readonly (keyof M & string)[];
+    options?(current: Readonly<BaseClientOptions>): SeyfertPluginOptions;
+    register?(api: SeyfertPluginApi<M, ExtendOf<I> & E>): void;
+    setup?(client: SeyfertPluginClient & ExtendOf<I> & E, api?: SeyfertPluginApi<M, ExtendOf<I> & E>): Awaitable<void>;
+    teardown?(client: SeyfertPluginClient & ExtendOf<I> & E, api?: SeyfertPluginTeardownApi): Awaitable<void>;
+};
+type CreatePluginReservedKey = keyof CreatePluginInputBase<string, readonly AnySeyfertPlugin[], object, object, PluginMiddlewareMap> | 'meta';
+type CreatePluginExtra<T extends object> = Omit<T, CreatePluginReservedKey>;
+type CreatePluginInputWithMeta<Name extends string, I extends readonly AnySeyfertPlugin[], E extends object, C extends object, M extends PluginMiddlewareMap, Meta> = CreatePluginInputBase<Name, I, E, C, M> & {
+    readonly meta: Meta;
+};
+type CreatePluginInputWithoutMeta<Name extends string, I extends readonly AnySeyfertPlugin[], E extends object, C extends object, M extends PluginMiddlewareMap> = CreatePluginInputBase<Name, I, E, C, M> & {
+    readonly meta?: never;
+};
+type CreatePluginOutputBase<Name extends string, I extends readonly AnySeyfertPlugin[], E extends object, C extends object, M extends PluginMiddlewareMap> = Omit<SeyfertPlugin<E, C, I, M>, 'meta'> & {
+    readonly name: Name;
+    readonly instanceId?: string;
+    readonly imports?: I;
+    readonly requires?: readonly PluginRequirementInput[];
+    readonly client?: PluginClientMap<E, I>;
+    readonly ctx?: PluginContextMap<C, I, E>;
+    readonly middlewares?: M;
+    readonly globalMiddlewares?: readonly (keyof M & string)[];
+};
+type CreatePluginOutputWithMeta<Name extends string, I extends readonly AnySeyfertPlugin[], E extends object, C extends object, M extends PluginMiddlewareMap, Meta> = CreatePluginOutputBase<Name, I, E, C, M> & {
+    readonly meta: Meta;
+};
+export interface ResolvedClientPlugins {
+    plugins: ResolvedPluginList;
+    options: BaseClientOptions;
+    registry: PluginRuntimeRegistry;
+}
+export declare function createPlugin<const Name extends string, const I extends readonly AnySeyfertPlugin[] = readonly [], E extends object = {}, C extends object = {}, M extends PluginMiddlewareMap = {}, const Meta = never, const Extra extends object = {}>(plugin: CreatePluginInputWithMeta<Name, I, E, C, M, Meta> & Extra): CreatePluginOutputWithMeta<Name, I, E, C, M, Meta> & CreatePluginExtra<Extra>;
+export declare function createPlugin<const Name extends string, const I extends readonly AnySeyfertPlugin[] = readonly [], E extends object = {}, C extends object = {}, M extends PluginMiddlewareMap = {}, const Extra extends object = {}>(plugin: CreatePluginInputWithoutMeta<Name, I, E, C, M> & Extra): CreatePluginOutputBase<Name, I, E, C, M> & CreatePluginExtra<Extra>;
+export declare function createPluginFactory<O extends object, P extends AnySeyfertPlugin>(setup: {
+    defaults: O;
+    validate?: (options: O) => void;
+    factory: (options: O) => P;
+}): (options?: Partial<O>) => P;
+export declare function definePlugins<const TPlugins extends readonly AnySeyfertPlugin[]>(plugins: TPlugins): TPlugins;
+export declare function definePlugins<const TPlugins extends readonly AnySeyfertPlugin[]>(...plugins: TPlugins): TPlugins;
+export declare function createContextScope(scope: ContextScope): ContextScope;
+export declare function resolveClientPlugins(defaults: BaseClientOptions, options?: BaseClientOptions): ResolvedClientPlugins;
+export declare function bindClientPlugins(client: BaseClient, registry: PluginRuntimeRegistry): void;
+export declare function refreshClientPluginGlobalMiddlewares(client: BaseClient, registry: PluginRuntimeRegistry): void;
+export declare function refreshClientPluginOptions(client: BaseClient, registry: PluginRuntimeRegistry): void;
+export declare function resolveClientPluginIntents(client: BaseClient, base?: GatewayIntentInput): number;
+export declare function runPluginAutocompleteWrappers(client: BaseClient, payload: PluginAutocompletePayload, run: PluginAutocompleteNext): Awaitable<void>;
+export declare function runPluginCommandObservers<K extends keyof PluginCommandObserver>(client: BaseClient, name: K, ...args: Parameters<NonNullable<PluginCommandObserver[K]>>): Promise<void>;
+export declare function runPluginHooks<K extends PluginHookName>(client: BaseClient, name: K, ...args: PluginHookPayload<K>): Promise<void>;
+export declare function applyPluginGatewayDispatchInterceptors(client: BaseClient, shardId: number, packet: GatewayDispatchPayload): Promise<GatewayDispatchPayload | null>;
+export declare function applyPluginGatewaySendPayloadWrappers(client: BaseClient, shardId: number, payload: PluginGatewaySendPayload['payload']): Promise<import("..").GatewaySendPayload | null>;
+export declare function setupClientPlugins(client: BaseClient & {
+    plugins: ResolvedPluginList;
+}, plugins: ResolvedPluginList): Promise<void>;
+export declare function teardownClientPlugins(client: BaseClient & {
+    plugins: ResolvedPluginList;
+}, plugins: readonly AnySeyfertPlugin[]): Promise<void>;
+export declare function runContextScopes<T>(scopes: readonly ContextScope[] | undefined, context: ContextScopeContext, run: () => Awaitable<T>): Awaitable<T>;

package/lib/client/plugins.js

@@ -0,0 +1,558 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginOrder = exports.createSharedKey = exports.SeyfertPluginError = exports.SeyfertPluginAggregateError = void 0;
+exports.createPlugin = createPlugin;
+exports.createPluginFactory = createPluginFactory;
+exports.definePlugins = definePlugins;
+exports.createContextScope = createContextScope;
+exports.resolveClientPlugins = resolveClientPlugins;
+exports.bindClientPlugins = bindClientPlugins;
+exports.refreshClientPluginGlobalMiddlewares = refreshClientPluginGlobalMiddlewares;
+exports.refreshClientPluginOptions = refreshClientPluginOptions;
+exports.resolveClientPluginIntents = resolveClientPluginIntents;
+exports.runPluginAutocompleteWrappers = runPluginAutocompleteWrappers;
+exports.runPluginCommandObservers = runPluginCommandObservers;
+exports.runPluginHooks = runPluginHooks;
+exports.applyPluginGatewayDispatchInterceptors = applyPluginGatewayDispatchInterceptors;
+exports.applyPluginGatewaySendPayloadWrappers = applyPluginGatewaySendPayloadWrappers;
+exports.setupClientPlugins = setupClientPlugins;
+exports.teardownClientPlugins = teardownClientPlugins;
+exports.runContextScopes = runContextScopes;
+const common_1 = require("../common");
+const intents_1 = require("./intents");
+const api_1 = require("./plugins/api");
+const errors_1 = require("./plugins/errors");
+const order_1 = require("./plugins/order");
+const registry_1 = require("./plugins/registry");
+const shared_1 = require("./plugins/shared");
+var errors_2 = require("./plugins/errors");
+Object.defineProperty(exports, "SeyfertPluginAggregateError", { enumerable: true, get: function () { return errors_2.SeyfertPluginAggregateError; } });
+Object.defineProperty(exports, "SeyfertPluginError", { enumerable: true, get: function () { return errors_2.SeyfertPluginError; } });
+var shared_2 = require("./plugins/shared");
+Object.defineProperty(exports, "createSharedKey", { enumerable: true, get: function () { return shared_2.createSharedKey; } });
+var types_1 = require("./plugins/types");
+Object.defineProperty(exports, "PluginOrder", { enumerable: true, get: function () { return types_1.PluginOrder; } });
+function createPlugin(plugin) {
+    return plugin;
+}
+function createPluginFactory(setup) {
+    return (options) => {
+        const resolved = { ...setup.defaults, ...options };
+        try {
+            setup.validate?.(resolved);
+            return setup.factory(resolved);
+        }
+        catch (error) {
+            throw (0, errors_1.wrapPluginError)('<createPluginFactory>', 'options', -1, error);
+        }
+    };
+}
+function definePlugins(...plugins) {
+    return (Array.isArray(plugins[0]) ? plugins[0] : plugins);
+}
+function createContextScope(scope) {
+    return scope;
+}
+const commandHookKeys = [
+    'onBeforeMiddlewares',
+    'onBeforeOptions',
+    'onRunError',
+    'onPermissionsFail',
+    'onBotPermissionsFail',
+    'onInternalError',
+    'onMiddlewaresError',
+    'onOptionsError',
+    'onAfterRun',
+];
+const componentHookKeys = [
+    'onBeforeMiddlewares',
+    'onRunError',
+    'onInternalError',
+    'onMiddlewaresError',
+    'onAfterRun',
+];
+const modalHookKeys = [
+    'onBeforeMiddlewares',
+    'onRunError',
+    'onInternalError',
+    'onMiddlewaresError',
+    'onAfterRun',
+];
+function resolveClientPlugins(defaults, options = {}) {
+    const registry = (0, registry_1.createPluginRuntimeRegistry)(options.plugins);
+    const userOptions = omitPlugins(options);
+    const pluginOptionContributions = [];
+    const addPluginOption = (record, fragment) => {
+        pluginOptionContributions.push({
+            record,
+            fragment: (0, registry_1.clonePluginOptions)(fragment),
+            sequence: (0, order_1.nextPluginContributionSequence)(registry),
+            scope: 'register',
+        });
+    };
+    const pluginOptions = () => pluginOptionContributions.map(contribution => contribution.fragment);
+    for (const record of registry.records) {
+        const contextFragment = (0, registry_1.createPluginContextFragment)(record, registry);
+        if (contextFragment)
+            addPluginOption(record, contextFragment);
+        if (record.plugin.globalMiddlewares?.length) {
+            const globalMiddlewares = record.plugin.globalMiddlewares;
+            (0, registry_1.addPluginGlobalMiddlewares)(registry, record, globalMiddlewares);
+            addPluginOption(record, { globalMiddlewares: globalMiddlewares });
+        }
+        const current = (0, registry_1.readonlyPluginOptions)((0, common_1.MergeOptions)(defaults, ...pluginOptions(), userOptions));
+        try {
+            const fragment = record.plugin.options?.(current);
+            if (fragment)
+                addPluginOption(record, fragment);
+        }
+        catch (error) {
+            throw (0, errors_1.wrapPluginError)(record.plugin.name, 'options', record.index, error, undefined, record.plugin.instanceId);
+        }
+        (0, registry_1.runPluginRegister)(record, registry);
+        pluginOptionContributions.push(...record.optionFragments);
+    }
+    (0, registry_1.validatePluginRequirements)(registry, 'capability');
+    const optionFragments = pluginOptions();
+    const merged = (0, common_1.MergeOptions)(defaults, ...optionFragments, userOptions);
+    merged.plugins = registry.plugins;
+    registry.globalMiddlewareOptions = {
+        defaults,
+        pluginOptions: pluginOptionContributions,
+        userOptions,
+    };
+    composeContext(merged, defaults, optionFragments, userOptions);
+    composeContextScopes(merged, defaults, optionFragments, userOptions);
+    composeGlobalMiddlewares(merged, defaults, pluginOptionContributions, userOptions, registry);
+    const commandDefaultContributions = collectPluginDefaultContributions(pluginOptionContributions, registry.pluginDefaults, 'commands');
+    composeDefaults(merged.commands?.defaults, defaults.commands?.defaults, commandDefaultContributions, userOptions.commands?.defaults, commandHookKeys);
+    composeCommandProps(merged.commands?.defaults, defaults.commands?.defaults, commandDefaultContributions, userOptions.commands?.defaults);
+    composeDefaults(merged.components?.defaults, defaults.components?.defaults, collectPluginDefaultContributions(pluginOptionContributions, registry.pluginDefaults, 'components'), userOptions.components?.defaults, componentHookKeys);
+    composeDefaults(merged.modals?.defaults, defaults.modals?.defaults, collectPluginDefaultContributions(pluginOptionContributions, registry.pluginDefaults, 'modals'), userOptions.modals?.defaults, modalHookKeys);
+    return { plugins: registry.plugins, options: merged, registry };
+}
+function bindClientPlugins(client, registry) {
+    (0, registry_1.bindPluginClient)(registry, client);
+    (0, registry_1.installPluginClientMaps)(client, registry);
+    (0, registry_1.installPluginMiddlewares)(client, registry);
+}
+function refreshClientPluginGlobalMiddlewares(client, registry) {
+    const sources = registry.globalMiddlewareOptions;
+    if (!sources)
+        return;
+    composeGlobalMiddlewares(client.options, sources.defaults, sources.pluginOptions, sources.userOptions, registry);
+}
+function refreshClientPluginOptions(client, registry) {
+    const sources = registry.globalMiddlewareOptions;
+    if (!sources)
+        return;
+    const optionFragments = sources.pluginOptions.map(contribution => contribution.fragment);
+    const merged = (0, common_1.MergeOptions)(sources.defaults, ...optionFragments, sources.userOptions);
+    merged.plugins = registry.plugins;
+    composeContext(merged, sources.defaults, optionFragments, sources.userOptions);
+    composeContextScopes(merged, sources.defaults, optionFragments, sources.userOptions);
+    composeGlobalMiddlewares(merged, sources.defaults, sources.pluginOptions, sources.userOptions, registry);
+    const commandDefaultContributions = collectPluginDefaultContributions(sources.pluginOptions, registry.pluginDefaults, 'commands');
+    composeDefaults(merged.commands?.defaults, sources.defaults.commands?.defaults, commandDefaultContributions, sources.userOptions.commands?.defaults, commandHookKeys);
+    composeCommandProps(merged.commands?.defaults, sources.defaults.commands?.defaults, commandDefaultContributions, sources.userOptions.commands?.defaults);
+    composeDefaults(merged.components?.defaults, sources.defaults.components?.defaults, collectPluginDefaultContributions(sources.pluginOptions, registry.pluginDefaults, 'components'), sources.userOptions.components?.defaults, componentHookKeys);
+    composeDefaults(merged.modals?.defaults, sources.defaults.modals?.defaults, collectPluginDefaultContributions(sources.pluginOptions, registry.pluginDefaults, 'modals'), sources.userOptions.modals?.defaults, modalHookKeys);
+    client.options = merged;
+}
+function resolveClientPluginIntents(client, base) {
+    return (0, registry_1.resolvePluginIntents)(client.pluginRegistry, (0, intents_1.resolveGatewayIntents)(base));
+}
+function runPluginAutocompleteWrappers(client, payload, run) {
+    const wrappers = client.pluginRegistry.autocompleteWrappers;
+    if (!wrappers.length)
+        return run();
+    const dispatch = (0, order_1.orderedPluginContributions)(wrappers).reduceRight((next, contribution) => () => Promise.resolve(contribution.wrapper(payload, next)).catch(error => {
+        throw (0, errors_1.wrapPluginError)(contribution.record.plugin.name, 'autocomplete.wrap', contribution.record.index, error, undefined, contribution.record.plugin.instanceId);
+    }), run);
+    return dispatch();
+}
+async function runPluginCommandObservers(client, name, ...args) {
+    const observers = (0, order_1.orderedPluginContributions)(client.pluginRegistry.commandObservers).filter(contribution => contribution.active);
+    for (const contribution of observers) {
+        const observer = contribution.observer[name];
+        if (!observer)
+            continue;
+        try {
+            await observer(...args);
+        }
+        catch (error) {
+            client.logger.error(`[plugin:${contribution.record.plugin.name}] command observer "${String(name)}" failed`, error);
+        }
+    }
+}
+async function runPluginHooks(client, name, ...args) {
+    const hooks = (0, order_1.orderedPluginContributions)(client.pluginRegistry.hooks).filter(contribution => contribution.active && contribution.name === name);
+    for (const contribution of hooks) {
+        try {
+            await contribution.handler(...args);
+        }
+        catch (error) {
+            await reportPluginHookFailure(client, name, (0, errors_1.wrapPluginError)(contribution.record.plugin.name, `hook:${name}`, contribution.record.index, error, undefined, contribution.record.plugin.instanceId));
+        }
+    }
+}
+async function reportPluginHookFailure(client, name, error) {
+    const observers = (0, order_1.orderedPluginContributions)(client.pluginRegistry.eventErrors).filter(contribution => contribution.active);
+    for (const contribution of observers) {
+        try {
+            await contribution.handler(error, `hook:${name}`);
+        }
+        catch (observerError) {
+            client.logger.warn('<Client>.hooks.onError', observerError, name);
+        }
+    }
+    client.logger.warn('<Client>.hooks.onFail', error, name);
+}
+async function applyPluginGatewayDispatchInterceptors(client, shardId, packet) {
+    const interceptors = (0, order_1.orderedPluginContributions)(client.pluginRegistry.gatewayDispatchInterceptors);
+    if (!interceptors.length)
+        return packet;
+    const run = async (index, current) => {
+        const contribution = interceptors[index];
+        if (!contribution)
+            return current;
+        let nextCalled = false;
+        let nextResult;
+        let nextValue;
+        const next = nextPacket => {
+            if (nextCalled) {
+                throw new Error('gateway.onDispatch next() was called multiple times.');
+            }
+            nextCalled = true;
+            nextResult = run(index + 1, nextPacket ?? current).then(value => {
+                nextValue = value;
+                return value;
+            });
+            return nextResult;
+        };
+        let result;
+        try {
+            result = await contribution.interceptor(current, next, { client, shardId });
+            if (nextCalled)
+                nextValue = await nextResult;
+        }
+        catch (error) {
+            throw (0, errors_1.wrapPluginError)(contribution.record.plugin.name, 'gateway.onDispatch', contribution.record.index, error, undefined, contribution.record.plugin.instanceId);
+        }
+        if (nextCalled && nextValue === null)
+            return null;
+        if (result === null) {
+            (0, registry_1.addPluginDiagnostic)(client.pluginRegistry, contribution.record, {
+                phase: 'gateway.onDispatch',
+                severity: 'warn',
+                code: 'gateway-dispatch-veto',
+                message: `Gateway dispatch interceptor from plugin "${contribution.record.plugin.name}" vetoed a dispatch packet.`,
+                data: { shardId, op: current.op, event: current.t },
+            });
+            return null;
+        }
+        if (nextCalled)
+            return result ?? nextValue ?? current;
+        return run(index + 1, result ?? current);
+    };
+    return run(0, packet);
+}
+async function applyPluginGatewaySendPayloadWrappers(client, shardId, payload) {
+    let current = payload;
+    for (const contribution of (0, order_1.orderedPluginContributions)(client.pluginRegistry.gatewaySendPayloadWrappers)) {
+        let result;
+        try {
+            result = await contribution.wrapper({ client, shardId, payload: current });
+        }
+        catch (error) {
+            throw (0, errors_1.wrapPluginError)(contribution.record.plugin.name, 'gateway.wrapSendPayload', contribution.record.index, error, undefined, contribution.record.plugin.instanceId);
+        }
+        if (result === null) {
+            (0, registry_1.addPluginDiagnostic)(client.pluginRegistry, contribution.record, {
+                phase: 'gateway.wrapSendPayload',
+                severity: 'warn',
+                code: 'gateway-send-payload-veto',
+                message: `Gateway send payload wrapper from plugin "${contribution.record.plugin.name}" vetoed a payload.`,
+                data: { shardId, op: current.op },
+            });
+            return null;
+        }
+        if (result !== undefined)
+            current = result;
+    }
+    return current;
+}
+async function setupClientPlugins(client, plugins) {
+    const completed = [];
+    const records = getPluginRecords(client, plugins);
+    try {
+        for (const record of records) {
+            const plugin = record.plugin;
+            try {
+                record.status = 'setting-up';
+                const registry = client.pluginRegistry;
+                if (registry)
+                    (0, registry_1.activatePluginEventListeners)(registry, record);
+                await plugin.setup?.(client, registry ? (0, api_1.createPluginApi)(record, registry, 'setup') : undefined);
+                record.status = 'ready';
+                completed.push(record);
+            }
+            catch (error) {
+                record.status = 'failed';
+                const setupError = (0, errors_1.wrapPluginError)(plugin.name, 'setup', record.index, error, undefined, plugin.instanceId);
+                const registry = client.pluginRegistry;
+                if (registry)
+                    (0, registry_1.cleanupPluginEventListeners)(registry, record);
+                const cleanupErrors = registry ? await (0, shared_1.disposePluginSharedValues)(client.shared, registry, record) : [];
+                const sharedMutationErrors = registry ? await (0, shared_1.cleanupPluginDynamicSharedContributions)(registry, record) : [];
+                if (registry)
+                    (0, registry_1.cleanupPluginDynamicContributionMutations)(registry, record);
+                refreshClientPluginContributions(client);
+                if (cleanupErrors.length || sharedMutationErrors.length) {
+                    throw new errors_1.SeyfertPluginAggregateError('PLUGIN_FAILED', '<multiple>', 'setup', -1, [setupError, ...cleanupErrors, ...sharedMutationErrors], 'Seyfert plugin setup failed and cleanup also failed.', setupError);
+                }
+                throw setupError;
+            }
+        }
+    }
+    catch (setupError) {
+        try {
+            await teardownPluginRecords(client, completed);
+        }
+        catch (teardownError) {
+            throw new errors_1.SeyfertPluginAggregateError('PLUGIN_FAILED', '<multiple>', 'setup', -1, [setupError, teardownError], 'Seyfert plugin setup failed and cleanup also failed.', setupError);
+        }
+        throw setupError;
+    }
+}
+async function teardownClientPlugins(client, plugins) {
+    await teardownPluginRecords(client, getPluginRecords(client, plugins));
+}
+async function teardownPluginRecords(client, records) {
+    const errors = [];
+    try {
+        for (const record of [...records].reverse()) {
+            const plugin = record.plugin;
+            let failed = false;
+            record.status = 'closing';
+            if (client.pluginRegistry)
+                (0, registry_1.cleanupPluginEventListeners)(client.pluginRegistry, record);
+            const registry = client.pluginRegistry;
+            try {
+                await plugin.teardown?.(client, registry ? (0, api_1.createPluginApi)(record, registry, 'teardown') : undefined);
+            }
+            catch (error) {
+                failed = true;
+                errors.push((0, errors_1.wrapPluginError)(plugin.name, 'teardown', record.index, error, 'PLUGIN_TEARDOWN_FAILED', plugin.instanceId));
+            }
+            finally {
+                if (registry)
+                    (0, registry_1.cleanupPluginEventListeners)(registry, record);
+            }
+            if (registry) {
+                const sharedErrors = await (0, shared_1.disposePluginSharedValues)(client.shared, registry, record);
+                if (sharedErrors.length) {
+                    failed = true;
+                    errors.push(...sharedErrors);
+                }
+                const sharedMutationErrors = await (0, shared_1.cleanupPluginDynamicSharedContributions)(registry, record);
+                if (sharedMutationErrors.length) {
+                    failed = true;
+                    errors.push(...sharedMutationErrors);
+                }
+                (0, registry_1.cleanupPluginDynamicContributionMutations)(registry, record);
+            }
+            record.status = failed ? 'failed' : 'closed';
+        }
+    }
+    finally {
+        if (client.shared)
+            (0, shared_1.clearSharedRegistryInstances)(client.shared);
+        refreshClientPluginContributions(client);
+    }
+    if (errors.length) {
+        throw new errors_1.SeyfertPluginAggregateError('PLUGIN_TEARDOWN_FAILED', '<multiple>', 'teardown', -1, errors, 'Seyfert plugin teardown failed.');
+    }
+}
+function getPluginRecords(client, plugins) {
+    const records = client.pluginRegistry?.records ?? [];
+    return plugins.map((plugin, index) => {
+        const record = records.find(record => record.plugin === plugin);
+        if (record)
+            return record;
+        return {
+            plugin,
+            identity: (0, registry_1.pluginIdentity)(plugin),
+            index,
+            imports: plugin.imports ?? [],
+            clientKeys: Object.keys(plugin.client ?? {}),
+            ctxKeys: Object.keys(plugin.ctx ?? {}),
+            optionFragments: [],
+            status: 'registered',
+        };
+    });
+}
+function refreshClientPluginContributions(client) {
+    client.refreshPluginContributions?.();
+}
+function runContextScopes(scopes, context, run) {
+    if (!scopes?.length)
+        return run();
+    const scopedRun = scopes.reduceRight((next, scope) => () => scope(context, next), run);
+    return scopedRun();
+}
+function omitPlugins(options) {
+    const { plugins: _plugins, ...rest } = options;
+    return rest;
+}
+function composeContext(target, defaults, pluginOptions, userOptions) {
+    const callbacks = [];
+    if (typeof defaults.context === 'function')
+        callbacks.push(defaults.context);
+    callbacks.push(...pluginOptions
+        .map(fragment => fragment.context)
+        .filter((callback) => typeof callback === 'function'));
+    if (typeof userOptions.context === 'function')
+        callbacks.push(userOptions.context);
+    if (!callbacks.length)
+        return;
+    target.context = interaction => callbacks.reduce((context, callback) => Object.assign(context, callback(interaction)), {});
+}
+function composeContextScopes(target, defaults, pluginOptions, userOptions) {
+    const scopes = [
+        ...(defaults.contextScopes ?? []),
+        ...pluginOptions.flatMap(fragment => fragment.contextScopes ?? []),
+        ...(userOptions.contextScopes ?? []),
+    ];
+    if (scopes.length)
+        target.contextScopes = scopes;
+}
+function composeGlobalMiddlewares(target, defaults, pluginOptions, userOptions, registry) {
+    const registryMiddlewares = collectActiveRegistryGlobalMiddlewares(registry);
+    const registryMiddlewareNames = new Set([...registry.globalMiddlewares, ...registry.middlewares.filter(contribution => contribution.global)].map(contribution => contribution.name));
+    const optionMiddlewares = pluginOptions.flatMap(contribution => (contribution.fragment.globalMiddlewares ?? [])
+        .map(name => String(name))
+        .filter(name => !registryMiddlewareNames.has(name))
+        .map(name => ({
+        name,
+        sequence: contribution.sequence,
+    })));
+    const pluginMiddlewares = (0, order_1.orderedPluginContributions)([
+        ...registryMiddlewares,
+        ...optionMiddlewares,
+    ]).map(contribution => contribution.name);
+    const middlewares = uniqueMiddlewareNames([
+        ...(defaults.globalMiddlewares ?? []),
+        ...pluginMiddlewares,
+        ...(userOptions.globalMiddlewares ?? []),
+    ]);
+    if (middlewares.length)
+        target.globalMiddlewares = middlewares;
+    else
+        delete target.globalMiddlewares;
+}
+function collectActiveRegistryGlobalMiddlewares(registry) {
+    const additions = [
+        ...registry.globalMiddlewares,
+        ...registry.middlewares.filter(contribution => contribution.global),
+    ];
+    const active = new Map();
+    const mutations = (0, order_1.orderedPluginContributions)([
+        ...additions.map(contribution => ({ ...contribution, kind: 'add' })),
+        ...registry.middlewareRemovals.map(contribution => ({ ...contribution, kind: 'remove' })),
+    ]);
+    for (const mutation of mutations) {
+        if (mutation.kind === 'remove') {
+            for (const name of mutation.names)
+                active.delete(name);
+            continue;
+        }
+        active.set(mutation.name, mutation);
+    }
+    return [...active.values()];
+}
+function uniqueMiddlewareNames(middlewares) {
+    const names = [];
+    const seen = new Set();
+    for (const middleware of middlewares) {
+        const name = String(middleware);
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}
+function suppressesDefault(flag, key) {
+    return flag === true || (Array.isArray(flag) && flag.includes(key));
+}
+function composeDefaults(target, defaults, contributions, userDefaults, keys) {
+    if (!target)
+        return;
+    const ordered = (0, order_1.orderedPluginContributions)(contributions);
+    for (const key of keys) {
+        const imperative = ordered.map(contribution => contribution.hooks?.[key]).filter(isFunction);
+        const additive = [...imperative];
+        const userHook = userDefaults?.[key];
+        if (!additive.length && typeof userHook !== 'function')
+            continue;
+        const suppressed = contributions.some(contribution => isFunction(contribution.hooks?.[key]) &&
+            suppressesDefault(contribution.suppressDefault, key));
+        const fallbackHook = defaults?.[key];
+        const base = isFunction(userHook)
+            ? userHook
+            : suppressed
+                ? undefined
+                : isFunction(fallbackHook)
+                    ? fallbackHook
+                    : undefined;
+        const hooks = base ? [...additive, base] : additive;
+        if (hooks.length)
+            target[key] = composeHooks(hooks);
+    }
+}
+function composeCommandProps(target, defaults, contributions, userDefaults) {
+    if (!target)
+        return;
+    const pluginProps = contributions
+        .map(contribution => contribution.hooks?.props)
+        .filter((props) => isPlainObject(props));
+    const merged = (0, common_1.MergeOptions)({}, isPlainObject(defaults?.props) ? defaults.props : {}, ...pluginProps, isPlainObject(userDefaults?.props) ? userDefaults.props : {});
+    if (Object.keys(merged).length)
+        target.props = merged;
+}
+function composeHooks(hooks) {
+    return async (...args) => {
+        for (const hook of hooks)
+            await hook(...args);
+    };
+}
+function collectPluginDefaultContributions(options, contributions, kind) {
+    return [
+        ...options.flatMap(contribution => {
+            const hooks = contribution.fragment[kind]?.defaults;
+            if (!hooks)
+                return [];
+            return [
+                {
+                    record: contribution.record,
+                    kind,
+                    hooks: hooks,
+                    scope: contribution.scope,
+                    order: contribution.order,
+                    sequence: contribution.sequence,
+                },
+            ];
+        }),
+        ...contributions.filter(contribution => contribution.kind === kind),
+    ];
+}
+function isFunction(value) {
+    return typeof value === 'function';
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}