seyfert 4.3.1-dev-27001512861.0 → 4.4.0

package/lib/api/utils/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const DefaultUserAgent: "DiscordBot (https://seyfert.dev, v4.0.0)";
+export declare const DefaultUserAgent: "DiscordBot (https://seyfert.dev, v4.4.0)";
 export declare const ALLOWED_EXTENSIONS: readonly ["webp", "png", "jpg", "jpeg", "gif"];
 export declare const ALLOWED_STICKER_EXTENSIONS: readonly ["png", "json", "gif"];
 export declare const ALLOWED_SIZES: readonly [16, 32, 64, 100, 128, 256, 512, 1024, 2048, 4096];

package/lib/api/utils/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALLOWED_TAG_BADGE_EXTENSIONS = exports.ALLOWED_SOUNDS_EXTENSIONS = exports.ALLOWED_SIZES = exports.ALLOWED_STICKER_EXTENSIONS = exports.ALLOWED_EXTENSIONS = exports.DefaultUserAgent = void 0;
-exports.DefaultUserAgent = 'DiscordBot (https://seyfert.dev, v4.0.0)';
+exports.DefaultUserAgent = 'DiscordBot (https://seyfert.dev, v4.4.0)';
 exports.ALLOWED_EXTENSIONS = ['webp', 'png', 'jpg', 'jpeg', 'gif'];
 exports.ALLOWED_STICKER_EXTENSIONS = ['png', 'json', 'gif'];
 exports.ALLOWED_SIZES = [16, 32, 64, 100, 128, 256, 512, 1_024, 2_048, 4_096];

package/lib/client/base.d.ts

@@ -15,9 +15,7 @@ import { ComponentHandler } from '../components/handler';
 import { LangsHandler } from '../langs/handler';
 import type { ChatInputCommandInteraction, ComponentInteraction, EntryPointInteraction, MessageCommandInteraction, ModalSubmitInteraction, UserCommandInteraction } from '../structures';
 import type { APIInteraction, APIInteractionResponse, LocaleString, RESTPostAPIChannelMessageJSONBody } from '../types';
-import { type SeyfertPlugin } from './plugins';
 import type { MessageStructure } from './transformers';
-export type ContextScope = <T>(context: unknown, run: () => Awaitable<T>) => Awaitable<T>;
 export declare class BaseClient {
     rest: ApiHandler;
     cache: Cache;
@@ -48,9 +46,6 @@ export declare class BaseClient {
     private _botId?;
     middlewares?: Record<string, MiddlewareContext>;
     protected static getBotIdFromToken(token: string): string;
-    readonly plugins: readonly SeyfertPlugin[];
-    private pluginsSetupPromise?;
-    private pluginsClosePromise?;
     options: BaseClientOptions;
     constructor(options?: BaseClientOptions);
     get proxy(): import("../api").APIRoutes;
@@ -61,14 +56,6 @@ export declare class BaseClient {
     setServices({ rest, cache, langs, middlewares, handleCommand }: ServicesOptions): void;
     protected execute(..._options: unknown[]): Promise<void>;
     start(options?: Pick<DeepPartial<StartOptions>, 'langsDir' | 'commandsDir' | 'connection' | 'token' | 'componentsDir'>): Promise<void>;
-    private setupPlugins;
-    /**
-     * 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.
-     */
-    close(): Promise<void>;
     protected onPacket(..._packet: unknown[]): Promise<any>;
     /**
      *
@@ -100,8 +87,6 @@ export declare class BaseClient {
     }>;
 }
 export interface BaseClientOptions {
-    plugins?: readonly SeyfertPlugin[];
-    contextScopes?: readonly ContextScope[];
     context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean> | ComponentInteraction | ModalSubmitInteraction | EntryPointInteraction<boolean> | When<InferWithPrefix, MessageStructure, never>) => Record<string, unknown>;
     globalMiddlewares?: readonly (keyof RegisteredMiddlewares)[];
     commands?: {

package/lib/client/base.js

@@ -16,7 +16,6 @@ const soundboard_1 = require("../common/shorters/soundboard");
 const voiceStates_1 = require("../common/shorters/voiceStates");
 const handler_2 = require("../components/handler");
 const handler_3 = require("../langs/handler");
-const plugins_1 = require("./plugins");
 class BaseClient {
     rest = new api_1.ApiHandler({ token: 'INVALID' });
     cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), {}, this);
@@ -51,14 +50,11 @@ class BaseClient {
     static getBotIdFromToken(token) {
         return Buffer.from(token.split('.')[0], 'base64').toString('ascii');
     }
-    plugins = [];
-    pluginsSetupPromise;
-    pluginsClosePromise;
     options;
     /**@internal */
     static _seyfertCfWorkerConfig;
     constructor(options) {
-        const defaults = {
+        this.options = (0, common_1.MergeOptions)({
             commands: {
                 defaults: {
                     onRunError(context, error) {
@@ -107,10 +103,7 @@ class BaseClient {
                     },
                 },
             },
-        };
-        const resolved = (0, plugins_1.resolveClientPlugins)(defaults, options);
-        this.options = resolved.options;
-        this.plugins = resolved.plugins;
+        }, options);
     }
     get proxy() {
         return this.rest.proxy;
@@ -192,6 +185,9 @@ 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');
@@ -200,51 +196,9 @@ class BaseClient {
         this.rest.debug = debug;
         if (!this.handleCommand)
             this.handleCommand = new handle_1.HandleCommand(this);
-        await this.setupPlugins();
         // 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 this.loadCommands(options.commandsDir);
-        await this.loadComponents(options.componentsDir);
-    }
-    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.teardownClientPlugins)(this, this.plugins);
-            })();
-        this.pluginsClosePromise = close;
-        try {
-            await close;
-        }
-        finally {
-            if (this.pluginsClosePromise === close) {
-                this.pluginsSetupPromise = undefined;
-                this.pluginsClosePromise = undefined;
-            }
-        }
     }
     async onPacket(..._packet) {
         throw new common_1.SeyfertError('FUNCTION_NOT_IMPLEMENTED', { metadata: { detail: 'Function not implemented' } });

package/lib/client/index.d.ts

@@ -1,6 +1,5 @@
 export type { RuntimeConfig, RuntimeConfigHTTP } from './base';
 export * from './client';
 export * from './httpclient';
-export * from './plugins';
 export * from './transformers';
 export * from './workerclient';

package/lib/client/index.js

@@ -16,6 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client"), exports);
 __exportStar(require("./httpclient"), exports);
-__exportStar(require("./plugins"), exports);
 __exportStar(require("./transformers"), exports);
 __exportStar(require("./workerclient"), exports);

package/lib/commands/handle.d.ts

@@ -29,17 +29,9 @@ export declare class HandleCommand {
     resolveCommandFromContent(content: string, _prefix: string, _message: GatewayMessageCreateDispatchData): CommandFromContent & {
         argsContent?: string;
     };
-    getCommandFromContent(commandRaw: string[], guildId?: string): CommandFromContent;
-    /**
-     * Resolves a message command by its full name.
-     *
-     * Guild-scoped commands require a matching `guildId`; without one, they intentionally resolve to `undefined`.
-     */
-    resolveByName(fullName: string, guildId?: string): CommandFromContent | undefined;
-    private resolveCommandFromNameParts;
+    getCommandFromContent(commandRaw: string[]): CommandFromContent;
     makeResolver(...args: Parameters<(typeof Transformers)['OptionResolver']>): OptionResolverStructure;
-    getParentMessageCommand(rawParentName: string, guildId?: string): Command | ContextMenuCommand | undefined;
-    private commandCanRunInGuild;
+    getParentMessageCommand(rawParentName: string): Command | ContextMenuCommand | undefined;
     getCommand<T extends Command | ContextMenuCommand | EntryPointCommand>(data: {
         guild_id?: string;
         name: string;

package/lib/commands/handle.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandleCommand = void 0;
-const plugins_1 = require("../client/plugins");
 const transformers_1 = require("../client/transformers");
 const constants_1 = require("../common/it/constants");
 const components_1 = require("../components");
@@ -38,38 +37,36 @@ class HandleCommand {
         }
     }
     async contextMenu(command, interaction, context) {
-        return (0, plugins_1.runContextScopes)(this.client.options.contextScopes, context, async () => {
+        try {
+            if (context.guildId && command.botPermissions) {
+                const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+                if (permissions)
+                    return await command.onBotPermissionsFail?.(context, permissions);
+            }
+            await command.onBeforeMiddlewares?.(context);
+            const resultGlobal = await this.runGlobalMiddlewares(command, context);
+            if (typeof resultGlobal === 'boolean')
+                return;
+            const resultMiddle = await this.runMiddlewares(command, context);
+            if (typeof resultMiddle === 'boolean')
+                return;
             try {
-                if (context.guildId && command.botPermissions) {
-                    const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
-                    if (permissions)
-                        return await command.onBotPermissionsFail?.(context, permissions);
-                }
-                await command.onBeforeMiddlewares?.(context);
-                const resultGlobal = await this.runGlobalMiddlewares(command, context);
-                if (typeof resultGlobal === 'boolean')
-                    return;
-                const resultMiddle = await this.runMiddlewares(command, context);
-                if (typeof resultMiddle === 'boolean')
-                    return;
-                try {
-                    await command.run(context);
-                    await command.onAfterRun?.(context, undefined);
-                }
-                catch (error) {
-                    await command.onRunError?.(context, error);
-                    await command.onAfterRun?.(context, error);
-                }
+                await command.run(context);
+                await command.onAfterRun?.(context, undefined);
             }
             catch (error) {
-                try {
-                    await command.onInternalError?.(this.client, command, error);
-                }
-                catch (err) {
-                    this.client.logger.error(`[${command.name}] Internal error:`, err);
-                }
+                await command.onRunError?.(context, error);
+                await command.onAfterRun?.(context, error);
             }
-        });
+        }
+        catch (error) {
+            try {
+                await command.onInternalError?.(this.client, command, error);
+            }
+            catch (err) {
+                this.client.logger.error(`[${command.name}] Internal error:`, err);
+            }
+        }
     }
     contextMenuMessage(command, interaction, context) {
         return this.contextMenu(command, interaction, context);
@@ -78,82 +75,78 @@ class HandleCommand {
         return this.contextMenu(command, interaction, context);
     }
     async entryPoint(command, interaction, context) {
-        return (0, plugins_1.runContextScopes)(this.client.options.contextScopes, context, async () => {
+        try {
+            if (context.guildId && command.botPermissions) {
+                const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+                if (permissions)
+                    return await command.onBotPermissionsFail(context, permissions);
+            }
+            await command.onBeforeMiddlewares?.(context);
+            const resultGlobal = await this.runGlobalMiddlewares(command, context);
+            if (typeof resultGlobal === 'boolean')
+                return;
+            const resultMiddle = await this.runMiddlewares(command, context);
+            if (typeof resultMiddle === 'boolean')
+                return;
             try {
-                if (context.guildId && command.botPermissions) {
-                    const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
-                    if (permissions)
-                        return await command.onBotPermissionsFail(context, permissions);
-                }
-                await command.onBeforeMiddlewares?.(context);
-                const resultGlobal = await this.runGlobalMiddlewares(command, context);
-                if (typeof resultGlobal === 'boolean')
-                    return;
-                const resultMiddle = await this.runMiddlewares(command, context);
-                if (typeof resultMiddle === 'boolean')
-                    return;
-                try {
-                    await command.run(context);
-                    await command.onAfterRun?.(context, undefined);
-                }
-                catch (error) {
-                    await command.onRunError(context, error);
-                    await command.onAfterRun?.(context, error);
-                }
+                await command.run(context);
+                await command.onAfterRun?.(context, undefined);
             }
             catch (error) {
-                try {
-                    await command.onInternalError(this.client, command, error);
-                }
-                catch (err) {
-                    this.client.logger.error(`[${command.name}] Internal error:`, err);
-                }
+                await command.onRunError(context, error);
+                await command.onAfterRun?.(context, error);
             }
-        });
+        }
+        catch (error) {
+            try {
+                await command.onInternalError(this.client, command, error);
+            }
+            catch (err) {
+                this.client.logger.error(`[${command.name}] Internal error:`, err);
+            }
+        }
     }
     async chatInput(command, interaction, resolver, context) {
-        return (0, plugins_1.runContextScopes)(this.client.options.contextScopes, context, async () => {
-            try {
-                if (context.guildId) {
-                    if (command.botPermissions) {
-                        const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
-                        if (permissions)
-                            return await command.onBotPermissionsFail?.(context, permissions);
-                    }
-                    if (command.defaultMemberPermissions) {
-                        const permissions = this.checkPermissions(interaction.member.permissions, command.defaultMemberPermissions);
-                        if (permissions)
-                            return await command.onPermissionsFail?.(context, permissions);
-                    }
-                }
-                await command.onBeforeOptions?.(context);
-                if (!(await this.runOptions(command, context, resolver)))
-                    return;
-                await command.onBeforeMiddlewares?.(context);
-                const resultGlobal = await this.runGlobalMiddlewares(command, context);
-                if (typeof resultGlobal === 'boolean')
-                    return;
-                const resultMiddle = await this.runMiddlewares(command, context);
-                if (typeof resultMiddle === 'boolean')
-                    return;
-                try {
-                    await command.run(context);
-                    await command.onAfterRun?.(context, undefined);
+        try {
+            if (context.guildId) {
+                if (command.botPermissions) {
+                    const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+                    if (permissions)
+                        return await command.onBotPermissionsFail?.(context, permissions);
                 }
-                catch (error) {
-                    await command.onRunError?.(context, error);
-                    await command.onAfterRun?.(context, error);
+                if (command.defaultMemberPermissions) {
+                    const permissions = this.checkPermissions(interaction.member.permissions, command.defaultMemberPermissions);
+                    if (permissions)
+                        return await command.onPermissionsFail?.(context, permissions);
                 }
             }
+            await command.onBeforeOptions?.(context);
+            if (!(await this.runOptions(command, context, resolver)))
+                return;
+            await command.onBeforeMiddlewares?.(context);
+            const resultGlobal = await this.runGlobalMiddlewares(command, context);
+            if (typeof resultGlobal === 'boolean')
+                return;
+            const resultMiddle = await this.runMiddlewares(command, context);
+            if (typeof resultMiddle === 'boolean')
+                return;
+            try {
+                await command.run(context);
+                await command.onAfterRun?.(context, undefined);
+            }
             catch (error) {
-                try {
-                    await command.onInternalError?.(this.client, command, error);
-                }
-                catch (err) {
-                    this.client.logger.error(`[${command.name}] Internal error:`, err);
-                }
+                await command.onRunError?.(context, error);
+                await command.onAfterRun?.(context, error);
             }
-        });
+        }
+        catch (error) {
+            try {
+                await command.onInternalError?.(this.client, command, error);
+            }
+            catch (err) {
+                this.client.logger.error(`[${command.name}] Internal error:`, err);
+            }
+        }
     }
     async modal(interaction) {
         const context = new components_1.ModalContext(this.client, interaction);
@@ -280,55 +273,53 @@ class HandleCommand {
             //@ts-expect-error
             const extendContext = self.options?.context?.(message) ?? {};
             Object.assign(context, extendContext);
-            return await (0, plugins_1.runContextScopes)(self.options.contextScopes, context, async () => {
-                if (errors.length) {
-                    return await command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
-                        return [
-                            x.name,
-                            {
-                                failed: true,
-                                value: x.error,
-                                parseError: x.fullError,
-                            },
-                        ];
-                    })));
-                }
-                if (rawMessage.guild_id) {
-                    if (command.defaultMemberPermissions) {
-                        const memberPermissions = await self.members.permissions(rawMessage.guild_id, rawMessage.author.id);
-                        const permissions = this.checkPermissions(memberPermissions, command.defaultMemberPermissions);
-                        const guild = await this.client.guilds.raw(rawMessage.guild_id);
-                        if (permissions && guild.owner_id !== rawMessage.author.id) {
-                            return await command.onPermissionsFail?.(context, memberPermissions.keys(permissions));
-                        }
-                    }
-                    if (command.botPermissions) {
-                        const appPermissions = await self.members.permissions(rawMessage.guild_id, self.botId);
-                        const permissions = this.checkPermissions(appPermissions, command.botPermissions);
-                        if (permissions) {
-                            return await command.onBotPermissionsFail?.(context, permissions);
-                        }
+            if (errors.length) {
+                return await command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
+                    return [
+                        x.name,
+                        {
+                            failed: true,
+                            value: x.error,
+                            parseError: x.fullError,
+                        },
+                    ];
+                })));
+            }
+            if (rawMessage.guild_id) {
+                if (command.defaultMemberPermissions) {
+                    const memberPermissions = await self.members.permissions(rawMessage.guild_id, rawMessage.author.id);
+                    const permissions = this.checkPermissions(memberPermissions, command.defaultMemberPermissions);
+                    const guild = await this.client.guilds.raw(rawMessage.guild_id);
+                    if (permissions && guild.owner_id !== rawMessage.author.id) {
+                        return await command.onPermissionsFail?.(context, memberPermissions.keys(permissions));
                     }
                 }
-                await command.onBeforeOptions?.(context);
-                if (!(await this.runOptions(command, context, optionsResolver)))
-                    return;
-                await command.onBeforeMiddlewares?.(context);
-                const resultGlobal = await this.runGlobalMiddlewares(command, context);
-                if (typeof resultGlobal === 'boolean')
-                    return;
-                const resultMiddle = await this.runMiddlewares(command, context);
-                if (typeof resultMiddle === 'boolean')
-                    return;
-                try {
-                    await command.run(context);
-                    await command.onAfterRun?.(context, undefined);
-                }
-                catch (error) {
-                    await command.onRunError?.(context, error);
-                    await command.onAfterRun?.(context, error);
+                if (command.botPermissions) {
+                    const appPermissions = await self.members.permissions(rawMessage.guild_id, self.botId);
+                    const permissions = this.checkPermissions(appPermissions, command.botPermissions);
+                    if (permissions) {
+                        return await command.onBotPermissionsFail?.(context, permissions);
+                    }
                 }
-            });
+            }
+            await command.onBeforeOptions?.(context);
+            if (!(await this.runOptions(command, context, optionsResolver)))
+                return;
+            await command.onBeforeMiddlewares?.(context);
+            const resultGlobal = await this.runGlobalMiddlewares(command, context);
+            if (typeof resultGlobal === 'boolean')
+                return;
+            const resultMiddle = await this.runMiddlewares(command, context);
+            if (typeof resultMiddle === 'boolean')
+                return;
+            try {
+                await command.run(context);
+                await command.onAfterRun?.(context, undefined);
+            }
+            catch (error) {
+                await command.onRunError?.(context, error);
+                await command.onAfterRun?.(context, error);
+            }
         }
         catch (error) {
             try {
@@ -350,7 +341,7 @@ class HandleCommand {
         const result = this.getCommandFromContent(content
             .split(' ')
             .filter(x => x)
-            .slice(0, 3), _message.guild_id);
+            .slice(0, 3));
         if (!result.command)
             return result;
         let newContent = content;
@@ -362,44 +353,19 @@ class HandleCommand {
             argsContent: newContent.slice(1),
         };
     }
-    getCommandFromContent(commandRaw, guildId) {
-        return this.resolveCommandFromNameParts(commandRaw, guildId);
-    }
-    /**
-     * Resolves a message command by its full name.
-     *
-     * Guild-scoped commands require a matching `guildId`; without one, they intentionally resolve to `undefined`.
-     */
-    resolveByName(fullName, guildId) {
-        const parts = fullName
-            .trim()
-            .split(/\s+/)
-            .filter(x => x)
-            .slice(0, 3);
-        if (!parts.length)
-            return undefined;
-        const resolved = this.resolveCommandFromNameParts(parts, guildId, false);
-        return resolved.command ? resolved : undefined;
-    }
-    resolveCommandFromNameParts(commandRaw, guildId, allowFallback = true) {
+    getCommandFromContent(commandRaw) {
         const rawParentName = commandRaw[0];
         const rawGroupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
         const rawSubcommandName = rawGroupName ? commandRaw[2] : commandRaw[1];
-        const parent = this.getParentMessageCommand(rawParentName, guildId);
+        const parent = this.getParentMessageCommand(rawParentName);
         const fullCommandName = `${rawParentName}${rawGroupName ? ` ${rawGroupName} ${rawSubcommandName}` : `${rawSubcommandName ? ` ${rawSubcommandName}` : ''}`}`;
         if (!(parent instanceof _1.Command))
             return { fullCommandName };
-        if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName]) {
-            if (!allowFallback)
-                return { fullCommandName };
-            return this.resolveCommandFromNameParts([rawParentName, rawGroupName], guildId);
-        }
+        if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName])
+            return this.getCommandFromContent([rawParentName, rawGroupName]);
         if (rawSubcommandName &&
-            !parent.options?.some(x => x instanceof _1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName)))) {
-            if (!allowFallback)
-                return { fullCommandName };
-            return this.resolveCommandFromNameParts([rawParentName], guildId);
-        }
+            !parent.options?.some(x => x instanceof _1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName))))
+            return this.getCommandFromContent([rawParentName]);
         const groupName = rawGroupName ? parent.groupsAliases?.[rawGroupName] || rawGroupName : undefined;
         const command = groupName || rawSubcommandName
             ? parent.options?.find(opt => {
@@ -424,16 +390,10 @@ class HandleCommand {
     makeResolver(...args) {
         return transformers_1.Transformers.OptionResolver(...args);
     }
-    getParentMessageCommand(rawParentName, guildId) {
+    getParentMessageCommand(rawParentName) {
         return this.client.commands.values.find(x => (!('ignore' in x) || x.ignore !== _1.IgnoreCommand.Message) &&
-            this.commandCanRunInGuild(x, guildId) &&
             (x.name === rawParentName || ('aliases' in x ? x.aliases?.includes(rawParentName) : false)));
     }
-    commandCanRunInGuild(command, guildId) {
-        if (!command.guildId?.length)
-            return true;
-        return guildId ? command.guildId.includes(guildId) : false;
-    }
     getCommand(data) {
         return this.client.commands.values.find(command => {
             if (data.guild_id) {

package/lib/commands/index.d.ts

@@ -7,5 +7,4 @@ export * from './applications/menucontext';
 export * from './applications/options';
 export * from './applications/shared';
 export * from './decorators';
-export type { CommandFromContent } from './handle';
 export * from './optionresolver';

package/lib/components/handler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentHandler = void 0;
-const plugins_1 = require("../client/plugins");
 const collection_1 = require("../collection");
 const commands_1 = require("../commands");
 const common_1 = require("../common");
@@ -259,41 +258,39 @@ class ComponentHandler extends common_1.BaseHandler {
         }
     }
     async execute(i, context) {
-        return (0, plugins_1.runContextScopes)(context.client.options.contextScopes, context, async () => {
+        try {
+            await i.onBeforeMiddlewares?.(context);
+            const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
+            if (resultRunGlobalMiddlewares.pass) {
+                return;
+            }
+            if ('error' in resultRunGlobalMiddlewares) {
+                return await i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+            }
+            const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
+            if (resultRunMiddlewares.pass) {
+                return;
+            }
+            if ('error' in resultRunMiddlewares) {
+                return await i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+            }
             try {
-                await i.onBeforeMiddlewares?.(context);
-                const resultRunGlobalMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, (context.client.options?.globalMiddlewares ?? []), true);
-                if (resultRunGlobalMiddlewares.pass) {
-                    return;
-                }
-                if ('error' in resultRunGlobalMiddlewares) {
-                    return await i.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
-                }
-                const resultRunMiddlewares = await commands_1.BaseCommand.__runMiddlewares(context, i.middlewares, false);
-                if (resultRunMiddlewares.pass) {
-                    return;
-                }
-                if ('error' in resultRunMiddlewares) {
-                    return await i.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
-                }
-                try {
-                    await i.run(context);
-                    await i.onAfterRun?.(context, undefined);
-                }
-                catch (error) {
-                    await i.onRunError?.(context, error);
-                    await i.onAfterRun?.(context, error);
-                }
+                await i.run(context);
+                await i.onAfterRun?.(context, undefined);
             }
             catch (error) {
-                try {
-                    await i.onInternalError?.(this.client, error);
-                }
-                catch (err) {
-                    this.client.logger.error(`[${i.customId ?? 'Component/Modal command'}] Internal error:`, err);
-                }
+                await i.onRunError?.(context, error);
+                await i.onAfterRun?.(context, error);
             }
-        });
+        }
+        catch (error) {
+            try {
+                await i.onInternalError?.(this.client, error);
+            }
+            catch (err) {
+                this.client.logger.error(`[${i.customId ?? 'Component/Modal command'}] Internal error:`, err);
+            }
+        }
     }
     async executeComponent(context) {
         for (const i of this.commands) {

package/lib/websocket/constants/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.properties = exports.WorkerManagerDefaults = exports.ShardManagerDefaults = exports.COMPRESS = void 0;
 const COMPRESS = false;
 exports.COMPRESS = COMPRESS;
-const propertiesVersion = 'Seyfert v4.2.2 (https://seyfert.dev)';
+const propertiesVersion = 'Seyfert v4.4.0 (https://seyfert.dev)';
 const properties = {
     os: process.platform,
     browser: propertiesVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "4.3.1-dev-27001512861.0",
+	"version": "4.4.0",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
@@ -70,4 +70,4 @@
 			"esbuild"
 		]
 	}
-}
+}

package/lib/client/plugins.d.ts

@@ -1,22 +0,0 @@
-import type { UsingClient } from '../commands';
-import type { Awaitable } from '../common/types/util';
-import type { BaseClientOptions, ContextScope } from './base';
-type ClientOptionsFragment = Partial<Omit<BaseClientOptions, 'plugins'>>;
-export type SeyfertPluginClient = UsingClient & {
-    plugins: readonly SeyfertPlugin[];
-};
-export interface SeyfertPlugin {
-    name: string;
-    options?(current: Readonly<BaseClientOptions>): ClientOptionsFragment;
-    setup?(client: SeyfertPluginClient): Awaitable<void>;
-    teardown?(client: SeyfertPluginClient): Awaitable<void>;
-}
-export interface ResolvedClientPlugins {
-    plugins: readonly SeyfertPlugin[];
-    options: BaseClientOptions;
-}
-export declare function resolveClientPlugins(defaults: BaseClientOptions, options?: BaseClientOptions): ResolvedClientPlugins;
-export declare function setupClientPlugins(client: SeyfertPluginClient, plugins: readonly SeyfertPlugin[]): Promise<void>;
-export declare function teardownClientPlugins(client: SeyfertPluginClient, plugins: readonly SeyfertPlugin[]): Promise<void>;
-export declare function runContextScopes<T>(scopes: readonly ContextScope[] | undefined, context: unknown, run: () => Awaitable<T>): Awaitable<T>;
-export {};

package/lib/client/plugins.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveClientPlugins = resolveClientPlugins;
-exports.setupClientPlugins = setupClientPlugins;
-exports.teardownClientPlugins = teardownClientPlugins;
-exports.runContextScopes = runContextScopes;
-const common_1 = require("../common");
-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 plugins = options.plugins ?? [];
-    const userOptions = omitPlugins(options);
-    const pluginOptions = [];
-    for (const plugin of plugins) {
-        const current = (0, common_1.MergeOptions)(defaults, ...pluginOptions, userOptions);
-        const fragment = plugin.options?.(current);
-        if (fragment)
-            pluginOptions.push(fragment);
-    }
-    const merged = (0, common_1.MergeOptions)(defaults, ...pluginOptions, userOptions);
-    merged.plugins = plugins;
-    composeContext(merged, defaults, pluginOptions, userOptions);
-    composeContextScopes(merged, defaults, pluginOptions, userOptions);
-    composeGlobalMiddlewares(merged, defaults, pluginOptions, userOptions);
-    composeDefaults(merged.commands?.defaults, defaults.commands?.defaults, pluginOptions.map(fragment => fragment.commands?.defaults), userOptions.commands?.defaults, commandHookKeys);
-    composeDefaults(merged.components?.defaults, defaults.components?.defaults, pluginOptions.map(fragment => fragment.components?.defaults), userOptions.components?.defaults, componentHookKeys);
-    composeDefaults(merged.modals?.defaults, defaults.modals?.defaults, pluginOptions.map(fragment => fragment.modals?.defaults), userOptions.modals?.defaults, modalHookKeys);
-    return { plugins, options: merged };
-}
-async function setupClientPlugins(client, plugins) {
-    const completed = [];
-    try {
-        for (const plugin of plugins) {
-            await plugin.setup?.(client);
-            completed.push(plugin);
-        }
-    }
-    catch (setupError) {
-        try {
-            await teardownClientPlugins(client, completed);
-        }
-        catch (teardownError) {
-            throw new AggregateError([setupError, teardownError], 'Seyfert plugin setup failed and cleanup also failed.');
-        }
-        throw setupError;
-    }
-}
-async function teardownClientPlugins(client, plugins) {
-    const errors = [];
-    for (const plugin of [...plugins].reverse()) {
-        try {
-            await plugin.teardown?.(client);
-        }
-        catch (error) {
-            errors.push(error);
-        }
-    }
-    if (errors.length)
-        throw new AggregateError(errors, 'Seyfert plugin teardown failed.');
-}
-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) {
-    const middlewares = [
-        ...(defaults.globalMiddlewares ?? []),
-        ...pluginOptions.flatMap(fragment => fragment.globalMiddlewares ?? []),
-    ];
-    middlewares.push(...(userOptions.globalMiddlewares ?? []));
-    if (middlewares.length)
-        target.globalMiddlewares = middlewares;
-}
-function composeDefaults(target, defaults, pluginDefaults, userDefaults, keys) {
-    if (!target)
-        return;
-    for (const key of keys) {
-        const pluginHooks = pluginDefaults.map(defaults => defaults?.[key]).filter(isFunction);
-        const userHook = userDefaults?.[key];
-        const fallbackHook = defaults?.[key];
-        if (!pluginHooks.length && typeof userHook !== 'function')
-            continue;
-        const hooks = isFunction(userHook)
-            ? [...pluginHooks, userHook]
-            : pluginHooks.length
-                ? pluginHooks
-                : isFunction(fallbackHook)
-                    ? [fallbackHook]
-                    : [];
-        target[key] = composeHooks(hooks);
-    }
-}
-function composeHooks(hooks) {
-    return async (...args) => {
-        for (const hook of hooks)
-            await hook(...args);
-    };
-}
-function isFunction(value) {
-    return typeof value === 'function';
-}