seyfert 4.4.1 → 5.0.0

package/lib/client/transformers.d.ts

@@ -38,39 +38,39 @@ export type WebhookStructure = InferCustomStructure<Webhook, 'Webhook'>;
 export type OptionResolverStructure = InferCustomStructure<OptionResolver, 'OptionResolver'>;
 export type EntitlementStructure = InferCustomStructure<Entitlement, 'Entitlement'>;
 export declare const Transformers: {
-    Application(client: import("../commands").UsingClient, data: import("../types").APIApplication): ApplicationStructure;
-    ApplicationEmoji(client: import("../commands").UsingClient, data: import("../types").APIApplicationEmoji): ApplicationEmojiStructure;
-    AnonymousGuild(client: import("../commands").UsingClient, data: import("../types").APIPartialGuild): AnonymousGuildStructure;
-    AutoModerationRule(client: import("../commands").UsingClient, data: import("../types").APIAutoModerationRule): AutoModerationRuleStructure;
-    BaseChannel(client: import("../commands").UsingClient, data: import("../types").APIChannelBase<ChannelType>): BaseChannelStructure;
-    BaseGuildChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): BaseGuildChannelStructure;
-    TextGuildChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): TextGuildChannelStructure;
-    DMChannel(client: import("../commands").UsingClient, data: import("../types").APIChannelBase<ChannelType>): DMChannelStructure;
-    VoiceChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): VoiceChannelStructure;
-    StageChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): StageChannelStructure;
-    MediaChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): MediaChannelStructure;
-    ForumChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): ForumChannelStructure;
-    ThreadChannel(client: import("../commands").UsingClient, data: import("../types").APIChannelBase<ChannelType>): ThreadChannelStructure;
+    Application(client: import("..").UsingClient, data: import("..").APIApplication): ApplicationStructure;
+    ApplicationEmoji(client: import("..").UsingClient, data: import("..").APIApplicationEmoji): ApplicationEmojiStructure;
+    AnonymousGuild(client: import("..").UsingClient, data: import("..").APIPartialGuild): AnonymousGuildStructure;
+    AutoModerationRule(client: import("..").UsingClient, data: import("..").APIAutoModerationRule): AutoModerationRuleStructure;
+    BaseChannel(client: import("..").UsingClient, data: import("..").APIChannelBase<ChannelType>): BaseChannelStructure;
+    BaseGuildChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): BaseGuildChannelStructure;
+    TextGuildChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): TextGuildChannelStructure;
+    DMChannel(client: import("..").UsingClient, data: import("..").APIChannelBase<ChannelType>): DMChannelStructure;
+    VoiceChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): VoiceChannelStructure;
+    StageChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): StageChannelStructure;
+    MediaChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): MediaChannelStructure;
+    ForumChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): ForumChannelStructure;
+    ThreadChannel(client: import("..").UsingClient, data: import("..").APIChannelBase<ChannelType>): ThreadChannelStructure;
     CategoryChannel(...args: ConstructorParameters<typeof CategoryChannel>): CategoryChannelStructure;
-    NewsChannel(client: import("../commands").UsingClient, data: import("../types").APIGuildChannel<ChannelType>): NewsChannelStructure;
-    DirectoryChannel(client: import("../commands").UsingClient, data: import("../types").APIChannelBase<ChannelType>): DirectoryChannelStructure;
-    ClientUser(client: import("../commands").UsingClient, data: import("../types").APIUser, application: Pick<import("../types").APIApplication, "id" | "flags">): ClientUserStructure;
-    Guild<State extends StructStates = "api">(client: import("../commands").UsingClient, data: import("../types").APIGuild | import("../types").GatewayGuildCreateDispatchData): GuildStructure<State>;
-    GuildBan(client: import("../commands").UsingClient, data: import("../types").APIBan | import("../types").ActuallyBan, guildId: string): GuildBanStructure;
-    Emoji(client: import("../commands").UsingClient, data: import("../types").APIEmoji): EmojiStructure;
-    GuildEmoji(client: import("../commands").UsingClient, data: import("../types").APIEmoji, guildId: string): GuildEmojiStructure;
-    GuildMember(client: import("../commands").UsingClient, data: import("../structures").GuildMemberData, user: import("../types").APIUser, guildId: string): GuildMemberStructure;
-    InteractionGuildMember(client: import("../commands").UsingClient, data: import("../types").APIInteractionDataResolvedGuildMember, user: import("../types").APIUser, guildId: string): InteractionGuildMemberStructure;
-    GuildRole(client: import("../commands").UsingClient, data: import("../types").APIRole, guildId: string): GuildRoleStructure;
-    GuildTemplate(client: import("../commands").UsingClient, data: import("../types").APITemplate): GuildTemplateStructure;
-    Message(client: import("../commands").UsingClient, data: import("../structures").MessageData): MessageStructure;
-    WebhookMessage(client: import("../commands").UsingClient, data: import("../structures").MessageData, webhookId: string, webhookToken: string): WebhookMessageStructure;
-    Poll(client: import("../commands").UsingClient, data: import("../types").APIPoll, channelId: string, messageId: string): PollStructure;
-    Sticker(client: import("../commands").UsingClient, data: import("../types").APISticker): StickerStructure;
-    User(client: import("../commands").UsingClient, data: import("../types").APIUser): UserStructure;
-    VoiceState(client: import("../commands").UsingClient, data: import("../types").APIVoiceState): VoiceStateStructure;
-    Webhook(client: import("../commands").UsingClient, data: import("../types").APIWebhook): WebhookStructure;
-    OptionResolver(client: import("../commands").UsingClient, options: import("../types").APIApplicationCommandInteractionDataOption[], parent?: import("../commands").Command | undefined, guildId?: string | undefined, resolved?: import("../commands").ContextOptionsResolved | undefined): OptionResolverStructure;
-    Entitlement(client: import("../commands").UsingClient, data: import("../types").APIEntitlement): EntitlementStructure;
+    NewsChannel(client: import("..").UsingClient, data: import("..").APIGuildChannel<ChannelType>): NewsChannelStructure;
+    DirectoryChannel(client: import("..").UsingClient, data: import("..").APIChannelBase<ChannelType>): DirectoryChannelStructure;
+    ClientUser(client: import("..").UsingClient, data: import("..").APIUser, application: Pick<import("..").APIApplication, "id" | "flags">): ClientUserStructure;
+    Guild<State extends StructStates = "api">(client: import("..").UsingClient, data: import("..").APIGuild | import("..").GatewayGuildCreateDispatchData): GuildStructure<State>;
+    GuildBan(client: import("..").UsingClient, data: import("..").APIBan | import("..").ActuallyBan, guildId: string): GuildBanStructure;
+    Emoji(client: import("..").UsingClient, data: import("..").APIEmoji): EmojiStructure;
+    GuildEmoji(client: import("..").UsingClient, data: import("..").APIEmoji, guildId: string): GuildEmojiStructure;
+    GuildMember(client: import("..").UsingClient, data: import("..").GuildMemberData, user: import("..").APIUser, guildId: string): GuildMemberStructure;
+    InteractionGuildMember(client: import("..").UsingClient, data: import("..").APIInteractionDataResolvedGuildMember, user: import("..").APIUser, guildId: string): InteractionGuildMemberStructure;
+    GuildRole(client: import("..").UsingClient, data: import("..").APIRole, guildId: string): GuildRoleStructure;
+    GuildTemplate(client: import("..").UsingClient, data: import("..").APITemplate): GuildTemplateStructure;
+    Message(client: import("..").UsingClient, data: import("..").MessageData): MessageStructure;
+    WebhookMessage(client: import("..").UsingClient, data: import("..").MessageData, webhookId: string, webhookToken: string): WebhookMessageStructure;
+    Poll(client: import("..").UsingClient, data: import("..").APIPoll, channelId: string, messageId: string): PollStructure;
+    Sticker(client: import("..").UsingClient, data: import("..").APISticker): StickerStructure;
+    User(client: import("..").UsingClient, data: import("..").APIUser): UserStructure;
+    VoiceState(client: import("..").UsingClient, data: import("..").APIVoiceState): VoiceStateStructure;
+    Webhook(client: import("..").UsingClient, data: import("..").APIWebhook): WebhookStructure;
+    OptionResolver(client: import("..").UsingClient, options: import("..").APIApplicationCommandInteractionDataOption[], parent?: import("..").Command | undefined, guildId?: string | undefined, resolved?: import("..").ContextOptionsResolved | undefined): OptionResolverStructure;
+    Entitlement(client: import("..").UsingClient, data: import("..").APIEntitlement): EntitlementStructure;
 };
 export type InferCustomStructure<T, N extends string> = CustomStructures extends Record<N, infer P> ? P : T;

package/lib/client/workerclient.d.ts

@@ -1,6 +1,6 @@
 import { type Awaitable, type DeepPartial, type MakeRequired, type When } from '../common';
 import { EventHandler } from '../events';
-import type { GatewayDispatchPayload } from '../types';
+import { type GatewayDispatchPayload } from '../types';
 import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
@@ -12,6 +12,7 @@ import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client, ClientOptions } from './client';
 import { Collectors } from './collectors';
+import { type RegisteredPluginExtension } from './plugins';
 import { type ClientUserStructure } from './transformers';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     memberUpdateHandler: MemberUpdateHandler;
@@ -47,13 +48,21 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
     tellWorkers<R, V extends Record<string, unknown>>(func: (_: this, vars: V) => R, vars: V): Promise<Awaited<R>[]>;
     createShard(id: number, data: Pick<ManagerSpawnShards, 'info' | 'compress' | 'properties'>): Shard;
     resumeShard(shardId: number, shardData: MakeRequired<ShardData>): Promise<unknown>;
-    protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
+    protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<GatewayDispatchPayload | null>;
+}
+export interface WorkerClient<Ready extends boolean = boolean> extends RegisteredPluginExtension {
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
 export interface WorkerClientOptions extends BaseClientOptions {
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
+    /**
+     * @deprecated Use shard disconnect events instead. Injected ShardManager callbacks can double-fire.
+     */
     onShardDisconnect?: ShardManagerOptions['onShardDisconnect'];
+    /**
+     * @deprecated Use shard reconnect events instead. Injected ShardManager callbacks can double-fire.
+     */
     onShardReconnect?: ShardManagerOptions['onShardReconnect'];
     gateway?: ClientOptions['gateway'];
     postMessage?: (body: unknown) => Awaitable<unknown>;

package/lib/client/workerclient.js

@@ -7,11 +7,13 @@ const __1 = require("..");
 const cache_1 = require("../cache");
 const common_1 = require("../common");
 const events_1 = require("../events");
+const types_1 = require("../types");
 const websocket_1 = require("../websocket");
 const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
 const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
 const collectors_1 = require("./collectors");
+const plugins_1 = require("./plugins");
 const transformers_1 = require("./transformers");
 let workerData;
 let manager;
@@ -61,6 +63,8 @@ class WorkerClient extends base_1.BaseClient {
         return workerData.workerId;
     }
     get latency() {
+        if (this.shards.size <= 0)
+            return 0;
         let acc = 0;
         this.shards.forEach(s => (acc += s.latency));
         return acc / this.shards.size;
@@ -98,9 +102,7 @@ class WorkerClient extends base_1.BaseClient {
         }
         if (workerData.mode !== 'custom')
             (manager ?? process).on('message', (data) => this.handleManagerMessages(data));
-        this.logger = new __1.Logger({
-            name: `[Worker #${workerData.workerId}]`,
-        });
+        this.configureLogger({ name: `[Worker #${workerData.workerId}]` }, this.options.logger);
         if (workerData.debug) {
             this.debugger = new __1.Logger({
                 name: `[Worker #${workerData.workerId}]`,
@@ -116,21 +118,24 @@ class WorkerClient extends base_1.BaseClient {
                 }),
             });
         }
-        this.cache.intents = workerData.intents;
+        this.resolvePluginGatewayIntents(workerData.intents);
         this.rest.workerData = workerData;
+        await super.start(options);
+        workerData.intents = this.resolvePluginGatewayIntents(workerData.intents);
         this.postMessage({
             type: workerData.resharding ? 'WORKER_START_RESHARDING' : 'WORKER_START',
             workerId: workerData.workerId,
         });
-        await super.start(options);
         await this.loadEvents(options.eventsDir);
     }
     async loadEvents(dir) {
         dir ??= await this.getRC().then(x => x.locations.events);
+        await (0, plugins_1.runPluginHooks)(this, 'events:beforeLoad', this, dir);
         if (dir) {
             await this.events.load(dir);
             this.logger.info('EventHandler loaded');
         }
+        await (0, plugins_1.runPluginHooks)(this, 'events:afterLoad', this, dir);
     }
     postMessage(body) {
         if (manager)
@@ -157,12 +162,13 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     const shard = this.shards.get(data.shardId);
                     if (!shard) {
-                        this.logger.fatal('Worker trying send payload by non-existent shard');
+                        this.logger.fatal(`Worker trying to send payload by non-existent shard (#${data.shardId})`);
                         return;
                     }
-                    await shard.send(true, {
-                        ...data,
-                    });
+                    const { nonce: _nonce, shardId: _shardId, type: _type, ...payload } = data;
+                    const pluginPayload = await (0, plugins_1.applyPluginGatewaySendPayloadWrappers)(this, data.shardId, payload);
+                    if (pluginPayload !== null)
+                        await shard.send(true, pluginPayload);
                     this.postMessage({
                         type: 'RESULT_PAYLOAD',
                         nonce: data.nonce,
@@ -174,7 +180,7 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     const shard = this.resharding.get(data.shardId);
                     if (!shard) {
-                        this.logger.fatal('Worker trying reshard non-existent shard');
+                        this.logger.fatal(`Worker trying to reshard non-existent shard (#${data.shardId})`);
                         return;
                     }
                     shard.options.presence = data.presence;
@@ -185,7 +191,7 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     const shard = this.shards.get(data.shardId);
                     if (!shard) {
-                        this.logger.fatal('Worker trying connect non-existent shard');
+                        this.logger.fatal(`Worker trying to connect non-existent shard (#${data.shardId})`);
                         return;
                     }
                     shard.options.presence = data.presence;
@@ -215,7 +221,7 @@ class WorkerClient extends base_1.BaseClient {
                                 ...this.options.gateway?.properties,
                             },
                             handlePayload(_, payload) {
-                                if (payload.t !== 'GUILDS_READY')
+                                if (payload.t !== types_1.GatewayDispatchEvents.GuildsReady)
                                     return;
                                 if (++shardsConnected === workerData.shards.length) {
                                     self.postMessage({
@@ -256,7 +262,7 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     const shard = this.shards.get(data.shardId);
                     if (!shard) {
-                        this.logger.fatal('Worker trying get non-existent shard');
+                        this.logger.fatal(`Worker trying to get non-existent shard (#${data.shardId})`);
                         return;
                     }
                     this.postMessage({
@@ -414,13 +420,13 @@ class WorkerClient extends base_1.BaseClient {
             },
             async handlePayload(shardId, payload) {
                 await handlePayload?.(shardId, payload);
-                await onPacket(payload, shardId);
-                if (self.options.sendPayloadToParent)
+                const pluginPacket = await onPacket(payload, shardId);
+                if (self.options.sendPayloadToParent && pluginPacket !== null)
                     self.postMessage({
                         workerId: workerData.workerId,
                         shardId,
                         type: 'RECEIVE_PAYLOAD',
-                        payload,
+                        payload: pluginPacket,
                     });
             },
         });
@@ -447,6 +453,10 @@ class WorkerClient extends base_1.BaseClient {
         });
     }
     async onPacket(packet, shardId) {
+        const pluginPacket = await (0, plugins_1.applyPluginGatewayDispatchInterceptors)(this, shardId, packet);
+        if (pluginPacket === null)
+            return null;
+        packet = pluginPacket;
         Promise.allSettled([
             this.events.runEvent('RAW', this, packet, shardId, false),
             this.collectors.run('RAW', packet, this),
@@ -455,7 +465,7 @@ class WorkerClient extends base_1.BaseClient {
             case 'GUILD_MEMBER_UPDATE':
                 {
                     if (!this.memberUpdateHandler.check(packet.d)) {
-                        return;
+                        return packet;
                     }
                     await this.events.execute(packet, this, shardId);
                 }
@@ -463,26 +473,26 @@ class WorkerClient extends base_1.BaseClient {
             case 'PRESENCE_UPDATE':
                 {
                     if (!this.presenceUpdateHandler.check(packet.d)) {
-                        return;
+                        return packet;
                     }
                     await this.events.execute(packet, this, shardId);
                 }
                 break;
             default: {
                 switch (packet.t) {
-                    case 'INTERACTION_CREATE':
+                    case types_1.GatewayDispatchEvents.InteractionCreate:
                         {
                             await this.events.execute(packet, this, shardId);
                             await this.handleCommand.interaction(packet.d, shardId);
                         }
                         break;
-                    case 'MESSAGE_CREATE':
+                    case types_1.GatewayDispatchEvents.MessageCreate:
                         {
                             await this.events.execute(packet, this, shardId);
                             await this.handleCommand.message(packet.d, shardId);
                         }
                         break;
-                    case 'READY': {
+                    case types_1.GatewayDispatchEvents.Ready: {
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
                         this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
@@ -497,7 +507,7 @@ class WorkerClient extends base_1.BaseClient {
                         this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         break;
                     }
-                    case 'GUILDS_READY':
+                    case types_1.GatewayDispatchEvents.GuildsReady:
                         {
                             if ([...this.shards.values()].every(shard => shard.isReady)) {
                                 this.postMessage({
@@ -516,6 +526,7 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             }
         }
+        return packet;
     }
 }
 exports.WorkerClient = WorkerClient;

package/lib/collection.d.ts

@@ -46,7 +46,10 @@ export declare class Collection<K, V> extends Map<K, V> {
      * const filteredArray = collection.filter((value, key) => key % 2 === 0);
      * console.log(filteredArray); // Output: ['two']
      */
+    filter<S extends V>(fn: (value: V, key: K, collection: this) => value is S): S[];
     filter(fn: (value: V, key: K, collection: this) => boolean): V[];
+    filterCollection<S extends V>(fn: (value: V, key: K, collection: this) => value is S): Collection<K, S>;
+    filterCollection(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V>;
     /**
      * Apply a function against an accumulator and each element in the collection (from left to right) to reduce it to a single value.
      * @param fn The function to execute on each element in the collection.
@@ -99,6 +102,7 @@ export declare class Collection<K, V> extends Map<K, V> {
      * const firstEvenValue = collection.find(value => value % 2 === 0);
      * console.log(firstEvenValue); // Output: 2
      */
+    find<S extends V>(fn: (value: V, key: K, collection: this) => value is S): S | undefined;
     find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
     /**
      * Returns the first key in the collection that satisfies the provided testing function.
@@ -114,7 +118,7 @@ export declare class Collection<K, V> extends Map<K, V> {
      */
     findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined;
 }
-type LimitedCollectionData<V> = {
+export type LimitedCollectionData<V> = {
     expire: number;
     expireOn: number;
     value: V;
@@ -242,13 +246,11 @@ export declare class LimitedCollection<K, V> {
     private stopTimeout;
     private startTimeout;
     keys(): MapIterator<K>;
-    values(): Generator<{
-        value: V;
-        expire: number;
-        expireOn: number;
-    }, void, unknown>;
-    entries(): Generator<[K, LimitedCollectionData<V>], void, unknown>;
+    values(): IterableIterator<V>;
+    rawValues(): IterableIterator<LimitedCollectionData<V>>;
+    entries(): IterableIterator<[K, V]>;
+    rawEntries(): IterableIterator<[K, LimitedCollectionData<V>]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
     clear(): void;
     private clearExpired;
 }
-export {};

package/lib/collection.js

@@ -50,19 +50,6 @@ class Collection extends Map {
         }
         return result;
     }
-    /**
-     * Creates a new array with all elements that pass the test implemented by the provided function.
-     * @param fn The function to test each element of the collection.
-     * @param thisArg The value to use as `this` when executing the filter function.
-     * @returns A new array with the elements that pass the test.
-     * @example
-     * const collection = new Collection<number, string>();
-     * collection.set(1, 'one');
-     * collection.set(2, 'two');
-     * collection.set(3, 'three');
-     * const filteredArray = collection.filter((value, key) => key % 2 === 0);
-     * console.log(filteredArray); // Output: ['two']
-     */
     filter(fn) {
         const result = [];
         for (const [key, value] of this.entries()) {
@@ -71,6 +58,14 @@ class Collection extends Map {
         }
         return result;
     }
+    filterCollection(fn) {
+        const result = new Collection();
+        for (const [key, value] of this.entries()) {
+            if (fn(value, key, this))
+                result.set(key, value);
+        }
+        return result;
+    }
     /**
      * Apply a function against an accumulator and each element in the collection (from left to right) to reduce it to a single value.
      * @param fn The function to execute on each element in the collection.
@@ -141,18 +136,6 @@ class Collection extends Map {
         }
         return false;
     }
-    /**
-     * Returns the value of the first element in the collection that satisfies the provided testing function.
-     * @param fn The function to test each element of the collection.
-     * @returns The value of the first element that passes the test. `undefined` if no element passes the test.
-     * @example
-     * const collection = new Collection<number, number>();
-     * collection.set(1, 1);
-     * collection.set(2, 2);
-     * collection.set(3, 3);
-     * const firstEvenValue = collection.find(value => value % 2 === 0);
-     * console.log(firstEvenValue); // Output: 2
-     */
     find(fn) {
         for (const [key, value] of this.entries()) {
             if (fn(value, key, this)) {
@@ -210,6 +193,8 @@ class LimitedCollection {
     _closerDirty = true;
     constructor(options = {}) {
         this.options = (0, common_1.MergeOptions)(LimitedCollection.default, options);
+        if (Number.isNaN(this.options.limit))
+            throw new TypeError('LimitedCollection limit cannot be NaN');
     }
     /**
      * Adds an element to the limited collection.
@@ -435,6 +420,9 @@ class LimitedCollection {
         return this.data.keys();
     }
     values() {
+        return this.data.values();
+    }
+    rawValues() {
         return (function* (self) {
             for (const key of self.data.keys()) {
                 yield self.raw(key);
@@ -442,12 +430,18 @@ class LimitedCollection {
         })(this);
     }
     entries() {
+        return this.data.entries();
+    }
+    rawEntries() {
         return (function* (self) {
             for (const key of self.data.keys()) {
                 yield [key, self.raw(key)];
             }
         })(this);
     }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
     clear() {
         this.data.clear();
         this.expirations.clear();

package/lib/commands/applications/chat.d.ts

@@ -1,27 +1,28 @@
 import type { PermissionStrings, SeyfertBaseChoiceableOption, SeyfertBasicOption, SeyfertChoice } from '../..';
 import type { Attachment } from '../../builders';
+import type { PluginMiddlewareDenialMetadata } from '../../client/plugins/types';
 import type { GuildMemberStructure, GuildRoleStructure, InteractionGuildMemberStructure, UserStructure } from '../../client/transformers';
 import type { AllChannels, AutocompleteInteraction } from '../../structures';
 import { type APIApplicationCommandBasicOption, type APIApplicationCommandOption, ApplicationCommandOptionType, ApplicationCommandType, type ApplicationIntegrationType, type InteractionContextType, type LocaleString } from '../../types';
-import type { Groups, RegisteredMiddlewares } from '../decorators';
+import type { Groups, ResolvedRegisteredMiddlewares } from '../decorators';
 import type { CommandOptionWithType } from '../handle';
 import type { CommandContext } from './chatcontext';
 import type { ExtraProps, IgnoreCommand, OnOptionsReturnObject, SeyfertChannelMap, UsingClient } from './shared';
 export interface ReturnOptionsTypes {
-    1: never;
-    2: never;
-    3: string;
-    4: number;
-    5: boolean;
-    6: InteractionGuildMemberStructure | UserStructure;
-    7: AllChannels;
-    8: GuildRoleStructure;
-    9: GuildRoleStructure | InteractionGuildMemberStructure | GuildMemberStructure | UserStructure;
-    10: number;
-    11: Attachment;
+    [ApplicationCommandOptionType.Subcommand]: never;
+    [ApplicationCommandOptionType.SubcommandGroup]: never;
+    [ApplicationCommandOptionType.String]: string;
+    [ApplicationCommandOptionType.Integer]: number;
+    [ApplicationCommandOptionType.Boolean]: boolean;
+    [ApplicationCommandOptionType.User]: InteractionGuildMemberStructure | UserStructure;
+    [ApplicationCommandOptionType.Channel]: AllChannels;
+    [ApplicationCommandOptionType.Role]: GuildRoleStructure;
+    [ApplicationCommandOptionType.Mentionable]: GuildRoleStructure | InteractionGuildMemberStructure | GuildMemberStructure | UserStructure;
+    [ApplicationCommandOptionType.Number]: number;
+    [ApplicationCommandOptionType.Attachment]: Attachment;
 }
-export type AutocompleteCallback = (interaction: AutocompleteInteraction) => any;
-export type OnAutocompleteErrorCallback = (interaction: AutocompleteInteraction, error: unknown) => any;
+export type AutocompleteCallback<ValueType extends string | number = string | number> = (interaction: AutocompleteInteraction<boolean, ValueType>) => any;
+export type OnAutocompleteErrorCallback<ValueType extends string | number = string | number> = (interaction: AutocompleteInteraction<boolean, ValueType>, error: unknown) => any;
 export type CommandBaseOption = SeyfertBaseChoiceableOption<ApplicationCommandOptionType> | SeyfertBasicOption<ApplicationCommandOptionType>;
 export type CommandBaseAutocompleteOption = (SeyfertBasicOption<ApplicationCommandOptionType> | SeyfertBaseChoiceableOption<ApplicationCommandOptionType>) & {
     autocomplete: AutocompleteCallback;
@@ -44,9 +45,9 @@ type ContextOptionsAuxInternal<T extends CommandBaseOption & {
     type: ApplicationCommandOptionType;
 }> = T['value'] extends (...args: any) => any ? Parameters<Parameters<T['value']>[1]>[0] : NonNullable<T['value']> extends (...args: any) => any ? Parameters<Parameters<NonNullable<T['value']>>[1]>[0] extends never ? T extends {
     channel_types?: infer C;
-} ? C extends any[] ? C[number] extends keyof SeyfertChannelMap ? SeyfertChannelMap[C[number]] : never : never : T extends {
+} ? C extends readonly any[] ? C[number] extends keyof SeyfertChannelMap ? SeyfertChannelMap[C[number]] : never : never : T extends {
     choices?: infer C;
-} ? C extends SeyfertChoice<string | number>[] ? C[number]['value'] : never : never : Parameters<Parameters<NonNullable<T['value']>>[1]>[0] : ReturnOptionsTypes[T['type']];
+} ? C extends readonly SeyfertChoice<string | number>[] ? C[number]['value'] : never : never : Parameters<Parameters<NonNullable<T['value']>>[1]>[0] : ReturnOptionsTypes[T['type']];
 type ContextOptionsAux<T extends OptionsRecord> = {
     [K in Exclude<keyof T, KeysWithoutRequired<T>>]: ContextOptionsAuxInternal<T[K]>;
 } & {
@@ -54,7 +55,7 @@ type ContextOptionsAux<T extends OptionsRecord> = {
 };
 export type ContextOptions<T extends OptionsRecord> = ContextOptionsAux<T>;
 export declare class BaseCommand {
-    middlewares: (keyof RegisteredMiddlewares)[];
+    middlewares: readonly (keyof ResolvedRegisteredMiddlewares)[];
     __filePath?: string;
     __t?: {
         name: string | undefined;
@@ -76,6 +77,7 @@ export declare class BaseCommand {
     ignore?: IgnoreCommand;
     aliases?: string[];
     props: ExtraProps;
+    private static __getMiddlewareOwnerName;
     toJSON(): {
         name: BaseCommand["name"];
         type: BaseCommand["type"];
@@ -95,7 +97,7 @@ export declare class BaseCommand {
     onAfterRun?(context: CommandContext, error: unknown | undefined): any;
     onRunError?(context: CommandContext, error: unknown): any;
     onOptionsError?(context: CommandContext, metadata: OnOptionsReturnObject): any;
-    onMiddlewaresError?(context: CommandContext, error: string): any;
+    onMiddlewaresError?(context: CommandContext, error: string, metadata: PluginMiddlewareDenialMetadata): any;
     onBotPermissionsFail?(context: CommandContext, permissions: PermissionStrings): any;
     onPermissionsFail?(context: CommandContext, permissions: PermissionStrings): any;
     onInternalError?(client: UsingClient, command: Command | SubCommand, error?: unknown): any;

package/lib/commands/applications/chat.js

@@ -79,39 +79,56 @@ class BaseCommand {
         if (!middlewares.length) {
             return Promise.resolve({});
         }
+        const missingMiddlewares = middlewares.filter(middleware => !context.client.middlewares?.[middleware]);
+        if (missingMiddlewares.length) {
+            const owner = BaseCommand.__getMiddlewareOwnerName(context);
+            const message = `${owner} has ${global ? 'global ' : ''}middleware${missingMiddlewares.length === 1 ? '' : 's'} ${missingMiddlewares
+                .map(middleware => `"${String(middleware)}"`)
+                .join(', ')} assigned, but ${missingMiddlewares.length === 1 ? 'it is' : 'they are'} not registered.`;
+            context.client.logger.warn(message);
+        }
+        const activeMiddlewares = middlewares.filter(middleware => context.client.middlewares?.[middleware]);
+        if (!activeMiddlewares.length)
+            return Promise.resolve({});
         let index = 0;
         return new Promise((res, rej) => {
             let running = true;
-            const pass = () => {
-                if (!running) {
-                    return;
-                }
-                running = false;
-                return res({ pass: true });
-            };
             function next(...args) {
                 if (!running) {
                     return;
                 }
                 if (args.length) {
-                    context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = args[0];
+                    context[global ? 'globalMetadata' : 'metadata'][activeMiddlewares[index]] = args[0];
                 }
-                if (++index >= middlewares.length) {
+                if (++index >= activeMiddlewares.length) {
                     running = false;
                     return res({});
                 }
-                void invoke(middlewares[index]);
+                void invoke(activeMiddlewares[index]);
             }
-            const stop = err => {
+            const deny = (err, middleware) => {
                 if (!running) {
                     return;
                 }
                 running = false;
-                return res({ error: err });
+                return res({
+                    error: err,
+                    metadata: { middleware: String(middleware), scope: global ? 'global' : 'command' },
+                });
+            };
+            const stop = err => {
+                if (err == null) {
+                    if (!running) {
+                        return;
+                    }
+                    running = false;
+                    return res({ pass: true });
+                }
+                return deny(err, activeMiddlewares[index]);
             };
             async function invoke(middleware) {
                 try {
-                    await context.client.middlewares[middleware]({ context, next, stop, pass });
+                    await context.client.middlewares[middleware]({ context, next, stop });
                 }
                 catch (err) {
                     if (!running) {
@@ -121,9 +138,17 @@ class BaseCommand {
                     rej(err);
                 }
             }
-            void invoke(middlewares[0]);
+            void invoke(activeMiddlewares[0]);
         });
     }
+    static __getMiddlewareOwnerName(context) {
+        const command = context.command;
+        if (command?.name)
+            return `Command "${command.name}"`;
+        if (typeof command?.customId === 'string')
+            return `Component "${command.customId}"`;
+        return 'Command';
+    }
     /** @internal */
     __runMiddlewares(context) {
         return BaseCommand.__runMiddlewares(context, this.middlewares, false);