meocord 4.2.2 → 4.2.3

package/dist/esm/testing/meocord-testing-module.js

@@ -4,26 +4,27 @@ import { COOLDOWN_POLICY, cooldownPolicyFrom, claimStoreDownNotice, claimCooldow
 import { Message, BaseInteraction, Client } from 'discord.js';
 import { ReactionHandlerAction } from '../enum/controller.enum.js';
 import { CooldownStore, MemoryCooldownStore } from '../common/cooldown-store.js';
-import { ExecutionContext } from '../common/execution-context.js';
-import { Translator, missingTranslatorError } from '../common/translator.js';
-import { injectedTokens, singletonContextError, recordInstanceContainers } from '../core/guard-runner.js';
-import { appPresenterOf, runHandler, appStages, bindGlobalStages, prepareHandlerStages, prepareAppPresenter, prepareThemes, bindAppPresenter } from '../core/handler-pipeline.js';
-import { setPresenter } from '../common/response/presenter.js';
-import { componentRouteFor, commandMismatch, handlerInput } from '../core/handler-input.js';
+import { ExecutionContext, inferContextType } from '../common/execution-context.js';
+import { Translator } from '../common/translator.js';
+import { injectedTokens, singletonContextError, prepareDirectCalls } from '../core/guard-runner.js';
+import { bindAppPresenter, runHandler, appPresenterOf, appStages, bindGlobalStages, prepareHandlerStages, prepareAppPresenter, prepareThemes } from '../core/handler-pipeline.js';
+import { setPresenter, clientPresenter } from '../common/response/presenter.js';
+import { componentRouteFor, commandMismatch, handlerInput, autocompleteMismatch } from '../core/handler-input.js';
 import { buildComponentRoutes } from '../core/component-routes.js';
 import { hasCustomId } from '../util/interaction.util.js';
 import { ThemeCache, themeResolverClass } from '../core/theme-resolvers.js';
-import { releaseAmbientAppTheme, claimAmbientAppTheme, registerClientTheme } from '../core/theme-runtime.js';
+import { prepareLateThemes, releaseAmbientAppTheme, claimAmbientAppTheme, registerClientTheme, appTheme } from '../core/theme-runtime.js';
 import { registerClientTranslator } from '../common/meocord-text.js';
-import { copyLayer, mergeTheme } from '../core/theme-scope.js';
+import { defaultTheme, copyLayer, mergeTheme } from '../core/theme-scope.js';
 import { assertValidTheme, themeForProblem } from '../core/theme-validation.js';
 import { messageParamsFor, buildMessageRoutes } from '../core/message-routes.js';
 import { assertDistinctCommands, warnUnregisteredCommands, warnInheritedRoutes, warnOverlappingPatterns, warnHandlersOffControllers } from '../core/command-conflicts.js';
 import { messageCommandHooks } from '../core/message-params.js';
 import { appObservers, assertObservers, bindObservers } from '../core/observer-runner.js';
-import { HandlerRegistry } from '../core/handler-registry.js';
-import { adviseInPlaceOfInjecting, meocordClasses } from '../core/meocord-classes.js';
-import { startupClasses, assertStartupClasses, lateGuardCheck, stageDependencies } from '../core/startup-roots.js';
+import { listEventSources, HandlerRegistry } from '../core/handler-registry.js';
+import { eventSources } from '../core/event-sources.js';
+import { adviseInPlaceOfInjecting, boundBeforeProviders, meocordClasses } from '../core/meocord-classes.js';
+import { startupClasses, assertStartupClasses, lateGuardCheck, stageDependencies, perCallEventWarnings } from '../core/startup-roots.js';
 import { markStartupChecked, assertStartupChecked } from '../core/startup-checked.js';
 import { makeInjectable } from '../util/injectable.util.js';
 import { ShardContext, shardCallHandler } from '../core/shard-context.js';
@@ -36,11 +37,12 @@ import { Logger } from '../common/logger.js';
 import { isExplainedError, markExplained } from '../common/explained-error.js';
 import { collectStartupErrors, declaredErrorsOf, startupError, stopOnStartupErrors, isRefusal, logStartupErrors } from '../util/refusal.util.js';
 import { DEFAULT_SHUTDOWN_TIMEOUT_MS, shutdownTimeoutProblem } from '../util/shutdown-timeout.util.js';
-import { isConstructor, describeValue } from '../util/value.util.js';
-import { resolveProviders, tokenName, bindsOwnToken, providerMap, assertProvidedServices, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies } from '../core/providers.js';
+import { isConstructor, describeValue, withArticle } from '../util/value.util.js';
+import { resolveProviders, tokenName, bindsOwnToken, providerMap, appProviderRefusal, assertProvidedServices, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies } from '../core/providers.js';
+import { getReactionHandlers, getHandlerRoutes } from '../decorator/controller.decorator.js';
 import { getEventHandlers } from '../decorator/event.decorator.js';
-import { getReactionHandlers } from '../decorator/controller.decorator.js';
 import { strictMocks } from './strict-mocks.js';
+import { notAClass } from './routing.js';
 import { warnOnce } from '../common/deprecation.js';
 import { META } from '../util/metadata-keys.js';
 import { isUserOutcome } from '../common/user-outcome.js';
@@ -109,7 +111,13 @@ import { isUserOutcome } from '../common/user-outcome.js';
    * ```
    */ async init(options = {}) {
         this.resolving ?? (this.resolving = resolveProviders(this.container, this.providers, this.order).then(()=>{
+            // As the bot reads them, once every provided value is made and before the services that could list them
+            this.sources ?? (this.sources = eventSources(this.container, this.providers, this.lifecycle, this.eventClasses, (text)=>new Logger('TestingModule').warn(text)));
+            listEventSources(this.container.get(HandlerRegistry), this.sources);
+            prepareLateThemes(this.container, this.sources.map(({ cls })=>cls));
             for (const service of this.services)this.container.get(service);
+            // After the providers and listed services, as the bot makes it, so a provided value it injects is made
+            if (this.app) bindAppPresenter(this.container, this.app);
         }));
         await this.resolving;
         if (options.ready) {
@@ -197,10 +205,9 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 error
             });
         // No warning for a hook whose dependency failed: the test sees the dependency's own error
-        // What close() shuts down is what was constructed, so the entries the runner records are not kept
         await runReadyHooks(this.container, this.lifecycle, client, {
             primary
-        }, [], {
+        }, {
             resolveFailed: failed,
             hookFailed: failed
         }, {
@@ -267,16 +274,24 @@ import { isUserOutcome } from '../common/user-outcome.js';
    *   command's or an autocomplete's options, or the handler's customId params with a modal's fields or
    *   a select menu's choices.
    *   An interaction's customId or command name must be one dispatch routes to the handler, ranking
-   *   every handler of the module as the bot does; a mock built without one is not checked. With a message alone, a patterned `@MessageHandler` gets the
-   *   params its pattern captures from the content, after the prefix of the module's `app`, with typed
-   *   params resolved as dispatch resolves them, from the message's guild caches first; a message
-   *   without content gets `{}`. A word that is not a value of its type, and a prefixed message that names
-   *   the command but leaves out a param, go through the handler's filters as a `MessageUsageError`, as
-   *   dispatch answers them.
+   *   every handler of the module as the bot does; a mock built without one is not checked. An autocomplete is
+   *   checked by its command path and its focused option: one dispatch gives to another `@Autocomplete` handler,
+   *   or to none, is refused under `useStrictMocks()`, and otherwise warned about once and run.
+   *   With a message alone, a patterned `@MessageHandler` gets the params its pattern captures from the content,
+   *   after the prefix of the module's `app`, with typed params resolved as dispatch resolves them, from the
+   *   message's guild caches first. A message whose `content` isn't a string, as a mock's without
+   *   `useStrictMocks()`, gets `{}`. Under strict mocks a message has empty `content`, and a patterned handler
+   *   rejects it, as dispatch runs no handler for a message with no text: give the mock the `content` the handler
+   *   takes. A word that is not a value of its type, and a prefixed message that names the command but leaves out
+   *   a param, go through the handler's filters as a `MessageUsageError`, as dispatch answers them.
+   *   An `@On` or `@Once` handler no route reaches runs as {@link emit} runs it, as an event with the arguments given,
+   *   under `useStrictMocks()`; without strict mocks it runs as its first argument's type, and `invoke` warns once
+   *   where that differs.
    * @returns Whether the handler ran, and the error a filter handled, if any. Rejects with an error no
    *   filter handles, or with the error a filter throws: the built-in fallback, which answers such
    *   errors in the bot, does not run here. Rejects before running anything with an interaction or a
-   *   message the handler's route does not match, naming both. Given fewer arguments than the handler
+   *   message the handler's route does not match, naming both, and under `useStrictMocks()` with such an
+   *   autocomplete. Given fewer arguments than the handler
    *   declares, with a first that is neither an interaction nor a message, such as a reaction without its
    *   `ReactionEvent`, it rejects under `useStrictMocks()`, and otherwise warns once and runs the handler.
    *
@@ -308,11 +323,25 @@ import { isUserOutcome } from '../common/user-outcome.js';
         const instance = this.container.get(controller);
         if (typeof instance[methodName] !== 'function') throw new Error(`${controller.name}.${methodName} is not a method.`);
         const [first] = args;
+        const event = eventHandlerOf(controller, methodName);
+        // As emit and the bot run it; without strict mocks it runs as before, as a test that passes that way could fail
+        if (event && strictMocks()) {
+            this.checkArgumentCount(controller, methodName, instance[methodName], first, args.length);
+            this.registerEventClients(args);
+            const { ran, error } = await this.track(this.runEventHandler(instance, methodName, args));
+            return error === undefined ? {
+                ran
+            } : {
+                ran,
+                error
+            };
+        }
         const interaction = first instanceof BaseInteraction ? first : undefined;
         // The handler dispatch gives the customId to, among every handler of the module
         const component = interaction && hasCustomId(interaction) ? componentRouteFor(this.componentRoutes(), controller, methodName, interaction) : undefined;
         const mismatch = component && 'mismatch' in component ? component.mismatch : interaction && commandMismatch(this.controllers, controller, methodName, interaction);
         if (mismatch) throw new Error(mismatch);
+        if (interaction) this.checkAutocompleteRoute(controller, methodName, interaction);
         let hooks = {};
         let callArgs = args.length === 1 && interaction ? [
             interaction,
@@ -331,10 +360,7 @@ import { isUserOutcome } from '../common/user-outcome.js';
             }
         }
         this.checkArgumentCount(controller, methodName, instance[methodName], first, callArgs.length);
-        const presenter = appPresenterOf(this.container);
-        // A message command's errors are drawn by the app's presenter too, as an interaction's are
-        const client = first instanceof BaseInteraction || first instanceof Message ? first.client : undefined;
-        if (presenter && client) setPresenter(client, presenter);
+        if (event) this.warnEventRun(controller, methodName, event, first, callArgs.length !== args.length);
         this.registerClient(first);
         const { ran, error } = await this.track(runHandler(this.container, instance, methodName, callArgs, {
             awaitObservers: true,
@@ -348,6 +374,36 @@ import { isUserOutcome } from '../common/user-outcome.js';
         };
     }
     /**
+   * Warns once, without strict mocks, that `invoke` runs an event handler other than as the bot does: as the type its
+   * first argument gives, or with params it added. Only `invoke` warns, on the test's own call.
+   */ warnEventRun(controller, methodName, event, first, paramsAdded) {
+        const type = inferContextType(first);
+        // invoke adds params only for an interaction or a message, whose type is never 'event'
+        if (type === 'event') return;
+        const key = `${controller.name}.${methodName}`;
+        if (this.warnedEventRuns.has(key)) return;
+        this.warnedEventRuns.add(key);
+        const call = `${withArticle(type)} call${paramsAdded ? ' with its params added' : ''}`;
+        new Logger('TestingModule').warn(`invoke runs ${key}, an @${event.once ? 'Once' : 'On'}('${event.event}') handler, as ${call}; the bot runs it as ` + 'an event with its arguments as given, and useStrictMocks() runs it so.');
+    }
+    /** Runs an `@On` or `@Once` handler as the bot and `emit` do: as an event, with its arguments as given. */ runEventHandler(instance, method, args) {
+        return runHandler(this.container, instance, method, args, {
+            type: 'event',
+            awaitObservers: true
+        });
+    }
+    /**
+   * Refuses under strict mocks, and otherwise warns once, an autocomplete dispatch gives to another handler or to none.
+   * Without strict mocks the handler still runs, since a test that passes that way would fail.
+   */ checkAutocompleteRoute(controller, methodName, interaction) {
+        const mismatch = autocompleteMismatch(this.controllers, controller, methodName, interaction);
+        if (!mismatch) return;
+        if (strictMocks()) throw new Error(mismatch);
+        if (this.warnedAutocompleteRoutes.has(mismatch)) return;
+        this.warnedAutocompleteRoutes.add(mismatch);
+        new Logger('TestingModule').warn(`${mismatch} Under useStrictMocks(), invoke rejects it.`);
+    }
+    /**
    * Refuses under `useStrictMocks()`, or warns once otherwise, a call that gives a handler fewer arguments than it
    * declares when `invoke` builds none for it, as for a reaction given without its `ReactionEvent`.
    */ checkArgumentCount(controller, methodName, method, first, given) {
@@ -366,14 +422,35 @@ import { isUserOutcome } from '../common/user-outcome.js';
         return call;
     }
     /**
-   * Makes this module the app of the input's client, as the bot is of its own, so `respond()` outside any call,
-   * as in a collector's callback on that client, answers in this module's theme.
+   * Makes this module the app of the input's client, as the bot is of its own: its answers are drawn by this
+   * module's presenter, in its theme and language, `respond()` outside any call included, as in a collector's callback
+   * on that client. A module without a presenter clears the client's under strict mocks, so the default draws; default
+   * mode leaves another module's in place and warns once.
    */ registerClient(input) {
         const client = input?.client;
         if (!client || typeof client !== 'object') return;
+        const presenter = appPresenterOf(this.container);
+        if (presenter || strictMocks()) setPresenter(client, presenter);
+        else if (clientPresenter(client)) {
+            warnOnce(new Logger('TestingModule'), "A module without a presenter here answers with the presenter another module set on the same client; under " + "useStrictMocks() this module's own presenter, or the default, is used.");
+        }
         registerClientTheme(client, this.container);
         registerClientTranslator(client, this.container.isBound(Translator) ? this.container.get(Translator) : undefined);
     }
+    /**
+   * Makes this module the app of each event argument's client, as the bot is of its own, under strict mocks; default
+   * mode leaves the clients as they are and warns once where this module would draw answers otherwise.
+   */ registerEventClients(args) {
+        const withClient = args.filter((arg)=>typeof arg?.client === 'object');
+        if (withClient.length === 0) return;
+        if (strictMocks()) {
+            for (const arg of withClient)this.registerClient(arg);
+            return;
+        }
+        const ownTheme = appTheme(this.container) !== defaultTheme();
+        if (!appPresenterOf(this.container) && !this.container.isBound(Translator) && !ownTheme) return;
+        warnOnce(new Logger('TestingModule'), "emit() here leaves the client's presenter, theme and translator as they were, where the bot draws the answers to " + "an event with its app's; in the next major version (5.0) emit sets the module's on the client. Call " + 'useStrictMocks() to have it set them now.');
+    }
     /** The module's component routes, ranked as dispatch ranks them; throws, as the bot would, for two of one shape. */ componentRoutes() {
         return this.builtComponentRoutes ?? (this.builtComponentRoutes = buildComponentRoutes(this.controllers));
     }
@@ -381,6 +458,26 @@ import { isUserOutcome } from '../common/user-outcome.js';
         if (this.dispatcher) return this.dispatcher;
         const logger = new Logger('TestingModule');
         const warnUnanswered = this.appWarnUnanswered ?? process.env.NODE_ENV === 'development';
+        const notices = {
+            cooldownNotice: (refusal)=>claimCooldownNotice(this.container, refusal),
+            storeDownNotice: (who)=>claimStoreDownNotice(this.container, who)
+        };
+        // Strict mocks log an answer MeoCord fails to build and end the call in that fault, as a bot does; default mode
+        // rethrows it from the fallback, so observers hear the call's own outcome, and an interaction's again as an error
+        const answer = createFallback(logger, ()=>this.messageOptions, notices);
+        const rethrowing = createFallback(logger, ()=>this.messageOptions, {
+            ...notices,
+            strict: true
+        });
+        const fallback = async (error, context)=>{
+            if (strictMocks()) return answer(error, context);
+            try {
+                return await rethrowing(error, context);
+            } catch (failure) {
+                warnOnce(logger, "dispatch() here reports a call whose answer MeoCord couldn't build with the call's own outcome, and an " + "interaction's a second time as an error; under useStrictMocks() the call is reported once, as 'error'.");
+                throw failure;
+            }
+        };
         this.dispatcher = new Dispatcher({
             container: this.container,
             controllerClasses: this.controllers,
@@ -388,12 +485,7 @@ import { isUserOutcome } from '../common/user-outcome.js';
             logger,
             // A test's fake clock can pass 5 s inside a handler, so the slow-handler warning waits to be asked for
             warnSlowMessageHandlers: false,
-            // Strict: an answer MeoCord fails to build rejects the dispatch, where a bot logs it and carries on
-            fallback: createFallback(logger, ()=>this.messageOptions, {
-                strict: true,
-                cooldownNotice: (refusal)=>claimCooldownNotice(this.container, refusal),
-                storeDownNotice: (who)=>claimStoreDownNotice(this.container, who)
-            }),
+            fallback,
             // A mock's client is the one bot every mock client is, so a mention of it starts a command
             botUserId: (event)=>{
                 const id = event.client?.user?.id;
@@ -411,6 +503,8 @@ import { isUserOutcome } from '../common/user-outcome.js';
         const dispatcher = this.dispatcherOf();
         const handlers = [];
         const unhandled = [];
+        // The fault each error's answer failed with, which the call ends in in that error's place
+        const unanswered = new Map();
         const record = {
             settled: (controller, method, { ran, error })=>handlers.push({
                     controller,
@@ -420,7 +514,8 @@ import { isUserOutcome } from '../common/user-outcome.js';
                         error
                     }
                 }),
-            unhandled: (error)=>unhandled.push(error)
+            unhandled: (error)=>unhandled.push(error),
+            unanswered: (error, failure)=>unanswered.set(error, failure)
         };
         if (options) {
             noteReactionDispatch(input);
@@ -429,18 +524,19 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 action: options.action ?? ReactionHandlerAction.ADD
             }, record));
         } else if (input instanceof BaseInteraction) {
-            const presenter = appPresenterOf(this.container);
-            if (presenter) setPresenter(input.client, presenter);
             await this.track(dispatcher.interaction(input, record));
         } else if (input instanceof Message) {
-            const presenter = appPresenterOf(this.container);
-            if (presenter) setPresenter(input.client, presenter);
             await this.track(dispatcher.message(input, record));
         } else {
             throw new TypeError('dispatch takes an interaction, a message, or a reaction with { user }.');
         }
-        // What the fallback answers as the user's own outcome, such as a usage reply or a refusal, is an outcome to assert on
-        const failures = unhandled.filter((error)=>!isUserOutcome(error, options ? undefined : input));
+        // What the fallback answers as the user's own outcome, such as a usage reply or a refusal, is an outcome to assert on,
+        // unless its answer failed to build, which is the call's fault, as on a bot
+        const failures = unhandled.flatMap((error)=>unanswered.has(error) ? [
+                unanswered.get(error)
+            ] : isUserOutcome(error, options ? undefined : input) ? [] : [
+                error
+            ]);
         if (failures.length === 1) throw failures[0];
         if (failures.length > 1) throw new AggregateError(failures, `${failures.length} errors were left to the fallback.`);
         const error = handlers.find((handler)=>handler.error !== undefined)?.error ?? unhandled[0];
@@ -455,8 +551,9 @@ import { isUserOutcome } from '../common/user-outcome.js';
     /**
    * Emits a client event to the module's `@On` and `@Once` handlers, through the pipeline the app runs
    * them in up to its event fallback: the global guards of the module's `app`, then each handler's own.
-   * Handlers on the module's controllers, class providers and their dependencies all receive it. A
-   * `@Once` handler handles only the first event, as it would on a client.
+   * As on the bot, every instance the module runs lifecycle hooks on, the cooldown store aside, receives
+   * it: the controllers and services, what they and the stages inject, and each provided class or value.
+   * A `@Once` handler handles only the first event, as it would on a client.
    *
    * The bot's event fallback doesn't run here. On a bot, a guard's `GuardDeniedError` is logged and the
    * event skipped, and a handler's `UserError` is logged and, when the event carries a message, answered
@@ -480,22 +577,21 @@ import { isUserOutcome } from '../common/user-outcome.js';
    */ async emit(event, ...args) {
         this.warnIfClosed();
         await this.init();
+        this.registerEventClients(args);
         const calls = [];
-        for (const cls of this.eventClasses){
-            for (const handler of getEventHandlers(cls.prototype)){
+        for (const [index, source] of (this.sources ?? []).entries()){
+            for (const handler of source.handlers){
                 if (handler.event !== event) continue;
                 if (handler.once) {
-                    const key = `${cls.name}.${handler.method}:${event}`;
+                    const key = `${index}.${handler.method}:${event}`;
                     if (this.firedOnce.has(key)) continue;
                     this.firedOnce.add(key);
                 }
                 // Resolved inside the call, so a class that cannot be resolved fails as its handler would
                 const run = async ()=>{
-                    const instance = this.container.get(cls);
-                    const { ran } = await runHandler(this.container, instance, handler.method, args, {
-                        type: 'event',
-                        awaitObservers: true
-                    });
+                    const instance = source.resolve();
+                    if (!instance) return false;
+                    const { ran } = await this.runEventHandler(instance, handler.method, args);
                     return ran;
                 };
                 calls.push(this.track(run()));
@@ -511,7 +607,7 @@ import { isUserOutcome } from '../common/user-outcome.js';
             ran: results.filter((result)=>result.status === 'fulfilled' && result.value).length
         };
     }
-    constructor(container, controllers = [], eventClasses = [], providers = new Map(), order = [], messageOptions = {}, lifecycle = [], /** The lifecycle units the container has constructed, which `close()` shuts down. */ constructed = new Set(), /** The `app`'s `warnUnanswered`, which dispatch follows as the bot does. */ appWarnUnanswered, /** The app's listed services, made at `init()` as the bot makes them before it logs in. */ services = [], /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */ shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT_MS){
+    constructor(container, controllers = [], eventClasses = [], providers = new Map(), order = [], messageOptions = {}, lifecycle = [], /** The lifecycle units the container has constructed, which `close()` shuts down. */ constructed = new Set(), /** The `app`'s `warnUnanswered`, which dispatch follows as the bot does. */ appWarnUnanswered, /** The app's listed services, made at `init()` as the bot makes them before it logs in. */ services = [], /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */ shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT_MS, /** The `app`, whose presenter `init()` makes after the providers, as the bot does. */ app){
         this.container = container;
         this.controllers = controllers;
         this.eventClasses = eventClasses;
@@ -523,10 +619,13 @@ import { isUserOutcome } from '../common/user-outcome.js';
         this.appWarnUnanswered = appWarnUnanswered;
         this.services = services;
         this.shutdownTimeout = shutdownTimeout;
+        this.app = app;
         /** The `onReady` hooks' pass, which `close()` waits for, less one whose `onReady` called `close()`. */ this.readyPass = new ReadyPass();
         this.warnedClosed = false;
         /** The `@Once` handlers that have already handled their event, as a client forgets its once listeners. */ this.firedOnce = new Set();
         /** The handlers already warned about for being given fewer arguments than they take, so each is named once. */ this.warnedArgumentCounts = new Set();
+        /** The `@On` and `@Once` handlers already warned about for running other than as an event, so each is named once. */ this.warnedEventRuns = new Set();
+        /** The autocomplete mismatches already warned about without strict mocks, so each handler and route warns once. */ this.warnedAutocompleteRoutes = new Set();
         /** The calls under way, each removed once it settles: what `close()` lets finish before the cooldown store stops. */ this.calls = new Set();
     }
 }
@@ -536,6 +635,10 @@ import { isUserOutcome } from '../common/user-outcome.js';
         throw new AggregateError(failures.map(({ error })=>error), `${failures.length} ${hook} hooks threw: ${failures.map(({ name })=>name).join(', ')}.`);
     }
 }
+/** A method's `@On` or `@Once` handler, when no route also reaches it: a route's input decides how that one runs. */ function eventHandlerOf(controller, methodName) {
+    if (getHandlerRoutes(controller.prototype).some((route)=>route.method === methodName)) return undefined;
+    return getEventHandlers(controller.prototype).find((handler)=>handler.method === methodName);
+}
 /** The app's `messages` options, when the testing module is given an app. */ function messagesOf(app) {
     return app && Reflect.getMetadata(META.appOptions, app)?.messages;
 }
@@ -570,7 +673,9 @@ import { isUserOutcome } from '../common/user-outcome.js';
     /**
    * Replaces a provider with a test double.
    *
-   * The double needs only the members the test uses; misspelled member names are still rejected.
+   * The double needs only the members the test uses; misspelled member names are still rejected. A token MeoCord binds
+   * itself, such as `ShardContext` or `HandlerRegistry`, takes the double in place of MeoCord's own, so a test can stub
+   * cross-shard calls.
    *
    * @param token - The provider to replace.
    * @example
@@ -754,7 +859,7 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 // Bound first, as in the app, so a class that injects it gets this instance
                 const appClasses = [];
                 const translator = ()=>container.isBound(Translator) ? container.get(Translator) : undefined;
-                container.bind(HandlerRegistry).toConstantValue(new HandlerRegistry(appClasses, messagesOf(this.options.app), translator));
+                container.bind(HandlerRegistry).toConstantValue(new HandlerRegistry(appClasses, messagesOf(this.options.app), translator, this.options.controllers ?? []));
                 // A testing module runs as one process, so a cross-shard call runs once, here
                 container.bind(ShardContext).toConstantValue(new ShardContext(undefined, shardCallHandler(container, ()=>[
                         ...appClasses,
@@ -767,6 +872,17 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 // Checked as the app checks its own: the app's providers in their order, then the test's, which replace them
                 // by token, then the overrides, which win
                 const providers = providerMap(this.wiring?.providers ?? [], '@MeoCord({ providers })');
+                // The app's own providers checked as the bot checks them. A token the module binds itself above fails at its
+                // first call, so it is refused; another the bot binds before its providers is refused under strict mocks, and
+                // runs here in default mode with a warning
+                const i18n = this.options.app && Reflect.getMetadata(META.appOptions, this.options.app)?.i18n;
+                const botBinds = boundBeforeProviders(i18n !== undefined);
+                for (const token of providers.keys()){
+                    const refusal = appProviderRefusal(`${this.options.app?.name}`, token, (own)=>botBinds.includes(own), new Logger('TestingModule'));
+                    if (!refusal) continue;
+                    if (container.isBound(token) || strictMocks()) startupError(refusal);
+                    else warnOnce(new Logger('TestingModule'), `${refusal.message} The testing module runs it; under useStrictMocks() compile() refuses it, as the bot does.`);
+                }
                 for (const [token, provider] of providerMap(this.options.providers ?? [], "the testing module's providers"))providers.set(token, provider);
                 for (const [token, override] of this.overrides)providers.set(token, override);
                 // A stage override stands in for its class wherever the class is bound. A stage also provided takes the stub in
@@ -822,7 +938,6 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 // The themeFor class this module runs, the app's or overrideThemeFor's, bound on its own as the app binds it
                 const themeResolver = themeResolverClass(stages?.themeFor?.resolvers);
                 // Every class the module runs, as the app finds them, except stage classes an override stands in for
-                const i18n = this.options.app && Reflect.getMetadata(META.appOptions, this.options.app)?.i18n;
                 const appPresenterClass = this.options.app && Reflect.getMetadata(META.appOptions, this.options.app)?.presenter;
                 const startup = startupClasses({
                     controllers: (this.options.controllers ?? []).filter(isConstructor),
@@ -876,8 +991,7 @@ import { isUserOutcome } from '../common/user-outcome.js';
                     container.bind(cls).toSelf().inSingletonScope();
                     // By constructor type or @inject token, as the app binds them
                     for (const dep of injectedTokens(cls)){
-                        if (dep === Translator && !container.isBound(Translator)) startupError(missingTranslatorError(cls));
-                        else if (isAppClassToken(dep)) bindClass(dep);
+                        if (isAppClassToken(dep)) bindClass(dep);
                     }
                 };
                 // The app's own store, resolved like a service, unless the test provides the CooldownStore itself; bound first, as the
@@ -891,8 +1005,12 @@ import { isUserOutcome } from '../common/user-outcome.js';
                     }
                     bindsOwnToken(container, CooldownStore, store);
                 }
-                // Before the controllers, so a class token that is provided is not also bound as itself
-                for (const provider of providers.values())bindProvider(container, provider, bindClass);
+                // Before the controllers, so a class token that is provided is not also bound as itself. A test's provider of a
+                // token the module bound above, as HandlerRegistry or ShardContext, stands in for that binding
+                for (const provider of providers.values()){
+                    if (container.isBound(provider.provide)) container.unbind(provider.provide);
+                    bindProvider(container, provider, bindClass);
+                }
                 for (const ctrl of this.options.controllers ?? [])bindClass(ctrl);
                 for (const service of services)bindClass(service);
                 if (themeResolver) bindClass(themeResolver);
@@ -950,15 +1068,18 @@ import { isUserOutcome } from '../common/user-outcome.js';
                             cooldownStore: true
                         }
                     }));
+                // Recorded as the container makes each one, before anything can be made, so close() shuts down exactly what exists
+                const constructed = new Set();
+                for (const { token } of lifecycle){
+                    container.onActivation(token, (_context, instance)=>{
+                        constructed.add(token);
+                        return instance;
+                    });
+                }
                 // Every check has run, and touched only the container: from here the module is made, once none found an error
                 stopOnStartupErrors();
                 // Every class the module runs, so @UseGuard resolves guards on a direct call to any of them
-                for (const cls of [
-                    ...this.options.controllers ?? [],
-                    ...startup.classes
-                ])Reflect.defineMetadata(META.container, container, cls);
-                // And each instance with the module that made it, as another module made from the same classes stamps them again
-                recordInstanceContainers(container, [
+                prepareDirectCalls(container, [
                     ...this.options.controllers ?? [],
                     ...startup.classes
                 ]);
@@ -969,20 +1090,12 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 });
                 warnInheritedRoutes(this.options.controllers ?? []);
                 warnOverlappingPatterns(this.options.controllers ?? []);
-                warnHandlersOffControllers(this.options.controllers ?? [], appClasses);
-                if (this.options.app) bindAppPresenter(container, this.options.app);
-                // Recorded as the container makes each one, so close() shuts down exactly what exists
-                const constructed = new Set();
-                for (const { token } of lifecycle){
-                    container.onActivation(token, (_context, instance)=>{
-                        constructed.add(token);
-                        return instance;
-                    });
-                }
+                warnHandlersOffControllers(this.options.controllers ?? [], startup.classes);
+                for (const warning of perCallEventWarnings(startup, providers, appPresenterClass))new Logger('TestingModule').warn(warning);
                 const warnUnanswered = this.options.app && Reflect.getMetadata(META.appOptions, this.options.app)?.warnUnanswered;
                 return new TestingModule(container, [
                     ...this.options.controllers ?? []
-                ], appClasses, providers, order, messages, lifecycle, constructed, warnUnanswered, services, this.options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT_MS);
+                ], appClasses, providers, order, messages, lifecycle, constructed, warnUnanswered, services, this.options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, this.options.app);
             });
         } catch (error) {
             if (isRefusal(error) && !isExplainedError(error)) {
@@ -1102,6 +1215,11 @@ import { isUserOutcome } from '../common/user-outcome.js';
    * expect(getResponse(interaction).calls[0].payload).toMatchObject({ content: '1 notes' })
    * ```
    */ static fromApp(app, options = {}) {
+        // An app that isn't a class at all, as a circular import gives, has no metadata to read
+        if (typeof app !== 'function') {
+            const { name, hint } = notAClass(app);
+            throw new TypeError(`${name} is not a @MeoCord app: fromApp takes the class @MeoCord decorates.${hint}`);
+        }
         const appOptions = Reflect.getMetadata(META.appOptions, app);
         if (!appOptions) {
             // A refused @MeoCord stores no options, so its own errors, kept with startupErrors: 'all', say why

package/dist/esm/testing/mock-fn.js

@@ -213,7 +213,13 @@ const collected = new FinalizationRegistry((ref)=>mocks.created.delete(ref));
         instances.push(this);
         contexts.push(this);
         invocationCallOrder.push(++mocks.invocationOrder);
-        // Updated in place as the call settles, so a promise's outcome shows once it resolves or rejects
+        // Recorded as the call starts, so each call's results sit at its own index however calls nest, and filled in as it
+        // ends: a promise's outcome shows in settledResults once it resolves or rejects
+        const result = {
+            type: 'incomplete',
+            value: undefined
+        };
+        results.push(result);
         const settled = {
             type: 'incomplete',
             value: undefined
@@ -261,7 +267,7 @@ const collected = new FinalizationRegistry((ref)=>mocks.created.delete(ref));
             });
             throw err;
         } finally{
-            results.push({
+            Object.assign(result, {
                 type,
                 value
             });