meocord 4.2.1 → 4.2.2

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # meocord
 
+## 4.2.2
+
+### Patch Changes
+
+- [#658](https://github.com/meocord/meocord/pull/658) [`e67cd51`](https://github.com/meocord/meocord/commit/e67cd51a6fdef4a21f1db6541e54b2bb421fbeb1) Thanks [@l7aromeo](https://github.com/l7aromeo)! - A button, select menu or message modal whose guard returns `false` is now acknowledged invisibly, with or without `@Defer`, so the user no longer sees "This interaction failed". The call still reports `ran: false`, and observers still see the outcome `'denied'`. A command, and a modal opened by a command, are left as they were: their only acknowledgement is a reply of their own.
+
+  A test that expects `getResponse(interaction).calls` to be `[]` after a denied click now sees `['deferUpdate']`, as a test of a handler with `@Defer` already did.
+
+  A guard that answers the click itself before returning `false` should await that answer. A reply still on its way when the guard returns races the acknowledgement, and Discord refuses whichever comes second, possibly the reply.
+
+  An app with both a route and a collector for one customId, where the guard returns `false` so the collector answers the click, should leave the click to one of them. Otherwise the two acknowledgements race, and the collector's can fail with "already acknowledged".
+
+- [#653](https://github.com/meocord/meocord/pull/653) [`fcd7cbf`](https://github.com/meocord/meocord/commit/fcd7cbf703618541ff3f42497254cfa33b729939) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `warnUnanswered` now names an `@Autocomplete` handler that returns without calling `interaction.respond()`, as it names any other handler that leaves its interaction unanswered. The user sees the autocomplete options fail to load in that case. The warning is shown once per handler: under `meocord start --dev`, and in tests whose app sets `warnUnanswered: true`. `@MeoCord({ warnUnanswered: false })` turns it off. Nothing about the answer itself changes.
+
+- [#656](https://github.com/meocord/meocord/pull/656) [`b951297`](https://github.com/meocord/meocord/commit/b9512974067160eddb0029a69e52ff228ba36e76) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `bindTheme`'s documentation now says that a bound function runs in the whole theme of the call that bound it, the server's and user's themes included. Every later call, such as another member's click on a collector, is answered in the starting member's theme. Its example comment said "the handler's theme", which left that out. Nothing about the behaviour changes.
+
+- [#652](https://github.com/meocord/meocord/pull/652) [`f8369b6`](https://github.com/meocord/meocord/commit/f8369b6e556ab317331ca70a14a093a0dbc4af2d) Thanks [@l7aromeo](https://github.com/l7aromeo)! - A catalog group whose keys include `other`, such as `reasons: { spam: 'Spam', other: 'Other' }`, is read as a group, as the types and `expectCompleteCatalog` read it. Reading the group's own key, `t('reasons')`, shows the key, and in development logs the warning, as any other group does, where it showed the `other` text. Only untyped code, such as code reading a JSON catalog, can make that call; to show the text, read `t('reasons.other')`. A plural is an object whose every key is a plural category, and a translation's plural without an `other` form still falls back to the next catalog.
+
+- [#659](https://github.com/meocord/meocord/pull/659) [`e9d25a4`](https://github.com/meocord/meocord/commit/e9d25a4bd27bf1e3adaa0506c1b165e8fe6ff20c) Thanks [@l7aromeo](https://github.com/l7aromeo)! - The built-in `help` reply over 2,000 characters is now split into messages Discord shows as written:
+
+  - A line longer than a message is cut after the last whole character that fits. An emoji, a flag, a joined emoji or a letter with its accent is no longer split across two messages.
+  - A message that would be only whitespace isn't sent. Discord refused it as empty, and the rest of the reply was lost with it.
+
+  A help text with no long line and no blank stretch at a cut is split as before.
+
+- [#665](https://github.com/meocord/meocord/pull/665) [`1a224e8`](https://github.com/meocord/meocord/commit/1a224e89d747b1dc0a29858f5bae8969d8657091) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Under `useStrictMocks()`, a mock interaction is marked `replied`, `deferred` or `responded` once its answer resolves, as discord.js marks it after Discord takes the answer, rather than when the answer is called. Code that doesn't await an answer now fails in a test as it would on a bot:
+
+  - an `editReply()`, `followUp()` or `deleteReply()` made before the first answer resolves rejects with `InteractionNotReplied`;
+  - a second answer sent while the first is in flight passes discord.js's check and is refused with Discord's 40060, unless the first one failed;
+  - `replied`, `deferred`, `responded` and `ephemeral` read in the same run as an un-awaited answer are as before it.
+
+  This catches overlaps within one synchronous run of the test's code. A mock answer resolves on the next microtask, so an answer still in flight across an `await`, as a guard's `void interaction.reply()` followed by `return false` is on a bot, isn't caught.
+
+  In both modes, an answer that fails no longer undoes an answer made after it. A test could make the first of two un-awaited replies reject, and the interaction then read as unanswered though the second reply went through; it now reads as answered by the second. A failed answer's change is undone once every change after it is undone too, so an interaction whose answers all fail still reads as unanswered.
+
+  In default mode the flags are still set at the call. The first time an interaction does what a bot would refuse, an edit or a second answer while its first is in flight, a warning says what the bot would do. In the next major version (5.0), every mock interaction marks its answers when they resolve, as strict mocks do now.
+
+- [#663](https://github.com/meocord/meocord/pull/663) [`3894f77`](https://github.com/meocord/meocord/commit/3894f77b099bc2bb82bed37b43944f9e6dc09feb) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Under `useStrictMocks()`, a mock interaction's `ephemeral` is `null` until `reply()` or `deferReply()` decides it, as discord.js has it; `update()` and `deferUpdate()` leave it `null`. In default mode it still reads `false` before an answer, and a test reading it there logs a warning once. MeoCord's own reads while it answers log nothing. The next major version (5.0) reads `null` without the call.
+
+- [#651](https://github.com/meocord/meocord/pull/651) [`8a56464`](https://github.com/meocord/meocord/commit/8a56464a42c47bddc3959bddc0748a710f656ffd) Thanks [@l7aromeo](https://github.com/l7aromeo)! - A mock guild's `emojis`, `stickers`, `scheduledEvents`, `autoModerationRules` and `invites` are managers, in both modes, as on a message's guild. Before, calling `create()`, `fetch()` or `cache.get()` on one threw a `TypeError`.
+
+  - `create()` resolves to a mock emoji, sticker, scheduled event or AutoMod rule in the guild, and caches it, as discord.js does.
+  - `invites.create(channel)` resolves to an invite for that channel in the guild, keyed by its `code`, and caches nothing, as discord.js does.
+  - `fetch(id)` resolves to the cached item, or makes and caches one; a list fetch resolves to an empty collection.
+  - Each item is named, and what discord.js formats from it computes: an emoji's mention (`String(emoji)`) and `identifier`, and a scheduled event's and an invite's `url`.
+
+- [#657](https://github.com/meocord/meocord/pull/657) [`8d1d3fc`](https://github.com/meocord/meocord/commit/8d1d3fc6eb0d4f59139ffc3033b1c416a507f804) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `MockedFunction`'s and `MockInstance`'s documentation says what their types check: calling a mock is checked against the function it mocks, and the values its mock API takes and records, such as `mockResolvedValue`'s and each of `mock.calls`' arguments, are not, for any function. A partial fake such as `guild.members.fetch.mockResolvedValue({ id })` type-checks. Types are unchanged.
+
+- [#654](https://github.com/meocord/meocord/pull/654) [`1cc5a4f`](https://github.com/meocord/meocord/commit/1cc5a4fd2243ff00be9ae3d89b389f11df3b337c) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Wherever MeoCord takes a class and is given something else, it now refuses the value and names where it was given, instead of crashing with an empty `TypeError` or reporting "This is a bug in MeoCord". TypeScript already rejects these values, so the refusal matters for plain JavaScript, `any` and casts.
+
+  - **`@MeoCord`'s `presenter`, `cooldownStore`, `controllers` and `services`** refuse an object or a function that isn't a class where the app is declared, for example `App: @MeoCord({ presenter }) takes a class implementing ResponsePresenter, not an object.`
+  - **A service listed by a string or symbol token** that no provider provides is refused as the app is created, naming the token.
+  - **Stage entries** given to `@UseGuard`, `@UseInterceptor`, `@UseFilter`, `@UsePipe` and `@MeoCord({ guards, interceptors, filters })` refuse an arrow function, a method, an async function or a generator function: "a function is not a class". A `function` declaration still works as a class.
+  - **`@Catch`** warns about an arrow function, as it already does for any other value that isn't a class, and treats it as matching no error. Before this fix, every call whose error reached that filter rejected with a `TypeError` from `instanceof`. A bound error class still matches.
+  - **A testing module** refuses a controller or an observer that isn't a class, and reports the refusal together with the other startup errors. After `reportAllStartupErrors()`, `fromApp()` on an app whose `@MeoCord` was refused throws the reason, not "is not a @MeoCord app".
+
+  A bot that started before starts unchanged.
+
 ## 4.2.1
 
 ### Patch Changes

package/dist/cjs/_shared/{controller.decorator-XKMlcUZz.cjs → controller.decorator-U2NBWcoU.cjs}

@@ -128,7 +128,7 @@ let problem;
     try {
         // Called through a variable so a bundler does not try to resolve the path while building the
         // application; the file is only there once the build is done.
-        const load = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/controller.decorator-XKMlcUZz.cjs', document.baseURI).href)));
+        const load = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/controller.decorator-U2NBWcoU.cjs', document.baseURI).href)));
         const loaded = load(compiledPath);
         return loaded.default ?? loaded;
     } catch (error) {
@@ -403,7 +403,7 @@ const warned = new Set();
     }
 });
 
-var version = "4.2.1";
+var version = "4.2.2";
 var packageJson = {
 	version: version};
 
@@ -595,6 +595,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.
  *
@@ -604,7 +607,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`)
  *   }))
  * }
@@ -1246,16 +1249,26 @@ const logger$5 = new Logger('SetMetadata');
 }
 const DISCORD_LOCALES = new Set(Object.values(discord_js.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();
@@ -1978,7 +1991,24 @@ brand(CooldownStoreError, 'CooldownStoreError');
     else logger.error(`Could not ${what}:`, error);
 }
 
-/** Whether a value is a class, which a stage entry or a `@Catch` type must be: what `new` and `instanceof` take. */ const isConstructor = (value)=>typeof value === 'function';
+/** Whether `new` takes a value, as `instanceof` needs of its right side, such as a `@Catch` type. */ function isConstructible(value) {
+    if (typeof value !== 'function') return false;
+    try {
+        // Fails unless value can be new.target, which only a constructor can; none of value's constructor code runs
+        Reflect.construct(String, [], value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Whether a value is a class, which a stage entry or an app option must be: constructible, with an object prototype for
+ * the metadata MeoCord reads. An arrow function, a method, an async or a generator function is none.
+ */ function isConstructor(value) {
+    if (!isConstructible(value)) return false;
+    const prototype = value.prototype;
+    return typeof prototype === 'object' && prototype !== null;
+}
 /** A value as a refusal or a warning names it: a string quoted, `null` and `undefined` as written, else its kind. */ function describeValue(value) {
     if (value === null || value === undefined) return String(value);
     if (typeof value === 'string') return quoteForLog(value);
@@ -3383,15 +3413,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();
@@ -5559,9 +5589,11 @@ exports.hideInLogs = hideInLogs;
 exports.inferContextType = inferContextType;
 exports.interactionLocale = interactionLocale;
 exports.isBuiltApplication = isBuiltApplication;
+exports.isConstructible = isConstructible;
 exports.isConstructor = isConstructor;
 exports.isCustomIdRouted = isCustomIdRouted;
 exports.isExplainedError = isExplainedError;
+exports.isPluralShape = isPluralShape;
 exports.isRefusal = isRefusal;
 exports.isTooLarge = isTooLarge;
 exports.isUserOutcome = isUserOutcome;

package/dist/cjs/_shared/{providers-BZgJyfZS.cjs → providers-B4MOFBrW.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var controller_decorator = require('./controller.decorator-XKMlcUZz.cjs');
+var controller_decorator = require('./controller.decorator-U2NBWcoU.cjs');
 require('reflect-metadata');
 var node_async_hooks = require('node:async_hooks');
 var inversify = require('inversify');
@@ -90,7 +90,8 @@ var Table__default = /*#__PURE__*/_interopDefaultCompat(Table);
     }
 }
 /** The class of a stage entry. */ function stageClass(entry) {
-    return controller_decorator.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(controller_decorator.META.stageTypes, stageClass(entry));
@@ -1684,7 +1685,7 @@ function isInterceptorWithParams(entry) {
             // Every filter reaching here was checked for @Catch at startup, so its types are always recorded
             const types = Reflect.getOwnMetadata(controller_decorator.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)=>controller_decorator.isConstructor(type) && error instanceof type)) return entry;
+            if (types.length === 0 || types.some((type)=>controller_decorator.isConstructible(type) && error instanceof type)) return entry;
         }
     }
     return undefined;
@@ -1789,7 +1790,7 @@ const logger$1 = new controller_decorator.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(controller_decorator.META.observerClass, observer)) {
-            const name = typeof observer === 'function' ? observer.name : String(observer);
+            const name = controller_decorator.isConstructor(observer) ? observer.name || 'an anonymous class' : typeof observer === 'function' ? 'a function' : String(observer);
             controller_decorator.startupError(new Error(`${where} takes classes decorated with @Observer(), not ${name}.`));
             continue;
         }
@@ -2332,7 +2333,9 @@ const logger = new controller_decorator.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?.() ? controller_decorator.responseOf(first) : undefined);
+            await denied?.abandon();
             return {
                 ran: false
             };
@@ -2388,14 +2391,18 @@ const logger = new controller_decorator.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
@@ -4190,22 +4197,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;
 }
 
@@ -4747,7 +4780,7 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
             controller_decorator.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 && !controller_decorator.isConstructor(entry.useClass)) {
             controller_decorator.startupError(new Error(`${where}: the provider for ${name} has a useClass that is not a class.`));
             continue;
         }
@@ -4824,6 +4857,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;
+        controller_decorator.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.
@@ -4991,6 +5033,7 @@ exports.appPresenterOf = appPresenterOf;
 exports.appStages = appStages;
 exports.assertObservers = assertObservers;
 exports.assertProvided = assertProvided;
+exports.assertProvidedServices = assertProvidedServices;
 exports.assertStageEntries = assertStageEntries;
 exports.assertStartupChecked = assertStartupChecked;
 exports.assertTypedParameters = assertTypedParameters;

package/dist/cjs/_shared/{sharded-cooldown-store-CsJJyCZd.cjs → sharded-cooldown-store-HTUb3Ii_.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var controller_decorator = require('./controller.decorator-XKMlcUZz.cjs');
+var controller_decorator = require('./controller.decorator-U2NBWcoU.cjs');
 
 /** The `fatal` code of a shard whose app MeoCord refused, which every shard would refuse alike. */ const REFUSED_CODE = 'Refused';
 /** Whether an IPC message is one of MeoCord's own, rather than one of discord.js's. */ function isShardMessage(message) {

package/dist/cjs/_shared/{startup-roots-CgfPQrNl.cjs → startup-roots-lA5xkBFq.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
 var discord_js = require('discord.js');
-var controller_decorator = require('./controller.decorator-XKMlcUZz.cjs');
-var providers = require('./providers-BZgJyfZS.cjs');
+var controller_decorator = require('./controller.decorator-U2NBWcoU.cjs');
+var providers = require('./providers-B4MOFBrW.cjs');
 var enum_index = require('../enum/index.cjs');
 var node_async_hooks = require('node:async_hooks');
-var translateError = require('./translate-error-BUAR1WYG.cjs');
+var translateError = require('./translate-error-CbBHUu5P.cjs');
 
 /**
  * How a pattern ranks, one character per segment twice over: `L` for literal text or `P` for a param, then how narrow
@@ -1480,10 +1480,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
    * 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 providers.runHandler(this.container, instance, methodName, args, {
             ...this.runOptions(call),
             onUnanswered,
@@ -1493,13 +1490,17 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         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/cjs/_shared/{translate-error-BUAR1WYG.cjs → translate-error-CbBHUu5P.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var controller_decorator = require('./controller.decorator-XKMlcUZz.cjs');
+var controller_decorator = require('./controller.decorator-U2NBWcoU.cjs');
 var discord_js = require('discord.js');
 
 const logger = new controller_decorator.Logger('Route');

package/dist/cjs/common/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
+var controller_decorator = require('../_shared/controller.decorator-U2NBWcoU.cjs');
 require('reflect-metadata');
-var translateError = require('../_shared/translate-error-BUAR1WYG.cjs');
-var shardedCooldownStore = require('../_shared/sharded-cooldown-store-CsJJyCZd.cjs');
+var translateError = require('../_shared/translate-error-CbBHUu5P.cjs');
+var shardedCooldownStore = require('../_shared/sharded-cooldown-store-HTUb3Ii_.cjs');
 require('../enum/index.cjs');
 require('discord.js');
 require('path');

package/dist/cjs/core/index.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-BZgJyfZS.cjs');
+var providers = require('../_shared/providers-B4MOFBrW.cjs');
 var inversify = require('inversify');
 var discord_js = require('discord.js');
-var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
+var controller_decorator = require('../_shared/controller.decorator-U2NBWcoU.cjs');
 require('node:crypto');
-var shardedCooldownStore = require('../_shared/sharded-cooldown-store-CsJJyCZd.cjs');
-var startupRoots = require('../_shared/startup-roots-CgfPQrNl.cjs');
+var shardedCooldownStore = require('../_shared/sharded-cooldown-store-HTUb3Ii_.cjs');
+var startupRoots = require('../_shared/startup-roots-lA5xkBFq.cjs');
 var enum_index = require('../enum/index.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
@@ -23,7 +23,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');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -1628,7 +1628,9 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         const providers$1 = controller_decorator.collectStartupErrors(()=>{
             declared.forEach(controller_decorator.startupError);
             startupRoots.assertDistinctCommands(options.controllers);
-            return providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
+            const providers$1 = providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
+            providers.assertProvidedServices(typeof target === 'function' ? target.name : String(target), options.services ?? [], providers$1, '@MeoCord({ providers })');
+            return providers$1;
         });
         // A themeFor class is bound on its own, as the cooldown store is, and resolved like a service
         const themeResolver = controller_decorator.themeResolverClass(options.themeFor);

package/dist/cjs/decorator/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-BZgJyfZS.cjs');
-var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
+var providers = require('../_shared/providers-B4MOFBrW.cjs');
+var controller_decorator = require('../_shared/controller.decorator-U2NBWcoU.cjs');
 var inversify = require('inversify');
 require('node:async_hooks');
 require('../enum/index.cjs');
@@ -447,7 +447,7 @@ require('chalk');
         controller_decorator.refuseOnMethod('@Catch', target, propertyKey);
         providers.makeInjectable(target);
         errorTypes.forEach((type, index)=>{
-            if (controller_decorator.isConstructor(type)) return;
+            if (controller_decorator.isConstructible(type)) return;
             const entry = ORDINALS[index] ? `${ORDINALS[index]} entry` : `entry ${index + 1}`;
             controller_decorator.warnDeprecatedBehaviour(logger$1, `${target.name}: @Catch's ${entry}, ${controller_decorator.describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
         });
@@ -555,6 +555,35 @@ const ORDINALS = [
         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 && !controller_decorator.isConstructor(value)) {
+            throw controller_decorator.refuse(new TypeError(`${appName}: @MeoCord({ ${name} }) takes a class implementing ${implementing}, not ${controller_decorator.describeValue(value)}.`));
+        }
+    }
+    for (const controller of controllers ?? []){
+        if (!controller_decorator.isConstructor(controller)) throw controller_decorator.refuse(new TypeError(`${appName}: @MeoCord({ controllers }) takes classes, not ${controller_decorator.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 (controller_decorator.isConstructor(service) || typeof service === 'string' || typeof service === 'symbol') continue;
+        throw controller_decorator.refuse(new TypeError(`${appName}: @MeoCord({ services }) takes classes, or tokens that providers provide, not ${controller_decorator.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 controller_decorator.refuse(new TypeError(`${where} ${String(labelKey)}; it takes a message key, such as 'types.${name}'.`));
@@ -599,6 +628,7 @@ const ORDINALS = [
  */ function MeoCord(options) {
     return controller_decorator.declaring((target, propertyKey)=>{
         if (controller_decorator.deprecatedOnMethod('@MeoCord', target, propertyKey)) return;
+        assertClassOptions(target.name, options);
         providers.assertStageEntries('@MeoCord({ guards })', 'guard', target.name, options.guards ?? []);
         providers.assertStageEntries('@MeoCord({ interceptors })', 'interceptor', target.name, options.interceptors ?? []);
         providers.assertStageEntries('@MeoCord({ filters })', 'filter', target.name, options.filters ?? []);