meocord 4.1.2 → 4.2.0

package/dist/esm/core/meocord-factory.js

@@ -27,20 +27,21 @@ import { bunDevelopmentValues, bunDevelopmentWarning } from '../util/inherited-e
 import { assertBuiltForThisPlatform } from '../util/platform.util.js';
 import { isRegisterOnly } from '../util/registration-mode.util.js';
 import { injectedTokens, singletonContextError } from './guard-runner.js';
-import { appStages, bindGlobalStages, prepareHandlerStages, bindAppPresenter } from './handler-pipeline.js';
+import { appStages, bindGlobalStages, prepareHandlerStages, prepareThemes, bindAppPresenter } from './handler-pipeline.js';
 import { startupClasses, assertStartupClasses, lateGuardCheck } from './startup-roots.js';
 import { markStartupChecked, assertStartupChecked } from './startup-checked.js';
+import { makeInjectable } from '../util/injectable.util.js';
 import { meocordClasses } from './meocord-classes.js';
+import { buildMessageRoutes } from './message-routes.js';
 import { appObservers, bindObservers } from './observer-runner.js';
-import { makeInjectable } from '../util/injectable.util.js';
 import { isAppClassToken } from './lifecycle-order.js';
-import { providerMap, reachableClasses, bindsOwnToken, tokenName, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies, resolveProviders } from './providers.js';
+import { reachableClasses, providerMap, bindsOwnToken, tokenName, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies, resolveProviders } from './providers.js';
 import { HandlerRegistry } from './handler-registry.js';
 import { ShardManager } from './shard-manager.js';
-import { assertDistinctCommands, warnUnregisteredCommands, warnInheritedRoutes, warnOverlappingPatterns, warnHandlersOffControllers } from './command-conflicts.js';
+import { warnUnregisteredCommands, warnInheritedRoutes, warnOverlappingPatterns, warnHandlersOffControllers, assertDistinctCommands } from './command-conflicts.js';
 import { ShardContext, SHARD_CALL_KEY, shardCallHandler } from './shard-context.js';
 import { registerClientTheme } from './theme-runtime.js';
-import { isRefusal, describeRefusal, refuse } from '../util/refusal.util.js';
+import { isRefusal, logStartupErrors, describeRefusal, allDeclaredErrors, declaredErrorsOf, collectStartupErrors, refuse, startupError, stopOnStartupErrors } from '../util/refusal.util.js';
 import { endFailedShard } from './shard-exit.js';
 import { isBuiltApplication } from '../util/bundle-entry.util.js';
 import { META } from '../util/metadata-keys.js';
@@ -51,14 +52,14 @@ import { isShardProcess } from '../util/shard-process.util.js';
  */ function bindDependencies(container, cls, providers) {
     // A provided class is bound by its own provider, wherever in the list that provider comes
     if (container.isBound(cls) || providers.has(cls)) return;
-    if (injectedTokens(cls).includes(ExecutionContext)) throw refuse(singletonContextError(cls));
+    if (injectedTokens(cls).includes(ExecutionContext)) return startupError(singletonContextError(cls));
     assertStartupChecked(container, cls);
     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 injectedTokens(cls)){
-        if (dep === Translator && !container.isBound(Translator)) throw refuse(missingTranslatorError(cls));
-        if (isAppClassToken(dep)) bindDependencies(container, dep, providers);
+        if (dep === Translator && !container.isBound(Translator)) startupError(missingTranslatorError(cls));
+        else if (isAppClassToken(dep)) bindDependencies(container, dep, providers);
     }
 }
 /**
@@ -124,34 +125,51 @@ import { isShardProcess } from '../util/shard-process.util.js';
    *   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
    *   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) {
         try {
             return this.createApplication(target);
         } catch (error) {
             // A shard ends, so its manager restarts it, or stops every shard for a refusal, which it logs
             if (isShardProcess()) endFailedShard(error);
-            else if (isBuiltApplication() && isRefusal(error) && !isExplainedError(error)) {
-                this.logger.error(describeRefusal(error, process.cwd()));
-                markExplained(error);
+            else if (isRefusal(error) && !isExplainedError(error)) {
+                // Every startup error found together is logged, in a test too; a lone one is logged in a built application
+                if (logStartupErrors(error, (text)=>this.logger.error(text), 'the bot did not start')) markExplained(error);
+                else if (isBuiltApplication()) {
+                    this.logger.error(describeRefusal(error, process.cwd()));
+                    markExplained(error);
+                }
             }
             throw error;
         }
     }
     static createApplication(target) {
         const options = Reflect.getMetadata(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 = isBuiltApplication() ? allDeclaredErrors() : declaredErrorsOf([
+            target,
+            ...options?.controllers ?? []
+        ]);
         if (!options) {
+            // A refused @MeoCord stores no options, so its own errors say why
+            collectStartupErrors(()=>declared.forEach(startupError));
             throw refuse(new Error(`${typeof target === 'function' ? target.name : String(target)}: not decorated with @MeoCord(), so there is no app to create.`));
         }
         const meocordConfig = loadMeoCordConfig();
         if (!meocordConfig) {
             throw refuse(new Error(compiledConfigMessage()));
         }
-        // Before any of the three ways a bot runs, so none registers or dispatches a command only one handler could take
-        assertDistinctCommands(options.controllers);
-        const 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 = collectStartupErrors(()=>{
+            declared.forEach(startupError);
+            assertDistinctCommands(options.controllers);
+            return 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 = themeResolverClass(options.themeFor);
         // The app's classes and every class they inject, which the container binds
@@ -193,153 +211,174 @@ import { isShardProcess } from '../util/shard-process.util.js';
                 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 = appStages(target);
-        const runs = startupClasses({
-            controllers: options.controllers,
-            services: options.services ?? [],
-            providers,
-            stages,
-            presenter: options.presenter,
-            cooldownStore: options.cooldownStore,
-            themeFor: options.themeFor,
-            observers: appObservers(target)
-        });
-        assertStartupClasses(runs, {
-            translator: options.i18n !== undefined || providers.has(Translator)
-        });
-        const container = new Container();
-        const translator = options.i18n !== undefined || providers.has(Translator);
-        markStartupChecked(container, [
-            ...runs.classes,
-            ...meocordClasses()
-        ], lateGuardCheck(providers, translator));
-        bindGlobalStages(container, stages);
-        // Bind the Discord client as a constant value
-        const discordClient = new Client(clientOptionsWithSharding(this.effectiveConfig(meocordConfig), options.clientOptions));
-        container.bind(Client).toConstantValue(discordClient);
-        if (options.i18n) {
-            container.bind(Translator).toConstantValue(options.i18n);
-            bindsOwnToken(container, 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(HandlerRegistry).toConstantValue(new HandlerRegistry(appClasses, options.messages, ()=>options.i18n));
-        container.bind(ShardContext).toConstantValue(new ShardContext(discordClient, (service, method, args)=>Reflect.get(discordClient, SHARD_CALL_KEY)(service, method, args)));
-        bindsOwnToken(container, HandlerRegistry);
-        bindsOwnToken(container, ShardContext);
-        container.bind(COOLDOWN_POLICY).toConstantValue(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);
-            container.bind(CooldownStore).toService(options.cooldownStore);
-        } else {
-            container.bind(CooldownStore).toConstantValue(new MemoryCooldownStore());
-        }
-        // A class that injects the token depends on the app's store, the one unit whose hooks run
-        bindsOwnToken(container, 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){
-            if (container.isBound(token)) {
-                throw refuse(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${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 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 = appStages(target);
+            const runs = startupClasses({
+                controllers: options.controllers,
+                services: options.services ?? [],
+                providers,
+                stages,
+                presenter: options.presenter,
+                cooldownStore: options.cooldownStore,
+                themeFor: options.themeFor,
+                observers: appObservers(target)
+            });
+            assertStartupClasses(runs, {
+                translator: options.i18n !== undefined || providers.has(Translator)
+            });
+            // Outside a built application, the kept errors of the stages and other classes the app's classes reach
+            if (!isBuiltApplication()) declaredErrorsOf(runs.classes).forEach(startupError);
+            // The checks of the wiring below run on classes that passed these, so a mistake in one is not reported again there
+            stopOnStartupErrors();
+            // The checks bind into this container and change nothing else: what they bind is made once all have passed
+            const container = new Container();
+            const translator = options.i18n !== undefined || providers.has(Translator);
+            markStartupChecked(container, [
+                ...runs.classes,
+                ...meocordClasses()
+            ], lateGuardCheck(providers, translator));
+            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 = clientOptionsWithSharding(this.effectiveConfig(meocordConfig), options.clientOptions);
+            container.bind(Client).toDynamicValue(()=>new Client(clientOptions)).inSingletonScope();
+            if (options.i18n) {
+                container.bind(Translator).toConstantValue(options.i18n);
+                bindsOwnToken(container, Translator);
             }
-            bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers));
-        }
-        // Bind all controllers and their transitive dependencies
-        for (const ctrl of options.controllers){
-            bindDependencies(container, ctrl, providers);
-        }
-        for (const svc of options.services ?? []){
-            bindDependencies(container, svc, providers);
-        }
-        if (themeResolver) bindDependencies(container, themeResolver, providers);
-        // Observers are services too: bound here so their lifecycle hooks run in dependency order
-        const observers = appObservers(target);
-        for (const observer of observers)bindDependencies(container, observer, providers);
-        // 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 = resolutionOrder(container, providers, [
-            ...providers.keys(),
-            ...options.services ?? [],
-            ...themeResolver ? [
-                themeResolver
-            ] : [],
-            ...options.controllers,
-            ...observers
-        ], {
-            followOwnTokens: false
-        });
-        appClasses.push(...order.filter((token)=>{
-            const provider = providers.get(token);
-            return isAppClassToken(token) && (!provider || isClassProvider(provider) && provider.useClass === token);
-        }));
-        assertProvided(container, providers, 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 ? resolutionOrder(container, providers, [
-            store,
-            ...order
-        ]) : order).map((token)=>({
-                token,
-                name: tokenName(token),
-                dependencies: tokenDependencies(container, providers, 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.keys()
-                ].filter(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 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.'));
+            // Bound before the app's classes, so a class that injects it gets this instance; filled once they are bound
+            const appClasses = [];
+            container.bind(HandlerRegistry).toConstantValue(new HandlerRegistry(appClasses, options.messages, ()=>options.i18n));
+            container.bind(ShardContext).toDynamicValue(()=>{
+                const client = container.get(Client);
+                return new ShardContext(client, (service, method, args)=>Reflect.get(client, SHARD_CALL_KEY)(service, method, args));
+            }).inSingletonScope();
+            bindsOwnToken(container, HandlerRegistry);
+            bindsOwnToken(container, ShardContext);
+            container.bind(COOLDOWN_POLICY).toConstantValue(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);
+                container.bind(CooldownStore).toService(options.cooldownStore);
+            } else {
+                container.bind(CooldownStore).toConstantValue(new MemoryCooldownStore());
+            }
+            // A class that injects the token depends on the app's store, the one unit whose hooks run
+            bindsOwnToken(container, 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){
+                if (container.isBound(token)) {
+                    startupError(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${tokenName(token)}, which MeoCord binds itself.`));
+                    continue;
                 }
-                names.add(cls.name);
+                bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers));
             }
-        }
-        Reflect.set(discordClient, SHARD_CALL_KEY, 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(META.container, container, cls);
-        }
-        prepareHandlerStages(container, appClasses);
-        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 resolveProviders(container, providers, order);
-            } catch (error) {
-                logger.error(`${error.message}. The bot cannot start without it.`);
-                logger.debug('Provider failure:', error.cause);
-                markExplained(error);
-                throw error;
+            // Bind all controllers and their transitive dependencies
+            for (const ctrl of options.controllers){
+                bindDependencies(container, ctrl, providers);
             }
-            // 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);
             }
-            if (shardingRole(meocordConfig) === 'shard' && container.get(CooldownStore) instanceof MemoryCooldownStore) {
-                warnPerShardCooldowns(options.controllers, logger);
+            if (themeResolver) bindDependencies(container, themeResolver, providers);
+            // Observers are services too: bound here so their lifecycle hooks run in dependency order
+            const observers = appObservers(target);
+            for (const observer of observers)bindDependencies(container, observer, providers);
+            // What follows walks what these bound, so a class refused here is not reported again as missing
+            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 = resolutionOrder(container, providers, [
+                ...providers.keys(),
+                ...options.services ?? [],
+                ...themeResolver ? [
+                    themeResolver
+                ] : [],
+                ...options.controllers,
+                ...observers
+            ], {
+                followOwnTokens: false
+            });
+            appClasses.push(...order.filter((token)=>{
+                const provider = providers.get(token);
+                return isAppClassToken(token) && (!provider || isClassProvider(provider) && provider.useClass === token);
+            }));
+            assertProvided(container, providers, 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 ? resolutionOrder(container, providers, [
+                store,
+                ...order
+            ]) : order).map((token)=>({
+                    token,
+                    name: tokenName(token),
+                    dependencies: tokenDependencies(container, providers, 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.keys()
+                    ].filter(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)) {
+                        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);
+                }
             }
-            bindAppPresenter(container, target, discordClient);
-            registerClientTheme(discordClient, container);
-            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');
+            prepareHandlerStages(container, appClasses);
+            bindObservers(container, observers);
+            // Read here with the rest, so a pattern that cannot be read is reported with them, before the dispatcher warns
+            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
+            stopOnStartupErrors();
+            const discordClient = container.get(Client);
+            Reflect.set(discordClient, SHARD_CALL_KEY, 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(META.container, container, cls);
+            }
+            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 ()=>{
+                try {
+                    await resolveProviders(container, providers, order);
+                } catch (error) {
+                    logger.error(`${error.message}. The bot cannot start without it.`);
+                    logger.debug('Provider failure:', error.cause);
+                    markExplained(error);
+                    throw error;
+                }
+                // 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);
+                }
+                if (shardingRole(meocordConfig) === 'shard' && container.get(CooldownStore) instanceof MemoryCooldownStore) {
+                    warnPerShardCooldowns(options.controllers, logger);
+                }
+                bindAppPresenter(container, target, discordClient);
+                registerClientTheme(discordClient, container);
+                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');
+        });
     }
 }
 MeoCordFactory.logger = new Logger();

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();

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;
 }