meocord 4.2.1 → 4.2.3

package/dist/esm/core/dispatcher.js

@@ -1,5 +1,6 @@
-import { getAutocompleteHandlers, getReactionHandlers, getMessageHandlers, matchesEmoji } from '../decorator/controller.decorator.js';
-import { hasCustomId, describeInteraction, focusedOptionName, resolveCommandPaths, resolveOptionParams, matchesCommandType } from '../util/interaction.util.js';
+import { getReactionHandlers, getMessageHandlers, matchesEmoji } from '../decorator/controller.decorator.js';
+import { hasCustomId, describeInteraction, resolveOptionParams, matchesCommandType } from '../util/interaction.util.js';
+import { buildAutocompleteRoutes, matchAutocompleteRoute } from './autocomplete-routes.js';
 import { buildComponentRoutes, matchComponentRoute } from './component-routes.js';
 import { handleUnroutedError, observeUnclaimed, runHandler, runInAppTheme, globalStagesOf, appPresenterOf } from './handler-pipeline.js';
 import { helpWords, isListable, matchHelpRequest, computeMessageHelp, helpInvocation, renderMessageHelp, splitReply } from './message-help.js';
@@ -12,7 +13,7 @@ import { handlerInput } from './handler-input.js';
 import { matchCommandRoute } from './command-routes.js';
 import { runGuards } from './guard-runner.js';
 import { HandlerRegistry, shareMessageRoutes } from './handler-registry.js';
-import { matchMessageRoute, matchMessageCommand, messageStartsFor, usesAppPrefix, matchMessageSubcommands, commandWordsOf, messageStarts, buildMessageRoutes } from './message-routes.js';
+import { matchMessageRoute, matchMessageCommand, hasMessageText, messageStartsFor, usesAppPrefix, matchMessageSubcommands, commandWordsOf, messageStarts, buildMessageRoutes, messageRouteWarnings } from './message-routes.js';
 import { subcommandUsageError, messageCommandHooks } from './message-params.js';
 import { CommandNotFoundError } from '../common/errors.js';
 import { existingResponse } from '../common/response/response-state.js';
@@ -83,13 +84,19 @@ import { existingResponse } from '../common/response/response-state.js';
             this.logger.warn(`messages.help is on, but ${route.controllerClass.name}.${route.method} (${JSON.stringify(route.pattern)}) takes "${shown}", ` + `which runs it instead, so the built-in help never answers. Turn help off, or give the handler another word.`);
         }
     }
-    /** The call for one event: the fallback, told of each error that reaches it when there is a recorder. */ callFor(record, startedAt) {
+    /**
+   * The call for one event, stamped as it is made, so every handler it runs reports one start and a duration that
+   * includes routing and any handler that ran before it; the fallback is told of each error that reaches it when there
+   * is a recorder.
+   */ callFor(record) {
         const fallback = record ? async (error, context)=>{
             record.unhandled(error);
-            return this.fallback(error, context);
+            const failure = await this.fallback(error, context);
+            if (failure !== undefined) record.unanswered(error, failure);
+            return failure;
         } : this.fallback;
         return {
-            startedAt,
+            startedAt: performance.now(),
             fallback,
             record
         };
@@ -100,32 +107,35 @@ import { existingResponse } from '../common/response/response-state.js';
         }
         return this.controllerInstancesCache.get(controllerClass);
     }
+    /**
+   * Runs `run` on the controller's instance, resolved as its handler starts. A controller that cannot be made fails
+   * only its own handlers: the error goes to the global filters, then the fallback, and the call goes on without it.
+   */ async withInstance(controllerClass, args, call, run, unresolved = new Set()) {
+        // A controller that failed to resolve for this event is reported once, however many of its handlers it reaches
+        if (unresolved.has(controllerClass)) return;
+        let instance;
+        try {
+            instance = this.getInstance(controllerClass);
+        } catch (error) {
+            unresolved.add(controllerClass);
+            await handleUnroutedError(this.container, args, error, this.runOptions(call));
+            return;
+        }
+        await run(instance);
+    }
     /** The component routes, built on first use; the app calls it as it is created. */ getComponentRoutes() {
         return this.componentRoutes ?? (this.componentRoutes = buildComponentRoutes([
             ...this.controllerClasses
         ]));
     }
     getAutocompleteRoutes() {
-        if (this.autocompleteRoutes) return this.autocompleteRoutes;
-        const routes = [];
-        for (const controllerClass of this.controllerClasses){
-            for (const meta of getAutocompleteHandlers(this.getInstance(controllerClass))){
-                routes.push({
-                    controllerClass,
-                    meta
-                });
-            }
-        }
-        routes.sort((a, b)=>Number(Boolean(b.meta.optionName)) - Number(Boolean(a.meta.optionName)));
-        this.autocompleteRoutes = routes;
-        return routes;
+        return this.autocompleteRoutes ?? (this.autocompleteRoutes = buildAutocompleteRoutes(this.controllerClasses));
     }
     /**
    * Dispatches an interaction. A failure outside any handler, such as no route matching or resolving
    * the controller, goes to the global filters, then the fallback.
    */ async interaction(interaction, record) {
-        // From the moment it arrives, so an observer's duration includes routing
-        const call = this.callFor(record, performance.now());
+        const call = this.callFor(record);
         try {
             await this.dispatchInteraction(interaction, call);
         } catch (error) {
@@ -151,14 +161,14 @@ import { existingResponse } from '../common/response/response-state.js';
             if (matched) {
                 const { route, params } = matched;
                 interaction.dynamicParams = params;
-                await this.executeCommand(this.getInstance(route.controllerClass), route.meta, interaction, call);
+                await this.executeCommand(route.controllerClass, route.meta, interaction, call);
                 return;
             }
         }
         // The same match a test's invoke checks a handler against, so the two cannot disagree
         const command = matchCommandRoute(this.controllerClasses, interaction);
         if (command) {
-            await this.executeCommand(this.getInstance(command.controllerClass), command.meta, interaction, call);
+            await this.executeCommand(command.controllerClass, command.meta, interaction, call);
             return;
         }
         // A component or modal no route takes may be a collector's: with another listener on the client, it has the
@@ -181,21 +191,17 @@ import { existingResponse } from '../common/response/response-state.js';
    * Answers an autocomplete interaction from the `@Autocomplete` handler that claims it. An unclaimed
    * option gets an empty list and a warning, rather than a menu stuck loading until Discord times out.
    */ async handleAutocomplete(interaction, call) {
-        const focusedName = focusedOptionName(interaction);
-        for (const path of resolveCommandPaths(interaction)){
-            for (const { controllerClass, meta } of this.getAutocompleteRoutes()){
-                if (meta.commandPath !== path) continue;
-                if (meta.optionName !== undefined && meta.optionName !== focusedName) continue;
-                const controllerInstance = this.getInstance(controllerClass);
-                this.logger.log('[AUTOCOMPLETE]', `[${path}]`, `[${meta.methodName}]`);
-                const params = resolveOptionParams(interaction);
-                const ran = await this.invokeHandler(controllerInstance, meta.methodName, [
-                    interaction,
-                    params
-                ], call);
-                if (!ran) await closeAutocomplete(interaction, this.logger);
-                return;
-            }
+        const route = matchAutocompleteRoute(this.getAutocompleteRoutes(), interaction);
+        if (route) {
+            const { controllerClass, meta } = route;
+            this.logger.log('[AUTOCOMPLETE]', `[${meta.commandPath}]`, `[${meta.methodName}]`);
+            const params = resolveOptionParams(interaction);
+            const ran = await this.invokeHandler(this.getInstance(controllerClass), meta.methodName, [
+                interaction,
+                params
+            ], call);
+            if (!ran) await closeAutocomplete(interaction, this.logger);
+            return;
         }
         this.logger.warn(`No handler matched ${describeInteraction(interaction)}. Declare an @Autocomplete handler for it, ` + `or drop setAutocomplete(true) from the option.`);
         await closeAutocomplete(interaction, this.logger);
@@ -203,19 +209,22 @@ import { existingResponse } from '../common/response/response-state.js';
             interaction
         ], this.runOptions(call));
     }
-    /** Warns, in development, that a modal field or select menu choice is hidden by a customId param of the same name. */ warnCollisions(methodName, names) {
+    /** Warns, in development, that a modal field or select menu choice is hidden by a customId param of the same name. */ warnCollisions(controllerClass, methodName, names) {
         if (process.env.NODE_ENV !== 'development') return;
+        let warned = this.warnedCollisions.get(controllerClass);
+        if (!warned) this.warnedCollisions.set(controllerClass, warned = new Set());
         for (const name of names){
             const key = `${methodName}:${name}`;
-            if (this.warnedCollisions.has(key)) continue;
-            this.warnedCollisions.add(key);
-            this.logger.warn(`"${name}" is both a customId param and a modal field or select menu choice of ${methodName}; the handler receives the customId ` + `param. Rename one to receive both.`);
+            if (warned.has(key)) continue;
+            warned.add(key);
+            this.logger.warn(`"${name}" is both a customId param and a modal field or select menu choice of ${controllerClass.name}.${methodName}; the handler ` + `receives the customId param. Rename one to receive both.`);
         }
     }
     /**
    * Runs a resolved command, shared by both dispatch paths so a pattern-matched
    * component and a named slash command behave identically once the route is chosen.
-   */ async executeCommand(controllerInstance, commandMetadata, interaction, call) {
+   */ async executeCommand(controllerClass, commandMetadata, interaction, call) {
+        const controllerInstance = this.getInstance(controllerClass);
         const { methodName, type } = commandMetadata;
         // No interaction-type check here: both callers pick the route with
         // `matchesCommandType` before getting this far, and `@Command` re-checks the
@@ -223,7 +232,7 @@ import { existingResponse } from '../common/response/response-state.js';
         this.logger.log('[INTERACTION]', `[${type}]`, `[${methodName}]`);
         const routeParams = interaction.dynamicParams;
         const { params, collisions } = handlerInput(interaction, routeParams);
-        this.warnCollisions(methodName, collisions);
+        this.warnCollisions(controllerClass, methodName, collisions);
         await this.invokeHandler(controllerInstance, methodName, [
             interaction,
             params
@@ -241,10 +250,7 @@ import { existingResponse } from '../common/response/response-state.js';
    * says whether the handler ran. Its guard wrappers let this call through, so each guard runs once.
    */ async invokeHandler(instance, methodName, args, call, hooks = {}) {
         const handler = `${instance.constructor.name}.${methodName}`;
-        const onUnanswered = this.options.warnUnanswered ? (phase, returnedBy)=>this.warnUnansweredOnce(handler, phase, returnedBy && {
-                name: returnedBy.interceptor.name,
-                handlerStarted: returnedBy.handlerStarted
-            }) : undefined;
+        const onUnanswered = this.options.warnUnanswered ? (unanswered)=>this.warnUnansweredOnce(handler, unanswered) : undefined;
         const outcome = await runHandler(this.container, instance, methodName, args, {
             ...this.runOptions(call),
             onUnanswered,
@@ -254,13 +260,17 @@ import { existingResponse } from '../common/response/response-state.js';
         return outcome.ran;
     }
     /**
-   * Warns, once per handler, that it left its interaction unanswered or deferred without a follow-up, or that
-   * `interceptor` returned before the handler ran or finished, and the call ended so.
-   */ warnUnansweredOnce(handler, phase, interceptor) {
+   * Warns, once per handler, that it left its interaction or autocomplete unanswered or deferred without a follow-up,
+   * or that an interceptor returned before the handler ran or finished, and the call ended so.
+   */ warnUnansweredOnce(handler, { type, phase, returnedBy }) {
         if (this.warnedUnanswered.has(handler)) return;
         this.warnedUnanswered.add(handler);
+        const interceptor = returnedBy && {
+            name: returnedBy.interceptor.name,
+            handlerStarted: returnedBy.handlerStarted
+        };
         const returned = interceptor && `${handler}: its interceptor ${interceptor.name} returned before the handler ${interceptor.handlerStarted ? 'finished' : 'ran'}`;
-        const what = interceptor ? phase === 'unanswered' ? `${returned}, without answering the interaction, so the user saw "The application did not respond". Answer it ` + `in ${interceptor.name}, or await next.handle().` : interceptor.handlerStarted ? `${returned}, and the deferred interaction had no follow-up when the call ended, so @Defer's lock was ` + `released while the user still saw it thinking. Follow up in ${interceptor.name} with respond(interaction).send(), ` + 'or await next.handle().' : `${returned}, and the deferred interaction was never followed up, so the user saw it thinking until Discord ` + `gave up. Follow up in ${interceptor.name} with respond(interaction).send(), or await next.handle().` : phase === 'unanswered' ? `${handler} finished without answering its interaction, so the user saw "The application did not respond". ` + 'Answer it with respond(interaction).send(), or acknowledge it first with @Defer().' : `${handler} deferred its interaction and never followed up, so the user saw it thinking until Discord gave up. ` + 'Follow up with respond(interaction).send().';
+        const what = type === 'autocomplete' ? `${handler} finished without answering its autocomplete, so the user saw its options fail to load. Answer it ` + 'with interaction.respond(choices) within 3 seconds.' : interceptor ? phase === 'unanswered' ? `${returned}, without answering the interaction, so the user saw "The application did not respond". Answer it ` + `in ${interceptor.name}, or await next.handle().` : interceptor.handlerStarted ? `${returned}, and the deferred interaction had no follow-up when the call ended, so @Defer's lock was ` + `released while the user still saw it thinking. Follow up in ${interceptor.name} with respond(interaction).send(), ` + 'or await next.handle().' : `${returned}, and the deferred interaction was never followed up, so the user saw it thinking until Discord ` + `gave up. Follow up in ${interceptor.name} with respond(interaction).send(), or await next.handle().` : phase === 'unanswered' ? `${handler} finished without answering its interaction, so the user saw "The application did not respond". ` + 'Answer it with respond(interaction).send(), or acknowledge it first with @Defer().' : `${handler} deferred its interaction and never followed up, so the user saw it thinking until Discord gave up. ` + 'Follow up with respond(interaction).send().';
         this.logger.warn(`${what} Shown once per handler; @MeoCord({ warnUnanswered: false }) turns it off.`);
     }
     /**
@@ -269,7 +279,7 @@ import { existingResponse } from '../common/response/response-state.js';
    * usage through that handler's filters. A bare parent's unguarded subcommands' usage, once the app's guards allow
    * it, and a failure to read the prefixes, go through the global filters, then the fallback; the listeners still run.
    */ async message(message, record) {
-        if (message.author.bot || !message.content?.trim()) return;
+        if (message.author.bot || !hasMessageText(message.content)) return;
         const call = this.callFor(record);
         let target;
         try {
@@ -296,24 +306,29 @@ import { existingResponse } from '../common/response/response-state.js';
         }
         // The matched handler, then every listener, each resolved from the container only as it starts
         const runs = [];
+        const unresolved = new Set();
         if (target) {
             const { route, params, start, given } = target;
             noteInvocation(message, `${start}${commandWordsOf(route.tokens).join(' ')}`);
             const hooks = messageCommandHooks(route, params, message, start, given, this.messageOptions.types);
             runs.push({
                 name: `${route.controllerClass.name}.${route.method}`,
-                run: (at)=>this.invokeHandler(this.getInstance(route.controllerClass), route.method, [
-                        message,
-                        params
-                    ], at, hooks)
+                run: (at)=>this.withInstance(route.controllerClass, [
+                        message
+                    ], at, (instance)=>this.invokeHandler(instance, route.method, [
+                            message,
+                            params
+                        ], at, hooks), unresolved)
             });
         }
         for (const { controllerClass, method } of this.messageListeners){
             runs.push({
                 name: `${controllerClass.name}.${method}`,
-                run: (at)=>this.invokeHandler(this.getInstance(controllerClass), method, [
+                run: (at)=>this.withInstance(controllerClass, [
                         message
-                    ], at)
+                    ], at, (instance)=>this.invokeHandler(instance, method, [
+                            message
+                        ], at), unresolved)
             });
         }
         if (this.messageOptions.handlers === 'concurrent') await this.runTogether(runs, call);
@@ -338,7 +353,8 @@ import { existingResponse } from '../common/response/response-state.js';
                 ...call,
                 record: {
                     settled: (...report)=>reports[index].push(report),
-                    unhandled: (error)=>record.unhandled(error)
+                    unhandled: (error)=>record.unhandled(error),
+                    unanswered: (error, failure)=>record.unanswered(error, failure)
                 }
             } : call)));
         for (const report of reports.flat())record?.settled(...report);
@@ -418,7 +434,7 @@ import { existingResponse } from '../common/response/response-state.js';
         const matching = this.controllerClasses.map((controllerClass)=>({
                 controllerClass,
                 // Handlers for this emoji first, then those for every emoji
-                handlers: getReactionHandlers(this.getInstance(controllerClass)).filter(forEmoji).sort((a, b)=>Number(!a.emoji) - Number(!b.emoji))
+                handlers: getReactionHandlers(controllerClass.prototype).filter(forEmoji).sort((a, b)=>Number(!a.emoji) - Number(!b.emoji))
             })).filter(({ handlers })=>handlers.length > 0);
         if (matching.length === 0) return;
         // Only asked when a matching handler leaves bots out, since a partial user costs a fetch
@@ -442,16 +458,21 @@ import { existingResponse } from '../common/response/response-state.js';
             return;
         }
         for (const { controllerClass, handlers } of runs){
-            const controllerInstance = this.getInstance(controllerClass);
-            for (const { method } of handlers){
-                await this.invokeHandler(controllerInstance, method, [
+            await this.withInstance(controllerClass, [
+                reaction,
+                {
+                    user,
+                    action
+                }
+            ], call, async (instance)=>{
+                for (const { method } of handlers)await this.invokeHandler(instance, method, [
                     reaction,
                     {
                         user,
                         action
                     }
                 ], call);
-            }
+            });
         }
     }
     /**
@@ -470,7 +491,10 @@ import { existingResponse } from '../common/response/response-state.js';
     constructor(options){
         this.options = options;
         this.controllerInstancesCache = new Map();
-        /** Handler and name pairs already warned about, so a collision warns once, not on every submit or selection. */ this.warnedCollisions = new Set();
+        /**
+   * Method and name pairs already warned about, by controller class, so a collision warns once per handler, not on
+   * every submit or selection. Keyed by the class itself, so two controllers of one name stay apart.
+   */ this.warnedCollisions = new WeakMap();
         /** The handlers already warned about, so each is named once however often it runs. */ this.warnedUnanswered = new Set();
         /** The message handlers already warned about as slow, so each is named once. */ this.warnedSlow = new Set();
         this.container = options.container;
@@ -485,6 +509,8 @@ import { existingResponse } from '../common/response/response-state.js';
         // The app's own help command reads this table too, so it lists the commands dispatch reaches
         if (this.container.isBound(HandlerRegistry)) shareMessageRoutes(this.container.get(HandlerRegistry), this.messageRoutes);
         this.warnUnreachableHelp();
+        // Here, where the routes are built once, rather than in buildMessageRoutes, which startup runs twice
+        for (const warning of messageRouteWarnings(this.messageRoutes, this.messageOptions))this.logger.warn(warning);
         this.messageListeners = this.controllerClasses.flatMap((controllerClass)=>getMessageHandlers(controllerClass.prototype).filter((handler)=>handler.pattern === undefined).map(({ method })=>({
                     controllerClass,
                     method

package/dist/esm/core/event-requirements.js

@@ -13,6 +13,22 @@ const REACTION_PARTIALS = [
     Partials.Message,
     Partials.Reaction
 ];
+const POLLS = [
+    GatewayIntentBits.GuildMessagePolls,
+    GatewayIntentBits.DirectMessagePolls
+];
+// discord.js drops a vote on a message it has not cached unless it may build the message, its poll and the answer
+const POLL_PARTIALS = [
+    Partials.Message,
+    Partials.Poll,
+    Partials.PollAnswer
+];
+// The partials whose warning names members and polls; the others keep the wording for messages, reactions and users
+const CACHED_ELSEWHERE = new Set([
+    Partials.GuildMember,
+    Partials.Poll,
+    Partials.PollAnswer
+]);
 /** The intents Discord only sends once they are also enabled for the app in the developer portal. */ const PRIVILEGED = new Set([
     GatewayIntentBits.GuildMembers,
     GatewayIntentBits.GuildPresences,
@@ -50,10 +66,9 @@ const REACTION_PARTIALS = [
                 ]
             }
         ])),
+    // A member that joins arrives whole; one that leaves or changes reaches its handler only if cached or with this partial
     ...Object.fromEntries([
         'guildMemberAdd',
-        'guildMemberRemove',
-        'guildMemberUpdate',
         'guildMemberAvailable',
         'threadMembersUpdate'
     ].map((event)=>[
@@ -66,6 +81,26 @@ const REACTION_PARTIALS = [
                 ]
             }
         ])),
+    guildMemberRemove: {
+        intents: [
+            [
+                GatewayIntentBits.GuildMembers
+            ]
+        ],
+        partials: [
+            Partials.GuildMember
+        ]
+    },
+    guildMemberUpdate: {
+        intents: [
+            [
+                GatewayIntentBits.GuildMembers
+            ]
+        ],
+        partials: [
+            Partials.GuildMember
+        ]
+    },
     guildAuditLogEntryCreate: {
         intents: [
             [
@@ -198,9 +233,7 @@ const REACTION_PARTIALS = [
         intents: [
             REACTIONS
         ],
-        partials: [
-            Partials.Reaction
-        ]
+        partials: REACTION_PARTIALS
     },
     typingStart: {
         intents: [
@@ -212,26 +245,20 @@ const REACTION_PARTIALS = [
     },
     messagePollVoteAdd: {
         intents: [
-            [
-                GatewayIntentBits.GuildMessagePolls,
-                GatewayIntentBits.DirectMessagePolls
-            ]
-        ]
+            POLLS
+        ],
+        partials: POLL_PARTIALS
     },
     messagePollVoteRemove: {
         intents: [
-            [
-                GatewayIntentBits.GuildMessagePolls,
-                GatewayIntentBits.DirectMessagePolls
-            ]
-        ]
+            POLLS
+        ],
+        partials: POLL_PARTIALS
     },
     ...Object.fromEntries([
         'guildScheduledEventCreate',
         'guildScheduledEventDelete',
-        'guildScheduledEventUpdate',
-        'guildScheduledEventUserAdd',
-        'guildScheduledEventUserRemove'
+        'guildScheduledEventUpdate'
     ].map((event)=>[
             event,
             {
@@ -242,6 +269,27 @@ const REACTION_PARTIALS = [
                 ]
             }
         ])),
+    // Each names its user by id alone, which discord.js reads from the cache unless this partial is on
+    guildScheduledEventUserAdd: {
+        intents: [
+            [
+                GatewayIntentBits.GuildScheduledEvents
+            ]
+        ],
+        partials: [
+            Partials.User
+        ]
+    },
+    guildScheduledEventUserRemove: {
+        intents: [
+            [
+                GatewayIntentBits.GuildScheduledEvents
+            ]
+        ],
+        partials: [
+            Partials.User
+        ]
+    },
     autoModerationRuleCreate: {
         intents: [
             [
@@ -355,7 +403,7 @@ function intentName(bit) {
         (labels.some((label)=>label.startsWith("@MessageHandler('")) ? "; messages: { mention: 'only' } needs none." : '.') : ''));
     }
     for (const [partial, labels] of missingPartials){
-        warnings.push(`Partials.${Partials[partial]} is not in clientOptions.partials, so ${labels.join(', ')} will miss ` + (partial === Partials.Channel ? 'direct messages: no DM channel is cached after the bot starts, and discord.js drops a message from a ' + 'channel it has not cached.' : 'events about messages, reactions or users the bot has not cached, such as messages sent before it started.'));
+        warnings.push(`Partials.${Partials[partial]} is not in clientOptions.partials, so ${labels.join(', ')} will miss ` + (partial === Partials.Channel ? 'direct messages: no DM channel is cached after the bot starts, and discord.js drops a message from a ' + 'channel it has not cached.' : CACHED_ELSEWHERE.has(partial) ? 'events about members or polls the bot has not cached, such as members who joined before it started.' : 'events about messages, reactions or users the bot has not cached, such as messages sent before it started.'));
     }
     return warnings;
 }

package/dist/esm/core/event-sources.js

@@ -0,0 +1,100 @@
+import { getEventHandlers } from '../decorator/event.decorator.js';
+import { prepareEventHandler } from './handler-pipeline.js';
+import { isAppClassToken } from './lifecycle-order.js';
+import { isClassProvider } from './providers.js';
+
+/**
+ * One source for each instance whose lifecycle hooks run, the cooldown store aside, in lifecycle order; read once the
+ * providers are made, as a value's or a factory's class is its instance's. A class `prepared` lacks has its handlers
+ * prepared here, and one a controller's would be refused for is left out, with `warn` naming the refusal.
+ */ function eventSources(container, providers, units, prepared, warn) {
+    // The tokens of each class the container makes, bound as itself or given as a provider's `useClass`, the cooldown
+    // store's included: no event reaches it, nor its instance through a factory
+    const classTokens = new Map();
+    for (const { token } of units){
+        const provider = providers.get(token);
+        if (provider && !isClassProvider(provider) || !provider && !isAppClassToken(token)) continue;
+        const cls = provider ? provider.useClass : token;
+        classTokens.set(cls, [
+            ...classTokens.get(cls) ?? [],
+            token
+        ]);
+    }
+    const names = new Map(prepared.map((cls)=>[
+            cls.name,
+            cls
+        ]));
+    const handlers = new Map();
+    const handlersOf = (cls)=>{
+        let found = handlers.get(cls);
+        if (!found) {
+            found = prepared.includes(cls) ? getEventHandlers(cls.prototype) : prepareClass(container, cls, names, warn);
+            handlers.set(cls, found);
+        }
+        return found;
+    };
+    const sources = [];
+    const given = new Set();
+    for (const { token, cooldownStore } of units){
+        // The cooldown store is the app's infrastructure, never one of its classes, so no event reaches it
+        if (cooldownStore) continue;
+        const provider = providers.get(token);
+        if (!provider || isClassProvider(provider)) {
+            const cls = provider ? provider.useClass : token;
+            const found = handlersOf(cls);
+            if (found.length > 0) sources.push({
+                cls,
+                handlers: found,
+                resolve: ()=>container.get(token)
+            });
+            continue;
+        }
+        // A value, or a factory's, made by now; one instance under several tokens is one source
+        const instance = container.get(token);
+        if (typeof instance !== 'object' || instance === null || given.has(instance)) continue;
+        given.add(instance);
+        const cls = instance.constructor;
+        if (typeof cls !== 'function') continue;
+        const found = handlersOf(cls);
+        if (found.length === 0) continue;
+        // A factory may return the instance the container made for a class unit, whose own source runs it; only units of
+        // the instance's class are resolved, and each resolves on the event through its own source anyway
+        const tokens = classTokens.get(cls) ?? [];
+        const owned = ()=>tokens.some((token)=>container.get(token) === instance);
+        sources.push({
+            cls,
+            handlers: found,
+            resolve: ()=>owned() ? undefined : instance
+        });
+    }
+    return sources;
+}
+/** The handlers of `cls` that pass a controller's checks, warning of each other one and why it does not run. */ function prepareClass(container, cls, names, warn) {
+    const declared = getEventHandlers(cls.prototype);
+    if (declared.length === 0) return [];
+    const other = names.get(cls.name);
+    if (!other) names.set(cls.name, cls);
+    // @Once tells classes apart by name, so this class's would share another's
+    const sharesName = other !== undefined && other !== cls && declared.some((handler)=>handler.once);
+    if (sharesName) {
+        refused(warn, cls, `${cls.name}: two classes have this name; @Cooldown and @Once tell classes apart by name, so they would share their counts. Rename one of them.`, declared.filter((handler)=>handler.once));
+    }
+    const errors = new Map();
+    return declared.filter((handler)=>{
+        if (sharesName && handler.once) return false;
+        let found = errors.get(handler.method);
+        if (!found) {
+            found = prepareEventHandler(container, cls, handler.method);
+            errors.set(handler.method, found);
+            const onMethod = declared.filter((other)=>other.method === handler.method && !(sharesName && other.once));
+            for (const error of found)refused(warn, cls, error.message, onMethod);
+        }
+        return found.length === 0;
+    });
+}
+function refused(warn, cls, reason, handlers) {
+    const labels = handlers.map(({ event, method, once })=>`@${once ? 'Once' : 'On'}('${event}') in ${cls.name}.${method}`);
+    warn(`${reason} Until the next major version (5.0) refuses it at startup, ${labels.join(', ')} does not run.`);
+}
+
+export { eventSources };

package/dist/esm/core/fallback.js

@@ -9,6 +9,7 @@ import { interactionLocale, translatorOfClient, messageLocale, renderText } from
 import { logFailedSend } from '../common/response/send-failure.js';
 import { presenterFor, fitText, TEXT_LIMITS, withSendableFiles, DEFAULT_ATTACHMENT_SIZE_LIMIT, attachmentsOf, renderEmbed, withoutFiles, isTooLarge, REFUSED_AS_TOO_LARGE } from '../common/response/presenter.js';
 import { escapeForLog, quoteForLog } from '../util/user-text.util.js';
+import { timerKeepsSeconds } from '../util/timer-limit.util.js';
 
 const UNKNOWN_INTERACTION = 10062;
 /** Discord's refusal of a direct message: the member's are closed, or they blocked the bot. */ const CANNOT_MESSAGE_USER = 50007;
@@ -280,7 +281,8 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
                     parse: []
                 }
             }));
-        if (seconds > 0) {
+        // Longer than a timer can wait keeps it, as 0 does; the timer would fire at once
+        if (seconds > 0 && timerKeepsSeconds(seconds)) {
             setTimeout(()=>{
                 reply.delete().catch((failure)=>logFailedSend(logger, 'delete a reply to a command', failure));
             }, seconds * 1000).unref?.();

package/dist/esm/core/filter-runner.js

@@ -1,8 +1,8 @@
 import 'reflect-metadata';
-import { perHandler, sourcePrototype, stageClasses } from './guard-runner.js';
+import { perHandler, sourcePrototype, stageClasses, stageOwners } from './guard-runner.js';
 import { bindShared } from './interceptor-runner.js';
 import { startupError } from '../util/refusal.util.js';
-import { isConstructor } from '../util/value.util.js';
+import { isConstructible } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /** The filter class an entry names. */ function filterClass(entry) {
@@ -26,13 +26,13 @@ import { META } from '../util/metadata-keys.js';
     ];
 }
 /** A handler's method and class filters, the classes innermost first, resolved once. */ const ownFilterLevels = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    if (!source) return {
+    if (!sourcePrototype(prototype, methodName)) return {
         method: [],
         classes: []
     };
     return {
-        method: Reflect.getOwnMetadata(META.methodFilters, source, methodName) ?? [],
+        // An override's filters before those of the methods it overrides, innermost first as the classes are
+        method: stageOwners(prototype, methodName).reverse().flatMap((owner)=>Reflect.getOwnMetadata(META.methodFilters, owner, methodName) ?? []),
         classes: [
             ...stageClasses(prototype, methodName)
         ].reverse().flatMap((cls)=>Reflect.getOwnMetadata(META.classFilters, cls) ?? [])
@@ -51,7 +51,7 @@ import { META } from '../util/metadata-keys.js';
             // Every filter reaching here was checked for @Catch at startup, so its types are always recorded
             const types = Reflect.getOwnMetadata(META.catchTypes, filterClass(entry));
             // Only classes match: anything else given to @Catch, warned of as it applied, matches no error
-            if (types.length === 0 || types.some((type)=>isConstructor(type) && error instanceof type)) return entry;
+            if (types.length === 0 || types.some((type)=>isConstructible(type) && error instanceof type)) return entry;
         }
     }
     return undefined;