seyfert 4.5.0 → 5.0.0

package/lib/client/base.js

@@ -6,6 +6,7 @@ const node_path_1 = require("node:path");
 const api_1 = require("../api");
 const utils_1 = require("../api/utils/utils");
 const cache_1 = require("../cache");
+const commands_1 = require("../commands");
 const shared_1 = require("../commands/applications/shared");
 const handle_1 = require("../commands/handle");
 const handler_1 = require("../commands/handler");
@@ -14,8 +15,29 @@ const utils_2 = require("../common/it/utils");
 const bans_1 = require("../common/shorters/bans");
 const soundboard_1 = require("../common/shorters/soundboard");
 const voiceStates_1 = require("../common/shorters/voiceStates");
+const components_1 = require("../components");
 const handler_2 = require("../components/handler");
+const events_1 = require("../events");
 const handler_3 = require("../langs/handler");
+const types_1 = require("../types");
+const intents_1 = require("./intents");
+const plugins_1 = require("./plugins");
+const errors_1 = require("./plugins/errors");
+const order_1 = require("./plugins/order");
+const registry_1 = require("./plugins/registry");
+const shared_2 = require("./plugins/shared");
+const pluginSourceKey = '__seyfertPluginSource';
+function componentIdentity(kind, customId) {
+    return `${kind}:${customId}`;
+}
+function capitalizePluginKind(kind) {
+    return kind[0].toUpperCase() + kind.slice(1);
+}
+function commandIdentity(command) {
+    const guildId = 'guildId' in command ? command.guildId : undefined;
+    const guildScope = Array.isArray(guildId) ? [...guildId].sort().join(',') : (guildId ?? '*');
+    return `${command.type}:${command.name}:${guildScope}`;
+}
 class BaseClient {
     rest = new api_1.ApiHandler({ token: 'INVALID' });
     cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), {}, this);
@@ -50,11 +72,24 @@ class BaseClient {
     static getBotIdFromToken(token) {
         return Buffer.from(token.split('.')[0], 'base64').toString('ascii');
     }
+    plugins = [];
+    shared;
+    events = new events_1.CustomEventHandler(this);
+    /** @internal */
+    pluginRegistry;
+    pluginsSetupPromise;
+    pluginsClosePromise;
+    langBaseValues = {};
+    pluginCacheDisabledCache = {};
+    pluginBaseGatewayIntents = this.cache.intents;
+    pluginComponentsBeforeLoadDepth = 0;
     options;
     /**@internal */
     static _seyfertCfWorkerConfig;
+    /**@internal */
+    _rcCache;
     constructor(options) {
-        this.options = (0, common_1.MergeOptions)({
+        const defaults = {
             commands: {
                 defaults: {
                     onRunError(context, error) {
@@ -85,8 +120,8 @@ class BaseClient {
                     onMiddlewaresError(context, error) {
                         context.client.logger.fatal('ComponentCommand.<onMiddlewaresError>', context.author.id, error);
                     },
-                    onInternalError(client, error) {
-                        client.logger.fatal(error);
+                    onInternalError(client, component, error) {
+                        client.logger.fatal(`[${component.customId ?? 'ComponentCommand'}].<onInternalError>`, error);
                     },
                 },
             },
@@ -98,12 +133,33 @@ class BaseClient {
                     onMiddlewaresError(context, error) {
                         context.client.logger.fatal('ModalCommand.<onMiddlewaresError>', context.author.id, error);
                     },
-                    onInternalError(client, error) {
-                        client.logger.fatal(error);
+                    onInternalError(client, modal, error) {
+                        client.logger.fatal(`[${modal.customId ?? 'ModalCommand'}].<onInternalError>`, error);
                     },
                 },
             },
-        }, options);
+        };
+        const resolved = (0, plugins_1.resolveClientPlugins)(defaults, options);
+        this.options = resolved.options;
+        this.configureLogger({ name: '[Seyfert]' }, this.options.logger);
+        this.plugins = resolved.plugins;
+        this.pluginRegistry = resolved.registry;
+        this.shared = (0, shared_2.createSharedRegistry)(this, this.pluginRegistry);
+        this.bindPluginLangReload();
+        (0, plugins_1.bindClientPlugins)(this, this.pluginRegistry);
+        this.bindPluginRestObserverProvider();
+        this.refreshPluginCacheResources();
+    }
+    configureLogger(defaults, options) {
+        const loggerOptions = (0, common_1.MergeOptions)(defaults, options ?? {});
+        if (loggerOptions.active !== undefined)
+            this.logger.active = loggerOptions.active;
+        if (loggerOptions.logLevel !== undefined)
+            this.logger.level = loggerOptions.logLevel;
+        if (loggerOptions.name !== undefined)
+            this.logger.name = loggerOptions.name;
+        if (loggerOptions.saveOnFile !== undefined)
+            this.logger.saveOnFile = loggerOptions.saveOnFile;
     }
     get proxy() {
         return this.rest.proxy;
@@ -126,6 +182,7 @@ class BaseClient {
             rest.onSuccessRequest ??= this.rest.onSuccessRequest?.bind(rest);
             rest.onFailRequest ??= this.rest.onFailRequest?.bind(rest);
             this.rest = rest;
+            this.bindPluginRestObserverProvider();
         }
         if (cache) {
             const caches = [
@@ -160,16 +217,19 @@ class BaseClient {
             }
             if (cache.adapter)
                 this.cache.adapter = cache.adapter;
-            if (cache.disabledCache)
-                this.cache.buildCache(disabledCache, this);
+            if (cache.disabledCache !== undefined)
+                this.refreshPluginCacheResources(disabledCache);
         }
         if (middlewares) {
-            this.middlewares = middlewares;
+            this.middlewares = { ...(this.middlewares ?? {}), ...middlewares };
         }
         if (langs) {
             this.langs ??= new handler_3.LangsHandler(this.logger);
+            this.bindPluginLangReload();
             if (langs.default)
                 this.langs.defaultLang = langs.default;
+            if (langs.preferGuildLocale !== undefined)
+                this.langs.preferGuildLocale = langs.preferGuildLocale;
             if (langs.aliases)
                 this.langs.aliases = Object.entries(langs.aliases);
         }
@@ -185,20 +245,392 @@ class BaseClient {
         }
     }
     async start(options = {}) {
-        await this.loadLangs(options.langsDir);
-        await this.loadCommands(options.commandsDir);
-        await this.loadComponents(options.componentsDir);
         const { token: tokenRC, debug } = await this.getRC();
         const token = options.token ?? tokenRC;
-        (0, common_1.assertString)(token, 'token is not a string');
+        if (typeof token !== 'string' || token.length === 0) {
+            throw new common_1.SeyfertError('INVALID_TOKEN', { metadata: { detail: 'token is not a string' } });
+        }
         if (this.rest.options.token === 'INVALID')
             this.rest.options.token = token;
-        this.rest.debug = debug;
+        this.rest.debug = !!debug;
         if (!this.handleCommand)
             this.handleCommand = new handle_1.HandleCommand(this);
+        await this.setupPlugins();
+        this.refreshPluginCacheResources();
+        this.reloadPluginMiddlewares();
+        await (0, plugins_1.runPluginHooks)(this, 'plugins:setupComplete', this);
+        await (0, plugins_1.runPluginHooks)(this, 'plugins:ready', this);
         // The reason of this method is so for adapters that need to connect somewhere, have time to connect.
         // Or maybe clear cache?
         await this.cache.adapter.start();
+        await this.loadLangs(options.langsDir);
+        await (0, plugins_1.runPluginHooks)(this, 'commands:beforeLoad', this, options.commandsDir);
+        await this.loadCommands(options.commandsDir);
+        await this.reloadPluginCommands();
+        await (0, plugins_1.runPluginHooks)(this, 'components:beforeLoad', this, options.componentsDir);
+        this.pluginComponentsBeforeLoadDepth++;
+        try {
+            await this.loadComponents(options.componentsDir);
+        }
+        finally {
+            this.pluginComponentsBeforeLoadDepth--;
+        }
+        await this.reloadPluginComponents();
+    }
+    async reloadPluginContributions() {
+        this.refreshPluginContributions();
+        const commandsMetadata = this.createPluginLoadedMetadata('commands', this.loadedCommands);
+        await (0, plugins_1.runPluginHooks)(this, 'commands:afterLoad', commandsMetadata);
+        await this.emitPluginCustomEvent('commandsLoaded', commandsMetadata);
+        const componentsMetadata = this.createPluginLoadedMetadata('components', this.components.commands);
+        await (0, plugins_1.runPluginHooks)(this, 'components:afterLoad', componentsMetadata);
+        await this.emitPluginCustomEvent('componentsLoaded', componentsMetadata);
+    }
+    /** @internal */
+    refreshPluginContributions() {
+        this.reloadPluginMiddlewares();
+        this.refreshPluginCacheResources();
+        this.applyPluginLangs();
+        this.applyPluginCommands();
+        this.applyPluginComponents();
+    }
+    bindPluginRestObserverProvider() {
+        this.rest.pluginRestObserverClient = this;
+        this.rest.pluginRestObserverProvider = () => (0, order_1.orderedPluginContributions)(this.pluginRegistry.restObservers)
+            .filter(contribution => contribution.active)
+            .map(contribution => ({
+            plugin: contribution.record.identity,
+            observer: contribution.observer,
+        }));
+    }
+    bindPluginLangReload() {
+        this.langs.onReload = (locale, value) => {
+            this.langBaseValues[locale] = cloneRecursive(value);
+            this.applyPluginLangs();
+        };
+    }
+    refreshPluginCacheResources(disabledCache = this.pluginCacheDisabledCache) {
+        this.pluginCacheDisabledCache = disabledCache;
+        this.cache.intents = (0, plugins_1.resolveClientPluginIntents)(this, this.pluginBaseGatewayIntents);
+        this.cache.buildCache(disabledCache, this);
+    }
+    resolvePluginGatewayIntents(base) {
+        this.pluginBaseGatewayIntents = (0, intents_1.resolveGatewayIntents)(base);
+        this.cache.intents = (0, plugins_1.resolveClientPluginIntents)(this, this.pluginBaseGatewayIntents);
+        return this.cache.intents;
+    }
+    reloadPluginMiddlewares() {
+        (0, registry_1.installPluginMiddlewares)(this, this.pluginRegistry);
+        (0, plugins_1.refreshClientPluginOptions)(this, this.pluginRegistry);
+    }
+    async reloadPluginCommands() {
+        this.applyPluginCommands();
+        const metadata = this.createPluginLoadedMetadata('commands', this.loadedCommands);
+        await (0, plugins_1.runPluginHooks)(this, 'commands:afterLoad', metadata);
+        await this.emitPluginCustomEvent('commandsLoaded', metadata);
+    }
+    async reloadPluginComponents() {
+        this.applyPluginComponents();
+        const metadata = this.createPluginLoadedMetadata('components', this.components.commands);
+        await (0, plugins_1.runPluginHooks)(this, 'components:afterLoad', metadata);
+        await this.emitPluginCustomEvent('componentsLoaded', metadata);
+    }
+    async setupPlugins() {
+        if (this.pluginsClosePromise)
+            await this.pluginsClosePromise;
+        this.pluginsSetupPromise ??= (0, plugins_1.setupClientPlugins)(this, this.plugins);
+        try {
+            await this.pluginsSetupPromise;
+        }
+        catch (error) {
+            this.pluginsSetupPromise = undefined;
+            throw error;
+        }
+    }
+    /**
+     * Closes resources managed by the plugin lifecycle.
+     *
+     * This waits for in-flight plugin setup and runs `SeyfertPlugin.teardown`.
+     * It does not close the gateway, REST client, or cache adapter.
+     */
+    async close() {
+        const setup = this.pluginsSetupPromise;
+        if (!setup)
+            return;
+        const close = this.pluginsClosePromise ??
+            (async () => {
+                await setup;
+                await (0, plugins_1.runPluginHooks)(this, 'client:close', this);
+                await (0, plugins_1.teardownClientPlugins)(this, this.plugins);
+            })();
+        this.pluginsClosePromise = close;
+        try {
+            await close;
+        }
+        finally {
+            if (this.pluginsClosePromise === close) {
+                this.pluginsSetupPromise = undefined;
+                this.pluginsClosePromise = undefined;
+            }
+        }
+    }
+    applyPluginCommands() {
+        const contributions = this.pluginRegistry.commands;
+        const removals = this.pluginRegistry.commandRemovals;
+        const hasPluginCommands = this.commands.values.some(command => pluginSourceKey in command) ||
+            !!(this.commands.entryPoint && pluginSourceKey in this.commands.entryPoint);
+        if (!(contributions.length || removals.length || hasPluginCommands))
+            return;
+        this.commands.values = this.commands.values.filter(command => !(pluginSourceKey in command));
+        if (this.commands.entryPoint && pluginSourceKey in this.commands.entryPoint)
+            this.commands.entryPoint = null;
+        const existingCommands = new Map();
+        for (const command of this.commands.values)
+            existingCommands.set(commandIdentity(command), { command });
+        if (this.commands.entryPoint)
+            existingCommands.set(commandIdentity(this.commands.entryPoint), { command: this.commands.entryPoint });
+        const mutations = (0, order_1.orderedPluginContributions)([
+            ...contributions.map(contribution => ({ ...contribution, kind: 'add' })),
+            ...removals.map(contribution => ({ ...contribution, kind: 'remove' })),
+        ]);
+        for (const mutation of mutations) {
+            if (mutation.kind === 'remove') {
+                for (const name of mutation.names) {
+                    const matches = [...existingCommands].filter(([, entry]) => entry.command.name === name);
+                    if (!matches.length)
+                        continue;
+                    for (const [key, existing] of matches) {
+                        (0, registry_1.assertCanMutatePluginContribution)(this.pluginRegistry, mutation.record, 'remove', 'command', name, existing.owner, 'commands.remove');
+                        existingCommands.delete(key);
+                        (0, registry_1.recordContributionMutationDiagnostic)(this.pluginRegistry, mutation, 'remove', 'command', name, existing.owner, 'commands.remove');
+                    }
+                }
+                continue;
+            }
+            for (const command of mutation.commands) {
+                const instance = this.createPluginCommandInstance(command, mutation.record, 'commands.add');
+                if (instance instanceof commands_1.SubCommand) {
+                    throw (0, errors_1.createPluginConflictError)(mutation.record.plugin.name, 'commands.add', mutation.record.index, `SubCommand "${instance.name}" cannot be registered as a top-level plugin command.`, mutation.record.plugin.instanceId);
+                }
+                if (!instance.name) {
+                    throw (0, errors_1.createPluginConflictError)(mutation.record.plugin.name, 'commands.add', mutation.record.index, 'Plugin command is missing a name.', mutation.record.plugin.instanceId);
+                }
+                if (mutation.guilds?.length) {
+                    if ('guildId' in instance) {
+                        instance.guildId = [...mutation.guilds];
+                    }
+                    else {
+                        (0, registry_1.addPluginDiagnostic)(this.pluginRegistry, mutation.record, {
+                            phase: 'commands.add',
+                            severity: 'warn',
+                            code: 'command-guild-scope',
+                            message: `Command "${instance.name}" does not support guild-scoped registration.`,
+                            data: { command: instance.name, guilds: [...mutation.guilds] },
+                        });
+                    }
+                }
+                const identity = commandIdentity(instance);
+                const existing = existingCommands.get(identity);
+                if (existing && !mutation.override) {
+                    throw (0, errors_1.createPluginConflictError)(mutation.record.plugin.name, 'commands.add', mutation.record.index, `Command "${instance.name}" is already registered.`, mutation.record.plugin.instanceId);
+                }
+                if (existing) {
+                    (0, registry_1.assertCanMutatePluginContribution)(this.pluginRegistry, mutation.record, 'override', 'command', instance.name, existing.owner, 'commands.add');
+                    (0, registry_1.recordContributionMutationDiagnostic)(this.pluginRegistry, mutation, 'override', 'command', instance.name, existing.owner, 'commands.add');
+                }
+                instance[pluginSourceKey] = mutation.record.identity;
+                existingCommands.set(identity, { command: instance, owner: mutation.record });
+            }
+        }
+        const commands = [...existingCommands.values()]
+            .filter(entry => !!entry.owner)
+            .map(entry => entry.command);
+        this.commands.set(commands, command => {
+            const source = command[pluginSourceKey];
+            const transformed = this.runPluginHandlerTransformers('command', command);
+            if (source)
+                transformed[pluginSourceKey] = source;
+            return transformed;
+        });
+    }
+    get loadedCommands() {
+        return this.commands.entryPoint ? [...this.commands.values, this.commands.entryPoint] : this.commands.values;
+    }
+    applyPluginComponents() {
+        const contributions = this.pluginRegistry.components;
+        const modalContributions = this.pluginRegistry.modals;
+        const removals = this.pluginRegistry.componentRemovals;
+        const modalRemovals = this.pluginRegistry.modalRemovals;
+        const hasPluginComponents = this.components.commands.some(command => pluginSourceKey in command);
+        if (!(contributions.length ||
+            modalContributions.length ||
+            removals.length ||
+            modalRemovals.length ||
+            hasPluginComponents)) {
+            return;
+        }
+        const existing = this.components.commands.filter(command => !(pluginSourceKey in command));
+        this.components.commands.splice(0, this.components.commands.length, ...existing);
+        const componentsByCustomId = new Map();
+        for (const component of this.components.commands) {
+            if (typeof component.customId === 'string') {
+                componentsByCustomId.set(componentIdentity(component instanceof components_1.ModalCommand ? 'modal' : 'component', component.customId), {
+                    component,
+                });
+            }
+        }
+        const dynamicComponents = [];
+        const mutations = (0, order_1.orderedPluginContributions)([
+            ...contributions.map(contribution => ({
+                ...contribution,
+                kind: 'add',
+                contributionKind: 'component',
+            })),
+            ...modalContributions.map(contribution => ({
+                ...contribution,
+                kind: 'add',
+                contributionKind: 'modal',
+            })),
+            ...removals.map(contribution => ({
+                ...contribution,
+                kind: 'remove',
+                contributionKind: 'component',
+            })),
+            ...modalRemovals.map(contribution => ({
+                ...contribution,
+                kind: 'remove',
+                contributionKind: 'modal',
+            })),
+        ]);
+        for (const mutation of mutations) {
+            if (mutation.kind === 'remove') {
+                for (const customId of mutation.customIds) {
+                    const key = componentIdentity(mutation.contributionKind, customId);
+                    const existing = componentsByCustomId.get(key);
+                    if (!existing)
+                        continue;
+                    (0, registry_1.assertCanMutatePluginContribution)(this.pluginRegistry, mutation.record, 'remove', mutation.contributionKind, customId, existing.owner, `${mutation.contributionKind}s.remove`);
+                    componentsByCustomId.delete(key);
+                    (0, registry_1.recordContributionMutationDiagnostic)(this.pluginRegistry, mutation, 'remove', mutation.contributionKind, customId, existing.owner, `${mutation.contributionKind}s.remove`);
+                }
+                continue;
+            }
+            const constructors = mutation.contributionKind === 'component'
+                ? mutation.components
+                : mutation.modals;
+            for (const constructor of constructors) {
+                const instance = this.createPluginComponentInstance(constructor, mutation.record, `${mutation.contributionKind}s.add`, mutation.contributionKind);
+                instance[pluginSourceKey] = mutation.record.identity;
+                if (typeof instance.customId !== 'string') {
+                    dynamicComponents.push({ component: instance, owner: mutation.record });
+                    continue;
+                }
+                const key = componentIdentity(mutation.contributionKind, instance.customId);
+                const existing = componentsByCustomId.get(key);
+                if (existing && !mutation.override) {
+                    throw (0, errors_1.createPluginConflictError)(mutation.record.plugin.name, `${mutation.contributionKind}s.add`, mutation.record.index, `${capitalizePluginKind(mutation.contributionKind)} "${instance.customId}" is already registered.`, mutation.record.plugin.instanceId);
+                }
+                if (existing) {
+                    (0, registry_1.assertCanMutatePluginContribution)(this.pluginRegistry, mutation.record, 'override', mutation.contributionKind, instance.customId, existing.owner, `${mutation.contributionKind}s.add`);
+                    (0, registry_1.recordContributionMutationDiagnostic)(this.pluginRegistry, mutation, 'override', mutation.contributionKind, instance.customId, existing.owner, `${mutation.contributionKind}s.add`);
+                }
+                componentsByCustomId.set(key, { component: instance, owner: mutation.record });
+            }
+        }
+        const components = [...componentsByCustomId.values(), ...dynamicComponents]
+            .filter((entry) => !!entry.owner)
+            .map(entry => entry.component);
+        this.components.set(components, component => {
+            const source = component[pluginSourceKey];
+            const transformed = this.runPluginHandlerTransformers(component instanceof components_1.ModalCommand ? 'modal' : 'component', component);
+            if (source)
+                transformed[pluginSourceKey] = source;
+            return transformed;
+        });
+    }
+    createPluginCommandInstance(command, record, phase) {
+        if (typeof command !== 'function')
+            return command;
+        return this.runPluginHandlerCreators('command', command, () => {
+            try {
+                return new command();
+            }
+            catch (error) {
+                throw (0, errors_1.wrapPluginError)(record.plugin.name, phase, record.index, error, undefined, record.plugin.instanceId);
+            }
+        });
+    }
+    createPluginComponentInstance(constructor, record, phase, kind) {
+        const instance = typeof constructor !== 'function'
+            ? constructor
+            : this.runPluginHandlerCreators(kind, constructor, () => {
+                try {
+                    return new constructor();
+                }
+                catch (error) {
+                    throw (0, errors_1.wrapPluginError)(record.plugin.name, phase, record.index, error, undefined, record.plugin.instanceId);
+                }
+            });
+        if (kind === 'modal' && !(instance instanceof components_1.ModalCommand)) {
+            throw (0, errors_1.createPluginConflictError)(record.plugin.name, phase, record.index, 'Plugin modal contribution must be a ModalCommand.', record.plugin.instanceId);
+        }
+        if (kind === 'component' && !(instance instanceof components_1.ComponentCommand)) {
+            throw (0, errors_1.createPluginConflictError)(record.plugin.name, phase, record.index, 'Plugin component contribution must be a ComponentCommand.', record.plugin.instanceId);
+        }
+        return instance;
+    }
+    runPluginHandlerCreators(kind, constructor, create) {
+        const creators = (0, order_1.orderedPluginContributions)(this.pluginRegistry.handlerCreators).filter(contribution => this.matchesPluginHandlerKind(contribution.kinds, kind));
+        const metadata = { kind };
+        return creators.reduceRight((next, contribution) => () => {
+            try {
+                return contribution.creator(constructor, next, metadata);
+            }
+            catch (error) {
+                throw (0, errors_1.wrapPluginError)(contribution.record.plugin.name, `handlers.construct:${kind}`, contribution.record.index, error, undefined, contribution.record.plugin.instanceId);
+            }
+        }, create)();
+    }
+    /** @internal */
+    runPluginHandlerTransformers(kind, instance) {
+        let current = instance;
+        const metadata = { kind };
+        for (const contribution of (0, order_1.orderedPluginContributions)(this.pluginRegistry.handlerTransformers)) {
+            if (!this.matchesPluginHandlerKind(contribution.kinds, kind))
+                continue;
+            try {
+                const transform = contribution.transformer;
+                current = (transform(current, metadata) ?? current);
+            }
+            catch (error) {
+                throw (0, errors_1.wrapPluginError)(contribution.record.plugin.name, `handlers.transform:${kind}`, contribution.record.index, error, undefined, contribution.record.plugin.instanceId);
+            }
+        }
+        return current;
+    }
+    matchesPluginHandlerKind(kinds, kind) {
+        return !kinds?.length || kinds.includes(kind);
+    }
+    createPluginLoadedMetadata(kind, items) {
+        const sources = Object.create(null);
+        for (const item of items) {
+            const source = item[pluginSourceKey];
+            if (source)
+                sources[source] = (sources[source] ?? 0) + 1;
+        }
+        const sourceSnapshot = Object.freeze(sources);
+        return Object.freeze({
+            kind,
+            total: items.length,
+            items: Object.freeze([...items]),
+            plugin: Object.freeze({
+                total: Object.values(sources).reduce((sum, value) => sum + value, 0),
+                sources: sourceSnapshot,
+            }),
+        });
+    }
+    async emitPluginCustomEvent(name, ...args) {
+        await this.events?.runCustom(name, ...args);
     }
     async onPacket(..._packet) {
         throw new common_1.SeyfertError('FUNCTION_NOT_IMPLEMENTED', { metadata: { detail: 'Function not implemented' } });
@@ -209,8 +641,15 @@ class BaseClient {
      * @returns
      */
     async onInteractionRequest(rawBody) {
-        return new Promise(async (r) => {
-            await this.handleCommand.interaction(rawBody, -1, async ({ body, files }) => {
+        if (rawBody.type === types_1.InteractionType.Ping) {
+            return {
+                headers: { 'Content-Type': 'application/json' },
+                response: { type: types_1.InteractionResponseType.Pong },
+            };
+        }
+        return new Promise((resolve, reject) => {
+            this.handleCommand
+                .interaction(rawBody, -1, async ({ body, files }) => {
                 let response;
                 const headers = {};
                 if (files) {
@@ -241,11 +680,12 @@ class BaseClient {
                     response = body ?? {};
                     headers['Content-Type'] = 'application/json';
                 }
-                return r({
+                resolve({
                     headers,
                     response,
                 });
-            });
+            })
+                .catch(reject);
         });
     }
     async shouldUploadCommands(cachePath, guildId) {
@@ -260,6 +700,29 @@ class BaseClient {
             .filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash)
             .map(x => x.toJSON())));
     }
+    async cachedCommandGuilds(cachePath) {
+        const guilds = new Set();
+        const cached = await node_fs_1.promises.readFile(cachePath, 'utf8').catch(() => undefined);
+        if (!cached)
+            return guilds;
+        try {
+            const commands = JSON.parse(cached);
+            for (const command of commands) {
+                const guildId = command.guild_id;
+                if (Array.isArray(guildId)) {
+                    for (const id of guildId)
+                        guilds.add(id);
+                }
+                else if (typeof guildId === 'string') {
+                    guilds.add(guildId);
+                }
+            }
+        }
+        catch {
+            return guilds;
+        }
+        return guilds;
+    }
     async uploadCommands({ applicationId, cachePath } = {}) {
         applicationId ??= await this.getRC().then(x => x.applicationId ?? this.applicationId);
         (0, common_1.assertString)(applicationId, 'applicationId is not a string');
@@ -268,68 +731,129 @@ class BaseClient {
         if (this.commands.entryPoint) {
             filter.expect.push(this.commands.entryPoint);
         }
-        if (!cachePath || (await this.shouldUploadCommands(cachePath)))
+        const globalCommands = filter.expect
+            .filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash)
+            .map(x => x.toJSON());
+        const shouldUploadGlobal = !cachePath || (await this.shouldUploadCommands(cachePath));
+        if (shouldUploadGlobal) {
             await this.proxy.applications(applicationId).commands.put({
-                body: filter.expect
-                    .filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash)
-                    .map(x => x.toJSON()),
+                body: globalCommands,
             });
+        }
+        await this.emitUploadCommandsMetadata({
+            applicationId,
+            cachePath,
+            commands: globalCommands.length,
+            reason: cachePath ? (shouldUploadGlobal ? 'cache-miss' : 'cache-hit') : 'forced',
+            scope: 'global',
+            status: shouldUploadGlobal ? 'uploaded' : 'skipped',
+        });
         const guilds = new Set();
+        if (cachePath) {
+            for (const guildId of await this.cachedCommandGuilds(cachePath))
+                guilds.add(guildId);
+        }
         for (const command of filter.never) {
             for (const guild_id of command.guildId) {
                 guilds.add(guild_id);
             }
         }
         for (const guildId of guilds) {
-            if (!cachePath || (await this.shouldUploadCommands(cachePath, guildId))) {
-                await this.proxy
-                    .applications(applicationId)
-                    .guilds(guildId)
-                    .commands.put({
-                    body: filter.never
-                        .filter(cmd => cmd.guildId.includes(guildId) && (!('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash))
-                        .map(x => x.toJSON()),
+            const guildCommands = filter.never
+                .filter(cmd => cmd.guildId.includes(guildId) && (!('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash))
+                .map(x => x.toJSON());
+            const shouldUploadGuild = !cachePath || (await this.shouldUploadCommands(cachePath, guildId));
+            if (shouldUploadGuild) {
+                await this.proxy.applications(applicationId).guilds(guildId).commands.put({
+                    body: guildCommands,
                 });
             }
+            await this.emitUploadCommandsMetadata({
+                applicationId,
+                cachePath,
+                commands: guildCommands.length,
+                guildId,
+                reason: cachePath ? (shouldUploadGuild ? 'cache-miss' : 'cache-hit') : 'forced',
+                scope: 'guild',
+                status: shouldUploadGuild ? 'uploaded' : 'skipped',
+            });
         }
         if (cachePath)
             await this.syncCachePath(cachePath);
     }
+    async emitUploadCommandsMetadata(metadata) {
+        await this.emitPluginCustomEvent('uploadCommands', metadata);
+    }
     async loadCommands(dir) {
         dir ??= await this.getRC().then(x => x.locations.commands);
         if (dir && this.commands) {
-            await this.commands.load(dir, this);
+            await this.commands.load(dir, this, this.createPluginCommandLoadOptions());
             this.logger.info('CommandHandler loaded');
         }
     }
     async loadComponents(dir) {
         dir ??= await this.getRC().then(x => x.locations.components);
+        if (!this.pluginComponentsBeforeLoadDepth)
+            await (0, plugins_1.runPluginHooks)(this, 'components:beforeLoad', this, dir);
         if (dir && this.components) {
-            await this.components.load(dir);
+            await this.components.load(dir, this.createPluginComponentLoadOptions());
             this.logger.info('ComponentHandler loaded');
         }
     }
+    /** @internal */
+    createPluginCommandLoadOptions() {
+        return {
+            create: (constructor, next) => this.runPluginHandlerCreators('command', constructor, next),
+            transform: command => this.runPluginHandlerTransformers('command', command),
+        };
+    }
+    /** @internal */
+    createPluginComponentLoadOptions() {
+        return {
+            create: (kind, constructor, next) => this.runPluginHandlerCreators(kind, constructor, next),
+            transform: (kind, component) => this.runPluginHandlerTransformers(kind, component),
+        };
+    }
     async loadLangs(dir) {
         dir ??= await this.getRC().then(x => x.locations.langs);
         if (dir && this.langs) {
             await this.langs.load(dir);
             this.logger.info('LangsHandler loaded');
         }
+        this.langBaseValues = this.langs ? cloneRecursive(this.langs.values) : this.langBaseValues;
+        this.applyPluginLangs();
+    }
+    applyPluginLangs() {
+        if (!this.langs)
+            return;
+        const localeContributions = (0, order_1.orderedPluginContributions)(this.pluginRegistry.langs);
+        const values = cloneRecursive(this.langBaseValues);
+        for (const contribution of localeContributions) {
+            const current = values[contribution.locale] ?? {};
+            values[contribution.locale] = (0, common_1.MergeOptions)(current, createNestedLangValues(contribution.prefix, cloneRecursive(contribution.values)));
+        }
+        this.langs.values = values;
     }
     t(locale) {
         return this.langs.get(locale);
     }
     async getRC() {
+        if (this._rcCache)
+            return this._rcCache;
         const seyfertConfig = (BaseClient._seyfertCfWorkerConfig ||
             (await this.options?.getRC?.()) ||
             (await Promise.any(['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'].map(ext => (0, common_1.magicImport)((0, node_path_1.join)(process.cwd(), `seyfert.config${ext}`)).then(x => x.default ?? x))).catch((e) => {
-                const errors = e.errors.map((err) => {
-                    err.message = err.message.replace(/seyfert\.config\.(js|mjs|cjs|ts|mts|cts)/g, 'seyfert.config');
-                    return err;
-                });
+                const errors = e.errors.map((err) => ({
+                    error: err,
+                    message: err.message.replace(/seyfert\.config\.(js|mjs|cjs|ts|mts|cts)/g, 'seyfert.config'),
+                }));
                 const uniqueError = errors.find(er => errors.filter(err => err.message === er.message).length === 1);
-                if (uniqueError)
-                    throw uniqueError;
+                if (uniqueError) {
+                    throw new common_1.SeyfertError('SEYFERT_CONFIG_LOAD_ERROR', {
+                        metadata: { detail: uniqueError.message },
+                        cause: uniqueError.error,
+                    });
+                }
                 throw new common_1.SeyfertError('NO_SEYFERT_CONFIG', {
                     metadata: { detail: 'No seyfert.config file found' },
                 });
@@ -349,11 +873,42 @@ class BaseClient {
                 locationsFullPaths[key] = location;
         }
         const obj = {
-            debug: !!debug,
             ...env,
+            debug: !!debug,
+            intents: (0, intents_1.resolveGatewayIntents)('intents' in seyfertConfig ? (seyfertConfig.intents ?? 0) : 0),
             locations: locationsFullPaths,
         };
+        this._rcCache = obj;
         return obj;
     }
 }
 exports.BaseClient = BaseClient;
+function createNestedLangValues(prefix, values) {
+    const route = prefix.split('.').filter(Boolean);
+    const clonedValues = cloneRecursive(values);
+    const root = {};
+    let current = root;
+    for (let i = 0; i < route.length; i++) {
+        const key = route[i];
+        if (i === route.length - 1) {
+            current[key] = clonedValues;
+            break;
+        }
+        const nested = {};
+        current[key] = nested;
+        current = nested;
+    }
+    return root;
+}
+function cloneRecursive(value) {
+    if (Array.isArray(value))
+        return value.map(item => cloneRecursive(item));
+    if (!value || typeof value !== 'object')
+        return value;
+    const entries = value;
+    const cloned = {};
+    for (const key of Object.keys(entries)) {
+        cloned[key] = cloneRecursive(entries[key]);
+    }
+    return cloned;
+}