meocord 4.2.2 → 4.2.3

package/dist/cjs/_shared/{startup-roots-lA5xkBFq.cjs → event-sources-DzqTODXg.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
 var discord_js = require('discord.js');
-var controller_decorator = require('./controller.decorator-U2NBWcoU.cjs');
-var providers = require('./providers-B4MOFBrW.cjs');
+var controller_decorator = require('./controller.decorator-hp5xdJU4.cjs');
+var providers = require('./providers-BBvbnmLP.cjs');
 var enum_index = require('../enum/index.cjs');
 var node_async_hooks = require('node:async_hooks');
-var translateError = require('./translate-error-CbBHUu5P.cjs');
+var translateError = require('./translate-error-wsgfsUET.cjs');
 
 /**
  * How a pattern ranks, one character per segment twice over: `L` for literal text or `P` for a param, then how narrow
@@ -392,9 +392,9 @@ const quoted = (names)=>names.length < 2 ? names.map((name)=>`"${name}"`).join('
 }
 /**
  * Warns about a handler a subclass re-declares on other routes while it still answers the ones it inherits, for
- * `@Command`, `@MessageHandler`, `@ReactionHandler` and `@Autocomplete` alike. The next major version (5.0) drops
- * the inherited routes. Every class a listed controller extends is checked, a base that is not listed included, for
- * the methods the controller still inherits through it.
+ * `@Command`, `@MessageHandler`, `@ReactionHandler`, `@Autocomplete`, `@On` and `@Once` alike. The next major version
+ * (5.0) drops the inherited routes. Every class a listed controller extends is checked, a base that is not listed
+ * included, for the methods the controller still inherits through it.
  */ function warnInheritedRoutes(controllerClasses) {
     // A set, so a class two listed controllers extend is named once, for the routes either of them still answers
     const problems = new Set();
@@ -403,11 +403,18 @@ const quoted = (names)=>names.length < 2 ? names.map((name)=>`"${name}"`).join('
         // nothing of them from above it, so a class above is not named for them
         const cut = new Set();
         for(let prototype = controllerClass.prototype; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)){
-            const declared = controller_decorator.getDeclaredRoutes(prototype);
             const base = Object.getPrototypeOf(prototype);
-            if (declared.length === 0 || !base) continue;
+            if (!base) continue;
+            const declared = [
+                ...controller_decorator.getDeclaredRoutes(prototype),
+                ...controller_decorator.ownEventHandlers(prototype).map(controller_decorator.eventRoute)
+            ];
+            if (declared.length === 0) continue;
             if (Reflect.getOwnMetadata(controller_decorator.META.replacesInheritedRoutes, prototype)) for (const route of declared)cut.add(route.method);
-            const inherited = controller_decorator.getHandlerRoutes(base).filter((route)=>!cut.has(route.method));
+            const inherited = [
+                ...controller_decorator.getHandlerRoutes(base),
+                ...providers.getEventHandlers(base).map(controller_decorator.eventRoute)
+            ].filter((route)=>!cut.has(route.method));
             for (const method of new Set(declared.map((route)=>route.method))){
                 const own = [
                     ...new Set(declared.filter((route)=>route.method === method).map((route)=>route.label))
@@ -721,7 +728,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 && providers.timerKeepsSeconds(seconds)) {
             setTimeout(()=>{
                 reply.delete().catch((failure)=>controller_decorator.logFailedSend(logger, 'delete a reply to a command', failure));
             }, seconds * 1000).unref?.();
@@ -919,9 +927,9 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
 }
 /**
  * Resolves each unit and runs its `onReady` one at a time, in the units' dependency order. A failure is
- * reported and the next unit still runs. Each unit whose `onReady` settled, or that has none, is pushed
- * to `entries` as it finishes, so a shutdown that starts meanwhile closes exactly those.
- */ async function runReadyHooks(container, units, client, info, entries, report, { stopped = ()=>false, slowAfterMs, settled, runOnReady } = {}) {
+ * reported and the next unit still runs. `settled` hears of each unit as its `onReady` settles, or once it is found
+ * to have none, which is what a shutdown that starts meanwhile reads.
+ */ async function runReadyHooks(container, units, client, info, report, { stopped = ()=>false, slowAfterMs, settled, runOnReady } = {}) {
     const failed = new Set();
     // For each unit, the failed units it depends on, directly or through another dependency
     const failedUpstream = new Map();
@@ -958,11 +966,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
             continue;
         }
         firstToken.set(instance, unit.token);
-        const entry = lifecycleEntry(unit, instance);
-        // Only a unit whose onReady has settled, or that has none, is shut down: a stop mid-ready waits for the one still
-        // starting, within its time, and skips those not reached yet
         if (typeof instance.onReady !== 'function') {
-            entries.push(entry);
             settled?.(unit);
             continue;
         }
@@ -979,7 +983,6 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         } finally{
             clearTimeout(slow);
         }
-        entries.push(entry);
         settled?.(unit);
     }
 }
@@ -1093,6 +1096,28 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
     ]);
 }
 
+/**
+ * Every `@Autocomplete` handler of the given controllers, read from their metadata, with the handlers of one option
+ * before those of a whole command, so an option's handler wins over its command's whatever order they are declared in.
+ */ function buildAutocompleteRoutes(controllers) {
+    const routes = controllers.flatMap((controllerClass)=>controller_decorator.getAutocompleteHandlers(controllerClass.prototype).map((meta)=>({
+                controllerClass,
+                meta
+            })));
+    return routes.sort((a, b)=>Number(Boolean(b.meta.optionName)) - Number(Boolean(a.meta.optionName)));
+}
+/**
+ * The handler an autocomplete reaches, as dispatch routes it: its full command path, then its command's name, and at
+ * each the first handler whose option is the focused one, or that names none.
+ */ function matchAutocompleteRoute(routes, interaction) {
+    const focused = controller_decorator.focusedOptionName(interaction);
+    for (const path of controller_decorator.resolveCommandPaths(interaction)){
+        const route = routes.find(({ meta })=>meta.commandPath === path && (meta.optionName === undefined || meta.optionName === focused));
+        if (route) return route;
+    }
+    return undefined;
+}
+
 /** The keys a command is routed by, most specific first: a chat command's full path, then its name; none for anything else. */ function commandRouteKeys(interaction) {
     if (interaction.isChatInputCommand()) return controller_decorator.resolveCommandPaths(interaction);
     if (interaction.isContextMenuCommand() || interaction.isPrimaryEntryPointCommand()) return [
@@ -1255,6 +1280,26 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
     if (winner) return `command '${keys[0]}' does not reach ${handler}: dispatch runs ${winner.controllerClass.name}.${winner.meta.methodName}.`;
     return `command '${keys[0]}' does not match ${handler}'s route ${named.map(({ route })=>`'${route}'`).join(' or ')}.`;
 }
+/**
+ * Why an autocomplete could not reach a handler, for a test calling the handler directly: the handler is checked
+ * against the one dispatch routes the autocomplete to among `controllers`, by its command path and focused option.
+ * `undefined` when it is that one, when the handler has no `@Autocomplete` route, or when the interaction is not an
+ * autocomplete or has no command name.
+ */ function autocompleteMismatch(controllers, controller, methodName, interaction) {
+    if (!interaction.isAutocomplete() || typeof interaction.commandName !== 'string') return undefined;
+    const own = controller_decorator.getAutocompleteHandlers(controller.prototype).filter((meta)=>meta.methodName === methodName);
+    if (own.length === 0) return undefined;
+    const winner = matchAutocompleteRoute(buildAutocompleteRoutes(controllers), interaction);
+    if (winner?.controllerClass === controller && winner.meta.methodName === methodName) return undefined;
+    const handler = `${controller.name}.${methodName}`;
+    const received = controller_decorator.describeInteraction(interaction);
+    // A mock without a focused option reaches no option's handler, the commonest way to miss one
+    const option = controller_decorator.focusedOptionName(interaction) === undefined ? own.find((meta)=>meta.optionName !== undefined)?.optionName : undefined;
+    const fix = option === undefined ? '' : ` Give the mock the focused option: options: createChatInputOptions({ focused: '${option}' }).`;
+    if (winner) return `${received} does not reach ${handler}: dispatch runs ${winner.controllerClass.name}.${winner.meta.methodName}.${fix}`;
+    const routes = own.map((meta)=>meta.optionName === undefined ? `'${meta.commandPath}'` : `'${meta.commandPath}' option '${meta.optionName}'`);
+    return `${received} does not match ${handler}'s route ${routes.join(' or ')}.${fix}`;
+}
 
 /**
  * How long a component or modal submission no route takes is left to the client's other listeners, such as a
@@ -1322,13 +1367,19 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
             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
         };
@@ -1339,32 +1390,35 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         }
         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 providers.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 controller_decorator.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) {
@@ -1390,14 +1444,14 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
             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
@@ -1420,21 +1474,17 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
    * 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 = controller_decorator.focusedOptionName(interaction);
-        for (const path of controller_decorator.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 = controller_decorator.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 = controller_decorator.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 ${controller_decorator.describeInteraction(interaction)}. Declare an @Autocomplete handler for it, ` + `or drop setAutocomplete(true) from the option.`);
         await closeAutocomplete(interaction, this.logger);
@@ -1442,19 +1492,22 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
             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
@@ -1462,7 +1515,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         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
@@ -1509,7 +1562,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
    * 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 || !providers.hasMessageText(message.content)) return;
         const call = this.callFor(record);
         let target;
         try {
@@ -1536,24 +1589,29 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         }
         // 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}${providers.commandWordsOf(route.tokens).join(' ')}`);
             const hooks = providers.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);
@@ -1578,7 +1636,8 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
                 ...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);
@@ -1658,7 +1717,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         const matching = this.controllerClasses.map((controllerClass)=>({
                 controllerClass,
                 // Handlers for this emoji first, then those for every emoji
-                handlers: controller_decorator.getReactionHandlers(this.getInstance(controllerClass)).filter(forEmoji).sort((a, b)=>Number(!a.emoji) - Number(!b.emoji))
+                handlers: controller_decorator.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
@@ -1682,16 +1741,21 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
             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);
-            }
+            });
         }
     }
     /**
@@ -1710,7 +1774,10 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
     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;
@@ -1725,6 +1792,8 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         // The app's own help command reads this table too, so it lists the commands dispatch reaches
         if (this.container.isBound(providers.HandlerRegistry)) providers.shareMessageRoutes(this.container.get(providers.HandlerRegistry), this.messageRoutes);
         this.warnUnreachableHelp();
+        // Here, where the routes are built once, rather than in buildMessageRoutes, which startup runs twice
+        for (const warning of providers.messageRouteWarnings(this.messageRoutes, this.messageOptions))this.logger.warn(warning);
         this.messageListeners = this.controllerClasses.flatMap((controllerClass)=>controller_decorator.getMessageHandlers(controllerClass.prototype).filter((handler)=>handler.pattern === undefined).map(({ method })=>({
                     controllerClass,
                     method
@@ -1808,19 +1877,38 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
     seen.add(cls);
     return providers.injectedTokens(cls).some((token)=>token === controller_decorator.ExecutionContext || providers.isAppClassToken(token) && !providers$1.has(token) && !seen.has(token) && reachesContext(token, providers$1, seen));
 }
-/**
- * The classes the app's stages and presenter inject, which they would make only at their first call. Made with the
- * app's own classes, a service among them gets its lifecycle hooks. One that reaches the call's `ExecutionContext` is
- * made for each call, so it is left out, and a stage a test replaces is not among the stages, so what it would inject
- * is not made.
- */ function stageDependencies({ decorators }, providers$1, presenter) {
+/** The app's classes the stages and presenter inject. */ function stageInjected({ decorators }, presenter) {
     const stages = [
         ...decorators
     ].filter(([, decorator])=>decorator !== '@Controller()').map(([stage])=>stage);
     if (typeof presenter === 'function') stages.push(presenter);
     return [
         ...new Set(stages.flatMap((stage)=>providers.injectedTokens(stage)))
-    ].filter(providers.isAppClassToken).filter((cls)=>!reachesContext(cls, providers$1));
+    ].filter(providers.isAppClassToken);
+}
+/**
+ * The classes the app's stages and presenter inject, which they would make only at their first call. Made with the
+ * app's own classes, a service among them gets its lifecycle hooks. One that reaches the call's `ExecutionContext` is
+ * made for each call, so it is left out, and a stage a test replaces is not among the stages, so what it would inject
+ * is not made.
+ */ function stageDependencies(startup, providers, presenter) {
+    return stageInjected(startup, presenter).filter((cls)=>!reachesContext(cls, providers));
+}
+/**
+ * A warning for each `@On` and `@Once` handler on a class the stages and presenter reach that is made for each call,
+ * as it reaches `ExecutionContext`: no one instance of it receives events.
+ */ function perCallEventWarnings(startup, providers$1, presenter) {
+    const perCall = new Set();
+    // What a class made for each call injects is made for each call too only if it also reaches the context
+    const visit = (cls)=>{
+        if (perCall.has(cls) || providers$1.has(cls) || !reachesContext(cls, providers$1)) return;
+        perCall.add(cls);
+        providers.injectedTokens(cls).filter(providers.isAppClassToken).forEach(visit);
+    };
+    stageInjected(startup, presenter).forEach(visit);
+    return [
+        ...perCall
+    ].flatMap((cls)=>providers.getEventHandlers(cls.prototype).map(({ event, method, once })=>`${cls.name}.${method}: @${once ? 'Once' : 'On'}('${event}') is on a class made for each call, as it injects ` + 'ExecutionContext or a class that does, so it receives no events. The next major version (5.0) refuses it; ' + 'move the handler to a service that does not.'));
 }
 /** How a container checks a guard first met at a call: the guard and what it injects, as the startup checks would. */ function lateGuardCheck(providers$1, translator) {
     return (guard)=>assertStartupClasses({
@@ -1843,6 +1931,100 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
     for (const needsOne of classes.filter((cls)=>providers.injectedTokens(cls).includes(controller_decorator.Translator)))controller_decorator.startupError(controller_decorator.missingTranslatorError(needsOne));
 }
 
+/**
+ * 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$1, 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$1.get(token);
+        if (provider && !providers.isClassProvider(provider) || !provider && !providers.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) ? providers.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$1.get(token);
+        if (!provider || providers.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 = providers.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 = providers.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.`);
+}
+
 exports.DEFAULT_SHUTDOWN_TIMEOUT_MS = DEFAULT_SHUTDOWN_TIMEOUT_MS;
 exports.Dispatcher = Dispatcher;
 exports.ReadyPass = ReadyPass;
@@ -1850,11 +2032,13 @@ exports.RunningCalls = RunningCalls;
 exports.SHUTDOWN_MARGIN_MS = SHUTDOWN_MARGIN_MS;
 exports.assertDistinctCommands = assertDistinctCommands;
 exports.assertStartupClasses = assertStartupClasses;
+exports.autocompleteMismatch = autocompleteMismatch;
 exports.buildComponentRoutes = buildComponentRoutes;
 exports.callsSettled = callsSettled;
 exports.commandMismatch = commandMismatch;
 exports.componentRouteFor = componentRouteFor;
 exports.createFallback = createFallback;
+exports.eventSources = eventSources;
 exports.findComponentRouteConflicts = findComponentRouteConflicts;
 exports.handlerInput = handlerInput;
 exports.lateGuardCheck = lateGuardCheck;
@@ -1862,6 +2046,7 @@ exports.lifecycleEntry = lifecycleEntry;
 exports.matchComponentRoute = matchComponentRoute;
 exports.messageDecorator = messageDecorator;
 exports.ownInteractionListener = ownInteractionListener;
+exports.perCallEventWarnings = perCallEventWarnings;
 exports.reactionDecorator = reactionDecorator;
 exports.readCustomId = readCustomId;
 exports.replyWithUserError = replyWithUserError;