meocord 4.1.2 → 4.2.1

package/dist/cjs/core/index.cjs

@@ -1,21 +1,21 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-BMMLp2SN.cjs');
+var providers = require('../_shared/providers-BZgJyfZS.cjs');
 var inversify = require('inversify');
 var discord_js = require('discord.js');
-var controller_decorator = require('../_shared/controller.decorator-BywwkU9O.cjs');
+var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
 require('node:crypto');
-var shardedCooldownStore = require('../_shared/sharded-cooldown-store-B65iaiAy.cjs');
-var path$1 = require('path');
-var startupRoots = require('../_shared/startup-roots-lFc69AxC.cjs');
+var shardedCooldownStore = require('../_shared/sharded-cooldown-store-CsJJyCZd.cjs');
+var startupRoots = require('../_shared/startup-roots-CgfPQrNl.cjs');
 var enum_index = require('../enum/index.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
 var node_util = require('node:util');
-var fs = require('fs');
 require('node:async_hooks');
 require('crypto');
+require('fs');
+require('path');
 require('cli-table3');
 require('node:url');
 require('dayjs');
@@ -23,11 +23,10 @@ require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-BnM8FbSH.cjs');
+require('../_shared/translate-error-BUAR1WYG.cjs');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var path__default$1 = /*#__PURE__*/_interopDefaultCompat(path$1);
 var path__default = /*#__PURE__*/_interopDefaultCompat(path);
 
 const MESSAGES = [
@@ -446,8 +445,8 @@ const slots = globalThis;
  * on Windows a signal ends a process outright, skipping its `onShutdown` hooks. The bundle's pre-entry calls it first,
  * so a stop is heard however early it comes; until an app or shard manager says how it stops, the process exits at
  * once, as SIGTERM's default would.
- */ function listenForDevRunnerStop() {
-    if (!underDevRunner() || slots[LISTENING]) return;
+ */ function listenForDevRunnerStop(shard = shardedCooldownStore.isShardProcess(process.env)) {
+    if (!underDevRunner(shard) || slots[LISTENING]) return;
     slots[LISTENING] = true;
     process.on('message', (message)=>{
         if (!isDevRunnerCommand(message)) return;
@@ -458,19 +457,19 @@ const slots = globalThis;
     // A 'message' listener keeps the process alive for its channel; what the bot does decides that, as without one
     process.channel?.unref();
 }
-/** Has a stop from `meocord start --dev` run `stop`, as SIGINT and SIGTERM do. */ function onDevRunnerStop(stop) {
-    listenForDevRunnerStop();
+/** Has a stop from `meocord start --dev` run `stop`, as SIGINT and SIGTERM do, in a process whose role is `shard`. */ function onDevRunnerStop(stop, shard) {
+    listenForDevRunnerStop(shard);
     slots[STOP] = stop;
 }
-/** Whether `meocord start --dev` runs this process and listens on its channel. */ function underDevRunner() {
-    return process.env[DEV_RUNNER_ENV] === '1' && !!process.send && !shardedCooldownStore.isShardProcess();
+/** Whether `meocord start --dev` runs this process, a shard or not as `shard` says, and listens on its channel. */ function underDevRunner(shard) {
+    return process.env[DEV_RUNNER_ENV] === '1' && !!process.send && !shard;
 }
 /**
  * Tells `meocord start --dev`, when it runs this process, whether the bot could log in, and waits until it is sent, or
  * until the dev runner is taken to be gone. A caller sets the exit code before sending, so it holds however the send
  * ends. A shard tells its manager instead, which tells the dev runner in turn.
- */ async function tellDevRunner(message) {
-    if (underDevRunner()) await sendToParent(message);
+ */ async function tellDevRunner(message, shard) {
+    if (underDevRunner(shard)) await sendToParent(message);
 }
 
 /** The errors the gateway closes with, which discord.js passes on without a code. */ const GATEWAY_CLOSE_MESSAGES = {
@@ -638,11 +637,11 @@ let shuttingDown;
  * 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
  * same request; one after it forces exit 1, except in a shard, whose manager forces it.
- */ async function shutdownAndExit() {
+ */ async function shutdownAndExit(shard) {
     const request = 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' || shardedCooldownStore.isShardProcess()) return;
+        if (request === 'duplicate' || shard) return;
         process.exit(1);
         return;
     }
@@ -663,47 +662,48 @@ let shuttingDown;
     controller_decorator.markExplained(error);
     return error;
 }
-/** One pair of signal listeners for the process, however many apps it starts. */ function installSignalHandlers() {
+/** 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;
-    process.on('SIGINT', ()=>void shutdownAndExit());
-    process.on('SIGTERM', ()=>void shutdownAndExit());
+    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
     // not the user's stop request: their first Ctrl+C during it joins this shutdown, and only a repeat forces exit 1.
-    onDevRunnerStop(()=>void shutDown());
+    onDevRunnerStop(()=>void shutDown(), shard);
     // A shard stops when its manager asks, or when the manager is gone and cannot ask
-    if (shardedCooldownStore.isShardProcess()) {
+    if (shard) {
         process.on('message', (message)=>{
-            if (shardedCooldownStore.isShardMessage(message) && message.meocord === 'shutdown') void shutdownAndExit();
+            if (shardedCooldownStore.isShardMessage(message) && message.meocord === 'shutdown') void shutdownAndExit(shard);
         });
-        process.on('disconnect', ()=>void shutdownAndExit());
+        process.on('disconnect', ()=>void shutdownAndExit(shard));
     }
 }
-/** Tells the manager a shard cannot log in, and why, and waits until the message is sent. */ async function reportFatalLogin(code, reason) {
-    if (shardedCooldownStore.isShardProcess()) await tellManager({
+/** Tells the manager a shard cannot log in, and why, and waits until the message is sent. */ async function reportFatalLogin(shard, code, reason) {
+    if (shard) await tellManager({
         meocord: 'fatal',
         code,
         message: reason
     });
 }
+/** How a shutdown warning names an interaction still being handled: by its command, or a component's customId. */ function interactionLabel(interaction) {
+    if ('commandName' in interaction) return `interaction "/${controller_decorator.escapeForLog(interaction.commandName)}"`;
+    if ('customId' in interaction) return `interaction "${controller_decorator.escapeForLog(interaction.customId)}"`;
+    return '"interactionCreate"';
+}
 class MeoCordApp {
     /**
    * Runs an event handler so its failure is logged against the event instead of surfacing as an
    * unhandled rejection, which would terminate the whole bot.
-   */ async runListener(event, run) {
-        const handled = (async ()=>{
+   */ async runListener(event, run, label = `"${event}"`) {
+        const handle = async ()=>{
             try {
                 await run();
             } catch (error) {
                 this.logger.error(`Unhandled error while handling "${event}":`, error);
             }
-        })();
-        // A call, which the cooldown store outlasts at shutdown; the ready listener's work is not one
-        if (event !== 'clientReady') {
-            this.calls.add(handled);
-            void handled.then(()=>this.calls.delete(handled));
-        }
-        await handled;
+        };
+        // A call, which shutdown waits for before the onShutdown hooks; the ready listener's work is not one
+        await (event === 'clientReady' ? handle() : this.calls.run(label, handle));
     }
     /**
    * Shows the next of the app's activities, in the order listed, starting again after the last. Guarded apart from
@@ -725,7 +725,7 @@ class MeoCordApp {
         if (this.online) return;
         this.starting ?? (this.starting = this.startOnce().catch((error)=>{
             // 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 (shardedCooldownStore.isShardProcess() && !this.closing) endFailedShard(error);
+            if (this.shard && !this.closing) endFailedShard(error);
             throw error;
         }).finally(()=>this.starting = undefined));
         return this.starting;
@@ -735,7 +735,10 @@ class MeoCordApp {
    * which then asks this one too, so the process ends. A client that fails to close sets `process.exitCode` to 1,
    * unless a code is already set.
    */ async stop() {
-        if (shardedCooldownStore.isShardProcess()) await tellManager({
+        // A handler or an onReady awaiting stop() would otherwise hold up the shutdown that waits for it
+        this.calls.excuseCurrent();
+        this.readyPass.excuseCurrent();
+        if (this.shard) await tellManager({
             meocord: 'stop'
         });
         // As a signal's shutdown exits 1 for a client that failed to close, a code another failure set aside
@@ -745,14 +748,20 @@ class MeoCordApp {
         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
         runningApps.add(this.close);
-        installSignalHandlers();
+        installSignalHandlers(this.shard);
         // A shard whose manager is already gone has no one to answer to, and nothing would stop it later
-        if (shardedCooldownStore.isShardProcess() && shardedCooldownStore.managerGone()) void shutdownAndExit();
+        if (this.shard && shardedCooldownStore.managerGone()) void shutdownAndExit(this.shard);
         // 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) {
-            await this.prepare();
+            // Kept while it runs, so a stop meanwhile waits for it
+            this.preparing = this.prepare();
+            try {
+                await this.preparing;
+            } finally{
+                this.preparing = undefined;
+            }
             this.prepared = true;
         }
         if (this.loginFailed) {
@@ -765,7 +774,10 @@ class MeoCordApp {
         // Every provided value is made before anything that injects it is resolved, and before login
         if (this.startup) {
             try {
-                await this.startup();
+                await this.startup({
+                    stopped: ()=>this.closing,
+                    pending: (name)=>this.pendingProvider = name
+                });
             } catch (error) {
                 providers.releaseAmbientAppTheme(this.container);
                 if (process.exitCode === undefined || process.exitCode === 0) {
@@ -775,7 +787,8 @@ class MeoCordApp {
                 throw error;
             }
         }
-        // A stop that came while the providers were being made has nothing to close: nothing is attached or logged in
+        // A stop that came while the providers were being made has waited for them, and the startup made no more after it;
+        // nothing is attached or logged in
         if (this.closing) throw stoppedBeforeOnline();
         // Calls wait for the store's onReady, which may connect it, before asking it
         if (this.lifecycleUnits.some((unit)=>unit.cooldownStore)) {
@@ -791,10 +804,10 @@ class MeoCordApp {
                 // Started before registration and not waited on by it, so a slow or failed registration never holds them up
                 const readyHooks = this.runReadyHooks(readyClient ?? this.bot);
                 // With process sharding, the manager registers once for every shard
-                if (!shardedCooldownStore.isShardProcess()) await this.registerCommands();
+                if (!this.shard) await this.registerCommands();
                 await readyHooks;
             }));
-        this.bot.on('interactionCreate', startupRoots.ownInteractionListener((interaction)=>this.runListener('interactionCreate', ()=>this.dispatcher.interaction(interaction))));
+        this.bot.on('interactionCreate', startupRoots.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,
@@ -837,18 +850,18 @@ class MeoCordApp {
             const explanation = fatal && explainLoginFailure(fatal, this.bot.options?.intents, this.discordToken);
             if (explanation) {
                 // The explanation is what to act on, and the stack only for debugging. A shard's manager logs it instead.
-                if (!shardedCooldownStore.isShardProcess()) this.logger.error(explanation);
+                if (!this.shard) this.logger.error(explanation);
                 this.logger.debug('Login failed:', error);
                 controller_decorator.markExplained(error);
             }
-            if (fatal) await reportFatalLogin(fatal, explanation ?? (error instanceof Error ? error.message : String(error)));
+            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;
             }
             await tellDevRunner({
                 meocord: 'login-failed'
-            });
+            }, this.shard);
             MeoCordApp.toldDevRunnerLoginFailed = true;
             this.loginFailed = true;
             throw error;
@@ -866,7 +879,7 @@ class MeoCordApp {
             MeoCordApp.toldDevRunnerLoginFailed = false;
             await tellDevRunner({
                 meocord: 'online'
-            });
+            }, this.shard);
         }
         this.online = true;
         this.logger.log('Bot is online!');
@@ -949,18 +962,20 @@ class MeoCordApp {
                     } else logError(error);
                     return undefined;
                 };
-                const listener = async (...args)=>{
-                    try {
-                        const instance = this.container.get(lifecycleClass);
-                        await providers.runHandler(this.container, instance, method, args, {
-                            fallback,
-                            type: 'event'
-                        });
-                    } catch (error) {
-                        // Only resolving the instance can fail here; the pipeline hands every other error to the fallback
-                        logError(error);
-                    }
-                };
+                const label = `@${once ? 'Once' : 'On'}('${event}') in ${lifecycleClass.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, {
+                                fallback,
+                                type: 'event'
+                            });
+                        } catch (error) {
+                            // Only resolving the instance can fail here; the pipeline hands every other error to the fallback
+                            logError(error);
+                        }
+                    });
                 if (once) this.bot.once(event, listener);
                 else this.bot.on(event, listener);
             }
@@ -1029,29 +1044,35 @@ class MeoCordApp {
    */ async runReadyHooks(client) {
         const entries = [];
         this.lifecycleEntries = entries;
-        await startupRoots.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.`),
-            slow: (unit)=>this.logger.warn(`onReady in ${unit.name} has run for over ${SLOW_READY_HOOK_MS} ms; the hooks after it are waiting.`)
-        }, // Shutdown has begun: the client is going away, so no further hook starts
-        {
-            stopped: ()=>this.closing,
-            slowAfterMs: SLOW_READY_HOOK_MS,
-            settled: (unit)=>unit.cooldownStore && this.storeReady?.resolve()
-        });
+        await this.readyPass.run(()=>startupRoots.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.`),
+                slow: (unit)=>this.logger.warn(`onReady in ${unit.name} has run for over ${SLOW_READY_HOOK_MS} ms; the hooks after it are waiting.`)
+            }, // Shutdown has begun: the client is going away, so no further hook starts
+            {
+                stopped: ()=>this.closing,
+                slowAfterMs: SLOW_READY_HOOK_MS,
+                settled: (unit)=>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(entries) {
-        await startupRoots.runShutdownSequence(this.container, entries, {
-            // No new call starts once the listeners are gone
+    /** 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 ?? [], {
+            // No new call starts once the listeners are gone; an error the client emits meanwhile still has its listeners
             drainCalls: ()=>{
-                this.bot.removeAllListeners();
-                return startupRoots.callsSettled(this.calls);
+                const emitter = this.bot;
+                for (const event of emitter.eventNames())if (event !== 'error') emitter.removeAllListeners(event);
+                return this.calls.settled();
             },
+            drainAlways: true,
+            runningCalls: ()=>this.calls.running(),
+            readyPass: this.readyPass,
             timeoutMs: this.shutdownTimeout,
             hookFailed: (name, error)=>this.logger.error(`onShutdown failed in ${name}:`, error),
             warn: (message)=>this.logger.warn(message)
@@ -1070,8 +1091,28 @@ class MeoCordApp {
             providers.releaseAmbientAppTheme(this.container);
         }
     }
+    /**
+   * 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.
+   */ async waitForStartup(preparing) {
+        let timer;
+        const outlasted = new Promise((resolve)=>{
+            timer = setTimeout(()=>resolve(true), this.shutdownTimeout);
+        });
+        const settled = preparing.then(()=>false, ()=>false);
+        if (await Promise.race([
+            settled,
+            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);
+    }
     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
         if (this.abortLogin) {
             this.logger.log('The bot was still logging in, so it stops without coming online');
@@ -1081,8 +1122,8 @@ class MeoCordApp {
             return true;
         }
         if (this.activityInterval) clearInterval(this.activityInterval);
-        // A login that failed never ran onReady, so there is nothing for onShutdown to undo
-        if (this.lifecycleEntries) await this.runShutdownHooks(this.lifecycleEntries);
+        // The calls drain on every shutdown, and the onReady in progress settles first
+        await this.runShutdownHooks();
         try {
             this.bot.removeAllListeners();
             await this.bot.destroy();
@@ -1093,7 +1134,7 @@ class MeoCordApp {
             return false;
         }
     }
-    constructor(controllerClasses, container, discordClient, discordToken, activities, lifecycleClasses = [], shutdownTimeout, startup, lifecycleUnits, messageOptions = {}, warnUnanswered = 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){
         this.controllerClasses = controllerClasses;
         this.container = container;
         this.discordClient = discordClient;
@@ -1102,6 +1143,7 @@ class MeoCordApp {
         this.lifecycleClasses = lifecycleClasses;
         this.startup = startup;
         this.messageOptions = messageOptions;
+        this.shard = shard;
         this.logger = new controller_decorator.Logger(MeoCordApp.name);
         this.fallback = startupRoots.createFallback(this.logger, ()=>this.messageOptions, {
             cooldownNotice: (refusal)=>providers.claimCooldownNotice(this.container, refusal),
@@ -1114,7 +1156,8 @@ class MeoCordApp {
    * 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, each settling once its handling has. */ this.calls = new Set();
+        /** 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;
         /** 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;
@@ -1204,66 +1247,6 @@ class MeoCordApp {
     return Object.fromEntries(Object.entries(node_util.parseEnv(text)).filter((entry)=>entry[1] !== undefined));
 }
 
-/**
- * File written beside a bundle that carries native addons, naming the platform it was built for.
- */ const PLATFORM_MANIFEST = 'meocord.platform.json';
-/** The C library this process runs against, when the runtime can say. */ function detectLibc() {
-    if (process.platform !== 'linux') return undefined;
-    try {
-        const report = process.report?.getReport?.();
-        if (!report?.header) return undefined;
-        return report.header.glibcVersionRuntime ? 'glibc' : 'musl';
-    } catch  {
-        return undefined;
-    }
-}
-/** The platform this process is running on. */ function currentPlatform() {
-    const libc = detectLibc();
-    return {
-        platform: process.platform,
-        arch: process.arch,
-        ...libc && {
-            libc
-        }
-    };
-}
-/** `linux-x64 (glibc)`, `darwin-arm64`. */ function describePlatform({ platform, arch, libc }) {
-    return `${platform}-${arch}${libc ? ` (${libc})` : ''}`;
-}
-/**
- * Whether native binaries built for one platform can load on another.
- *
- * The C library is compared only when both sides are known, so a runtime that cannot report it
- * is not refused on a guess.
- */ function isSamePlatform(built, running) {
-    if (built.platform !== running.platform || built.arch !== running.arch) return false;
-    return !built.libc || !running.libc || built.libc === running.libc;
-}
-/**
- * Stops a bundle from starting on a platform its native addons were not built for, with one clear
- * message instead of a linker error on the first command that loads an addon.
- * @param distDir - Directory holding the manifest. Defaults to the built bundle's directory, which a process manager's
- *   wrapper in `argv[1]` would hide, and else to the entry script's.
- */ function assertBuiltForThisPlatform(distDir = defaultDistDir()) {
-    if (!distDir) return;
-    const manifest = path__default$1.default.join(distDir, PLATFORM_MANIFEST);
-    if (!fs.existsSync(manifest)) return;
-    let built;
-    try {
-        built = JSON.parse(fs.readFileSync(manifest, 'utf8'));
-    } catch  {
-        return;
-    }
-    const running = currentPlatform();
-    if (isSamePlatform(built, running)) return;
-    throw controller_decorator.refuse(new Error(`${path__default$1.default.basename(distDir)}: this build carries native addons compiled for ${describePlatform(built)}, but is ` + `running on ${describePlatform(running)}. Compiled binaries only load on the platform they were built for. ` + 'Build on the same platform you deploy to -- for a container, run `meocord build` inside the image.'));
-}
-/** The built bundle's directory, or the entry script's outside a built bot. */ function defaultDistDir() {
-    const entry = controller_decorator.isBuiltApplication() ? controller_decorator.bundleEntry() : undefined;
-    if (entry) return path__default$1.default.dirname(entry);
-    return process.argv[1] ? path__default$1.default.dirname(process.argv[1]) : undefined;
-}
-
 /** How long the manager waits for a shard to become ready before spawning the next. */ const SHARD_READY_TIMEOUT_MS = 30000;
 /** The pause between spawning two shards, as Discord's identify rate limit asks. */ const SHARD_SPAWN_DELAY_MS = 5500;
 /** The first respawn delay, doubled for each exit in a row. */ const RESPAWN_BASE_MS = 1000;
@@ -1300,7 +1283,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         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
-        onDevRunnerStop(()=>void this.exitAfterShutdown());
+        onDevRunnerStop(()=>void this.exitAfterShutdown(), false);
         let total;
         try {
             const shards = config.sharding?.shards ?? 'auto';
@@ -1317,6 +1300,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         const manager = (this.options.createManager ?? ((path, opts)=>new discord_js.ShardingManager(path, opts)))(file, {
             token,
             totalShards: total,
+            // discord.js refuses a call to every shard unless shardList counts the shards; createShard leaves it 'auto'
+            shardList: [
+                ...Array(total).keys()
+            ],
             mode: 'process',
             execArgv: process.execArgv,
             respawn: false
@@ -1413,12 +1400,12 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         void this.exitForLogin();
     }
     /** Exits 1 for a bot that could not log in, telling `meocord start --dev` first, which then waits for a change. */ exitForLogin() {
-        if (!underDevRunner()) return this.exit(1);
+        if (!this.devRunner) return this.exit(1);
         // Set first, so the process exits 1 even if it ends while the message is still on its way
         process.exitCode = 1;
         return tellDevRunner({
             meocord: 'login-failed'
-        }).then(()=>this.exit(1));
+        }, false).then(()=>this.exit(1));
     }
     /**
    * Asks every shard to shut down through its own hooks, waits for them up to the shutdown timeout plus a margin, and
@@ -1495,6 +1482,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         /** Every shard's cooldown calls, for an app whose store is ShardedCooldownStore. */ this.cooldowns = new controller_decorator.MemoryCooldownStore();
         this.stopping = false;
         this.fatal = false;
+        /**
+   * Whether `meocord start --dev` runs the manager, decided before discord.js's ShardingManager, which writes the
+   * variable that marks a shard into this process too.
+   */ this.devRunner = underDevRunner(false);
         // The manager holds the credential for its shards and logs their failures, without an app of its own to register it
         controller_decorator.hideInLogs(options.token);
         this.exit = options.exit ?? ((code)=>process.exit(code));
@@ -1510,14 +1501,14 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  */ function bindDependencies(container, cls, providers$1) {
     // A provided class is bound by its own provider, wherever in the list that provider comes
     if (container.isBound(cls) || providers$1.has(cls)) return;
-    if (providers.injectedTokens(cls).includes(controller_decorator.ExecutionContext)) throw controller_decorator.refuse(providers.singletonContextError(cls));
+    if (providers.injectedTokens(cls).includes(controller_decorator.ExecutionContext)) return controller_decorator.startupError(providers.singletonContextError(cls));
     providers.assertStartupChecked(container, cls);
     providers.makeInjectable(cls);
     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)) throw controller_decorator.refuse(controller_decorator.missingTranslatorError(cls));
-        if (providers.isAppClassToken(dep)) bindDependencies(container, dep, providers$1);
+        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);
     }
 }
 /**
@@ -1560,8 +1551,8 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
    * The config a single process runs with. Under `meocord start --dev` without `sharding.development`,
    * process sharding falls back to running every shard in this process, so the watcher restarts one
    * process and leaves no shards behind.
-   */ static effectiveConfig(config) {
-        if (config.sharding?.mode !== 'process' || shardedCooldownStore.isShardProcess() || shardedCooldownStore.processShardingEnabled(config)) return config;
+   */ static effectiveConfig(config, shard) {
+        if (config.sharding?.mode !== 'process' || shard || shardedCooldownStore.processShardingEnabled(config)) return config;
         this.logger.info("sharding.mode 'process' is off in development, so every shard runs in this process; set " + 'sharding.development: true to run them in separate processes.');
         return {
             ...config,
@@ -1581,36 +1572,64 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
    * @returns The application, which `start()` logs in.
    * @throws Error when the class has no `@MeoCord`, when the compiled config is missing beside the bundle or fails to
    *   load, naming the file and the reason, with what to do about it, when a provider cannot
-   *   be bound, such as one for a token MeoCord binds itself, when two handlers take one command, or two builder
+   *   be bound, such as one for a token MeoCord binds itself (a provider for `ThemeCache` or `ExecutionContext` is warned
+   *   about instead, and refused from the next major version, 5.0), when two handlers take one command, or two builder
    *   classes build one, naming both, and for any other mistake it refuses as the app loads, such as two component
-   *   patterns that match the same customIds. In a built application it is logged first, with where in the source it
-   *   comes from, so `isExplainedError()` tells a caller not to log it again; in a shard of process sharding, the
-   *   manager logs it.
+   *   patterns that match the same customIds. Each check reports every error it finds, and the first is thrown,
+   *   unchanged. When there are several, each is logged first, with where in the source it comes from; a lone one is
+   *   logged in a built application. Either way `isExplainedError()` then tells a caller not to log it again; in a
+   *   shard of process sharding, the manager logs it. With `startupErrors: 'all'` in `meocord.config.ts`, the errors
+   *   decorators kept are among them.
    */ static create(target) {
+        // Decided first, once, and handed to all that asks: a ShardingManager this app builds writes the variable into its
+        // own process too, which would make the manager read as a shard
+        const shard = shardedCooldownStore.isShardProcess(process.env);
         try {
-            return this.createApplication(target);
+            return this.createApplication(target, shard);
         } catch (error) {
             // A shard ends, so its manager restarts it, or stops every shard for a refusal, which it logs
-            if (shardedCooldownStore.isShardProcess()) endFailedShard(error);
-            else if (controller_decorator.isBuiltApplication() && controller_decorator.isRefusal(error) && !controller_decorator.isExplainedError(error)) {
-                this.logger.error(controller_decorator.describeRefusal(error, process.cwd()));
-                controller_decorator.markExplained(error);
+            if (shard) endFailedShard(error);
+            else if (controller_decorator.isRefusal(error) && !controller_decorator.isExplainedError(error)) {
+                // Every startup error found together is logged, in a test too; a lone one is logged in a built application
+                if (controller_decorator.logStartupErrors(error, (text)=>this.logger.error(text), 'the bot did not start')) controller_decorator.markExplained(error);
+                else if (controller_decorator.isBuiltApplication()) {
+                    this.logger.error(controller_decorator.describeRefusal(error, process.cwd()));
+                    controller_decorator.markExplained(error);
+                }
             }
             throw error;
         }
     }
-    static createApplication(target) {
-        const options = Reflect.getMetadata(controller_decorator.META.appOptions, target);
-        if (!options) {
+    static createApplication(target, shard) {
+        const appOptions = Reflect.getMetadata(controller_decorator.META.appOptions, target);
+        // With startupErrors: 'all', what the decorators kept: a built bot's every one, else the app's and its controllers'
+        const declared = controller_decorator.isBuiltApplication() ? controller_decorator.allDeclaredErrors() : controller_decorator.declaredErrorsOf([
+            target,
+            ...appOptions?.controllers ?? []
+        ]);
+        if (!appOptions) {
+            // A refused @MeoCord stores no options, so its own errors say why
+            controller_decorator.collectStartupErrors(()=>declared.forEach(controller_decorator.startupError));
             throw controller_decorator.refuse(new Error(`${typeof target === 'function' ? target.name : String(target)}: not decorated with @MeoCord(), so there is no app to create.`));
         }
+        // A controller listed twice is one controller, as the command checks and fromApp already take it
+        const options = {
+            ...appOptions,
+            controllers: [
+                ...new Set(appOptions.controllers)
+            ]
+        };
         const meocordConfig = controller_decorator.loadMeoCordConfig();
         if (!meocordConfig) {
             throw controller_decorator.refuse(new Error(controller_decorator.compiledConfigMessage()));
         }
-        // Before any of the three ways a bot runs, so none registers or dispatches a command only one handler could take
-        startupRoots.assertDistinctCommands(options.controllers);
-        const providers$1 = providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
+        // Before any of the three ways a bot runs, so none registers or dispatches a command only one handler could take; every
+        // error each check finds is reported, the first thrown
+        const providers$1 = controller_decorator.collectStartupErrors(()=>{
+            declared.forEach(controller_decorator.startupError);
+            startupRoots.assertDistinctCommands(options.controllers);
+            return providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
+        });
         // 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
@@ -1626,7 +1645,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             ...providers.appObservers(target)
         ];
         // A shard's manager runs the same checks, so a sharded bot warns once
-        if (!shardedCooldownStore.isShardProcess()) {
+        if (!shard) {
             startupRoots.warnUnregisteredCommands(options.controllers);
             startupRoots.warnInheritedRoutes(options.controllers);
             startupRoots.warnOverlappingPatterns(options.controllers);
@@ -1641,164 +1660,200 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         if (isRegisterOnly()) {
             return new MeoCordApp(options.controllers, new inversify.Container(), new discord_js.Client(options.clientOptions), meocordConfig.discordToken);
         }
-        // Before anything is resolved: a controller or service is what first loads a native addon, and one built for another
-        // platform would otherwise fail there with a linker error. A manager checks too, before it registers or spawns.
-        assertBuiltForThisPlatform();
         // A process-sharding manager only spawns shards, so it binds, constructs and connects nothing itself.
-        if (shardedCooldownStore.shardingRole(meocordConfig) === 'manager') {
+        if (shardedCooldownStore.shardingRole(meocordConfig, shard) === 'manager') {
             return new ShardManager({
                 controllerClasses: options.controllers,
                 token: meocordConfig.discordToken,
                 config: meocordConfig
             });
         }
-        // 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, {
-            translator: options.i18n !== undefined || providers$1.has(controller_decorator.Translator)
-        });
-        const container = new inversify.Container();
-        const translator = options.i18n !== undefined || providers$1.has(controller_decorator.Translator);
-        providers.markStartupChecked(container, [
-            ...runs.classes,
-            ...providers.meocordClasses()
-        ], startupRoots.lateGuardCheck(providers$1, translator));
-        providers.bindGlobalStages(container, stages);
-        // Bind the Discord client as a constant value
-        const discordClient = new discord_js.Client(shardedCooldownStore.clientOptionsWithSharding(this.effectiveConfig(meocordConfig), options.clientOptions));
-        container.bind(discord_js.Client).toConstantValue(discordClient);
-        if (options.i18n) {
-            container.bind(controller_decorator.Translator).toConstantValue(options.i18n);
-            providers.bindsOwnToken(container, controller_decorator.Translator);
-        }
-        // 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));
-        container.bind(providers.ShardContext).toConstantValue(new providers.ShardContext(discordClient, (service, method, args)=>Reflect.get(discordClient, providers.SHARD_CALL_KEY)(service, method, args)));
-        providers.bindsOwnToken(container, providers.HandlerRegistry);
-        providers.bindsOwnToken(container, providers.ShardContext);
-        container.bind(providers.COOLDOWN_POLICY).toConstantValue(providers.cooldownPolicyFrom(options));
-        // A store of the app's own is resolved like a service, so it can inject its client
-        if (options.cooldownStore) {
-            bindDependencies(container, options.cooldownStore, providers$1);
-            container.bind(controller_decorator.CooldownStore).toService(options.cooldownStore);
-        } else {
-            container.bind(controller_decorator.CooldownStore).toConstantValue(new controller_decorator.MemoryCooldownStore());
-        }
-        // A class that injects the token depends on the app's store, the one unit whose hooks run
-        providers.bindsOwnToken(container, controller_decorator.CooldownStore, options.cooldownStore);
-        // 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){
-            if (container.isBound(token)) {
-                throw controller_decorator.refuse(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${providers.tokenName(token)}, which MeoCord binds itself.`));
+        // 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, {
+                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
+            if (!controller_decorator.isBuiltApplication()) controller_decorator.declaredErrorsOf(runs.classes).forEach(controller_decorator.startupError);
+            // The checks of the wiring below run on classes that passed these, so a mistake in one is not reported again there
+            controller_decorator.stopOnStartupErrors();
+            // The checks bind into this container and change nothing else: what they bind is made once all have passed
+            const container = new inversify.Container();
+            const translator = options.i18n !== undefined || providers$1.has(controller_decorator.Translator);
+            providers.markStartupChecked(container, [
+                ...runs.classes,
+                ...providers.meocordClasses()
+            ], startupRoots.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);
+            container.bind(discord_js.Client).toDynamicValue(()=>new discord_js.Client(clientOptions)).inSingletonScope();
+            if (options.i18n) {
+                container.bind(controller_decorator.Translator).toConstantValue(options.i18n);
+                providers.bindsOwnToken(container, controller_decorator.Translator);
             }
-            providers.bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers$1));
-        }
-        // Bind all controllers and their transitive dependencies
-        for (const ctrl of options.controllers){
-            bindDependencies(container, ctrl, providers$1);
-        }
-        for (const svc of options.services ?? []){
-            bindDependencies(container, svc, providers$1);
-        }
-        if (themeResolver) bindDependencies(container, themeResolver, providers$1);
-        // Observers are services too: bound here so their lifecycle hooks run in dependency order
-        const observers = providers.appObservers(target);
-        for (const observer of observers)bindDependencies(container, observer, providers$1);
-        // Providers first, then the services, the controllers and the observers, each after what it depends on. The app's
-        // own classes, which a class injecting CooldownStore does not make of the store
-        const order = providers.resolutionOrder(container, providers$1, [
-            ...providers$1.keys(),
-            ...options.services ?? [],
-            ...themeResolver ? [
-                themeResolver
-            ] : [],
-            ...options.controllers,
-            ...observers
-        ], {
-            followOwnTokens: false
-        });
-        appClasses.push(...order.filter((token)=>{
-            const provider = providers$1.get(token);
-            return providers.isAppClassToken(token) && (!provider || providers.isClassProvider(provider) && provider.useClass === token);
-        }));
-        providers.assertProvided(container, providers$1, runs.classes, '@MeoCord({ providers })');
-        // The store first, after only what it injects: it is ready before anything a call reaches, and shuts down last
-        const store = options.cooldownStore;
-        const lifecycle = (store ? providers.resolutionOrder(container, providers$1, [
-            store,
-            ...order
-        ]) : order).map((token)=>({
-                token,
-                name: providers.tokenName(token),
-                dependencies: providers.tokenDependencies(container, providers$1, token),
-                ...token === store && {
-                    cooldownStore: true
+            // 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));
+            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));
+            }).inSingletonScope();
+            providers.bindsOwnToken(container, providers.HandlerRegistry);
+            providers.bindsOwnToken(container, providers.ShardContext);
+            container.bind(providers.COOLDOWN_POLICY).toConstantValue(providers.cooldownPolicyFrom(options));
+            // A store of the app's own is resolved like a service, so it can inject its client
+            if (options.cooldownStore) {
+                bindDependencies(container, options.cooldownStore, providers$1);
+                container.bind(controller_decorator.CooldownStore).toService(options.cooldownStore);
+            } else {
+                container.bind(controller_decorator.CooldownStore).toConstantValue(new controller_decorator.MemoryCooldownStore());
+            }
+            // A class that injects the token depends on the app's store, the one unit whose hooks run
+            providers.bindsOwnToken(container, controller_decorator.CooldownStore, options.cooldownStore);
+            // 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.');
                 }
-            }));
-        // What ShardContext.call reaches: the app's classes, and the classes its providers stand in for
-        const callable = [
-            ...new Set([
-                ...appClasses,
-                ...[
-                    ...providers$1.keys()
-                ].filter(providers.isAppClassToken)
-            ])
-        ];
-        // From another shard a call names its class, so with process sharding every name it can reach is one class's
-        if (meocordConfig.sharding?.mode === 'process') {
-            const names = new Set();
-            for (const cls of callable){
-                if (names.has(cls.name)) {
-                    throw controller_decorator.refuse(new Error(`${cls.name}: two classes have this name; with process sharding, ShardContext.call finds a class in another ` + 'shard by its name, so give each controller, service and provided class a distinct name.'));
+                if (container.isBound(token)) {
+                    controller_decorator.startupError(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${providers.tokenName(token)}, which MeoCord binds itself.`));
+                    continue;
                 }
-                names.add(cls.name);
+                providers.bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers$1));
             }
-        }
-        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.prepareHandlerStages(container, appClasses);
-        providers.bindObservers(container, observers);
-        // 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;
-        const startup = async ()=>{
-            try {
-                await providers.resolveProviders(container, providers$1, order);
-            } catch (error) {
-                logger.error(`${error.message}. The bot cannot start without it.`);
-                logger.debug('Provider failure:', error.cause);
-                controller_decorator.markExplained(error);
-                throw error;
+            // Bind all controllers and their transitive dependencies
+            for (const ctrl of options.controllers){
+                bindDependencies(container, ctrl, providers$1);
             }
-            // The listed services are made now, so constructors that attach listeners or connect run before login
             for (const svc of options.services ?? []){
-                container.get(svc);
+                bindDependencies(container, svc, providers$1);
             }
-            if (shardedCooldownStore.shardingRole(meocordConfig) === 'shard' && container.get(controller_decorator.CooldownStore) instanceof controller_decorator.MemoryCooldownStore) {
-                warnPerShardCooldowns(options.controllers, logger);
+            if (themeResolver) bindDependencies(container, themeResolver, providers$1);
+            // Observers are services too: bound here so their lifecycle hooks run in dependency order
+            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);
+            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();
+            // Providers first, then the services, the controllers and the observers, each after what it depends on. The app's
+            // own classes, which a class injecting CooldownStore does not make of the store
+            const order = providers.resolutionOrder(container, providers$1, [
+                ...providers$1.keys(),
+                ...options.services ?? [],
+                ...themeResolver ? [
+                    themeResolver
+                ] : [],
+                ...options.controllers,
+                ...observers
+            ], {
+                followOwnTokens: false
+            });
+            appClasses.push(...order.filter((token)=>{
+                const provider = providers$1.get(token);
+                return providers.isAppClassToken(token) && (!provider || providers.isClassProvider(provider) && provider.useClass === token);
+            }));
+            providers.assertProvided(container, providers$1, runs.classes, '@MeoCord({ providers })');
+            // With what the stages inject among them, each after what it depends on, so their hooks run as a listed service's do
+            const roots = stageServices.length > 0 ? providers.resolutionOrder(container, providers$1, [
+                ...order,
+                ...stageServices
+            ], {
+                followOwnTokens: false
+            }) : order;
+            // The store first, after only what it injects: it is ready before anything a call reaches, and shuts down last
+            const store = options.cooldownStore;
+            const lifecycle = (store ? providers.resolutionOrder(container, providers$1, [
+                store,
+                ...roots
+            ]) : roots).map((token)=>({
+                    token,
+                    name: providers.tokenName(token),
+                    dependencies: providers.tokenDependencies(container, providers$1, token),
+                    ...token === store && {
+                        cooldownStore: true
+                    }
+                }));
+            // What ShardContext.call reaches: the app's classes, and the classes its providers stand in for
+            const callable = [
+                ...new Set([
+                    ...appClasses,
+                    ...[
+                        ...providers$1.keys()
+                    ].filter(providers.isAppClassToken)
+                ])
+            ];
+            // From another shard a call names its class, so with process sharding every name it can reach is one class's
+            if (meocordConfig.sharding?.mode === 'process') {
+                const names = new Set();
+                for (const cls of callable){
+                    if (names.has(cls.name)) {
+                        controller_decorator.startupError(new Error(`${cls.name}: two classes have this name; with process sharding, ShardContext.call finds a class in another ` + 'shard by its name, so give each controller, service and provided class a distinct name.'));
+                        continue;
+                    }
+                    names.add(cls.name);
+                }
             }
-            providers.bindAppPresenter(container, target, discordClient);
-            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');
+            providers.prepareHandlerStages(container, appClasses);
+            providers.bindObservers(container, observers);
+            // Read here with the rest, so a pattern that cannot be read is reported with them, before the dispatcher warns
+            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();
+            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);
+            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;
+            const startup = async (control)=>{
+                try {
+                    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;
+                }
+                // 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 ?? []){
+                    if (control.stopped()) return;
+                    container.get(svc);
+                }
+                if (control.stopped()) return;
+                if (shard && container.get(controller_decorator.CooldownStore) instanceof controller_decorator.MemoryCooldownStore) {
+                    warnPerShardCooldowns(options.controllers, logger);
+                }
+                providers.bindAppPresenter(container, target, discordClient);
+                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);
+        });
     }
 }
 MeoCordFactory.logger = new controller_decorator.Logger();