meocord 4.2.1 → 4.2.2

package/dist/cjs/testing/index.cjs

@@ -2,11 +2,11 @@
 
 require('reflect-metadata');
 var inversify = require('inversify');
-var providers = require('../_shared/providers-BZgJyfZS.cjs');
+var providers = require('../_shared/providers-B4MOFBrW.cjs');
 var discord_js = require('discord.js');
 var enum_index = require('../enum/index.cjs');
-var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
-var startupRoots = require('../_shared/startup-roots-CgfPQrNl.cjs');
+var controller_decorator = require('../_shared/controller.decorator-U2NBWcoU.cjs');
+var startupRoots = require('../_shared/startup-roots-lA5xkBFq.cjs');
 var node_crypto = require('node:crypto');
 require('node:async_hooks');
 require('crypto');
@@ -21,7 +21,7 @@ require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-BUAR1WYG.cjs');
+require('../_shared/translate-error-CbBHUu5P.cjs');
 
 // Framework-agnostic mock function, so `meocord/testing` depends on neither jest nor vitest.
 // Both detect it through `_isMockFunction` and read `fn.mock.calls` in their assertions.
@@ -517,8 +517,9 @@ const settings = controller_decorator.shared('strictMocks', ()=>({
  * and `message.thread` is `null` when the channel caches no thread under the message's id. So do a message's
  * `editedAt`, a member's `presence`, a server's `verified` and `systemChannel` and a channel's `parent`, each `null` or
  * `false` until the test gives what it is computed from. A reaction's `me` is `false`, a message's
- * `mentions.repliedUser` and a modal's `message` are `null`, and a reaction has a whole message of its own, so
- * MeoCord's dispatcher fetches neither. No placeholder warning is logged.
+ * `mentions.repliedUser` and a modal's `message` are `null`, an interaction's `ephemeral` is `null` until `reply()` or
+ * `deferReply()` decides it, and a reaction has a whole message of its own, so MeoCord's dispatcher fetches neither. No
+ * placeholder warning is logged.
  *
  * @remarks
  * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in the
@@ -531,8 +532,10 @@ const settings = controller_decorator.shared('strictMocks', ()=>({
  * A message the bot sends is its `client.user`'s, and one it sends in a DM is in that DM. Give the bot's member a role
  * to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the computed
  * one. An interaction's answer that discord.js would refuse, such as a second `reply()` after one a test set with
- * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. The next major version (5.0)
- * computes these values, and refuses those answers, without the call.
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. An answer marks the interaction
+ * `replied`, `deferred` or `responded` once it resolves, as discord.js does, so code that doesn't await one fails as it
+ * would on a bot, within one run of the test's code. The next major version (5.0) computes these values, and refuses
+ * those answers, without the call.
  *
  * `invoke` also refuses a call that gives a handler fewer arguments than it declares where it builds none, such as a
  * reaction handler given its reaction without its `ReactionEvent`; without strict mocks, it warns once and calls it.
@@ -684,6 +687,26 @@ const channelPermissions = discord_js.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(discord_js.GuildEmoji, {
+        name: ()=>'emoji',
+        animated: ()=>false,
+        identifier: REAL_GETTER
+    }),
+    defaultsOf(discord_js.Sticker, {
+        name: ()=>'sticker'
+    }),
+    defaultsOf(discord_js.GuildScheduledEvent, {
+        name: ()=>'event',
+        url: REAL_GETTER
+    }),
+    defaultsOf(discord_js.AutoModerationRule, {
+        name: ()=>'rule'
+    }),
+    defaultsOf(discord_js.Invite, {
+        url: REAL_GETTER
+    }),
     defaultsOf(discord_js.Role, {
         name: ()=>'role',
         // Above @everyone, which a server's role manager makes at position 0
@@ -1584,8 +1607,49 @@ const MANAGER_ITEMS = [
                     guild: guildOf(manager)
                 } : {}
             })
+    ],
+    [
+        discord_js.GuildEmojiManager,
+        (id, manager)=>itemInGuild(discord_js.GuildEmoji, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        discord_js.GuildStickerManager,
+        (id, manager)=>itemInGuild(discord_js.Sticker, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        discord_js.GuildScheduledEventManager,
+        (id, manager)=>itemInGuild(discord_js.GuildScheduledEvent, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        discord_js.AutoModerationRuleManager,
+        (id, manager)=>itemInGuild(discord_js.AutoModerationRule, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    // An invite is keyed by its code, as discord.js caches and fetches one
+    [
+        discord_js.GuildInviteManager,
+        (code, manager)=>itemInGuild(discord_js.Invite, {
+                code: code ?? BigInt(nextSnowflake()).toString(36)
+            }, manager)
     ]
 ];
+/** A mock of `Class` with `props`, in the manager's guild, by the guild and its id, when the manager has one. */ function itemInGuild(Class, props, manager) {
+    const guild = guildOf(manager);
+    return createMockInteraction(Class, {
+        ...props,
+        ...guild ? {
+            guild,
+            guildId: guild.id
+        } : {}
+    });
+}
 const returnsPromise = (key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || /^set[A-Z]/.test(key) && !SYNC_SETTERS.has(key);
 // The ids a fetch asks for: an id, a discord.js object, or options naming one or several, such as `{ user: id }` or
 // `{ user: [ids] }`; undefined for a fetch of a list
@@ -1659,6 +1723,18 @@ function fetchedIds(args) {
                 return typeof user === 'string' ? user : user?.id;
             });
         }
+        // An invite is made for the channel given, in its guild, and cached nowhere, as discord.js's create does
+        if (item && key === 'create' && target instanceof discord_js.GuildInviteManager) {
+            return createMockFn(async (channel)=>{
+                const invite = item(undefined, receiver());
+                const channelId = typeof channel === 'string' ? channel : channel?.id;
+                const found = channel instanceof discord_js.BaseChannel ? channel : channelId ? cacheOf(guildOf(receiver())?.channels)?.get(channelId) ?? null : null;
+                return Object.assign(invite, {
+                    channel: found,
+                    channelId: channelId ?? null
+                });
+            });
+        }
         // Every other manager here caches what its create() makes, as discord.js's does; check a manager's create when
         // adding it to MANAGER_ITEMS
         if (item && key === 'create') {
@@ -1875,24 +1951,36 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
             };
             controller_decorator.stampCall(call);
             log.push(call);
-            let undo;
+            let gated;
             try {
-                // Before the behaviour, as discord.js changes the state at once: a second answer made without awaiting is refused
-                if (gate) undo = gate(args, byTest);
+                // Before the behaviour, as discord.js checks the state before it sends an answer
+                if (gate) gated = gate(args, byTest);
             } catch (error) {
                 call.error = error;
                 return Promise.reject(error);
             }
             const failed = (error)=>{
-                undo?.();
+                gated?.settle?.();
+                gated?.undo?.();
                 call.error = error;
                 throw error;
             };
+            // Once the behaviour resolves, as discord.js changes the state once Discord has taken the answer
+            const landed = (value)=>{
+                gated?.settle?.();
+                try {
+                    gated?.land?.();
+                } catch (error) {
+                    call.error = error;
+                    throw error;
+                }
+                return value;
+            };
             try {
                 const result = Reflect.apply(behaviour, this, args);
                 // Recorded and passed on, so a rejection nobody awaits is unhandled in the test, as it is on a bot
-                if (result instanceof Promise) return result.then(undefined, failed);
-                return result;
+                if (result instanceof Promise) return result.then(landed, failed);
+                return landed(result);
             } catch (error) {
                 return failed(error);
             }
@@ -2006,7 +2094,31 @@ function createMockInteraction(Class, props) {
     if (repliable) {
         instance.replied = false;
         instance.deferred = false;
-        instance.ephemeral = false;
+        // Null until reply() or deferReply() decides it, as discord.js has it; default mode reads false until then, and a
+        // test reading it there is told once. A value the test sets is read as set
+        const strict = strictMocks();
+        let ephemeral = strict ? null : false;
+        let ephemeralDecided = false;
+        // Whether one of the mock's own first answers ran; flags a test sets without one leave ephemeral as discord.js would
+        let answeredByMock = false;
+        const answeredOutside = ()=>Boolean(instance.replied || instance.deferred) && !answeredByMock;
+        const decideEphemeral = (value, decided)=>{
+            ephemeral = value;
+            ephemeralDecided = decided;
+        };
+        Object.defineProperty(instance, 'ephemeral', {
+            get: ()=>{
+                // Quiet once a test answered the interaction itself: MeoCord then reads ephemeral only for truthiness, where false
+                // and null act alike
+                if (!ephemeralDecided && !strict && !answeredOutside()) {
+                    controller_decorator.warnPlaceholder(mockLogger, `${Object.getPrototypeOf(instance).constructor.name}.ephemeral`, 'it is null until reply() or deferReply() decides it, as discord.js has it', 'Reply or defer first, or call useStrictMocks() to read null now.');
+                }
+                return ephemeral;
+            },
+            set: (value)=>decideEphemeral(value, true),
+            enumerable: true,
+            configurable: true
+        });
         // discord.js's errors, with their codes; a call before any answer keeps the message the mock has always given
         const alreadyReplied = ()=>discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
         const notYetReplied = (method)=>discordjsError(discord_js.DiscordjsErrorCodes.InteractionNotReplied, `Cannot call ${method}() before replying or deferring.`);
@@ -2032,7 +2144,9 @@ function createMockInteraction(Class, props) {
             const saved = {
                 replied: instance.replied,
                 deferred: instance.deferred,
-                ephemeral: instance.ephemeral,
+                ephemeral,
+                ephemeralDecided,
+                answeredByMock,
                 original,
                 originalGone,
                 followUps: new Map(followUps),
@@ -2042,10 +2156,10 @@ function createMockInteraction(Class, props) {
             return ()=>{
                 Object.assign(instance, {
                     replied: saved.replied,
-                    deferred: saved.deferred,
-                    ephemeral: saved.ephemeral
+                    deferred: saved.deferred
                 });
-                ({ original, originalGone, answeredByTest, modalAnswered } = saved);
+                decideEphemeral(saved.ephemeral, saved.ephemeralDecided);
+                ({ original, originalGone, answeredByTest, answeredByMock, modalAnswered } = saved);
                 followUps.clear();
                 for (const [id, held] of saved.followUps)followUps.set(id, held);
             };
@@ -2070,24 +2184,76 @@ function createMockInteraction(Class, props) {
                 return build;
             }
         };
-        /** A first answer: refused once the interaction has one, else it replies or defers. */ const first = (method, kind, then)=>(args, byTest)=>{
-                if (answered()) refuse(method, alreadyReplied(), byTest);
-                // Read first: flags discord.js refuses throw before anything changes
-                const ephemeral = method === 'reply' || method === 'deferReply' ? hasEphemeralFlag(args[0]) : undefined;
+        // The changes answers make to the reply state, in order. One whose answer fails is undone once every change after
+        // it is undone too, so a later answer's change stands while it does, as on a bot
+        const changes = [];
+        const undoneInTurn = (undo)=>{
+            const change = {
+                undo,
+                failed: false
+            };
+            changes.push(change);
+            return ()=>{
+                change.failed = true;
+                while(changes.at(-1)?.failed)changes.pop().undo();
+            };
+        };
+        // The first answers called and not yet settled, oldest first, for default mode to warn where a bot would differ
+        const unsettled = [];
+        // Default mode warns once per interaction where code that doesn't await an answer would fail on a bot
+        let inFlightWarned = false;
+        const warnInFlight = (text)=>{
+            if (inFlightWarned) return;
+            inFlightWarned = true;
+            mockLogger.warn(text);
+        };
+        /**
+     * A first answer: refused once the interaction has one, else it replies or defers. Under strict mocks the change
+     * waits for the answer to land, as discord.js makes it once the request resolves, so one sent while another is in
+     * flight passes discord.js's check and Discord refuses it with 40060 if the other landed first. Default mode makes
+     * the change at once.
+     */ const first = (method, kind, then)=>(args, byTest)=>{
+                if (answered()) {
+                    if (unsettled.length > 0) {
+                        warnInFlight(`${method}() was called while ${unsettled[0]}() had not resolved; on a bot discord.js sends it, and Discord ` + `refuses it with 40060 ("Interaction has already been acknowledged") once the first lands. Await ` + `${unsettled[0]}() before answering again, or call useStrictMocks() to have the mock answer as Discord does.`);
+                    }
+                    refuse(method, alreadyReplied(), byTest);
+                }
+                // Read first: flags discord.js refuses throw before anything changes; reply() and deferReply() decide
+                // ephemeral, as discord.js's do, and update() and deferUpdate() leave it
+                const flagged = method === 'reply' || method === 'deferReply' ? hasEphemeralFlag(args[0]) : undefined;
                 const undo = snapshot();
                 instance[kind] = true;
-                if (ephemeral) instance.ephemeral = true;
+                if (flagged !== undefined) decideEphemeral(flagged, true);
                 answeredByTest = byTest;
+                answeredByMock = true;
                 try {
                     then(args);
                 } catch (error) {
                     undo();
                     throw error;
                 }
-                return undo;
+                if (strict) {
+                    const land = snapshot();
+                    undo();
+                    return {
+                        land: ()=>{
+                            if (answered()) throw createDiscordError(40060, 'Interaction has already been acknowledged.');
+                            land();
+                        }
+                    };
+                }
+                unsettled.push(method);
+                return {
+                    undo: undoneInTurn(undo),
+                    settle: ()=>void unsettled.splice(unsettled.indexOf(method), 1)
+                };
             };
         /** A later answer: refused before the interaction has one. */ const later = (method, then)=>(args, byTest)=>{
                 if (!answered()) refuse(method, notYetReplied(method), byTest);
+                if (unsettled.length > 0) {
+                    warnInFlight(`${unsettled[0]}() had not resolved when ${method}() was called; on a bot this throws InteractionNotReplied. ` + `Await ${unsettled[0]}() first, or call useStrictMocks() to have the mock refuse it now.`);
+                }
                 const undo = snapshot();
                 try {
                     then(args);
@@ -2095,7 +2261,9 @@ function createMockInteraction(Class, props) {
                     undo();
                     throw error;
                 }
-                return undo;
+                return {
+                    undo: undoneInTurn(undo)
+                };
             };
         /** The id an edit, fetch or delete names, `undefined` for the original response. */ const targetId = (message)=>{
             if (message === undefined || message === '@original') return undefined;
@@ -2213,12 +2381,31 @@ function createMockInteraction(Class, props) {
     // it before answering would decide the window was already closed.
     if (instance.type === discord_js.InteractionType.ApplicationCommandAutocomplete) {
         instance.responded = false;
+        // Under strict mocks responded is set once respond() lands, as discord.js sets it once the request resolves, and a
+        // second one sent while the first is in flight is refused by Discord with 40060; default mode sets it at once
+        let respondsInFlight = 0;
+        let respondWarned = false;
         stubs.set('respond', createMockFn(async (choices)=>{
-            if (instance.responded) throw discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
+            if (instance.responded) {
+                if (respondsInFlight > 0 && !respondWarned) {
+                    respondWarned = true;
+                    mockLogger.warn('respond() was called while respond() had not resolved; on a bot discord.js sends it, and Discord refuses ' + 'it with 40060 ("Interaction has already been acknowledged") once the first lands. Await respond() ' + 'before responding again, or call useStrictMocks() to have the mock respond as Discord does.');
+                }
+                throw discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
+            }
             // Discord refuses a list longer than its limit, and the menu shows nothing
             if (Array.isArray(choices) && choices.length > MAX_AUTOCOMPLETE_CHOICES) {
                 throw createDiscordError(50035, `Invalid Form Body\ndata.choices[BASE_TYPE_MAX_LENGTH]: Must be ${MAX_AUTOCOMPLETE_CHOICES} or fewer in length.`);
             }
+            respondsInFlight++;
+            if (!strictMocks()) instance.responded = true;
+            try {
+                await undefined;
+            } finally{
+                respondsInFlight--;
+            }
+            if (!strictMocks()) return;
+            if (instance.responded) throw createDiscordError(40060, 'Interaction has already been acknowledged.');
             instance.responded = true;
         }));
     }
@@ -2796,6 +2983,26 @@ const HOLDS = [
     [
         discord_js.PresenceManager.prototype,
         discord_js.Presence
+    ],
+    [
+        discord_js.GuildEmojiManager.prototype,
+        discord_js.GuildEmoji
+    ],
+    [
+        discord_js.GuildStickerManager.prototype,
+        discord_js.Sticker
+    ],
+    [
+        discord_js.GuildScheduledEventManager.prototype,
+        discord_js.GuildScheduledEvent
+    ],
+    [
+        discord_js.AutoModerationRuleManager.prototype,
+        discord_js.AutoModerationRule
+    ],
+    [
+        discord_js.GuildInviteManager.prototype,
+        discord_js.Invite
     ]
 ];
 /**
@@ -2843,7 +3050,8 @@ const HOLDS = [
     return manager;
 }
 /**
- * Creates a mock {@link Guild}, with the `members`, `channels`, `roles` and `bans` managers ready to stub.
+ * Creates a mock {@link Guild}, with its `members`, `channels`, `roles`, `bans`, `emojis`, `stickers`, `scheduledEvents`,
+ * `autoModerationRules` and `invites` managers ready to stub.
  *
  * Use it for the server a message or an interaction came from, with the members, roles and channels a handler looks
  * up in it.
@@ -2853,9 +3061,11 @@ const HOLDS = [
  *
  * @remarks
  * A manager's `fetch(id)` resolves to its cached item with that id, as discord.js looks there first, or to a new one it
- * caches under that id: a member or channel in this guild, a role with that id, or a ban. `members.fetch({ user: ids })`
- * resolves to a collection of each of those members, found or made the same way; `create()` and `edit()` resolve to a
- * mock of its item, and a list fetch to an empty collection. Members, roles and channels given are put in
+ * caches under that id: a member, channel, emoji, sticker, scheduled event or AutoMod rule in this guild, a role with
+ * that id, a ban, or an invite with that code. `members.fetch({ user: ids })` resolves to a collection of each of those
+ * members, found or made the same way; `create()` and `edit()` resolve to a mock of its item, which `create()` caches
+ * as discord.js does, but for an invite, made for the channel given and cached nowhere; a list fetch resolves to an
+ * empty collection. Members, roles and channels given are put in
  * their managers' caches, where dispatch looks first when it resolves a message's typed params; a member
  * {@link createMockMember} made without a server is in this one. Its `roles.everyone` is the role given with the
  * guild's id, or else an @everyone role of its own at position 0 with no permissions, in `roles.cache` as Discord has
@@ -2886,7 +3096,7 @@ const HOLDS = [
     instance.members = managerWith(discord_js.GuildMemberManager.prototype, overrides.members);
     instance.channels = managerWith(discord_js.GuildChannelManager.prototype, overrides.channels);
     instance.roles = guildRoleManager(instance.id, overrides.roles);
-    instance.bans = managerWith(discord_js.GuildBanManager.prototype, undefined);
+    for (const [key, Manager] of GUILD_MANAGERS)instance[key] = managerWith(Manager.prototype, undefined);
     const guild = stubDeep(instance);
     settleGuild(instance, guild);
     // A member made without a server of its own is in this one
@@ -3510,7 +3720,7 @@ let placeReadsSeen;
     guild.members = managerWith(discord_js.GuildMemberManager.prototype, undefined);
     guild.channels = managerWith(discord_js.GuildChannelManager.prototype, undefined);
     guild.roles = guildRoleManager(guild.id, undefined);
-    guild.bans = managerWith(discord_js.GuildBanManager.prototype, undefined);
+    for (const [key, Manager] of GUILD_MANAGERS)guild[key] = managerWith(Manager.prototype, undefined);
     const proxy = stubDeep(guild);
     settleGuild(guild, proxy);
     return proxy;
@@ -3532,12 +3742,39 @@ const botMembers = new WeakMap();
         return guildId ? cacheOf(guild.channels)?.get(channelId) : null;
     });
 }
+// A guild's managers beside members, channels and roles, each empty, of its discord.js class
+const GUILD_MANAGERS = [
+    [
+        'bans',
+        discord_js.GuildBanManager
+    ],
+    [
+        'emojis',
+        discord_js.GuildEmojiManager
+    ],
+    [
+        'stickers',
+        discord_js.GuildStickerManager
+    ],
+    [
+        'scheduledEvents',
+        discord_js.GuildScheduledEventManager
+    ],
+    [
+        'autoModerationRules',
+        discord_js.AutoModerationRuleManager
+    ],
+    [
+        'invites',
+        discord_js.GuildInviteManager
+    ]
+];
 /** Gives a guild's managers the guild, as discord.js's do, so what they fetch or make is in it. */ function homeManagers(instance, guild) {
     for (const key of [
         'members',
         'channels',
         'roles',
-        'bans'
+        ...GUILD_MANAGERS.map(([key])=>key)
     ])instance[key].guild = guild;
 }
 /**
@@ -5041,7 +5278,17 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 }
                 // Each pass of checks ends before the next step that is no check, so a module with one error stops where it always did
                 controller_decorator.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) providers.assertProvidedServices(this.options.app.name, services, providers$1, "@MeoCord({ providers }) or the testing module's providers");
+                for (const controller of this.options.controllers ?? []){
+                    if (!controller_decorator.isConstructor(controller)) controller_decorator.startupError(new Error(`the testing module's controllers takes classes, not ${controller_decorator.describeValue(controller)}.`));
+                }
+                const observers = [
+                    ...this.options.app ? providers.appObservers(this.options.app) : [],
+                    ...this.options.observers ?? []
+                ];
+                providers.assertObservers("the testing module's observers", observers);
                 const appOptions = this.options.app ? Reflect.getMetadata(controller_decorator.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
@@ -5052,17 +5299,14 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 const i18n = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.i18n;
                 const appPresenterClass = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.presenter;
                 const startup = startupRoots.startupClasses({
-                    controllers: this.options.controllers ?? [],
+                    controllers: (this.options.controllers ?? []).filter(controller_decorator.isConstructor),
                     services,
                     providers: providers$1,
                     stages,
                     presenter: appPresenterClass,
                     cooldownStore: store,
                     themeFor: stages?.themeFor?.resolvers,
-                    observers: [
-                        ...this.options.app ? providers.appObservers(this.options.app) : [],
-                        ...this.options.observers ?? []
-                    ],
+                    observers,
                     stubs: [
                         ...this.guardOverrides.keys(),
                         ...this.interceptorOverrides.keys(),
@@ -5152,13 +5396,6 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 // As the app does when it is created, so a test sees the refusal the bot would give
                 startupRoots.assertDistinctCommands(this.options.controllers ?? []);
                 if (this.options.app) providers.prepareAppPresenter(container, this.options.app);
-                const observers = [
-                    ...this.options.app ? providers.appObservers(this.options.app) : [],
-                    ...this.options.observers ?? []
-                ];
-                providers.assertObservers("the testing module's observers", observers);
-                // Only @Observer classes are bound as observers
-                controller_decorator.stopOnStartupErrors();
                 providers.bindObservers(container, observers);
                 // The store calls ask: the test's own when it provides CooldownStore, else the app's
                 const boundStore = store ?? (providers$1.has(controller_decorator.CooldownStore) ? controller_decorator.CooldownStore : undefined);
@@ -5298,7 +5535,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    * @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
@@ -5339,7 +5577,13 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    * ```
    */ static fromApp(app, options = {}) {
         const appOptions = Reflect.getMetadata(controller_decorator.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
+            controller_decorator.collectStartupErrors(()=>controller_decorator.declaredErrorsOf([
+                    app
+                ]).forEach(controller_decorator.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,
@@ -5587,15 +5831,6 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
     return new Fields(components);
 }
 
-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}`;
@@ -5605,7 +5840,7 @@ const PLURAL_CATEGORIES = new Set([
                 plural: false
             }
         ];
-        if (isPlural(value)) return [
+        if (controller_decorator.isPluralShape(value)) return [
             {
                 key,
                 plural: true
@@ -5629,7 +5864,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 (controller_decorator.isPluralShape(original)) taken.add('count');
     return [
         ...placeholders(translation)
     ].filter((name)=>!taken.has(name));
@@ -5695,7 +5930,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 !== controller_decorator.isPluralShape(message) || !plural && typeof message !== 'string') {
                 problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
                 continue;
             }

package/dist/cli.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "meocordVersion": "4.2.1",
+  "meocordVersion": "4.2.2",
   "name": "meocord",
   "description": "CLI for managing the MeoCord application",
   "usage": "[options] [command]",

package/dist/esm/common/response/response-state.js

@@ -414,15 +414,15 @@ function toJson(value) {
         });
     }
     /**
-   * Undoes `@Defer`'s acknowledgement after a guard denied the call silently: a command's deferred
-   * reply is deleted while nothing was sent into it; a component's invisible acknowledgement needs
-   * nothing. Never throws.
+   * Ends a call a guard denied silently. A component still unanswered is acknowledged invisibly, with or without
+   * `@Defer`, since Discord tells the user an unanswered call failed; so is a command `@Defer`'s 'auto' timer was
+   * waiting on, whose deferred reply is then deleted, as `@Defer`'s is while nothing was sent into it. Never throws.
    */ abandon() {
         const waiting = this.timer !== undefined;
         this.cancelScheduled();
         return this.queued(async ()=>{
-            // Denied before the 'auto' timer: acknowledged here, since Discord tells the user an unanswered call failed
-            if (waiting) await this.acknowledgeUnanswered({
+            // A command's acknowledgement shows "thinking…", so one is made only for the timer that would have made it
+            if (waiting || !answersWithOwnMessage(this.interaction)) await this.acknowledgeUnanswered({
                 ephemeral: true
             });
             this.sync();