meocord 4.1.2 → 4.2.1

package/dist/esm/core/meocord.app.js

@@ -5,18 +5,15 @@ import './theme-scope.js';
 import './theme-validation.js';
 import '../common/decorator.js';
 import 'reflect-metadata';
+import '../common/response/response-state.js';
 import { GuardDeniedError, UserError } from '../common/errors.js';
-import '../common/translator.js';
-import '../common/response/send-failure.js';
-import '../util/interaction.util.js';
-import '../common/response/flags.js';
-import 'path';
-import '../common/response/components.js';
 import 'node:crypto';
 import { getMessageHandlers, getReactionHandlers } from '../decorator/controller.decorator.js';
 import './scalar-types.js';
 import { isShardMessage } from './shard-messages.js';
 import { managerGone } from '../util/sharding-mode.util.js';
+import '../common/translator.js';
+import '../common/meocord-text.js';
 import { markExplained } from '../common/explained-error.js';
 import { messageDecorator, reactionDecorator } from './command-conflicts.js';
 import { ReactionHandlerAction } from '../enum/controller.enum.js';
@@ -27,7 +24,8 @@ import { stageTypes, stageClass } from './stage-scope.js';
 import { getEventHandlers } from '../decorator/event.decorator.js';
 import { eventRequirements, messageHandlerRequirements, REACTION_HANDLER_REQUIREMENTS, missingRequirementWarnings } from './event-requirements.js';
 import { classUnits } from './lifecycle-order.js';
-import { runReadyHooks, runShutdownSequence, callsSettled } from './lifecycle-hooks.js';
+import { runReadyHooks, runShutdownSequence, ReadyPass } from './lifecycle-hooks.js';
+import { RunningCalls } from './running-calls.js';
 import { stopRequests } from '../util/stop-request.util.js';
 import { tellDevRunner, onDevRunnerStop } from '../util/dev-runner.util.js';
 import { fatalLoginCode, explainLoginFailure, tokenMessage, isRefusedToken } from './login-failure.js';
@@ -41,7 +39,6 @@ import { loadMeoCordConfig } from '../util/meocord-config-loader.util.js';
 import { isRegisterOnly, FORCE_REGISTER_ENV, REGISTER_GUILD_ENV } from '../util/registration-mode.util.js';
 import { shutdownTimeoutOf } from '../util/shutdown-timeout.util.js';
 import { escapeForLog } from '../util/user-text.util.js';
-import { isShardProcess } from '../util/shard-process.util.js';
 
 /** 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();
@@ -52,11 +49,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' || isShardProcess()) return;
+        if (request === 'duplicate' || shard) return;
         process.exit(1);
         return;
     }
@@ -77,47 +74,48 @@ let shuttingDown;
     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 (isShardProcess()) {
+    if (shard) {
         process.on('message', (message)=>{
-            if (isShardMessage(message) && message.meocord === 'shutdown') void shutdownAndExit();
+            if (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 (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 "/${escapeForLog(interaction.commandName)}"`;
+    if ('customId' in interaction) return `interaction "${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
@@ -139,7 +137,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 (isShardProcess() && !this.closing) endFailedShard(error);
+            if (this.shard && !this.closing) endFailedShard(error);
             throw error;
         }).finally(()=>this.starting = undefined));
         return this.starting;
@@ -149,7 +147,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 (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
@@ -159,14 +160,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 (isShardProcess() && managerGone()) void shutdownAndExit();
+        if (this.shard && 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
         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) {
@@ -179,7 +186,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) {
                 releaseAmbientAppTheme(this.container);
                 if (process.exitCode === undefined || process.exitCode === 0) {
@@ -189,7 +199,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)) {
@@ -205,10 +216,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 (!isShardProcess()) await this.registerCommands();
+                if (!this.shard) await this.registerCommands();
                 await readyHooks;
             }));
-        this.bot.on('interactionCreate', ownInteractionListener((interaction)=>this.runListener('interactionCreate', ()=>this.dispatcher.interaction(interaction))));
+        this.bot.on('interactionCreate', 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,
@@ -251,18 +262,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 (!isShardProcess()) this.logger.error(explanation);
+                if (!this.shard) this.logger.error(explanation);
                 this.logger.debug('Login failed:', error);
                 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;
@@ -280,7 +291,7 @@ class MeoCordApp {
             MeoCordApp.toldDevRunnerLoginFailed = false;
             await tellDevRunner({
                 meocord: 'online'
-            });
+            }, this.shard);
         }
         this.online = true;
         this.logger.log('Bot is online!');
@@ -363,18 +374,20 @@ class MeoCordApp {
                     } else logError(error);
                     return undefined;
                 };
-                const listener = async (...args)=>{
-                    try {
-                        const instance = this.container.get(lifecycleClass);
-                        await 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 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);
             }
@@ -443,29 +456,35 @@ class MeoCordApp {
    */ async runReadyHooks(client) {
         const entries = [];
         this.lifecycleEntries = entries;
-        await 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(()=>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 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 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 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)
@@ -484,8 +503,28 @@ class MeoCordApp {
             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');
@@ -495,8 +534,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();
@@ -507,7 +546,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;
@@ -516,6 +555,7 @@ class MeoCordApp {
         this.lifecycleClasses = lifecycleClasses;
         this.startup = startup;
         this.messageOptions = messageOptions;
+        this.shard = shard;
         this.logger = new Logger(MeoCordApp.name);
         this.fallback = createFallback(this.logger, ()=>this.messageOptions, {
             cooldownNotice: (refusal)=>claimCooldownNotice(this.container, refusal),
@@ -528,7 +568,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 RunningCalls();
+        /** The ready hooks' pass, whose `onReady` in progress shutdown waits for, less one that asked the app to stop. */ this.readyPass = new 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;

package/dist/esm/core/message-routes.js

@@ -2,7 +2,7 @@ import { getMessageHandlers } from '../decorator/controller.decorator.js';
 import { routeSpecificity } from './route-specificity.js';
 import { isKnownParamType, BUILT_IN_TYPES, isGuildType, fitsParamType } from './message-params.js';
 import { isSpace, splitFlagWords, splitWords, restFrom } from './message-words.js';
-import { refuse } from '../util/refusal.util.js';
+import { startupError } from '../util/refusal.util.js';
 
 /** Whether a route's scope lets it run where the message was sent. */ const fitsScope = (scope, inGuild)=>inGuild === undefined || scope === 'any' || scope === 'guild' === inGuild;
 const PARAM = /^\{(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\.\.\.)?(\?)?\}$/;
@@ -201,7 +201,8 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
                 if (own.hidden !== undefined && typeof own.hidden !== 'boolean') throw new Error(`hidden is true or false, not ${JSON.stringify(own.hidden)}.`);
                 aliases = aliasPatterns(pattern, parsed.tokens, own.aliases);
             } catch (error) {
-                throw refuse(new Error(`${controllerClass.name}.${method}: @MessageHandler('${pattern}'): ${error.message}`));
+                startupError(new Error(`${controllerClass.name}.${method}: @MessageHandler('${pattern}'): ${error.message}`));
+                continue;
             }
             const shared = {
                 controllerClass,
@@ -240,7 +241,7 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
                 routes.splice(j--, 1);
                 continue;
             }
-            throw refuse(new Error(`${a.controllerClass.name}.${a.method}: ${describeRoute(a)} and ${describeRoute(b)} in ${b.controllerClass.name}.${b.method} ` + `match the same messages, so only one of them could ever answer those. Change one pattern, or give one its own prefix.`));
+            startupError(new Error(`${a.controllerClass.name}.${a.method}: ${describeRoute(a)} and ${describeRoute(b)} in ${b.controllerClass.name}.${b.method} ` + `match the same messages, so only one of them could ever answer those. Change one pattern, or give one its own prefix.`));
         }
     }
     return routes;

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

@@ -4,16 +4,17 @@ import { Logger } from '../common/logger.js';
 import { bindShared } from './interceptor-runner.js';
 import { appliesTo } from './stage-scope.js';
 import { respond } from '../common/response/response-state.js';
-import { refuse } from '../util/refusal.util.js';
+import { startupError } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /** Where a container keeps the observers its calls are reported to, in order. */ const OBSERVERS = Symbol('observers');
 const logger = new Logger('Observer');
-/** Throws unless every entry is an `@Observer` class, naming where it was listed. */ function assertObservers(where, observers) {
+/** Reports each entry that is not an `@Observer` class, naming where it was listed. */ function assertObservers(where, observers) {
     for (const observer of observers){
         if (typeof observer !== 'function' || !Reflect.getMetadata(META.observerClass, observer)) {
             const name = typeof observer === 'function' ? observer.name : String(observer);
-            throw refuse(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
+            startupError(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
+            continue;
         }
     }
 }

package/dist/esm/core/providers.js

@@ -3,7 +3,7 @@ import { injectedTokens, undecoratedConstructor, untypedParameter } from './guar
 import { meocordClasses, meocordClassAdvice } from './meocord-classes.js';
 import { isAppClassToken } from './lifecycle-order.js';
 import { makeInjectable } from '../util/injectable.util.js';
-import { refuse } from '../util/refusal.util.js';
+import { startupError, refuse } from '../util/refusal.util.js';
 
 const isValueProvider = (provider)=>'useValue' in provider;
 const isClassProvider = (provider)=>'useClass' in provider;
@@ -15,9 +15,9 @@ const isFactoryProvider = (provider)=>'useFactory' in provider;
 }
 const isToken = (value)=>typeof value === 'function' || typeof value === 'string' || typeof value === 'symbol';
 /**
- * Checks each provider's shape and indexes them by token, throwing on the first that cannot be bound, such as one with
- * no token, not exactly one of `useValue`, `useClass` and `useFactory`, one that injects `ExecutionContext`, or a
- * token provided twice.
+ * Checks each provider's shape and indexes them by token, reporting each that cannot be bound, such as one with no
+ * token, not exactly one of `useValue`, `useClass` and `useFactory`, one that injects `ExecutionContext`, or a token
+ * provided twice, as a startup error; see `startupError`.
  */ function providerMap(providers, where) {
     const map = new Map();
     for (const provider of providers){
@@ -26,10 +26,12 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
         if (typeof entry === 'function') {
             const name = tokenName(entry);
             const listing = where.includes('@MeoCord') ? 'list a service in @MeoCord({ services })' : 'a class a controller or service injects is bound for you, so it needs no listing';
-            throw refuse(new Error(`${where}: ${name} is a class, not a provider: ${listing}. To put something in its place, write ` + `{ provide: ${name}, useValue } or { provide: ${name}, useClass }.`));
+            startupError(new Error(`${where}: ${name} is a class, not a provider: ${listing}. To put something in its place, write ` + `{ provide: ${name}, useValue } or { provide: ${name}, useClass }.`));
+            continue;
         }
         if (!entry || typeof entry !== 'object' || !isToken(entry.provide)) {
-            throw refuse(new Error(`${where}: a provider has no token: set provide to a class, a string or a symbol.`));
+            startupError(new Error(`${where}: a provider has no token: set provide to a class, a string or a symbol.`));
+            continue;
         }
         const name = tokenName(entry.provide);
         const kinds = [
@@ -38,26 +40,35 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
             'useFactory'
         ].filter((kind)=>kind in entry);
         if (kinds.length !== 1) {
-            throw refuse(new Error(`${where}: the provider for ${name} needs exactly one of useValue, useClass and useFactory.`));
+            startupError(new Error(`${where}: the provider for ${name} needs exactly one of useValue, useClass and useFactory.`));
+            continue;
         }
         if ('useClass' in entry && typeof entry.useClass !== 'function') {
-            throw refuse(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
+            startupError(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
+            continue;
         }
         if ('useClass' in entry && injectedTokens(entry.useClass).includes(ExecutionContext)) {
-            throw refuse(new Error(`${where}: the provider for ${name} uses ${tokenName(entry.useClass)}, which injects ExecutionContext, but it is ` + "made once and shared, so it would keep the first call's context for every later call. Inject " + 'ExecutionContext only into guards.'));
+            startupError(new Error(`${where}: the provider for ${name} uses ${tokenName(entry.useClass)}, which injects ExecutionContext, but it is ` + "made once and shared, so it would keep the first call's context for every later call. Inject " + 'ExecutionContext only into guards.'));
+            continue;
         }
         if ('useFactory' in entry) {
             if (typeof entry.useFactory !== 'function') {
-                throw refuse(new Error(`${where}: the provider for ${name} has a useFactory that is not a function.`));
+                startupError(new Error(`${where}: the provider for ${name} has a useFactory that is not a function.`));
+                continue;
             }
             if (entry.inject !== undefined && !(Array.isArray(entry.inject) && entry.inject.every(isToken))) {
-                throw refuse(new Error(`${where}: the provider for ${name} has an inject that is not a list of tokens.`));
+                startupError(new Error(`${where}: the provider for ${name} has an inject that is not a list of tokens.`));
+                continue;
             }
             if (entry.inject?.includes(ExecutionContext)) {
-                throw refuse(new Error(`${where}: the provider for ${name} injects ExecutionContext, but its factory runs once and its value is ` + "shared, so it would keep the first call's context for every later call. Inject ExecutionContext only into guards."));
+                startupError(new Error(`${where}: the provider for ${name} injects ExecutionContext, but its factory runs once and its value is ` + "shared, so it would keep the first call's context for every later call. Inject ExecutionContext only into guards."));
+                continue;
             }
         }
-        if (map.has(entry.provide)) throw refuse(new Error(`${where}: ${name} is provided twice.`));
+        if (map.has(entry.provide)) {
+            startupError(new Error(`${where}: ${name} is provided twice.`));
+            continue;
+        }
         map.set(entry.provide, provider);
     }
     return map;
@@ -110,22 +121,23 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     for (const dependency of inject)if (isAppClassToken(dependency)) bindClass(dependency);
 }
 /**
- * Throws when a class or a factory asks for a string or symbol token that nothing binds, naming both,
- * rather than failing when the class is first resolved. A class token is bound on demand, so it is
- * never missing.
+ * Reports a class or a factory that asks for a string or symbol token nothing binds, naming both, rather than failing
+ * when the class is first resolved. A class token is bound on demand, so it is never missing.
  */ function assertProvided(container, providers, classes, where) {
     const missing = (token)=>(typeof token === 'string' || typeof token === 'symbol') && !container.isBound(token);
     for (const cls of classes){
         const token = injectedTokens(cls).find(missing);
         if (token !== undefined) {
-            throw refuse(new Error(`${cls.name}: it injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            startupError(new Error(`${cls.name}: it injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            continue;
         }
     }
     for (const [provided, provider] of providers){
         const dependencies = isFactoryProvider(provider) ? provider.inject ?? [] : isClassProvider(provider) ? injectedTokens(provider.useClass) : [];
         const token = dependencies.find(missing);
         if (token !== undefined) {
-            throw refuse(new Error(`${tokenName(provided)}: its provider injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            startupError(new Error(`${tokenName(provided)}: its provider injects ${tokenName(token)}, which nothing provides: add a provider for it to ${where}.`));
+            continue;
         }
     }
 }
@@ -158,16 +170,21 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
  */ function assertTypedParameters(classes, decorators) {
     for (const cls of classes){
         const instead = meocordClassAdvice(cls);
-        if (instead && undecoratedConstructor(cls)) throw refuse(new Error(`${cls.name}: MeoCord does not inject it; ${instead}.`));
+        if (instead && undecoratedConstructor(cls)) {
+            startupError(new Error(`${cls.name}: MeoCord does not inject it; ${instead}.`));
+            continue;
+        }
         if (undecoratedConstructor(cls)) {
             const decorator = decorators.get(cls);
-            throw refuse(new Error(`${cls.name}: its constructor takes parameters, but ${cls.name} has no decorator, so TypeScript recorded none of ` + `their types and it cannot be created. ${decorator ? `Decorate it with ${decorator}.` : 'Decorate it with @Service(), or give a class from a package a provider in @MeoCord({ providers }).'}`));
+            startupError(new Error(`${cls.name}: its constructor takes parameters, but ${cls.name} has no decorator, so TypeScript recorded none of ` + `their types and it cannot be created. ${decorator ? `Decorate it with ${decorator}.` : 'Decorate it with @Service(), or give a class from a package a provider in @MeoCord({ providers }).'}`));
+            continue;
         }
         const index = untypedParameter(cls);
         if (index === -1) continue;
         const injectors = classes.filter((other)=>other !== cls && injectedTokens(other).includes(cls)).map((other)=>other.name);
         const injectedBy = injectors.length === 0 ? '' : ` (${injectors.length === 1 ? injectors[0] : `${injectors.slice(0, -1).join(', ')} and ${injectors.at(-1)}`} ` + `inject${injectors.length === 1 ? 's' : ''} ${cls.name})`;
-        throw refuse(new Error(`${cls.name}: parameter ${index + 1} of its constructor has no runtime type, so it cannot be created. Usually ` + `${cls.name} and a class it injects import each other${injectedBy}, or the parameter is typed with an ` + 'interface or an `import type`. Move what they both need into a third service, or inject the parameter ' + 'with @Inject(token).'));
+        startupError(new Error(`${cls.name}: parameter ${index + 1} of its constructor has no runtime type, so it cannot be created. Usually ` + `${cls.name} and a class it injects import each other${injectedBy}, or the parameter is typed with an ` + 'interface or an `import type`. Move what they both need into a third service, or inject the parameter ' + 'with @Inject(token).'));
+        continue;
     }
 }
 /** For each container, the tokens MeoCord binds itself, each to the app's class it stands for, if any. */ const ownTokens = new WeakMap();
@@ -236,15 +253,20 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
 }
 /**
  * Runs every factory in `order`, awaiting those that return a promise, so each value is made before
- * anything that injects it is resolved. Rejects with {@link providerFailure} for the first that fails.
- */ async function resolveProviders(container, providers, order) {
+ * anything that injects it is resolved. Rejects with {@link providerFailure} for the first that fails. With `control`,
+ * it makes no further value once the app is stopping.
+ */ async function resolveProviders(container, providers, order, control) {
     for (const token of order){
         const provider = providers.get(token);
         if (!provider || !isFactoryProvider(provider)) continue;
+        if (control?.stopped()) return;
+        control?.pending(tokenName(token));
         try {
             await container.getAsync(token);
         } catch (error) {
             throw providerFailure(token, error);
+        } finally{
+            control?.pending(undefined);
         }
     }
 }

package/dist/esm/core/route-specificity.js

@@ -1,8 +1,8 @@
 /**
- * How specific a route pattern is, for ranking the patterns that can match one input: more literal
- * text first, then a fixed length before one taking the rest, then no optional param before one, then
- * fewer params, then narrower typed params, whose segments take fewer values. Component patterns count literal
- * characters; message patterns count literal words.
+ * How specific a route pattern is, for ranking the message patterns that can match one message: more literal
+ * words first, then a fixed length before one taking the rest, then no optional param before one, then
+ * fewer params, then narrower typed params, whose words take fewer values. Component patterns count literal
+ * characters, for CommandMeta.specificity alone.
  */ function routeSpecificity({ literals, params, rest = false, optional = false, typed = 0 }) {
     return literals * 1000 - (rest ? 500 : 0) - (optional ? 250 : 0) - params + typed / 1000;
 }