meocord 4.2.2 → 4.2.3

package/dist/cjs/core/index.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-B4MOFBrW.cjs');
+var providers = require('../_shared/providers-BBvbnmLP.cjs');
 var inversify = require('inversify');
 var discord_js = require('discord.js');
-var controller_decorator = require('../_shared/controller.decorator-U2NBWcoU.cjs');
+var controller_decorator = require('../_shared/controller.decorator-hp5xdJU4.cjs');
 require('node:crypto');
-var shardedCooldownStore = require('../_shared/sharded-cooldown-store-HTUb3Ii_.cjs');
-var startupRoots = require('../_shared/startup-roots-lA5xkBFq.cjs');
+var shardedCooldownStore = require('../_shared/sharded-cooldown-store-B62g5O88.cjs');
+var eventSources = require('../_shared/event-sources-DzqTODXg.cjs');
 var enum_index = require('../enum/index.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
@@ -17,13 +17,13 @@ require('crypto');
 require('fs');
 require('path');
 require('cli-table3');
-require('node:url');
 require('dayjs');
 require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-CbBHUu5P.cjs');
+require('node:url');
+require('../_shared/translate-error-wsgfsUET.cjs');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -42,6 +42,22 @@ const REACTION_PARTIALS = [
     discord_js.Partials.Message,
     discord_js.Partials.Reaction
 ];
+const POLLS = [
+    discord_js.GatewayIntentBits.GuildMessagePolls,
+    discord_js.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 = [
+    discord_js.Partials.Message,
+    discord_js.Partials.Poll,
+    discord_js.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([
+    discord_js.Partials.GuildMember,
+    discord_js.Partials.Poll,
+    discord_js.Partials.PollAnswer
+]);
 /** The intents Discord only sends once they are also enabled for the app in the developer portal. */ const PRIVILEGED = new Set([
     discord_js.GatewayIntentBits.GuildMembers,
     discord_js.GatewayIntentBits.GuildPresences,
@@ -79,10 +95,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)=>[
@@ -95,6 +110,26 @@ const REACTION_PARTIALS = [
                 ]
             }
         ])),
+    guildMemberRemove: {
+        intents: [
+            [
+                discord_js.GatewayIntentBits.GuildMembers
+            ]
+        ],
+        partials: [
+            discord_js.Partials.GuildMember
+        ]
+    },
+    guildMemberUpdate: {
+        intents: [
+            [
+                discord_js.GatewayIntentBits.GuildMembers
+            ]
+        ],
+        partials: [
+            discord_js.Partials.GuildMember
+        ]
+    },
     guildAuditLogEntryCreate: {
         intents: [
             [
@@ -227,9 +262,7 @@ const REACTION_PARTIALS = [
         intents: [
             REACTIONS
         ],
-        partials: [
-            discord_js.Partials.Reaction
-        ]
+        partials: REACTION_PARTIALS
     },
     typingStart: {
         intents: [
@@ -241,26 +274,20 @@ const REACTION_PARTIALS = [
     },
     messagePollVoteAdd: {
         intents: [
-            [
-                discord_js.GatewayIntentBits.GuildMessagePolls,
-                discord_js.GatewayIntentBits.DirectMessagePolls
-            ]
-        ]
+            POLLS
+        ],
+        partials: POLL_PARTIALS
     },
     messagePollVoteRemove: {
         intents: [
-            [
-                discord_js.GatewayIntentBits.GuildMessagePolls,
-                discord_js.GatewayIntentBits.DirectMessagePolls
-            ]
-        ]
+            POLLS
+        ],
+        partials: POLL_PARTIALS
     },
     ...Object.fromEntries([
         'guildScheduledEventCreate',
         'guildScheduledEventDelete',
-        'guildScheduledEventUpdate',
-        'guildScheduledEventUserAdd',
-        'guildScheduledEventUserRemove'
+        'guildScheduledEventUpdate'
     ].map((event)=>[
             event,
             {
@@ -271,6 +298,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: [
+            [
+                discord_js.GatewayIntentBits.GuildScheduledEvents
+            ]
+        ],
+        partials: [
+            discord_js.Partials.User
+        ]
+    },
+    guildScheduledEventUserRemove: {
+        intents: [
+            [
+                discord_js.GatewayIntentBits.GuildScheduledEvents
+            ]
+        ],
+        partials: [
+            discord_js.Partials.User
+        ]
+    },
     autoModerationRuleCreate: {
         intents: [
             [
@@ -384,7 +432,7 @@ function intentName(bit) {
         (labels.some((label)=>label.startsWith("@MessageHandler('")) ? "; messages: { mention: 'only' } needs none." : '.') : ''));
     }
     for (const [partial, labels] of missingPartials){
-        warnings.push(`Partials.${discord_js.Partials[partial]} is not in clientOptions.partials, so ${labels.join(', ')} will miss ` + (partial === discord_js.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.${discord_js.Partials[partial]} is not in clientOptions.partials, so ${labels.join(', ')} will miss ` + (partial === discord_js.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;
 }
@@ -405,6 +453,21 @@ function intentName(bit) {
     };
 }
 
+/** Where both builds of this version keep the process's state, as {@link shared} names it. */ const PROCESS_STATE = 'processState';
+/**
+ * What the process's apps share, kept by both builds of this version, so a process that loads both has one pair of
+ * signal listeners and one shutdown, which stops the apps either build started, one exit code a failed start set, and
+ * one end of a failed shard.
+ */ const processState = controller_decorator.shared(PROCESS_STATE, ()=>({
+        /** Closes each started app: runs its shutdown hooks and destroys its client, resolving `false` on failure. */ runningApps: new Set(),
+        stopRequest: stopRequests(),
+        signalHandlersInstalled: false,
+        shuttingDown: undefined,
+        /** Whether a failed start, of a provider's factory or the login, set the exit code, so a later login knows to clear it. */ startFailureSetExitCode: false,
+        /** Whether `meocord start --dev` was told the bot could not log in, so a later login tells it the bot is online. */ toldDevRunnerLoginFailed: false,
+        /** Whether this shard is already ending, so a failure reported twice, as one going on uncaught is, ends it once. */ shardEnding: false
+    }));
+
 /** How long a message to the parent process may take to be sent before the parent is taken to be gone. */ const PARENT_SEND_TIMEOUT_MS = 1000;
 /**
  * Sends a message over the IPC channel to the parent process and waits until it is sent, or `PARENT_SEND_TIMEOUT_MS`:
@@ -516,14 +579,13 @@ const slots = globalThis;
  */ async function tellManager(message) {
     await sendToParent(message);
 }
-/** Whether this shard is already ending, so a failure reported twice, as one going on uncaught is, ends it once. */ let ending = false;
 /**
  * Ends a shard whose startup failed, which its manager restarts unless it was told the failure is one every shard
  * meets: a refusal, told here first, which the manager logs before stopping them all, or a login Discord refused, told
  * as it failed. The exit waits until the caller has handled the error and the manager has the reason.
  */ function endFailedShard(error) {
-    if (ending) return;
-    ending = true;
+    if (processState.shardEnding) return;
+    processState.shardEnding = true;
     const refused = controller_decorator.isRefusal(error);
     const reason = refused && controller_decorator.describeRefusal(error, process.cwd());
     if (refused) {
@@ -624,21 +686,31 @@ const slots = globalThis;
  */ /** Set by `meocord register`: register the commands over REST and exit, without logging in. */ const REGISTER_ONLY_ENV = 'MEOCORD_REGISTER_ONLY';
 /** Set by `meocord register --guild <id>`: register every command to that guild only. */ const REGISTER_GUILD_ENV = 'MEOCORD_REGISTER_GUILD';
 /** Set by `meocord start --force-register` and by `meocord register`: send even an unchanged payload. */ const FORCE_REGISTER_ENV = 'MEOCORD_FORCE_REGISTER';
+/**
+ * Set by the CLI for every bot it starts: `development` or `production`, the mode the command runs in. A bundle built
+ * with `bundleDependencies` has `process.env.NODE_ENV` written in as the mode it was built in, MeoCord's own reads
+ * included, so the command's mode reaches it through this variable instead.
+ */ const REGISTER_MODE_ENV = 'MEOCORD_REGISTER_MODE';
+/**
+ * Whether commands register as development does, to `commands.developmentGuild`: as the CLI command that started the
+ * bot says, else as `NODE_ENV` says.
+ */ function registersAsDevelopment(env = process.env) {
+    const mode = env[REGISTER_MODE_ENV];
+    if (mode === 'development' || mode === 'production') return mode === 'development';
+    return process.env.NODE_ENV === 'development';
+}
 /** Whether this process was started to register commands and exit. */ function isRegisterOnly(env = process.env) {
     return env[REGISTER_ONLY_ENV] === '1';
 }
 
 /** How long an `onReady` hook runs before a warning says the hooks after it are waiting. */ const SLOW_READY_HOOK_MS = 10000;
-/** Closes each started app: runs its shutdown hooks and destroys its client, resolving `false` on failure. */ const runningApps = new Set();
-const stopRequest = stopRequests();
-let signalHandlersInstalled = false;
-let shuttingDown;
+const { runningApps } = processState;
 /**
- * Shuts every started app down and exits, with a code already set or 0, and 1 if a client failed to close. Signals call
- * it, and in a shard its manager's request or its going. A call within `REPEAT_SIGNAL_WINDOW_MS` of the first is the
+ * Shuts every started app down and exits, with the code set when the shutdown began or 0, and 1 if an app failed to
+ * close. Signals call it, and in a shard its manager's request or its going. A call within `REPEAT_SIGNAL_WINDOW_MS` of the first is the
  * same request; one after it forces exit 1, except in a shard, whose manager forces it.
  */ async function shutdownAndExit(shard) {
-    const request = stopRequest();
+    const request = processState.stopRequest();
     if (request !== 'first') {
         // A shard hears Ctrl+C both directly and from its manager, which owns forcing it; so it waits
         if (request === 'duplicate' || shard) return;
@@ -648,23 +720,28 @@ let shuttingDown;
     return shutDown();
 }
 /** The one shutdown of the process, however many ask for it: a stop request joins one already under way. */ function shutDown() {
-    shuttingDown ?? (shuttingDown = (async ()=>{
+    var _processState;
+    (_processState = processState).shuttingDown ?? (_processState.shuttingDown = (async ()=>{
+        // A clean stop keeps a code already set, such as the 1 a failed login set, so a supervisor still sees it. Read as
+        // the shutdown begins: a code main.ts sets as it hears of the stop is the stop's, not a failure.
+        const exitCode = Number(process.exitCode ?? 0) || 0;
         const closed = await Promise.all([
             ...runningApps
         ].map((close)=>close()));
-        // A clean stop keeps a code already set, such as the 1 a failed login set, so a supervisor still sees it
-        process.exit(closed.every(Boolean) ? Number(process.exitCode ?? 0) || 0 : 1);
+        process.exit(closed.every(Boolean) ? exitCode : 1);
     })());
-    return shuttingDown;
+    return processState.shuttingDown;
 }
+/** The errors {@link stoppedBeforeOnline} made, which end a start without being its failure. */ const stops = new WeakSet();
 /** What `start()` rejects with when shutdown begins before the bot came online, which shutdown has logged. */ function stoppedBeforeOnline() {
     const error = new Error('The bot was stopped before it came online.');
     controller_decorator.markExplained(error);
+    stops.add(error);
     return error;
 }
 /** One pair of signal listeners for the process, however many apps it starts, for the role the first decided. */ function installSignalHandlers(shard) {
-    if (signalHandlersInstalled) return;
-    signalHandlersInstalled = true;
+    if (processState.signalHandlersInstalled) return;
+    processState.signalHandlersInstalled = true;
     process.on('SIGINT', ()=>void shutdownAndExit(shard));
     process.on('SIGTERM', ()=>void shutdownAndExit(shard));
     // How `meocord start --dev` stops the application to restart it, a signal being no graceful stop on Windows. It is
@@ -717,13 +794,21 @@ class MeoCordApp {
         }
     }
     /**
-   * Logs the bot in, as {@link MeoCordApplication.start} describes. The providers, services and event handlers are set
-   * up once, or again after a provider's factory failed; a retry after a failed login reuses them.
+   * Logs the bot in, as {@link MeoCordApplication.start} describes. The event handlers are attached once; the providers
+   * and services are made for each start, as a failed one, of a factory or the login, shuts them down and drops them.
    */ async start() {
         if (isRegisterOnly()) return this.registerOnly();
         if (this.stopped) throw new Error('This app was stopped; use MeoCordFactory.create to make a new one.');
         if (this.online) return;
-        this.starting ?? (this.starting = this.startOnce().catch((error)=>{
+        this.starting ?? (this.starting = this.startOnce().catch(async (error)=>{
+            // A failed start stays among the running apps while it shuts down what it made, which a stop meanwhile waits
+            // for, and then while it holds a value it was given open, which a signal closes as stop() does. One that holds
+            // nothing leaves, so a signal later stops only the apps that run; a stopped start stays until its close settles
+            if (!this.closing) {
+                this.undoing = this.undoStart().finally(()=>this.undoing = undefined);
+                await this.undoing;
+                if (!this.closing && !this.holdsOpen()) runningApps.delete(this.close);
+            }
             // A shard ends, for its manager to restart, or to stop all if told it is fatal; a stopped start is the stop's
             if (this.shard && !this.closing) endFailedShard(error);
             throw error;
@@ -744,6 +829,30 @@ class MeoCordApp {
         // As a signal's shutdown exits 1 for a client that failed to close, a code another failure set aside
         if (!await this.close() && !process.exitCode) process.exitCode = 1;
     }
+    /**
+   * Shuts down what a failed start made, by the rule a stop follows, and drops it from the container, so the process
+   * holds nothing of it open and a retry makes it afresh.
+   */ async undoStart() {
+        if (!this.attempt || !this.begun) return;
+        this.begun = false;
+        const { given, constructed } = this.attempt;
+        const entries = this.shutdownEntries().filter(({ token })=>!given.has(token));
+        // A value the app gave stays constructed, so a stop with no retry still closes it
+        for (const token of constructed)if (!given.has(token)) constructed.delete(token);
+        this.readySettled.clear();
+        this.attempt.drop();
+        this.made = false;
+        // Nothing came online, so no call runs and no listener needs removing
+        await eventSources.runShutdownSequence(this.container, ()=>entries, {
+            drainCalls: ()=>this.calls.settled(),
+            timeoutMs: this.shutdownTimeout,
+            hookFailed: (name, error)=>this.logger.error(`onShutdown failed in ${name}:`, error),
+            warn: (message)=>this.logger.warn(message)
+        });
+    }
+    /** Whether a shutdown has an `onShutdown` to run, as for a value the app gave once a failed start is undone. */ holdsOpen() {
+        return this.shutdownEntries().some(({ instance })=>typeof instance.onShutdown === 'function');
+    }
     async startOnce() {
         this.logger.log('Starting bot...');
         // Before the providers are made, so a signal, or a shard's manager, can stop a start that is slow to come online
@@ -754,7 +863,9 @@ class MeoCordApp {
         // A bot runs one app, whose theme code outside any call reads, its providers' factories included; claimed for
         // each start, as a failed one gives it up
         providers.claimAmbientAppTheme(this.container);
-        if (!this.prepared) {
+        if (!this.made) {
+            this.attempt?.begin();
+            this.begun = true;
             // Kept while it runs, so a stop meanwhile waits for it
             this.preparing = this.prepare();
             try {
@@ -762,7 +873,11 @@ class MeoCordApp {
             } finally{
                 this.preparing = undefined;
             }
-            this.prepared = true;
+            this.made = true;
+        }
+        if (!this.attached) {
+            this.attachHandlers();
+            this.attached = true;
         }
         if (this.loginFailed) {
             controller_decorator.warnDeprecatedBehaviour(this.logger, 'Retrying start() after a failed login', 'rejects', 'MeoCordFactory.create to make a new app');
@@ -770,7 +885,7 @@ class MeoCordApp {
         }
         await this.login();
     }
-    /** Makes the provided values and listed services, and attaches the Discord event handlers. */ async prepare() {
+    /** Makes the provided values and listed services. */ async prepare() {
         // Every provided value is made before anything that injects it is resolved, and before login
         if (this.startup) {
             try {
@@ -782,7 +897,7 @@ class MeoCordApp {
                 providers.releaseAmbientAppTheme(this.container);
                 if (process.exitCode === undefined || process.exitCode === 0) {
                     process.exitCode = 1;
-                    MeoCordApp.failedLoginSetExitCode = true;
+                    processState.startFailureSetExitCode = true;
                 }
                 throw error;
             }
@@ -795,6 +910,8 @@ class MeoCordApp {
             this.storeReady = Promise.withResolvers();
             providers.waitForCooldownStore(this.container, this.storeReady.promise);
         }
+    }
+    /** Attaches the Discord event handlers. */ attachHandlers() {
         this.bot.on('clientReady', (readyClient)=>this.runListener('clientReady', async ()=>{
                 // Only for activities the app listed: without them, a status it sets itself stays as it set it
                 if (this.activities?.length) {
@@ -807,7 +924,7 @@ class MeoCordApp {
                 if (!this.shard) await this.registerCommands();
                 await readyHooks;
             }));
-        this.bot.on('interactionCreate', startupRoots.ownInteractionListener((interaction)=>this.runListener('interactionCreate', ()=>this.dispatcher.interaction(interaction), interactionLabel(interaction))));
+        this.bot.on('interactionCreate', eventSources.ownInteractionListener((interaction)=>this.runListener('interactionCreate', ()=>this.dispatcher.interaction(interaction), interactionLabel(interaction))));
         this.bot.on('messageCreate', (message)=>this.runListener('messageCreate', ()=>this.dispatcher.message(message)));
         this.bot.on('messageReactionAdd', (reaction, user)=>this.runListener('messageReactionAdd', ()=>this.dispatcher.reaction(reaction, {
                     user,
@@ -819,9 +936,10 @@ class MeoCordApp {
                 })));
         // discord.js drops a reaction in a DM channel it has not cached; this fetches the channel and delivers it
         deliverUncachedDmReactions(this.bot, this.logger);
-        this.attachEventHandlers();
-        this.warnAboutMissingRequirements();
-        this.noteGlobalStagesOnEvents();
+        const sources = this.eventSources();
+        this.attachEventHandlers(sources);
+        this.warnAboutMissingRequirements(sources);
+        this.noteGlobalStagesOnEvents(sources);
     }
     /** Logs the bot in, setting the exit code when that fails and clearing it when a later attempt succeeds. */ async login() {
         // Checked here as well, after the last await before the login: from here to setting abortLogin runs in one turn,
@@ -842,7 +960,6 @@ class MeoCordApp {
             ]);
         } catch (error) {
             if (this.closing) throw error;
-            runningApps.delete(this.close);
             // A bot that never came online is not the app whose theme is read outside calls
             providers.releaseAmbientAppTheme(this.container);
             const fatal = fatalLoginCode(error);
@@ -857,12 +974,12 @@ class MeoCordApp {
             if (fatal) await reportFatalLogin(this.shard, fatal, explanation ?? (error instanceof Error ? error.message : String(error)));
             if (process.exitCode === undefined || process.exitCode === 0) {
                 process.exitCode = 1;
-                MeoCordApp.failedLoginSetExitCode = true;
+                processState.startFailureSetExitCode = true;
             }
             await tellDevRunner({
                 meocord: 'login-failed'
             }, this.shard);
-            MeoCordApp.toldDevRunnerLoginFailed = true;
+            processState.toldDevRunnerLoginFailed = true;
             this.loginFailed = true;
             throw error;
         } finally{
@@ -871,12 +988,12 @@ class MeoCordApp {
         // A shutdown that began as the login completed has the client to close; the bot is not reported online
         if (this.closing) throw stoppedBeforeOnline();
         // 0 rather than undefined, which Bun ignores
-        if (MeoCordApp.failedLoginSetExitCode && process.exitCode === 1) {
+        if (processState.startFailureSetExitCode && process.exitCode === 1) {
             process.exitCode = 0;
-            MeoCordApp.failedLoginSetExitCode = false;
+            processState.startFailureSetExitCode = false;
         }
-        if (MeoCordApp.toldDevRunnerLoginFailed) {
-            MeoCordApp.toldDevRunnerLoginFailed = false;
+        if (processState.toldDevRunnerLoginFailed) {
+            processState.toldDevRunnerLoginFailed = false;
             await tellDevRunner({
                 meocord: 'online'
             }, this.shard);
@@ -886,11 +1003,16 @@ class MeoCordApp {
     }
     /**
    * Registers the application's commands with Discord, where `meocord.config.ts`'s `commands` says. Runs once the bot
-   * is ready, except in a shard, whose manager registers. It never throws: a failure is logged and the bot stays
+   * is ready, except in a shard, whose manager registers. Called before the bot is online, it logs a warning and
+   * registers nothing, as the application comes from the login. It never throws: a failure is logged and the bot stays
    * online.
    */ async registerCommands() {
+        // discord.js sets the application when the gateway's READY arrives
         const applicationId = this.bot.application?.id;
-        if (!applicationId) return;
+        if (!applicationId) {
+            this.logger.warn('registerCommands() registers nothing before the bot is online, as Discord names the application at login. ' + 'The bot registers once it is online; to register without logging in, run `meocord register`.');
+            return;
+        }
         const config = controller_decorator.loadMeoCordConfig()?.commands;
         if (config?.register === false) {
             this.logger.log('Command registration is off (commands.register: false); run `meocord register` to register.');
@@ -902,7 +1024,7 @@ class MeoCordApp {
             controllerClasses: this.controllerClasses,
             logger: this.logger,
             config,
-            development: process.env.NODE_ENV === 'development',
+            development: registersAsDevelopment(),
             force: process.env[FORCE_REGISTER_ENV] === '1'
         });
     }
@@ -933,24 +1055,25 @@ class MeoCordApp {
             controllerClasses: this.controllerClasses,
             logger: this.logger,
             config: controller_decorator.loadMeoCordConfig()?.commands,
-            development: process.env.NODE_ENV === 'development',
+            development: registersAsDevelopment(),
             onlyGuild: process.env[REGISTER_GUILD_ENV],
             force: true
         });
         process.exit(registered ? 0 : 1);
     }
     /**
-   * Adds a client listener for every `@On` and `@Once` handler on the app's controllers and services, each event run on
-   * the class's one instance from the container. Each call is isolated: an error is logged against the event and the
-   * handler, and the next listener still runs.
-   */ attachEventHandlers() {
-        for (const lifecycleClass of this.lifecycleClasses){
-            for (const { event, method, once } of providers.getEventHandlers(lifecycleClass.prototype)){
-                const logError = (error)=>this.logger.error(`Error handling event "${event}" in ${lifecycleClass.name}.${method}:`, error);
+   * Adds a client listener for every `@On` and `@Once` handler on each instance whose lifecycle hooks run, in lifecycle
+   * order, each event run on the instance the container holds. Each call is isolated: an error is logged against the
+   * event and the handler, and the next listener still runs.
+   */ attachEventHandlers(sources) {
+        for (const source of sources){
+            const { name } = source.cls;
+            for (const { event, method, once } of source.handlers){
+                const logError = (error)=>this.logger.error(`Error handling event "${event}" in ${name}.${method}:`, error);
                 // An error no filter handles is logged, with the handler. A guard denying an event only filters which
                 // events the handler takes, and a UserError is meant for the sender of the event's message, if it has one
                 const fallback = async (error, context)=>{
-                    const where = `event "${event}" in ${lifecycleClass.name}.${method}`;
+                    const where = `event "${event}" in ${name}.${method}`;
                     if (error instanceof controller_decorator.GuardDeniedError) this.logger.debug(`Denied ${where}: ${controller_decorator.escapeForLog(error.message)}`);
                     else if (error instanceof controller_decorator.UserError) {
                         this.logger.debug(`Refused ${where}: ${controller_decorator.escapeForLog(error.message)}`);
@@ -958,16 +1081,16 @@ class MeoCordApp {
                         const message = [
                             ...context.getArgs()
                         ].reverse().find((arg)=>arg instanceof discord_js.Message);
-                        if (message) return startupRoots.replyWithUserError(message, error, this.logger, this.messageOptions?.replyEmoji);
+                        if (message) return eventSources.replyWithUserError(message, error, this.logger, this.messageOptions?.replyEmoji);
                     } else logError(error);
                     return undefined;
                 };
-                const label = `@${once ? 'Once' : 'On'}('${event}') in ${lifecycleClass.name}.${method}`;
+                const label = `@${once ? 'Once' : 'On'}('${event}') in ${name}.${method}`;
                 // A call, as a dispatched one is, which shutdown waits for
                 const listener = (...args)=>this.calls.run(label, async ()=>{
                         try {
-                            const instance = this.container.get(lifecycleClass);
-                            await providers.runHandler(this.container, instance, method, args, {
+                            const instance = source.resolve();
+                            if (instance) await providers.runHandler(this.container, instance, method, args, {
                                 fallback,
                                 type: 'event'
                             });
@@ -984,8 +1107,8 @@ class MeoCordApp {
     /**
    * Says, once per stage, which global guards and interceptors declare no `types` and so also run
    * before `@On` and `@Once` handlers, when the app has any.
-   */ noteGlobalStagesOnEvents() {
-        if (!this.lifecycleClasses.some((cls)=>providers.getEventHandlers(cls.prototype).length > 0)) return;
+   */ noteGlobalStagesOnEvents(sources) {
+        if (sources.length === 0) return;
         const { guards, interceptors } = providers.globalStagesOf(this.container);
         for (const [label, decorator, entries] of [
             [
@@ -1008,29 +1131,29 @@ class MeoCordApp {
     /**
    * Warns about handlers whose events the client options will not deliver, once per missing intent or partial. Only a
    * controller's message and reaction handlers are counted, as only those run.
-   */ warnAboutMissingRequirements() {
+   */ warnAboutMissingRequirements(sources) {
         const options = this.bot.options;
         if (!options?.intents) return;
-        const controllers = new Set(this.controllerClasses);
         const handlers = [];
-        for (const lifecycleClass of this.lifecycleClasses){
-            const prototype = lifecycleClass.prototype;
-            for (const { event, method, once } of providers.getEventHandlers(prototype)){
+        for (const { cls, handlers: events } of sources){
+            for (const { event, method, once } of events){
                 handlers.push({
-                    label: `@${once ? 'Once' : 'On'}('${event}') in ${lifecycleClass.name}.${method}`,
+                    label: `@${once ? 'Once' : 'On'}('${event}') in ${cls.name}.${method}`,
                     requirements: eventRequirements(event)
                 });
             }
-            if (!controllers.has(lifecycleClass)) continue;
+        }
+        for (const controller of this.controllerClasses){
+            const prototype = controller.prototype;
             for (const handler of controller_decorator.getMessageHandlers(prototype)){
                 handlers.push({
-                    label: `${startupRoots.messageDecorator(handler.pattern)} in ${lifecycleClass.name}.${handler.method}`,
+                    label: `${eventSources.messageDecorator(handler.pattern)} in ${controller.name}.${handler.method}`,
                     requirements: messageHandlerRequirements(handler, this.messageOptions ?? {})
                 });
             }
             for (const { emoji, method } of controller_decorator.getReactionHandlers(prototype)){
                 handlers.push({
-                    label: `${startupRoots.reactionDecorator(emoji)} in ${lifecycleClass.name}.${method}`,
+                    label: `${eventSources.reactionDecorator(emoji)} in ${controller.name}.${method}`,
                     requirements: REACTION_HANDLER_REQUIREMENTS
                 });
             }
@@ -1042,11 +1165,9 @@ class MeoCordApp {
    * at a time, in dependency order. A failure is logged and the next one still runs, with a warning for each hook
    * whose dependencies failed. Once shutdown begins, no further hook starts.
    */ async runReadyHooks(client) {
-        const entries = [];
-        this.lifecycleEntries = entries;
-        await this.readyPass.run(()=>startupRoots.runReadyHooks(this.container, this.lifecycleUnits, client, {
+        await this.readyPass.run(()=>eventSources.runReadyHooks(this.container, this.lifecycleUnits, client, {
                 primary: client.shard ? client.shard.ids.includes(0) : true
-            }, entries, {
+            }, {
                 resolveFailed: (unit, error)=>this.logger.error(`Could not resolve ${unit.name} to run its lifecycle hooks:`, error),
                 hookFailed: (unit, error)=>this.logger.error(`onReady failed in ${unit.name}:`, error),
                 dependsOnFailed: (unit, failed)=>this.logger.warn(`Running onReady in ${unit.name} although it depends on ${failed.map(({ name })=>name).join(', ')}, which failed.`),
@@ -1055,15 +1176,37 @@ class MeoCordApp {
             {
                 stopped: ()=>this.closing,
                 slowAfterMs: SLOW_READY_HOOK_MS,
-                settled: (unit)=>unit.cooldownStore && this.storeReady?.resolve(),
+                settled: (unit)=>{
+                    this.readySettled.add(unit.token);
+                    if (unit.cooldownStore) this.storeReady?.resolve();
+                },
                 runOnReady: this.readyPass.runOnReady
             }));
         // Also when shutdown stopped the hooks before the store's, so no call waits on it
         this.storeReady?.resolve();
     }
-    /** Runs the `onShutdown` hooks through the shutdown sequence, within the configured `shutdownTimeout`. */ async runShutdownHooks() {
-        // Read once the onReady in progress settled; a login that failed never ran onReady, so there is no onShutdown to undo
-        await startupRoots.runShutdownSequence(this.container, ()=>this.lifecycleEntries ?? [], {
+    /**
+   * The units a shutdown closes: each one the container constructed whose `onReady`, and that of every unit it depends
+   * on, has settled or doesn't exist, in dependency order. A unit whose `onReady` never ran gets no `onShutdown`, so a
+   * hook that undoes `onReady` never runs without it, and neither does anything that depends on it.
+   */ shutdownEntries() {
+        const units = new Set(this.lifecycleUnits.map(({ token })=>token));
+        const closes = new Set();
+        const entries = [];
+        for (const unit of this.lifecycleUnits){
+            if (!this.attempt?.constructed.has(unit.token)) continue;
+            // Already made, so this returns the instance; a provided value may be anything, null included
+            const instance = this.container.get(unit.token) ?? {};
+            const ready = typeof instance.onReady !== 'function' || this.readySettled.has(unit.token);
+            if (!ready || unit.dependencies.some((dependency)=>units.has(dependency) && !closes.has(dependency))) continue;
+            closes.add(unit.token);
+            entries.push(eventSources.lifecycleEntry(unit, instance));
+        }
+        return entries;
+    }
+    /** Runs the `onShutdown` hooks through the shutdown sequence, within `timeoutMs`: the stop's share of `shutdownTimeout`. */ async runShutdownHooks(timeoutMs) {
+        // Read once the onReady in progress settled
+        await eventSources.runShutdownSequence(this.container, ()=>this.shutdownEntries(), {
             // No new call starts once the listeners are gone; an error the client emits meanwhile still has its listeners
             drainCalls: ()=>{
                 const emitter = this.bot;
@@ -1073,7 +1216,7 @@ class MeoCordApp {
             drainAlways: true,
             runningCalls: ()=>this.calls.running(),
             readyPass: this.readyPass,
-            timeoutMs: this.shutdownTimeout,
+            timeoutMs,
             hookFailed: (name, error)=>this.logger.error(`onShutdown failed in ${name}:`, error),
             warn: (message)=>this.logger.warn(message)
         });
@@ -1081,7 +1224,8 @@ class MeoCordApp {
     /**
    * Runs the shutdown hooks, if the ready hooks ran, then destroys the client; a stop during login ends the login.
    *
-   * @returns Whether the client closed cleanly, which an ended login counts as.
+   * @returns Whether the client closed cleanly, which an ended login counts as, and the startup it waited for, if any,
+   * did not fail.
    */ async closeClient() {
         this.closing = true;
         try {
@@ -1094,80 +1238,98 @@ class MeoCordApp {
     /**
    * Waits for the startup under way to stop making providers and services, at most `shutdownTimeout`; past it, warns
    * with the factory it still awaits, which then makes nothing more.
+   *
+   * @returns Whether the startup failed meanwhile, as a provider's factory that rejects does, rather than stopping.
    */ async waitForStartup(preparing) {
         let timer;
         const outlasted = new Promise((resolve)=>{
-            timer = setTimeout(()=>resolve(true), this.shutdownTimeout);
+            timer = setTimeout(()=>resolve('outlasted'), this.shutdownTimeout);
         });
-        const settled = preparing.then(()=>false, ()=>false);
-        if (await Promise.race([
+        const settled = preparing.then(()=>'stopped', (error)=>error instanceof Error && stops.has(error) ? 'stopped' : 'failed');
+        const outcome = await Promise.race([
             settled,
             outlasted
-        ])) {
+        ]);
+        clearTimeout(timer);
+        if (outcome === 'outlasted') {
             const what = this.pendingProvider ? `the factory providing ${this.pendingProvider}` : 'its providers';
             this.logger.warn(`The startup still waits for ${what} after ${this.shutdownTimeout} ms; shutting down without it.`);
         }
-        clearTimeout(timer);
+        return outcome === 'failed';
     }
     async shutDownClient() {
         this.logger.log('Shutting down bot...');
-        // So nothing is made after the bot has shut down
-        if (this.preparing) await this.waitForStartup(this.preparing);
-        // Nothing came online, so there are no hooks to undo; the listeners go first, so none of them runs
+        // A failed start's shutdown under way finishes first, so its hooks run in full, before those of what it left open.
+        // `shutdownTimeout` bounds the whole stop, as a shard's manager waits only that long, so the rest gets what is left
+        let timeoutMs = this.shutdownTimeout;
+        if (this.undoing) {
+            const waitedFrom = Date.now();
+            await this.undoing;
+            timeoutMs = Math.max(0, timeoutMs - (Date.now() - waitedFrom));
+        }
+        // So nothing is made after the bot has shut down; a factory that fails meanwhile is a failure of the stop too
+        const startupFailed = this.preparing !== undefined && await this.waitForStartup(this.preparing);
+        // Nothing came online, so no onReady ran; the listeners go first, so none of them runs, then what the start made
+        // without an onReady to wait for shuts down
         if (this.abortLogin) {
             this.logger.log('The bot was still logging in, so it stops without coming online');
             this.bot.removeAllListeners();
             this.abortLogin();
+            await this.runShutdownHooks(timeoutMs);
             this.logger.log('Bot has shut down');
             return true;
         }
         if (this.activityInterval) clearInterval(this.activityInterval);
         // The calls drain on every shutdown, and the onReady in progress settles first
-        await this.runShutdownHooks();
+        await this.runShutdownHooks(timeoutMs);
         try {
             this.bot.removeAllListeners();
             await this.bot.destroy();
             this.logger.log('Bot has shut down');
-            return true;
+            return !startupFailed;
         } catch (error) {
             this.logger.error('Error during shutdown:', error);
             return false;
         }
     }
-    constructor(controllerClasses, container, discordClient, discordToken, activities, lifecycleClasses = [], shutdownTimeout, startup, lifecycleUnits, messageOptions = {}, warnUnanswered = false, /** Whether a manager spawned this process, as `MeoCordFactory.create` decided before anything could change it. */ shard = false){
+    constructor(controllerClasses, container, discordClient, discordToken, activities, /** The instances whose `@On` and `@Once` handlers run, read once the providers are made. */ eventSources$1 = ()=>[], shutdownTimeout, startup, lifecycleUnits, messageOptions = {}, warnUnanswered = false, /** Whether a manager spawned this process, as `MeoCordFactory.create` decided before anything could change it. */ shard = false, /** What each start makes; without one, as an app built by hand in a spec, nothing is shut down before ready. */ attempt){
         this.controllerClasses = controllerClasses;
         this.container = container;
         this.discordClient = discordClient;
         this.discordToken = discordToken;
         this.activities = activities;
-        this.lifecycleClasses = lifecycleClasses;
+        this.eventSources = eventSources$1;
         this.startup = startup;
         this.messageOptions = messageOptions;
         this.shard = shard;
+        this.attempt = attempt;
         this.logger = new controller_decorator.Logger(MeoCordApp.name);
-        this.fallback = startupRoots.createFallback(this.logger, ()=>this.messageOptions, {
+        this.fallback = eventSources.createFallback(this.logger, ()=>this.messageOptions, {
             cooldownNotice: (refusal)=>providers.claimCooldownNotice(this.container, refusal),
             storeDownNotice: (who)=>providers.claimStoreDownNotice(this.container, who)
         });
         this.activityInterval = null;
         /** Where the activities' rotation is: the index of the next one shown. */ this.nextActivity = 0;
         /** Whether shutdown has begun, so the ready hooks start no more. */ this.closing = false;
+        /** The tokens of the units whose `onReady` the ready pass has settled, or found they have none. */ this.readySettled = new Set();
         /**
    * Closes the app once, however many stops and signals ask: whether the client was destroyed cleanly. The app stays
    * among the running ones until the close settles, so a signal or a manager's request meanwhile waits for it.
    */ this.close = ()=>this.stopped ?? (this.stopped = this.closeClient().finally(()=>runningApps.delete(this.close)));
-        /** The calls under way, which shutdown waits for, less one that asked the app to stop. */ this.calls = new startupRoots.RunningCalls();
-        /** The ready hooks' pass, whose `onReady` in progress shutdown waits for, less one that asked the app to stop. */ this.readyPass = new startupRoots.ReadyPass();
-        /** Whether the providers, services and event handlers are set up, which a retry after a failed login reuses. */ this.prepared = false;
+        /** The calls under way, which shutdown waits for, less one that asked the app to stop. */ this.calls = new eventSources.RunningCalls();
+        /** The ready hooks' pass, whose `onReady` in progress shutdown waits for, less one that asked the app to stop. */ this.readyPass = new eventSources.ReadyPass();
+        /** Whether a start has marked where it began and not been undone, so a failed one drops what it made exactly once. */ this.begun = false;
+        /** Whether this start's providers and services are made; a failed start drops them, so a retry makes them again. */ this.made = false;
+        /** Whether the Discord event handlers are attached, once for the app: they resolve what they run as each event comes. */ this.attached = false;
         /** Whether the bot logged in, after which `start()` has nothing to do. */ this.online = false;
         /** Whether a login of this app failed, so a retry restores the client discord.js destroyed. */ this.loginFailed = false;
         // First, so nothing logged from here on, before login or after, prints it
         controller_decorator.hideInLogs(discordToken);
-        this.lifecycleUnits = lifecycleUnits ?? providers.classUnits(container, lifecycleClasses);
+        this.lifecycleUnits = lifecycleUnits ?? [];
         this.bot = this.discordClient;
         // Built now, so a pattern that cannot be read or two that match the same messages or customIds stop the bot as it
         // is created, before start() attaches anything
-        this.dispatcher = new startupRoots.Dispatcher({
+        this.dispatcher = new eventSources.Dispatcher({
             container,
             controllerClasses,
             messageOptions,
@@ -1178,11 +1340,9 @@ class MeoCordApp {
         });
         this.dispatcher.getComponentRoutes();
         // Read through the config's own check: a bot started without the CLI loads its config unchecked
-        this.shutdownTimeout = startupRoots.shutdownTimeoutOf(shutdownTimeout, (message)=>this.logger.warn(message));
+        this.shutdownTimeout = eventSources.shutdownTimeoutOf(shutdownTimeout, (message)=>this.logger.warn(message));
     }
 }
-/** Whether a failed login set the process exit code, so a later successful one knows to clear it. */ MeoCordApp.failedLoginSetExitCode = false;
-/** Whether `meocord start --dev` was told the bot could not log in, so a later login tells it the bot is online. */ MeoCordApp.toldDevRunnerLoginFailed = false;
 
 /** The mode whose .env files Bun reads for a `NODE_ENV`: `production` or `test` as given, else `development`. */ const envMode = (nodeEnv)=>nodeEnv === 'production' || nodeEnv === 'test' ? nodeEnv : 'development';
 /**
@@ -1214,16 +1374,11 @@ class MeoCordApp {
     const productionFiles = envFiles('production');
     // In Bun's order, a later file winning, as the config's dotenv also settles them
     const production = Object.assign({}, ...productionFiles.map((file)=>read(root, file)));
-    const development = new Map();
-    for (const file of envFiles(env.NODE_ENV).filter((file)=>!productionFiles.includes(file))){
-        for (const [key, value] of Object.entries(read(root, file)))development.set(key, {
-            value,
-            file
-        });
-    }
+    const files = envFiles(env.NODE_ENV);
+    // Listed file by file, in Bun's order
     const loaded = [
-        ...development
-    ].filter(([key, { value }])=>env[key] === value && production[key] !== value);
+        ...bunLoadedValues(env, root, files)
+    ].filter(([key, { value, file }])=>!productionFiles.includes(file) && env[key] === value && production[key] !== value).sort(([, a], [, b])=>files.indexOf(a.file) - files.indexOf(b.file));
     if (loaded.length === 0) return none;
     return {
         files: [
@@ -1237,6 +1392,68 @@ class MeoCordApp {
     const mode = envMode(nodeEnv);
     return `Bun loaded ${controller_decorator.listed(files)} because NODE_ENV is ${nodeEnv || 'unset'}, and this is a production build, so ` + `${controller_decorator.listed(keys)} ${keys.length === 1 ? `has its ${mode} value` : `have their ${mode} values`}; set ` + 'NODE_ENV=production, or start with `bun --no-env-file`.';
 }
+/**
+ * The value Bun gives each variable the .env files set, and the file it comes from: Bun loads them before any code
+ * runs, the file that wins in `files` first, sets only a variable not already set, and expands `$NAME`, `${NAME}` and
+ * `${NAME:-default}` line by line from what is set so far, a later line of the same file giving its text as written.
+ * A variable the shell set keeps the shell's value, which `env` holds, so it differs from the one given here.
+ */ function bunLoadedValues(env, root, files) {
+    // Each variable's first line in Bun's order: the one Bun loads it from
+    const lines = [];
+    const first = new Map();
+    for (const file of [
+        ...files
+    ].reverse()){
+        const own = read(root, file);
+        for (const [key, text] of Object.entries(own)){
+            if (!first.has(key)) first.set(key, lines.length);
+            lines.push({
+                key,
+                text,
+                file,
+                own
+            });
+        }
+    }
+    const values = new Map();
+    const fromShell = new Map();
+    // A variable the shell set holds a value its line doesn't give; one its own line refers to back counts as from it
+    const shellSet = (key)=>{
+        if (!fromShell.has(key)) {
+            fromShell.set(key, false);
+            fromShell.set(key, env[key] !== undefined && env[key] !== valueAt(first.get(key)));
+        }
+        return fromShell.get(key);
+    };
+    const valueAt = (index)=>{
+        if (!values.has(index)) {
+            const { text, file, own } = lines[index];
+            const lookup = (name)=>{
+                const at = first.get(name);
+                if (at === undefined || shellSet(name) || at < index) return env[name] ?? '';
+                // Not loaded yet: its text as written in this file, or unset until a later file loads it
+                return lines[at].file === file ? own[name] : '';
+            };
+            values.set(index, expandAsBun(text, lookup));
+        }
+        return values.get(index);
+    };
+    return new Map([
+        ...first
+    ].map(([key, index])=>[
+            key,
+            {
+                value: valueAt(index),
+                file: lines[index].file
+            }
+        ]));
+}
+/** A `$NAME` or `${NAME}` reference, with `${NAME:-default}`'s default, or a `\$` Bun reads as a dollar sign. */ const BUN_REFERENCE = /\\\$|\$\{([A-Za-z0-9_]+)(?::-([^}]*))?\}|\$([A-Za-z0-9_]+)/g;
+/** A .env value as Bun expands it, each reference read through `lookup`; any other `$` stays as it is. */ const expandAsBun = (text, lookup)=>text.replace(BUN_REFERENCE, (match, braced, fallback, bare)=>{
+        if (match === '\\$') return '$';
+        const value = lookup(braced ?? bare);
+        return fallback !== undefined && value === '' ? fallback : value;
+    });
 /** A .env file's values, or none when it is not there to read. */ function read(root, file) {
     let text;
     try {
@@ -1279,7 +1496,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             return this.exit(1);
         }
         this.logger.log('Starting shards in separate processes...');
-        if (!await this.register()) return this.exitForLogin();
+        const registered = await this.register();
+        // A stop that came while it waited ends the start here: nothing after it asks Discord, spawns, listens or exits
+        if (this.stopping) return;
+        if (!registered) return this.exitForLogin();
         process.on('SIGINT', ()=>void this.stopAndExit());
         process.on('SIGTERM', ()=>void this.stopAndExit());
         // How `meocord start --dev` stops the bot to restart it; no stop request of the user's, whose first Ctrl+C joins it
@@ -1289,6 +1509,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             const shards = config.sharding?.shards ?? 'auto';
             total = shards === 'auto' ? await (this.options.recommendedShardCount ?? discord_js.fetchRecommendedShardCount)(token) : shards;
         } catch (error) {
+            if (this.stopping) return;
             if (isRefusedToken(error)) {
                 this.logger.error(tokenMessage(token));
                 this.logger.debug('Asking for the shard count failed:', error);
@@ -1297,6 +1518,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             }
             return this.exitForLogin();
         }
+        if (this.stopping) return;
         const manager = (this.options.createManager ?? ((path, opts)=>new discord_js.ShardingManager(path, opts)))(file, {
             token,
             totalShards: total,
@@ -1330,13 +1552,15 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         try {
             const rest = this.options.createRest?.(token) ?? new discord_js.REST().setToken(token);
             const applicationId = (await rest.get(discord_js.Routes.currentApplication())).id;
+            // Stopped while it asked: the commands are left as they are
+            if (this.stopping) return true;
             await providers.registerCommands({
                 rest,
                 applicationId,
                 controllerClasses,
                 logger: this.logger,
                 config: config.commands,
-                development: process.env.NODE_ENV === 'development',
+                development: registersAsDevelopment(),
                 force: process.env[FORCE_REGISTER_ENV] === '1'
             });
         } catch (error) {
@@ -1378,7 +1602,8 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         if (this.now() - state.spawnedAt >= RESPAWN_RESET_MS) state.attempts = 0;
         const delay = Math.min(RESPAWN_BASE_MS * 2 ** state.attempts, RESPAWN_CAP_MS);
         state.attempts++;
-        this.logger.warn(`Shard ${shard.id} exited with code ${child?.exitCode ?? 'unknown'}; restarting it in ${delay} ms.`);
+        const how = child?.signalCode ? `on ${child.signalCode}` : `with code ${child?.exitCode ?? 'unknown'}`;
+        this.logger.warn(`Shard ${shard.id} exited ${how}; restarting it in ${delay} ms.`);
         state.timer = setTimeout(()=>{
             state.timer = undefined;
             if (!this.stopping && !this.fatal) void this.spawn(shard);
@@ -1451,7 +1676,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                 if (shard.process) shard.kill();
             });
         }
-        const wait = this.shutdownTimeout + startupRoots.SHUTDOWN_MARGIN_MS;
+        const wait = this.shutdownTimeout + eventSources.SHUTDOWN_MARGIN_MS;
         let timer;
         const timedOut = new Promise((resolve)=>{
             timer = setTimeout(()=>resolve('timeout'), wait);
@@ -1492,7 +1717,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         this.sleep = options.sleep ?? sleep;
         this.now = options.now ?? (()=>Date.now());
         this.stopRequest = stopRequests(this.now);
-        this.shutdownTimeout = startupRoots.shutdownTimeoutOf(options.config.shutdownTimeout, (message)=>this.logger.warn(message));
+        this.shutdownTimeout = eventSources.shutdownTimeoutOf(options.config.shutdownTimeout, (message)=>this.logger.warn(message));
     }
 }
 
@@ -1507,8 +1732,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
     container.bind(cls).toSelf().inSingletonScope();
     // By constructor type or @inject token; an interface-typed parameter records Object, which is skipped
     for (const dep of providers.injectedTokens(cls)){
-        if (dep === controller_decorator.Translator && !container.isBound(controller_decorator.Translator)) controller_decorator.startupError(controller_decorator.missingTranslatorError(cls));
-        else if (providers.isAppClassToken(dep)) bindDependencies(container, dep, providers$1);
+        if (providers.isAppClassToken(dep)) bindDependencies(container, dep, providers$1);
     }
 }
 /**
@@ -1597,6 +1821,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                     controller_decorator.markExplained(error);
                 }
             }
+            // A built bot that refuses its app exits 1, as one whose start fails does, whatever main.ts does with the error
+            if (!shard && controller_decorator.isBuiltApplication() && controller_decorator.isRefusal(error) && (process.exitCode === undefined || process.exitCode === 0)) {
+                process.exitCode = 1;
+            }
             throw error;
         }
     }
@@ -1627,31 +1855,31 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         // error each check finds is reported, the first thrown
         const providers$1 = controller_decorator.collectStartupErrors(()=>{
             declared.forEach(controller_decorator.startupError);
-            startupRoots.assertDistinctCommands(options.controllers);
+            eventSources.assertDistinctCommands(options.controllers);
             const providers$1 = providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
             providers.assertProvidedServices(typeof target === 'function' ? target.name : String(target), options.services ?? [], providers$1, '@MeoCord({ providers })');
             return providers$1;
         });
         // A themeFor class is bound on its own, as the cooldown store is, and resolved like a service
         const themeResolver = controller_decorator.themeResolverClass(options.themeFor);
-        // The app's classes and every class they inject, which the container binds
-        const roots = [
-            ...options.controllers,
-            ...options.services ?? [],
-            ...themeResolver ? [
-                themeResolver
-            ] : [],
-            ...options.cooldownStore ? [
-                options.cooldownStore
-            ] : [],
-            ...providers.appObservers(target)
-        ];
+        // Every class the app runs, its stages and presenter and what they inject included
+        const stages = providers.appStages(target);
+        const runs = eventSources.startupClasses({
+            controllers: options.controllers,
+            services: options.services ?? [],
+            providers: providers$1,
+            stages,
+            presenter: options.presenter,
+            cooldownStore: options.cooldownStore,
+            themeFor: options.themeFor,
+            observers: providers.appObservers(target)
+        });
         // A shard's manager runs the same checks, so a sharded bot warns once
         if (!shard) {
-            startupRoots.warnUnregisteredCommands(options.controllers);
-            startupRoots.warnInheritedRoutes(options.controllers);
-            startupRoots.warnOverlappingPatterns(options.controllers);
-            startupRoots.warnHandlersOffControllers(options.controllers, providers.reachableClasses(roots, providers$1));
+            eventSources.warnUnregisteredCommands(options.controllers);
+            eventSources.warnInheritedRoutes(options.controllers);
+            eventSources.warnOverlappingPatterns(options.controllers);
+            eventSources.warnHandlersOffControllers(options.controllers, runs.classes);
             const developmentEnv = bunDevelopmentValues();
             if (developmentEnv.keys.length > 0) {
                 this.logger.warn(bunDevelopmentWarning(developmentEnv));
@@ -1672,20 +1900,9 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         }
         // The checks of what the app binds and runs report every error each finds, and the first is thrown
         return controller_decorator.collectStartupErrors(()=>{
-            // Every class the app runs, its stages and presenter included, checked before binding, where inversify would
-            // otherwise fail first with an error about compiler options, or a guard only at its first call
-            const stages = providers.appStages(target);
-            const runs = startupRoots.startupClasses({
-                controllers: options.controllers,
-                services: options.services ?? [],
-                providers: providers$1,
-                stages,
-                presenter: options.presenter,
-                cooldownStore: options.cooldownStore,
-                themeFor: options.themeFor,
-                observers: providers.appObservers(target)
-            });
-            startupRoots.assertStartupClasses(runs, {
+            // Every class the app runs checked before binding, where inversify would otherwise fail first with an error about
+            // compiler options, or a guard only at its first call
+            eventSources.assertStartupClasses(runs, {
                 translator: options.i18n !== undefined || providers$1.has(controller_decorator.Translator)
             });
             // Outside a built application, the kept errors of the stages and other classes the app's classes reach
@@ -1698,7 +1915,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             providers.markStartupChecked(container, [
                 ...runs.classes,
                 ...providers.meocordClasses()
-            ], startupRoots.lateGuardCheck(providers$1, translator));
+            ], eventSources.lateGuardCheck(providers$1, translator));
             providers.bindGlobalStages(container, stages);
             // Bound now, so no provider stands in for it; made once the checks pass, the one Client the app logs in with
             const clientOptions = shardedCooldownStore.clientOptionsWithSharding(this.effectiveConfig(meocordConfig, shard), options.clientOptions);
@@ -1709,7 +1926,8 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             }
             // Bound before the app's classes, so a class that injects it gets this instance; filled once they are bound
             const appClasses = [];
-            container.bind(providers.HandlerRegistry).toConstantValue(new providers.HandlerRegistry(appClasses, options.messages, ()=>options.i18n));
+            const registry = new providers.HandlerRegistry(appClasses, options.messages, ()=>options.i18n, options.controllers);
+            container.bind(providers.HandlerRegistry).toConstantValue(registry);
             container.bind(providers.ShardContext).toDynamicValue(()=>{
                 const client = container.get(discord_js.Client);
                 return new providers.ShardContext(client, (service, method, args)=>Reflect.get(client, providers.SHARD_CALL_KEY)(service, method, args));
@@ -1729,12 +1947,9 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             // After MeoCord's own tokens, which a provider may not replace, and before the app's classes, so
             // a class token that is provided is not also bound as itself
             for (const [token, provider] of providers$1){
-                // Bound later, or for each call, so not caught below; supported until 5.0 refuses it
-                if (token === controller_decorator.ThemeCache || token === controller_decorator.ExecutionContext) {
-                    controller_decorator.warnOnce(this.logger, `${target.name}: @MeoCord({ providers }) provides ${providers.tokenName(token)}, which MeoCord binds itself; ` + 'the next major version (5.0) refuses it. Remove the provider.');
-                }
-                if (container.isBound(token)) {
-                    controller_decorator.startupError(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${providers.tokenName(token)}, which MeoCord binds itself.`));
+                const refusal = providers.appProviderRefusal(`${target.name}`, token, (own)=>container.isBound(own), this.logger);
+                if (refusal) {
+                    controller_decorator.startupError(refusal);
                     continue;
                 }
                 providers.bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers$1));
@@ -1751,7 +1966,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             const observers = providers.appObservers(target);
             for (const observer of observers)bindDependencies(container, observer, providers$1);
             // What the stages and presenter inject, bound now so a service among them is made as the bot comes online
-            const stageServices = startupRoots.stageDependencies(runs, providers$1, options.presenter);
+            const stageServices = eventSources.stageDependencies(runs, providers$1, options.presenter);
             for (const service of stageServices)bindDependencies(container, service, providers$1);
             // What follows walks what these bound, so a class refused here is not reported again as missing
             controller_decorator.stopOnStartupErrors();
@@ -1819,26 +2034,35 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             providers.buildMessageRoutes(options.controllers, options.messages);
             // Every check has run, and touched only the container: from here the app is made, once none found an error
             controller_decorator.stopOnStartupErrors();
+            for (const warning of eventSources.perCallEventWarnings(runs, providers$1, options.presenter))this.logger.warn(warning);
             const discordClient = container.get(discord_js.Client);
             Reflect.set(discordClient, providers.SHARD_CALL_KEY, providers.shardCallHandler(container, ()=>callable, 'this app'));
-            // Stamp every class the app runs with the container, so @UseGuard resolves guards on a direct call to any of them
-            for (const cls of runs.classes){
-                Reflect.defineMetadata(controller_decorator.META.container, container, cls);
-            }
-            providers.recordInstanceContainers(container, runs.classes);
+            // Every class the app runs, so @UseGuard resolves guards on a direct call to any of them
+            providers.prepareDirectCalls(container, runs.classes);
             providers.prepareThemes(container, appClasses);
             // Run by start() before it logs in: what may inject a provided value is resolved once every factory
             // has made its value, including those that return a promise
             const logger = this.logger;
+            let sources;
             const startup = async (control)=>{
+                let made;
                 try {
-                    await providers.resolveProviders(container, providers$1, order, control);
+                    made = await providers.resolveProviders(container, providers$1, order, control);
                 } catch (error) {
                     logger.error(`${error.message}. The bot cannot start without it.`);
                     logger.debug('Provider failure:', error.cause);
                     controller_decorator.markExplained(error);
                     throw error;
                 }
+                // A stop came while the providers were being made: what follows resolves provided values, which would make the
+                // factories it left unmade
+                if (!made) return;
+                // Read once every provided value is made, and before anything the app makes could list its handlers
+                if (!sources) {
+                    sources = eventSources.eventSources(container, providers$1, lifecycle, appClasses, (text)=>logger.warn(text));
+                    providers.listEventSources(registry, sources);
+                    providers.prepareLateThemes(container, sources.map(({ cls })=>cls));
+                }
                 // The listed services are made now, so constructors that attach listeners or connect run before login; a stop
                 // meanwhile makes no more of them
                 for (const svc of options.services ?? []){
@@ -1853,12 +2077,39 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                 providers.registerClientTheme(discordClient, container);
                 controller_decorator.registerClientTranslator(discordClient, options.i18n);
             };
-            return new MeoCordApp(options.controllers, container, discordClient, meocordConfig.discordToken, options.activities, appClasses, meocordConfig.shutdownTimeout, startup, lifecycle, options.messages, // In development only, unless the app says otherwise
-            options.warnUnanswered ?? process.env.NODE_ENV === 'development', shard);
+            return new MeoCordApp(options.controllers, container, discordClient, meocordConfig.discordToken, options.activities, ()=>sources ?? [], meocordConfig.shutdownTimeout, startup, lifecycle, options.messages, // In development only, unless the app says otherwise
+            options.warnUnanswered ?? process.env.NODE_ENV === 'development', shard, startAttempt(container, lifecycle, providers$1));
         });
     }
 }
 MeoCordFactory.logger = new controller_decorator.Logger();
+/**
+ * What the app's starts make: each lifecycle unit is recorded as the container constructs it, as the testing module
+ * records them, and a container snapshot marks where a start begins, so a failed start drops every singleton it made,
+ * the values factory providers keep included.
+ */ function startAttempt(container, lifecycle, providers$1) {
+    const constructed = new Set();
+    for (const { token } of lifecycle){
+        container.onActivation(token, (_context, instance)=>{
+            constructed.add(token);
+            return instance;
+        });
+    }
+    const drop = ()=>{
+        container.restore();
+        providers.forgetFactoryValues(container);
+    };
+    const given = new Set(lifecycle.map(({ token })=>token).filter((token)=>{
+        const provider = providers$1.get(token);
+        return provider !== undefined && providers.isValueProvider(provider);
+    }));
+    return {
+        constructed,
+        given,
+        begin: ()=>container.snapshot(),
+        drop
+    };
+}
 
 exports.HandlerRegistry = providers.HandlerRegistry;
 exports.ShardContext = providers.ShardContext;