meocord 4.2.1 → 4.2.2

package/dist/esm/common/translator.js

@@ -69,16 +69,26 @@ import { sharedName } from '../util/shared-state.util.js';
 }
 const DISCORD_LOCALES = new Set(Object.values(Locale));
 const languageOf = (locale)=>locale.split('-')[0];
-/** A message by its dotted key, or undefined when the catalog lacks it or the key names a group. */ function lookup(catalog, key) {
+const PLURAL_CATEGORIES = new Set([
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other'
+]);
+/** A plural's shape: a non-empty object whose every key is a plural category, as the types read one; any other is a group. */ const isPluralShape = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
+/**
+ * A message by its dotted key, or undefined when the catalog lacks it or the key names a group. A plural without an
+ * `other` form reads as missing, so a translation that left it out falls back to the next catalog.
+ */ function lookup(catalog, key) {
     let current = catalog;
     for (const part of key.split('.')){
         if (typeof current !== 'object' || current === null) return undefined;
         current = current[part];
     }
     if (typeof current === 'string') return current;
-    if (typeof current === 'object' && current !== null && typeof current.other === 'string') {
-        return current;
-    }
+    if (isPluralShape(current) && typeof current.other === 'string') return current;
     return undefined;
 }
 const plurals = new Map();
@@ -278,4 +288,4 @@ class CatalogTranslator extends Translator {
     return new CatalogTranslator(defaultLocale, locales);
 }
 
-export { CATALOGS, LOCALE_CHAIN, Translator, createTranslator, defineCatalog, fillPlaceholders, languageOf, lookup, missingTranslatorError, placeholderNames, pluralForm };
+export { CATALOGS, LOCALE_CHAIN, Translator, createTranslator, defineCatalog, fillPlaceholders, isPluralShape, languageOf, lookup, missingTranslatorError, placeholderNames, pluralForm };

package/dist/esm/core/dispatcher.js

@@ -241,10 +241,7 @@ import { existingResponse } from '../common/response/response-state.js';
    * says whether the handler ran. Its guard wrappers let this call through, so each guard runs once.
    */ async invokeHandler(instance, methodName, args, call, hooks = {}) {
         const handler = `${instance.constructor.name}.${methodName}`;
-        const onUnanswered = this.options.warnUnanswered ? (phase, returnedBy)=>this.warnUnansweredOnce(handler, phase, returnedBy && {
-                name: returnedBy.interceptor.name,
-                handlerStarted: returnedBy.handlerStarted
-            }) : undefined;
+        const onUnanswered = this.options.warnUnanswered ? (unanswered)=>this.warnUnansweredOnce(handler, unanswered) : undefined;
         const outcome = await runHandler(this.container, instance, methodName, args, {
             ...this.runOptions(call),
             onUnanswered,
@@ -254,13 +251,17 @@ import { existingResponse } from '../common/response/response-state.js';
         return outcome.ran;
     }
     /**
-   * Warns, once per handler, that it left its interaction unanswered or deferred without a follow-up, or that
-   * `interceptor` returned before the handler ran or finished, and the call ended so.
-   */ warnUnansweredOnce(handler, phase, interceptor) {
+   * Warns, once per handler, that it left its interaction or autocomplete unanswered or deferred without a follow-up,
+   * or that an interceptor returned before the handler ran or finished, and the call ended so.
+   */ warnUnansweredOnce(handler, { type, phase, returnedBy }) {
         if (this.warnedUnanswered.has(handler)) return;
         this.warnedUnanswered.add(handler);
+        const interceptor = returnedBy && {
+            name: returnedBy.interceptor.name,
+            handlerStarted: returnedBy.handlerStarted
+        };
         const returned = interceptor && `${handler}: its interceptor ${interceptor.name} returned before the handler ${interceptor.handlerStarted ? 'finished' : 'ran'}`;
-        const what = interceptor ? phase === 'unanswered' ? `${returned}, without answering the interaction, so the user saw "The application did not respond". Answer it ` + `in ${interceptor.name}, or await next.handle().` : interceptor.handlerStarted ? `${returned}, and the deferred interaction had no follow-up when the call ended, so @Defer's lock was ` + `released while the user still saw it thinking. Follow up in ${interceptor.name} with respond(interaction).send(), ` + 'or await next.handle().' : `${returned}, and the deferred interaction was never followed up, so the user saw it thinking until Discord ` + `gave up. Follow up in ${interceptor.name} with respond(interaction).send(), or await next.handle().` : phase === 'unanswered' ? `${handler} finished without answering its interaction, so the user saw "The application did not respond". ` + 'Answer it with respond(interaction).send(), or acknowledge it first with @Defer().' : `${handler} deferred its interaction and never followed up, so the user saw it thinking until Discord gave up. ` + 'Follow up with respond(interaction).send().';
+        const what = type === 'autocomplete' ? `${handler} finished without answering its autocomplete, so the user saw its options fail to load. Answer it ` + 'with interaction.respond(choices) within 3 seconds.' : interceptor ? phase === 'unanswered' ? `${returned}, without answering the interaction, so the user saw "The application did not respond". Answer it ` + `in ${interceptor.name}, or await next.handle().` : interceptor.handlerStarted ? `${returned}, and the deferred interaction had no follow-up when the call ended, so @Defer's lock was ` + `released while the user still saw it thinking. Follow up in ${interceptor.name} with respond(interaction).send(), ` + 'or await next.handle().' : `${returned}, and the deferred interaction was never followed up, so the user saw it thinking until Discord ` + `gave up. Follow up in ${interceptor.name} with respond(interaction).send(), or await next.handle().` : phase === 'unanswered' ? `${handler} finished without answering its interaction, so the user saw "The application did not respond". ` + 'Answer it with respond(interaction).send(), or acknowledge it first with @Defer().' : `${handler} deferred its interaction and never followed up, so the user saw it thinking until Discord gave up. ` + 'Follow up with respond(interaction).send().';
         this.logger.warn(`${what} Shown once per handler; @MeoCord({ warnUnanswered: false }) turns it off.`);
     }
     /**

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

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { perHandler, sourcePrototype, stageClasses } from './guard-runner.js';
 import { bindShared } from './interceptor-runner.js';
 import { startupError } from '../util/refusal.util.js';
-import { isConstructor } from '../util/value.util.js';
+import { isConstructible } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /** The filter class an entry names. */ function filterClass(entry) {
@@ -51,7 +51,7 @@ import { META } from '../util/metadata-keys.js';
             // Every filter reaching here was checked for @Catch at startup, so its types are always recorded
             const types = Reflect.getOwnMetadata(META.catchTypes, filterClass(entry));
             // Only classes match: anything else given to @Catch, warned of as it applied, matches no error
-            if (types.length === 0 || types.some((type)=>isConstructor(type) && error instanceof type)) return entry;
+            if (types.length === 0 || types.some((type)=>isConstructible(type) && error instanceof type)) return entry;
         }
     }
     return undefined;

package/dist/esm/core/handler-pipeline.js

@@ -343,7 +343,9 @@ const logger = new Logger('ExceptionFilter');
             denial
         })) {
             outcome = 'denied';
-            await response?.abandon();
+            // Without @Defer too, so a denied component is acknowledged rather than left to fail
+            const denied = response ?? (type === 'interaction' && first?.isRepliable?.() ? responseOf(first) : undefined);
+            await denied?.abandon();
             return {
                 ran: false
             };
@@ -399,14 +401,18 @@ const logger = new Logger('ExceptionFilter');
         };
     } finally{
         await response?.release();
-        if (options.onUnanswered && (ran || returnedEarly) && outcome === 'ran' && type === 'interaction') {
+        if (options.onUnanswered && (ran || returnedEarly) && outcome === 'ran' && (type === 'interaction' || type === 'autocomplete')) {
             const phase = responsePhaseOf(contextOf());
             // The handler is to blame only once it has finished; until then, the interceptor that ended the call is
-            const blamed = !finished && returnedEarly ? {
+            const returnedBy = !finished && returnedEarly ? {
                 interceptor: returnedEarly,
                 handlerStarted: ran
             } : undefined;
-            if (phase === 'unanswered' || phase === 'deferred') options.onUnanswered(phase, blamed);
+            if (phase === 'unanswered' || phase === 'deferred') options.onUnanswered({
+                type,
+                phase,
+                returnedBy
+            });
         }
         if (options.awaitObservers) await starting;
         // After the answer and the release, so the duration covers the whole call

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

@@ -32,7 +32,7 @@ import { meocordClasses } from './meocord-classes.js';
 import { buildMessageRoutes } from './message-routes.js';
 import { appObservers, bindObservers } from './observer-runner.js';
 import { isAppClassToken } from './lifecycle-order.js';
-import { reachableClasses, providerMap, bindsOwnToken, tokenName, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies, resolveProviders } from './providers.js';
+import { reachableClasses, providerMap, assertProvidedServices, bindsOwnToken, tokenName, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies, resolveProviders } from './providers.js';
 import { HandlerRegistry } from './handler-registry.js';
 import { ShardManager } from './shard-manager.js';
 import { warnUnregisteredCommands, warnInheritedRoutes, warnOverlappingPatterns, warnHandlersOffControllers, assertDistinctCommands } from './command-conflicts.js';
@@ -176,7 +176,9 @@ import { isShardProcess } from '../util/shard-process.util.js';
         const providers = collectStartupErrors(()=>{
             declared.forEach(startupError);
             assertDistinctCommands(options.controllers);
-            return providerMap(options.providers ?? [], '@MeoCord({ providers })');
+            const providers = providerMap(options.providers ?? [], '@MeoCord({ providers })');
+            assertProvidedServices(typeof target === 'function' ? target.name : String(target), options.services ?? [], providers, '@MeoCord({ providers })');
+            return providers;
         });
         // A themeFor class is bound on its own, as the cooldown store is, and resolved like a service
         const themeResolver = themeResolverClass(options.themeFor);

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

@@ -249,22 +249,48 @@ const sortedEntries = (entries)=>entries.sort((a, b)=>a.usage < b.usage ? -1 : a
         scope
     ].filter((line)=>line !== undefined).join('\n');
 }
-/** Splits a reply into Discord-sized messages at line breaks, a line longer than one message cut where it must be. */ function splitReply(text) {
+// Built on first use, for a line longer than a message
+let graphemes;
+/**
+ * Where a line longer than one message is cut: after the last character a reader sees as one, such as an emoji, a flag
+ * or a letter with its accent, that still fits. A single such character longer than a message is cut between code points.
+ */ function fittingCut(piece) {
+    let cut = 0;
+    graphemes ?? (graphemes = new Intl.Segmenter(undefined, {
+        granularity: 'grapheme'
+    }));
+    for (const { index, segment } of graphemes.segment(piece)){
+        if (index + segment.length > MAX_REPLY_LENGTH) break;
+        cut = index + segment.length;
+    }
+    if (cut > 0) return cut;
+    const high = piece.charCodeAt(MAX_REPLY_LENGTH - 1);
+    return high >= 0xd800 && high <= 0xdbff ? MAX_REPLY_LENGTH - 1 : MAX_REPLY_LENGTH;
+}
+/**
+ * Splits a reply into Discord-sized messages at line breaks, a line longer than one message cut where it must be. A
+ * message of only whitespace, which Discord refuses as empty, is left out.
+ */ function splitReply(text) {
     const chunks = [];
+    const push = (chunk)=>{
+        if (chunk.trim() !== '') chunks.push(chunk);
+    };
     let current = '';
     for (const line of text.split('\n')){
-        for(let piece = line;; piece = piece.slice(MAX_REPLY_LENGTH)){
-            const part = piece.slice(0, MAX_REPLY_LENGTH);
+        for(let piece = line;;){
+            const cut = piece.length <= MAX_REPLY_LENGTH ? piece.length : fittingCut(piece);
+            const part = piece.slice(0, cut);
             const joined = current ? `${current}\n${part}` : part;
             if (joined.length <= MAX_REPLY_LENGTH) current = joined;
             else {
-                chunks.push(current);
+                push(current);
                 current = part;
             }
-            if (piece.length <= MAX_REPLY_LENGTH) break;
+            if (cut === piece.length) break;
+            piece = piece.slice(cut);
         }
     }
-    if (current) chunks.push(current);
+    push(current);
     return chunks;
 }
 

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

@@ -5,6 +5,7 @@ import { bindShared } from './interceptor-runner.js';
 import { appliesTo } from './stage-scope.js';
 import { respond } from '../common/response/response-state.js';
 import { startupError } from '../util/refusal.util.js';
+import { isConstructor } from '../util/value.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');
@@ -12,7 +13,7 @@ const logger = new Logger('Observer');
 /** 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);
+            const name = isConstructor(observer) ? observer.name || 'an anonymous class' : typeof observer === 'function' ? 'a function' : String(observer);
             startupError(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
             continue;
         }

package/dist/esm/core/providers.js

@@ -4,6 +4,7 @@ import { meocordClasses, meocordClassAdvice } from './meocord-classes.js';
 import { isAppClassToken } from './lifecycle-order.js';
 import { makeInjectable } from '../util/injectable.util.js';
 import { startupError, refuse } from '../util/refusal.util.js';
+import { isConstructor } from '../util/value.util.js';
 
 const isValueProvider = (provider)=>'useValue' in provider;
 const isClassProvider = (provider)=>'useClass' in provider;
@@ -43,7 +44,7 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
             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') {
+        if ('useClass' in entry && !isConstructor(entry.useClass)) {
             startupError(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
             continue;
         }
@@ -120,6 +121,15 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     });
     for (const dependency of inject)if (isAppClassToken(dependency)) bindClass(dependency);
 }
+/**
+ * Reports each service listed by a string or symbol token that no provider provides, which would otherwise be bound
+ * as if it were a class.
+ */ function assertProvidedServices(appName, services, providers, where) {
+    for (const service of services){
+        if (typeof service === 'function' || providers.has(service)) continue;
+        startupError(new Error(`${appName}: @MeoCord({ services }) lists ${tokenName(service)}, which nothing provides: add a provider for it to ${where}.`));
+    }
+}
 /**
  * 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.
@@ -271,4 +281,4 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     }
 }
 
-export { assertProvided, assertTypedParameters, bindProvider, bindsOwnToken, isClassProvider, isFactoryProvider, isValueProvider, providerFailure, providerMap, reachableClasses, resolutionOrder, resolveProviders, tokenDependencies, tokenName };
+export { assertProvided, assertProvidedServices, assertTypedParameters, bindProvider, bindsOwnToken, isClassProvider, isFactoryProvider, isValueProvider, providerFailure, providerMap, reachableClasses, resolutionOrder, resolveProviders, tokenDependencies, tokenName };

package/dist/esm/core/stage-scope.js

@@ -46,7 +46,8 @@ import { META } from '../util/metadata-keys.js';
     }
 }
 /** The class of a stage entry. */ function stageClass(entry) {
-    return isConstructor(entry) ? entry : entry.provide;
+    // Entries were checked as they were declared, so a function is the class itself
+    return typeof entry === 'function' ? entry : entry.provide;
 }
 /** The context types a stage declared, or `undefined` when it runs for every type. */ function stageTypes(entry) {
     return Reflect.getMetadata(META.stageTypes, stageClass(entry));

package/dist/esm/core/theme-scope.js

@@ -172,6 +172,9 @@ let themeOutsideCalls;
  * Such a listener runs in its emitter's context, so without it a `useTheme()` inside reads the theme outside any call.
  * Timers and promises the handler starts keep its theme without it.
  *
+ * The theme is the binding call's whole theme, its server's and user's themes included, so every later call, whoever
+ * it is for, is answered in the starting member's theme.
+ *
  * @param fn - The function to run in the call's theme; `this` and its arguments are passed through.
  * @returns A function that runs `fn` in the theme `useTheme()` returns where `bindTheme` is called.
  *
@@ -181,7 +184,7 @@ let themeOutsideCalls;
  * async poll(message: Message) {
  *   const collector = message.createMessageComponentCollector({ componentType: ComponentType.Button, time: 60_000 })
  *   collector.on('collect', bindTheme(async (click: ButtonInteraction) => {
- *     const { emojis } = useTheme() // the handler's theme, @UseTheme included
+ *     const { emojis } = useTheme() // the starting member's theme, @UseTheme included
  *     await click.reply(`${emojis.success} Picked`)
  *   }))
  * }

package/dist/esm/decorator/app.decorator.js

@@ -9,6 +9,7 @@ import { assertValidTheme, themeForProblem } from '../core/theme-validation.js';
 import { copyLayer } from '../core/theme-scope.js';
 import { declaring, deprecatedOnMethod, refuse } from '../util/refusal.util.js';
 import { timeoutProblem } from '../util/timer-limit.util.js';
+import { isConstructor, describeValue } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /** Refuses a `messages` option of the wrong type where the app is declared, rather than at the first message. */ function assertMessageOptions(appName, messages, i18n) {
@@ -52,6 +53,35 @@ import { META } from '../util/metadata-keys.js';
         if (type.labelKey !== undefined) assertLabelKey(appName, name, type.labelKey, i18n);
     }
 }
+/**
+ * Refuses an option that takes a class given anything else, such as an object or an arrow function, where the app is
+ * declared: the startup checks read each class's prototype, and would otherwise fail on it without naming the option.
+ */ function assertClassOptions(appName, { presenter, cooldownStore, controllers, services }) {
+    for (const [name, value, implementing] of [
+        [
+            'presenter',
+            presenter,
+            'ResponsePresenter'
+        ],
+        [
+            'cooldownStore',
+            cooldownStore,
+            'CooldownStore'
+        ]
+    ]){
+        if (value !== undefined && !isConstructor(value)) {
+            throw refuse(new TypeError(`${appName}: @MeoCord({ ${name} }) takes a class implementing ${implementing}, not ${describeValue(value)}.`));
+        }
+    }
+    for (const controller of controllers ?? []){
+        if (!isConstructor(controller)) throw refuse(new TypeError(`${appName}: @MeoCord({ controllers }) takes classes, not ${describeValue(controller)}.`));
+    }
+    // A string or symbol is a token, which a provider has to provide; that is checked as the app is created
+    for (const service of services ?? []){
+        if (isConstructor(service) || typeof service === 'string' || typeof service === 'symbol') continue;
+        throw refuse(new TypeError(`${appName}: @MeoCord({ services }) takes classes, or tokens that providers provide, not ${describeValue(service)}.`));
+    }
+}
 /** Refuses a type's `labelKey` that no message of the app's default catalog has, as it would be shown as the key. */ function assertLabelKey(appName, name, labelKey, i18n) {
     const where = `${appName}: @MeoCord({ messages: { types } }): "${name}" has labelKey`;
     if (typeof labelKey !== 'string') throw refuse(new TypeError(`${where} ${String(labelKey)}; it takes a message key, such as 'types.${name}'.`));
@@ -96,6 +126,7 @@ import { META } from '../util/metadata-keys.js';
  */ function MeoCord(options) {
     return declaring((target, propertyKey)=>{
         if (deprecatedOnMethod('@MeoCord', target, propertyKey)) return;
+        assertClassOptions(target.name, options);
         assertStageEntries('@MeoCord({ guards })', 'guard', target.name, options.guards ?? []);
         assertStageEntries('@MeoCord({ interceptors })', 'interceptor', target.name, options.interceptors ?? []);
         assertStageEntries('@MeoCord({ filters })', 'filter', target.name, options.filters ?? []);

package/dist/esm/decorator/filter.decorator.js

@@ -3,7 +3,7 @@ import { makeInjectable } from '../util/injectable.util.js';
 import { assertStageEntries } from '../core/stage-scope.js';
 import { Logger } from '../common/logger.js';
 import { warnDeprecatedBehaviour } from '../common/deprecation.js';
-import { isConstructor, describeValue } from '../util/value.util.js';
+import { isConstructible, describeValue } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 import { declaring, refuseOnMethod } from '../util/refusal.util.js';
 
@@ -40,7 +40,7 @@ import { declaring, refuseOnMethod } from '../util/refusal.util.js';
         refuseOnMethod('@Catch', target, propertyKey);
         makeInjectable(target);
         errorTypes.forEach((type, index)=>{
-            if (isConstructor(type)) return;
+            if (isConstructible(type)) return;
             const entry = ORDINALS[index] ? `${ORDINALS[index]} entry` : `entry ${index + 1}`;
             warnDeprecatedBehaviour(logger, `${target.name}: @Catch's ${entry}, ${describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
         });

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.2.1";
+var version = "4.2.2";
 var engines = {
 	node: ">=22.13"
 };

package/dist/esm/testing/catalog.js

@@ -1,15 +1,6 @@
-import { CATALOGS, placeholderNames } from '../common/translator.js';
+import { isPluralShape, CATALOGS, placeholderNames } from '../common/translator.js';
 import { MEOCORD_MESSAGES } from '../common/meocord-messages.js';
 
-const PLURAL_CATEGORIES = new Set([
-    'zero',
-    'one',
-    'two',
-    'few',
-    'many',
-    'other'
-]);
-/** A plural: an object whose every key is a plural category, as the translator's types read one; any other is a group. */ const isPlural = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
 /** Every message key of a catalog, and whether it is a plural. */ function leaves(catalog, prefix = '') {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
@@ -19,7 +10,7 @@ const PLURAL_CATEGORIES = new Set([
                 plural: false
             }
         ];
-        if (isPlural(value)) return [
+        if (isPluralShape(value)) return [
             {
                 key,
                 plural: true
@@ -43,7 +34,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
 /** A message as a report shows it: the text, or a plural's `other` form. */ const shown = (message)=>typeof message === 'string' ? message : String(message.other);
 /** The `{params}` a translation uses that the message it translates doesn't take; a plural's `{count}` is taken. */ function strayParams(translation, original) {
     const taken = placeholders(original);
-    if (isPlural(original)) taken.add('count');
+    if (isPluralShape(original)) taken.add('count');
     return [
         ...placeholders(translation)
     ].filter((name)=>!taken.has(name));
@@ -109,7 +100,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
                 continue;
             }
             // A translation of another shape than the default's can't be read as it: a text for a plural, or the reverse
-            if (plural !== isPlural(message) || !plural && typeof message !== 'string') {
+            if (plural !== isPluralShape(message) || !plural && typeof message !== 'string') {
                 problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
                 continue;
             }

package/dist/esm/testing/discord-defaults.js

@@ -1,4 +1,4 @@
-import { GuildChannel, MessageReaction, MessageMentions, Message, GuildMember, BaseGuild, Guild, ModalSubmitInteraction, TextChannel, ThreadChannel, BaseGuildVoiceChannel, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, PresenceManager, ClientUser, UserFlagsBitField, User, GuildMemberFlagsBitField, Role, Collection, MessageType, ReactionManager, ChatInputCommandInteraction, CommandInteraction, AutocompleteInteraction, ReactionUserManager, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, PermissionsBitField, PermissionFlagsBits } from 'discord.js';
+import { GuildChannel, MessageReaction, MessageMentions, Message, GuildMember, BaseGuild, Guild, ModalSubmitInteraction, TextChannel, ThreadChannel, BaseGuildVoiceChannel, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, PresenceManager, ClientUser, UserFlagsBitField, User, GuildMemberFlagsBitField, GuildEmoji, Sticker, GuildScheduledEvent, AutoModerationRule, Invite, Role, Collection, MessageType, ReactionManager, ChatInputCommandInteraction, CommandInteraction, AutocompleteInteraction, ReactionUserManager, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, PermissionsBitField, PermissionFlagsBits } from 'discord.js';
 import { createMockChannel, createMockGuild, createMockMessage, ownedManager, memberRoles, createMockUser, createChatInputOptions, readPlaceAs, botMemberOf, heldChannelOf, isRawMember, isUnsetEveryone, NEW_SERVER_EVERYONE_PERMISSIONS } from './mock-interaction.js';
 import { nextSnowflake } from './snowflake.js';
 import { strictMocks } from './strict-mocks.js';
@@ -129,6 +129,26 @@ const channelPermissions = GuildChannel.prototype;
         roles: (member)=>memberRoles(member, []),
         permissions: REAL_GETTER
     }),
+    // A server's emoji, sticker, scheduled event and AutoMod rule are named, and what discord.js formats from them
+    // computes: an emoji's mention and identifier, an event's and an invite's link
+    defaultsOf(GuildEmoji, {
+        name: ()=>'emoji',
+        animated: ()=>false,
+        identifier: REAL_GETTER
+    }),
+    defaultsOf(Sticker, {
+        name: ()=>'sticker'
+    }),
+    defaultsOf(GuildScheduledEvent, {
+        name: ()=>'event',
+        url: REAL_GETTER
+    }),
+    defaultsOf(AutoModerationRule, {
+        name: ()=>'rule'
+    }),
+    defaultsOf(Invite, {
+        url: REAL_GETTER
+    }),
     defaultsOf(Role, {
         name: ()=>'role',
         // Above @everyone, which a server's role manager makes at position 0

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

@@ -34,9 +34,10 @@ import { Dispatcher } from '../core/dispatcher.js';
 import { createFallback } from '../core/fallback.js';
 import { Logger } from '../common/logger.js';
 import { isExplainedError, markExplained } from '../common/explained-error.js';
-import { declaredErrorsOf, collectStartupErrors, startupError, stopOnStartupErrors, isRefusal, logStartupErrors } from '../util/refusal.util.js';
+import { collectStartupErrors, declaredErrorsOf, startupError, stopOnStartupErrors, isRefusal, logStartupErrors } from '../util/refusal.util.js';
 import { DEFAULT_SHUTDOWN_TIMEOUT_MS, shutdownTimeoutProblem } from '../util/shutdown-timeout.util.js';
-import { resolveProviders, tokenName, bindsOwnToken, providerMap, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies } from '../core/providers.js';
+import { isConstructor, describeValue } from '../util/value.util.js';
+import { resolveProviders, tokenName, bindsOwnToken, providerMap, assertProvidedServices, bindProvider, resolutionOrder, isClassProvider, assertProvided, tokenDependencies } from '../core/providers.js';
 import { getEventHandlers } from '../decorator/event.decorator.js';
 import { getReactionHandlers } from '../decorator/controller.decorator.js';
 import { strictMocks } from './strict-mocks.js';
@@ -803,7 +804,17 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 }
                 // Each pass of checks ends before the next step that is no check, so a module with one error stops where it always did
                 stopOnStartupErrors();
+                // What the walk below takes as classes, reported with what the walk finds; an entry refused here is left out of it
                 const services = this.wiring?.services ?? [];
+                if (this.options.app) assertProvidedServices(this.options.app.name, services, providers, "@MeoCord({ providers }) or the testing module's providers");
+                for (const controller of this.options.controllers ?? []){
+                    if (!isConstructor(controller)) startupError(new Error(`the testing module's controllers takes classes, not ${describeValue(controller)}.`));
+                }
+                const observers = [
+                    ...this.options.app ? appObservers(this.options.app) : [],
+                    ...this.options.observers ?? []
+                ];
+                assertObservers("the testing module's observers", observers);
                 const appOptions = this.options.app ? Reflect.getMetadata(META.appOptions, this.options.app) : undefined;
                 // The app's own store, as the bot binds it, whether the module is given the app or built from it; none when the
                 // test provides the CooldownStore, so nothing builds the app's or asks for what it injects
@@ -814,17 +825,14 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 const i18n = this.options.app && Reflect.getMetadata(META.appOptions, this.options.app)?.i18n;
                 const appPresenterClass = this.options.app && Reflect.getMetadata(META.appOptions, this.options.app)?.presenter;
                 const startup = startupClasses({
-                    controllers: this.options.controllers ?? [],
+                    controllers: (this.options.controllers ?? []).filter(isConstructor),
                     services,
                     providers,
                     stages,
                     presenter: appPresenterClass,
                     cooldownStore: store,
                     themeFor: stages?.themeFor?.resolvers,
-                    observers: [
-                        ...this.options.app ? appObservers(this.options.app) : [],
-                        ...this.options.observers ?? []
-                    ],
+                    observers,
                     stubs: [
                         ...this.guardOverrides.keys(),
                         ...this.interceptorOverrides.keys(),
@@ -914,13 +922,6 @@ import { isUserOutcome } from '../common/user-outcome.js';
                 // As the app does when it is created, so a test sees the refusal the bot would give
                 assertDistinctCommands(this.options.controllers ?? []);
                 if (this.options.app) prepareAppPresenter(container, this.options.app);
-                const observers = [
-                    ...this.options.app ? appObservers(this.options.app) : [],
-                    ...this.options.observers ?? []
-                ];
-                assertObservers("the testing module's observers", observers);
-                // Only @Observer classes are bound as observers
-                stopOnStartupErrors();
                 bindObservers(container, observers);
                 // The store calls ask: the test's own when it provides CooldownStore, else the app's
                 const boundStore = store ?? (providers.has(CooldownStore) ? CooldownStore : undefined);
@@ -1060,7 +1061,8 @@ import { isUserOutcome } from '../common/user-outcome.js';
    * @param app - The class `@MeoCord` decorates.
    * @param options - Providers that replace the app's by token, extra controllers, and observers.
    * @returns The builder, whose `override*` methods still apply, for `compile()`.
-   * @throws TypeError when `app` is not a `@MeoCord` class.
+   * @throws TypeError when `app` is not a `@MeoCord` class. After {@link reportAllStartupErrors}, an app whose
+   *   `@MeoCord` was refused throws the error it was refused for instead.
    *
    * @example
    * ```ts
@@ -1101,7 +1103,13 @@ import { isUserOutcome } from '../common/user-outcome.js';
    * ```
    */ static fromApp(app, options = {}) {
         const appOptions = Reflect.getMetadata(META.appOptions, app);
-        if (!appOptions) throw new TypeError(`${app?.name ?? String(app)} is not a @MeoCord app: fromApp takes the class @MeoCord decorates.`);
+        if (!appOptions) {
+            // A refused @MeoCord stores no options, so its own errors, kept with startupErrors: 'all', say why
+            collectStartupErrors(()=>declaredErrorsOf([
+                    app
+                ]).forEach(startupError));
+            throw new TypeError(`${app?.name ?? String(app)} is not a @MeoCord app: fromApp takes the class @MeoCord decorates.`);
+        }
         const controllers = [
             ...new Set([
                 ...appOptions.controllers,