meocord 4.1.2 → 4.2.1

package/dist/esm/core/running-calls.js

@@ -0,0 +1,43 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * The calls an app is running, which shutdown waits for before the `onShutdown` hooks. A call that asks the app to
+ * stop is excused, so a handler awaiting `app.stop()` never waits for itself.
+ */ class RunningCalls {
+    /** Runs `run` as a call named `label`, tracked until it settles. */ run(label, run) {
+        const token = {};
+        this.calls.set(token, label);
+        const done = this.current.run(token, run);
+        const settle = ()=>{
+            this.calls.delete(token);
+            this.notify();
+        };
+        done.then(settle, settle);
+        return done;
+    }
+    /** Excuses the call this runs in, and any it runs within, from the wait; outside a call, nothing. */ excuseCurrent() {
+        const token = this.current.getStore();
+        if (!token || !this.calls.has(token)) return;
+        this.excused.add(token);
+        this.notify();
+    }
+    /** The names of the calls a wait would still wait for. */ running() {
+        return [
+            ...this.calls
+        ].filter(([token])=>!this.excused.has(token)).map(([, label])=>label);
+    }
+    /** Settles once every call not excused has, those that start or are excused meanwhile included. */ async settled() {
+        while(this.running().length > 0)await (this.changed ?? (this.changed = Promise.withResolvers())).promise;
+    }
+    notify() {
+        this.changed?.resolve();
+        this.changed = undefined;
+    }
+    constructor(){
+        this.current = new AsyncLocalStorage();
+        /** Each call under way, by its token, with the name a log gives it. */ this.calls = new Map();
+        this.excused = new WeakSet();
+    }
+}
+
+export { RunningCalls };

package/dist/esm/core/scalar-types.js

@@ -34,18 +34,30 @@ const UNIT_MS = lookupTable({
         return total + Number(amount) * UNIT_MS[unit];
     }, 0);
 }
+/** The largest snowflake: Discord's IDs are unsigned 64-bit integers. */ const MAX_SNOWFLAKE = 2n ** 64n - 1n;
+/**
+ * A Discord ID, kept as its text: 17 to 20 digits, no leading zero, up to the largest 64-bit value. An ID's top 42 bits
+ * are milliseconds since 2015-01-01, so every ID made from 2015-01-28 on has 17 digits or more, and none is a safe
+ * integer.
+ */ const snowflake = (word)=>/^[1-9]\d{16,19}$/.test(word) && BigInt(word) <= MAX_SNOWFLAKE ? word : undefined;
+/** A UUID in its canonical 8-4-4-4-12 form, in either case, kept as written. */ const uuid = (word)=>/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(word) ? word : undefined;
 /** The words a type such as `on|off` chooses from, or `undefined` for any other type. */ const choicesOf = (type)=>type.includes('|') ? type.split('|') : undefined;
 /** The types a component's customId segment can take: each parsed from the segment alone, with no request. */ const SEGMENT_TYPES = lookupTable({
     string: (segment)=>segment,
     int: (segment)=>number(segment, true),
     number: (segment)=>number(segment, false),
-    bool
+    bool,
+    snowflake,
+    uuid
 });
-/** Whether `type` can type a customId segment: `string`, `int`, `number`, `bool`, or words to choose from. */ const isSegmentType = (type)=>type in SEGMENT_TYPES || choicesOf(type) !== undefined;
+/**
+ * Whether `type` can type a customId segment: `string`, `int`, `number`, `bool`, `snowflake`, `uuid`, or words to
+ * choose from.
+ */ const isSegmentType = (type)=>type in SEGMENT_TYPES || choicesOf(type) !== undefined;
 /** A customId segment as its type's value, words to choose from compared as written: `undefined` when it is not one. */ function parseSegment(type, segment) {
     const choices = choicesOf(type);
     if (choices) return choices.includes(segment) ? segment : undefined;
     return SEGMENT_TYPES[type](segment);
 }
 
-export { bool, choicesOf, duration, isSegmentType, lookupTable, number, parseSegment };
+export { bool, choicesOf, duration, isSegmentType, lookupTable, number, parseSegment, snowflake, uuid };

package/dist/esm/core/shard-context.js

@@ -5,16 +5,15 @@ import './theme-validation.js';
 import '../common/decorator.js';
 import 'reflect-metadata';
 import 'discord.js';
-import '../common/translator.js';
-import '../common/response/send-failure.js';
-import '../util/interaction.util.js';
-import '../common/response/flags.js';
-import 'path';
-import '../common/response/components.js';
+import '../common/response/response-state.js';
+import '../common/errors.js';
 import '../decorator/controller.decorator.js';
 import './scalar-types.js';
+import 'path';
 import 'node:fs';
 import 'node:url';
+import '../common/translator.js';
+import '../common/meocord-text.js';
 
 /** Where each shard's client keeps the function that runs a `ShardContext.call` in that shard. */ const SHARD_CALL_KEY = Symbol.for('meocord.shardCall');
 const packArgs = (args)=>Object.assign({
@@ -95,7 +94,7 @@ async function withTimeout(promise, ms, what) {
  *
  * @group Controllers
  * @see {@link ShardCallResult}
- * @see {@link https://meocord.dev/docs/4.1/sharding | Sharding}
+ * @see {@link https://meocord.dev/docs/4.2/sharding | Sharding}
  */ class ShardContext {
     /** The ids of the shards this process runs. With process sharding, one id; otherwise every shard, once ready. */ get ids() {
         if (this.client?.shard) return [

package/dist/esm/core/shard-manager.js

@@ -4,24 +4,22 @@ import './theme-scope.js';
 import './theme-validation.js';
 import '../common/decorator.js';
 import 'reflect-metadata';
-import '../common/translator.js';
-import '../common/response/send-failure.js';
-import '../util/interaction.util.js';
-import '../common/response/flags.js';
-import 'path';
-import '../common/response/components.js';
+import '../common/response/response-state.js';
+import '../common/errors.js';
 import { MemoryCooldownStore } from '../common/cooldown-store.js';
 import 'node:crypto';
 import '../decorator/controller.decorator.js';
 import './scalar-types.js';
 import { answerCooldown } from '../common/sharded-cooldown-store.js';
+import '../common/translator.js';
+import '../common/meocord-text.js';
 import { registerCommands } from './command-registration.js';
 import { SHUTDOWN_MARGIN_MS, shutdownTimeoutOf } from '../util/shutdown-timeout.util.js';
 import { bundleEntry } from '../util/bundle-entry.util.js';
 import { FORCE_REGISTER_ENV } from '../util/registration-mode.util.js';
 import { isShardMessage, REFUSED_CODE } from './shard-messages.js';
 import { tokenMessage, isRefusedToken } from './login-failure.js';
-import { onDevRunnerStop, underDevRunner, tellDevRunner } from '../util/dev-runner.util.js';
+import { onDevRunnerStop, tellDevRunner, underDevRunner } from '../util/dev-runner.util.js';
 import { stopRequests } from '../util/stop-request.util.js';
 
 /** How long the manager waits for a shard to become ready before spawning the next. */ const SHARD_READY_TIMEOUT_MS = 30000;
@@ -60,7 +58,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         process.on('SIGINT', ()=>void this.stopAndExit());
         process.on('SIGTERM', ()=>void this.stopAndExit());
         // How `meocord start --dev` stops the bot to restart it; no stop request of the user's, whose first Ctrl+C joins it
-        onDevRunnerStop(()=>void this.exitAfterShutdown());
+        onDevRunnerStop(()=>void this.exitAfterShutdown(), false);
         let total;
         try {
             const shards = config.sharding?.shards ?? 'auto';
@@ -77,6 +75,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         const manager = (this.options.createManager ?? ((path, opts)=>new ShardingManager(path, opts)))(file, {
             token,
             totalShards: total,
+            // discord.js refuses a call to every shard unless shardList counts the shards; createShard leaves it 'auto'
+            shardList: [
+                ...Array(total).keys()
+            ],
             mode: 'process',
             execArgv: process.execArgv,
             respawn: false
@@ -173,12 +175,12 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         void this.exitForLogin();
     }
     /** Exits 1 for a bot that could not log in, telling `meocord start --dev` first, which then waits for a change. */ exitForLogin() {
-        if (!underDevRunner()) return this.exit(1);
+        if (!this.devRunner) return this.exit(1);
         // Set first, so the process exits 1 even if it ends while the message is still on its way
         process.exitCode = 1;
         return tellDevRunner({
             meocord: 'login-failed'
-        }).then(()=>this.exit(1));
+        }, false).then(()=>this.exit(1));
     }
     /**
    * Asks every shard to shut down through its own hooks, waits for them up to the shutdown timeout plus a margin, and
@@ -255,6 +257,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         /** Every shard's cooldown calls, for an app whose store is ShardedCooldownStore. */ this.cooldowns = new MemoryCooldownStore();
         this.stopping = false;
         this.fatal = false;
+        /**
+   * Whether `meocord start --dev` runs the manager, decided before discord.js's ShardingManager, which writes the
+   * variable that marks a shard into this process too.
+   */ this.devRunner = underDevRunner(false);
         // The manager holds the credential for its shards and logs their failures, without an app of its own to register it
         hideInLogs(options.token);
         this.exit = options.exit ?? ((code)=>process.exit(code));

package/dist/esm/core/startup-roots.js

@@ -3,8 +3,10 @@ import { injectedTokens, isGuardWithParams } from './guard-runner.js';
 import { classDecorators, handlerStageClasses } from './handler-pipeline.js';
 import { reachableClasses, assertTypedParameters } from './providers.js';
 import { themeResolverClass } from './theme-resolvers.js';
+import { isAppClassToken } from './lifecycle-order.js';
+import { ExecutionContext } from '../common/execution-context.js';
 import { META } from '../util/metadata-keys.js';
-import { refuse } from '../util/refusal.util.js';
+import { startupError } from '../util/refusal.util.js';
 
 /** The guards `@UseGuard` puts on a class's methods, handlers or not, which a direct call runs too. */ function methodGuards(cls) {
     const guards = [];
@@ -57,6 +59,24 @@ import { refuse } from '../util/refusal.util.js';
         for (const [stage, decorator] of found)decorators.set(stage, decorator);
     }
 }
+/** Whether making `cls` reaches the per-call `ExecutionContext` through the classes it injects, which each call makes. */ function reachesContext(cls, providers, seen = new Set()) {
+    seen.add(cls);
+    return injectedTokens(cls).some((token)=>token === ExecutionContext || isAppClassToken(token) && !providers.has(token) && !seen.has(token) && reachesContext(token, providers, seen));
+}
+/**
+ * The classes the app's stages and presenter inject, which they would make only at their first call. Made with the
+ * app's own classes, a service among them gets its lifecycle hooks. One that reaches the call's `ExecutionContext` is
+ * made for each call, so it is left out, and a stage a test replaces is not among the stages, so what it would inject
+ * is not made.
+ */ function stageDependencies({ decorators }, providers, presenter) {
+    const stages = [
+        ...decorators
+    ].filter(([, decorator])=>decorator !== '@Controller()').map(([stage])=>stage);
+    if (typeof presenter === 'function') stages.push(presenter);
+    return [
+        ...new Set(stages.flatMap((stage)=>injectedTokens(stage)))
+    ].filter(isAppClassToken).filter((cls)=>!reachesContext(cls, providers));
+}
 /** How a container checks a guard first met at a call: the guard and what it injects, as the startup checks would. */ function lateGuardCheck(providers, translator) {
     return (guard)=>assertStartupClasses({
             classes: reachableClasses([
@@ -75,8 +95,7 @@ import { refuse } from '../util/refusal.util.js';
 /** Runs the startup checks over every class an app runs, so a class that cannot be made is refused by name now. */ function assertStartupClasses({ classes, decorators }, { translator }) {
     assertTypedParameters(classes, decorators);
     if (translator) return;
-    const needsOne = classes.find((cls)=>injectedTokens(cls).includes(Translator));
-    if (needsOne) throw refuse(missingTranslatorError(needsOne));
+    for (const needsOne of classes.filter((cls)=>injectedTokens(cls).includes(Translator)))startupError(missingTranslatorError(needsOne));
 }
 
-export { assertStartupClasses, lateGuardCheck, startupClasses };
+export { assertStartupClasses, lateGuardCheck, stageDependencies, startupClasses };

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

@@ -118,7 +118,10 @@ const logger = new Logger('Theme');
    */ accept(id, result, report) {
         if (result === undefined || result === null) return undefined;
         const layer = copyLayer(result);
-        const problems = themeProblems(layer, `themeFor.${this.kind} for ${this.kind} ${id}`);
+        // A value from the app's data, such as a user's saved choice, shown as a log line shows outside text
+        const problems = themeProblems(layer, `themeFor.${this.kind} for ${this.kind} ${id}`, {
+            forLog: true
+        });
         if (problems.length === 0) {
             if (report) this.warned.delete(id);
             return layer;

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

@@ -1,8 +1,8 @@
 import 'reflect-metadata';
 import { stageClasses, sourcePrototype } from './guard-runner.js';
 import { makeInjectable } from '../util/injectable.util.js';
-import { resolverCaches, ThemeCache, attachThemeCache, lookupLayers } from './theme-resolvers.js';
-import { releaseAmbientTheme, claimAmbientTheme, defaultTheme, mergeTheme, themeLayersVersion, ambientThemeVersion, ownsAmbientTheme, hasAmbientTheme, setThemeOutsideCalls, useTheme } from './theme-scope.js';
+import { lookupLayers, resolverCaches, ThemeCache, attachThemeCache } from './theme-resolvers.js';
+import { releaseAmbientTheme, claimAmbientTheme, mergeTheme, defaultTheme, themeLayersVersion, ambientThemeVersion, ownsAmbientTheme, hasAmbientTheme, setThemeOutsideCalls, useTheme } from './theme-scope.js';
 import { META } from '../util/metadata-keys.js';
 
 /** Classes with a `@UseTheme`, on the class or one of its methods. */ const THEMED_CLASSES = new WeakSet();

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

@@ -1,7 +1,9 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { DEFAULT_THEME } from './theme-defaults.js';
+import { shared } from '../util/shared-state.util.js';
 
-const scope = new AsyncLocalStorage();
+// One per process for this meocord version, so a call's theme reads the same from its ES module and CommonJS builds
+const scope = shared('themeScope', ()=>new AsyncLocalStorage());
 const isPlainObject = (value)=>{
     if (value === null || typeof value !== 'object') return false;
     const prototype = Object.getPrototypeOf(value);

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

@@ -1,5 +1,6 @@
 import { ButtonStyle, Colors } from 'discord.js';
 import { refuse } from '../util/refusal.util.js';
+import { escapeForLog, quoteForLog } from '../util/user-text.util.js';
 
 /**
  * The role names MeoCord keeps for roles it may add to `colors`, `emojis` and `buttons`: the runtime copy of
@@ -25,9 +26,10 @@ const EMOJI = 'a unicode emoji, or a custom one written <:name:id> or <a:name:id
 const BUTTON = 'ButtonStyle.Primary, Secondary, Success or Danger';
 /** A custom emoji as Discord writes one in text: its name, 2 to 32 word characters, and its id. */ const CUSTOM_EMOJI = /^<a?:\w{2,32}:\d{17,20}>$/;
 /**
- * One unicode emoji: a flag of two regional indicators, a keycap, or a pictograph with an optional presentation
- * selector or skin tone, joined to others by zero-width joiners into one sequence.
- */ const UNICODE_EMOJI = /^(?:\p{Regional_Indicator}{2}|[#*0-9]️?⃣|\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?)*)$/u;
+ * One unicode emoji: a flag of two regional indicators, a subdivision flag (a black flag, tag characters and a cancel
+ * tag, as England's), a keycap, or a pictograph with an optional presentation selector or skin tone, joined to others by
+ * zero-width joiners into one sequence.
+ */ const UNICODE_EMOJI = /^(?:\p{Regional_Indicator}{2}|\u{1F3F4}[\u{E0020}-\u{E007E}]+\u{E007F}|[#*0-9]️?⃣|\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?)*)$/u;
 const byte = (value)=>Number.isInteger(value) && value >= 0 && value <= 255;
 /** Whether discord.js resolves the value to a colour Discord takes. Stricter on tuples, whose channels it only sums. */ function isColour(value) {
     if (typeof value === 'string') return /^#?[\da-f]{6}$/i.test(value) || value === 'Random' || value === 'Default' || Object.hasOwn(Colors, value);
@@ -42,8 +44,9 @@ const THEMED_BUTTON_STYLES = [
     ButtonStyle.Danger
 ];
 const isButtonStyle = (value)=>THEMED_BUTTON_STYLES.includes(value);
-const describe = (value)=>typeof value === 'string' ? `'${value}'` : Array.isArray(value) ? `[${value.map((item)=>typeof item === 'string' ? `'${item}'` : String(item)).join(', ')}]` : value === null ? 'null' : typeof value === 'object' ? 'an object' : String(value);
-const describeGroup = (value)=>Array.isArray(value) ? 'an array' : describe(value);
+const asWritten = (text)=>`'${text}'`;
+const describe = (value, quote = asWritten)=>typeof value === 'string' ? quote(value) : Array.isArray(value) ? `[${value.map((item)=>typeof item === 'string' ? quote(item) : String(item)).join(', ')}]` : value === null ? 'null' : typeof value === 'object' ? 'an object' : String(value);
+const describeGroup = (value, quote = asWritten)=>Array.isArray(value) ? 'an array' : describe(value, quote);
 /** Whether a value is a plain object, as an object literal or `JSON.parse` makes: one a theme merges key by key. */ const isPlainObject = (value)=>{
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
@@ -75,11 +78,15 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
  * roles an app added, a colour discord.js cannot resolve, an emoji Discord would refuse, a button style other than
  * Discord's four coloured ones, or a reserved role name. A group of the app's own is its to check.
  * @param where - Where it was set, such as `themeFor.guild for guild 123`, to begin each line with.
- */ function themeProblems(theme, where) {
+ * @param options.forLog - Shows values and role names as a log line shows text from outside the code, for a theme a
+ *   `themeFor` resolver returned: escaped, and a value quoted and cut short.
+ */ function themeProblems(theme, where, { forLog = false } = {}) {
     const at = where ? `${where}: ` : '';
+    const quote = forLog ? quoteForLog : asWritten;
+    const name = forLog ? escapeForLog : (role)=>role;
     if (typeof theme !== 'object' || theme === null || Array.isArray(theme)) {
         return [
-            `${at}theme must be an object of groups (got ${describeGroup(theme)})`
+            `${at}theme must be an object of groups (got ${describeGroup(theme, quote)})`
         ];
     }
     if (!isPlainObject(theme)) return [
@@ -91,7 +98,7 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
         const roles = theme[group];
         if (roles === undefined) continue;
         if (typeof roles !== 'object' || roles === null || Array.isArray(roles)) {
-            problems.push(`${at}theme.${group} must be an object of roles (got ${describeGroup(roles)})`);
+            problems.push(`${at}theme.${group} must be an object of roles (got ${describeGroup(roles, quote)})`);
             continue;
         }
         if (!isPlainObject(roles)) {
@@ -99,8 +106,8 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
             continue;
         }
         for (const [role, value] of Object.entries(roles)){
-            if (reserved.has(role)) problems.push(`${at}theme.${group}.${role}: MeoCord reserves the role name ${role} for a role it may add; rename yours`);
-            else if (value !== undefined && !check(value)) problems.push(`${at}theme.${group}.${role}: ${describe(value)} is not ${what}: give ${instead}`);
+            if (reserved.has(role)) problems.push(`${at}theme.${group}.${name(role)}: MeoCord reserves the role name ${name(role)} for a role it may add; rename yours`);
+            else if (value !== undefined && !check(value)) problems.push(`${at}theme.${group}.${name(role)}: ${describe(value, quote)} is not ${what}: give ${instead}`);
         }
     }
     return problems;

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

@@ -7,7 +7,7 @@ import { BUILT_IN_TYPES } from '../core/message-params.js';
 import { assertObservers } from '../core/observer-runner.js';
 import { assertValidTheme, themeForProblem } from '../core/theme-validation.js';
 import { copyLayer } from '../core/theme-scope.js';
-import { deprecatedOnMethod, refuse } from '../util/refusal.util.js';
+import { declaring, deprecatedOnMethod, refuse } from '../util/refusal.util.js';
 import { timeoutProblem } from '../util/timer-limit.util.js';
 import { META } from '../util/metadata-keys.js';
 
@@ -18,14 +18,19 @@ import { META } from '../util/metadata-keys.js';
     if (prefix !== undefined && !isText(prefix) && typeof prefix !== 'function' && !(Array.isArray(prefix) && prefix.every(isText))) {
         throw refuse(new TypeError(`${appName}: @MeoCord({ messages: { prefix } }) takes a string, a list of strings, or a function of the message returning them.`));
     }
-    for (const [name, value] of Object.entries({
+    const flags = {
         caseSensitive,
         replyEmoji: messages.replyEmoji,
         dmOnError: messages.dmOnError,
-        dmOnCooldown: messages.dmOnCooldown
-    })){
+        dmOnCooldown: messages.dmOnCooldown,
+        slowHandlerWarning: messages.slowHandlerWarning
+    };
+    for (const [name, value] of Object.entries(flags)){
         if (value !== undefined && typeof value !== 'boolean') throw refuse(new TypeError(`${appName}: @MeoCord({ messages: { ${name} } }) takes true or false.`));
     }
+    if (messages.handlers !== undefined && messages.handlers !== 'sequential' && messages.handlers !== 'concurrent') {
+        throw refuse(new TypeError(`${appName}: @MeoCord({ messages: { handlers } }) takes 'sequential' or 'concurrent'.`));
+    }
     if (mention !== undefined && typeof mention !== 'boolean' && mention !== 'only') {
         throw refuse(new TypeError(`${appName}: @MeoCord({ messages: { mention } }) takes true, false or 'only'.`));
     }
@@ -87,9 +92,9 @@ import { META } from '../util/metadata-keys.js';
  * @see {@link MeoCordOptions}
  * @see {@link MeoCordFactory}
  * @see {@link MeoCordConfig}
- * @see {@link https://meocord.dev/docs/4.1/configuration | Configuration}
+ * @see {@link https://meocord.dev/docs/4.2/configuration | Configuration}
  */ function MeoCord(options) {
-    return (target, propertyKey)=>{
+    return declaring((target, propertyKey)=>{
         if (deprecatedOnMethod('@MeoCord', target, propertyKey)) return;
         assertStageEntries('@MeoCord({ guards })', 'guard', target.name, options.guards ?? []);
         assertStageEntries('@MeoCord({ interceptors })', 'interceptor', target.name, options.interceptors ?? []);
@@ -111,7 +116,7 @@ import { META } from '../util/metadata-keys.js';
             ...options,
             theme
         }, target);
-    };
+    });
 }
 /** Refuses theme resolvers and cache options the runtime cannot follow, where the app is declared. */ function assertThemeFor(appName, { themeFor, themeCache, themeForTimeoutMs }) {
     const problem = themeFor === undefined ? undefined : themeForProblem(themeFor, `${appName}: @MeoCord({ themeFor })`, 'or a class implementing ThemeResolver.');

package/dist/esm/decorator/command-builder.decorator.js

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
 import { META } from '../util/metadata-keys.js';
-import { deprecatedOnMethod } from '../util/refusal.util.js';
+import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
 
 /**
  * Marks a class as a command's builder, which describes the command MeoCord registers with Discord.
@@ -30,9 +30,9 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
  * @group Decorators
  * @category Handlers
  * @see {@link Command}
- * @see {@link https://meocord.dev/docs/4.1/slash-commands | Slash commands}
+ * @see {@link https://meocord.dev/docs/4.2/slash-commands | Slash commands}
  */ function CommandBuilder(commandType, options = {}) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         if (deprecatedOnMethod('@CommandBuilder', target, propertyKey)) return;
         makeInjectable(target);
         // Define the command type metadata for the target class
@@ -40,7 +40,7 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
         if (options.guilds) Reflect.defineMetadata(META.builderGuilds, [
             ...options.guilds
         ], target);
-    };
+    });
 }
 
 export { CommandBuilder };

package/dist/esm/decorator/controller-class.decorator.js

@@ -1,7 +1,8 @@
+import { dropInheritedRoutes } from './controller.decorator.js';
 import { guardOwnHandlersWithBaseGuards } from './guard.decorator.js';
 import { makeInjectable } from '../util/injectable.util.js';
 import { META } from '../util/metadata-keys.js';
-import { deprecatedOnMethod } from '../util/refusal.util.js';
+import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
 
 /**
  * Marks a class as a controller, whose methods handle commands, components, messages, reactions or events.
@@ -35,14 +36,18 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
  * @category Controllers
  * @see {@link Command}
  * @see {@link ControllerOptions}
- * @see {@link https://meocord.dev/docs/4.1/how-a-call-runs | How a call runs}
+ * @see {@link https://meocord.dev/docs/4.2/how-a-call-runs | How a call runs}
  */ function Controller(options = {}) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         if (deprecatedOnMethod('@Controller', target, propertyKey)) return;
         makeInjectable(target);
         if (options.inheritStages === false) Reflect.defineMetadata(META.inheritStages, false, target);
+        if (options.inheritedRoutes === 'replace') {
+            dropInheritedRoutes(target.prototype);
+            Reflect.defineMetadata(META.replacesInheritedRoutes, true, target.prototype);
+        }
         guardOwnHandlersWithBaseGuards(target);
-    };
+    });
 }
 
 export { Controller };