meocord 4.2.2 → 4.2.3

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var controller_decorator = require('./controller.decorator-U2NBWcoU.cjs');
+var controller_decorator = require('./controller.decorator-hp5xdJU4.cjs');
 require('reflect-metadata');
 var node_async_hooks = require('node:async_hooks');
 var inversify = require('inversify');
@@ -11,8 +11,6 @@ var fs = require('fs');
 var path = require('path');
 var Table = require('cli-table3');
 var node_crypto = require('node:crypto');
-require('node:fs');
-require('node:url');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -104,13 +102,12 @@ function eventDecorator(event, once) {
     // Generic over the method, so it is checked against the event's arguments rather than required to match exactly
     return controller_decorator.declaring(function(target, propertyKey, _descriptor) {
         controller_decorator.refuseOnClass(once ? '@Once' : '@On', target, propertyKey);
-        const handlers = controller_decorator.ownHandlerList(controller_decorator.META.eventHandlers, target);
-        handlers.push({
+        // One the class inherits for the same method and event is replaced, as for every other kind of handler
+        controller_decorator.addOwnHandler(controller_decorator.META.eventHandlers, target, {
             event,
             method: propertyKey,
             once
-        });
-        Reflect.defineMetadata(controller_decorator.META.eventHandlers, handlers, target);
+        }, (other)=>other.method === propertyKey && other.event === event);
     });
 }
 /**
@@ -306,14 +303,14 @@ const perCallKeys = new WeakMap();
         });
     }
 }
-const logger$4 = new controller_decorator.Logger('Guard');
+const logger$5 = new controller_decorator.Logger('Guard');
 const warnedShared = new WeakMap();
 /** Warns once per guard in each app that its params are set on the one instance every call shares, and why. */ function warnSharedParams(container, guardClass, why, remedy) {
     let warned = warnedShared.get(container);
     if (!warned) warnedShared.set(container, warned = new Set());
     if (warned.has(guardClass)) return;
     warned.add(guardClass);
-    logger$4.warn(`${guardClass.name} is one instance every call shares, and ${why}, so each call's params are set on that ` + `instance: calls that overlap can read each other's. ${remedy}, or stop binding the guard, in services, ` + `providers or a constructor that injects it, so each call gets its own.`);
+    logger$5.warn(`${guardClass.name} is one instance every call shares, and ${why}, so each call's params are set on that ` + `instance: calls that overlap can read each other's. ${remedy}, or stop binding the guard, in services, ` + `providers or a constructor that injects it, so each call gets its own.`);
 }
 /** Whether each of these properties can be made to read the call's params, which a frozen or sealed instance's cannot. */ function canReadPerCall(instance, keys) {
     return keys.every((key)=>{
@@ -427,6 +424,28 @@ const warnedShared = new WeakMap();
     }
     return undefined;
 }
+/**
+ * The prototypes on the chain that declare `methodName` as written, base first: the handler and each override of it,
+ * looking through methods a class-level `@UseGuard` re-declared to wrap an inherited handler. A handler's method-level
+ * stages are read from each, so an override keeps its base method's, as it keeps its route.
+ */ function stageOwners(prototype, methodName) {
+    const owners = [];
+    for(let current = prototype; current && current !== Object.prototype; current = Object.getPrototypeOf(current)){
+        if (!Object.prototype.hasOwnProperty.call(current, methodName)) continue;
+        if (!Reflect.getOwnMetadata(controller_decorator.META.inheritedFrom, current, methodName)) owners.push(current);
+    }
+    return owners.reverse();
+}
+/** The entries a method-level stage lists under `key` on each of a handler's {@link stageOwners}, base first. */ function methodStages(prototype, methodName, key) {
+    return stageOwners(prototype, methodName).flatMap((owner)=>Reflect.getOwnMetadata(key, owner, methodName) ?? []);
+}
+/** The value a method-level stage holds under `key` on the nearest of a handler's {@link stageOwners} that declares one. */ function nearestMethodStage(prototype, methodName, key) {
+    for (const owner of stageOwners(prototype, methodName).reverse()){
+        const value = Reflect.getOwnMetadata(key, owner, methodName);
+        if (value !== undefined) return value;
+    }
+    return undefined;
+}
 /**
  * Caches a function of a class's prototype and one of its handlers. Handler metadata is fixed once
  * the classes are decorated, so dispatch resolves each handler's stages once, not on every call.
@@ -478,50 +497,165 @@ const warnedShared = new WeakMap();
  * The guards dispatch runs before a handler: its classes' class-level guards, outermost first, then
  * the method's. A method that is no handler has only its own, since class guards apply to handlers.
  */ const handlerGuards = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    if (!source) return [];
+    if (!sourcePrototype(prototype, methodName)) return [];
     return [
         ...handlerMethods$1(prototype).has(methodName) ? stageClasses(prototype, methodName).flatMap(classLevelGuards) : [],
-        ...Reflect.getOwnMetadata(controller_decorator.META.methodGuards, source, methodName) ?? []
+        ...methodStages(prototype, methodName, controller_decorator.META.methodGuards)
+    ];
+});
+/**
+ * The type a direct call to a handler runs as, which is the one dispatch gives it: `'event'` for an `@On` or `@Once`
+ * handler, as its first argument may be a message or an interaction; otherwise read from the first argument.
+ */ const directCallType = perHandler((prototype, methodName)=>{
+    if (!getEventHandlers(prototype).some((handler)=>handler.method === methodName)) return undefined;
+    const routed = [
+        ...Object.values(controller_decorator.getCommandMap(prototype) ?? {}).flat().map((command)=>command.methodName),
+        ...controller_decorator.getMessageHandlers(prototype).map((handler)=>handler.method),
+        ...controller_decorator.getReactionHandlers(prototype).map((handler)=>handler.method),
+        ...controller_decorator.getAutocompleteHandlers(prototype).map((handler)=>handler.methodName)
     ];
+    // A method dispatch also routes as a command, message or reaction has no one type
+    return routed.includes(methodName) ? undefined : 'event';
 });
-const wrapperCount = perHandler((prototype, methodName)=>{
-    const owner = declaringPrototype(prototype, methodName);
-    return owner ? Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, owner, methodName) ?? 0 : 0;
+/** Whether `@UseGuard` wraps the method anywhere on the chain, an override's base included. */ const isWrapped = perHandler((prototype, methodName)=>{
+    for(let current = prototype; current; current = Object.getPrototypeOf(current)){
+        if (Object.prototype.hasOwnProperty.call(current, methodName) && Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, current, methodName)) return true;
+    }
+    return false;
 });
 /**
- * Calls dispatch has already guarded, keyed by first argument and method, counting the wrappers still
- * to pass. A user decorator that awaits between two wrappers leaves a pass pending during that await,
- * which a concurrent direct call with the same object and method could take; other overlaps fail closed.
- * An event whose first argument is not an object, such as `debug`'s string, is keyed by the instance.
- */ const dispatched = new WeakMap();
-/** The object a call's dispatch mark is kept on: its first argument, or the instance when that is not an object. */ function markKey(first, instance) {
-    return typeof first === 'object' && first !== null ? first : instance;
-}
-/** Takes one pass for the wrapper being entered, if dispatch left one for this call. */ function consumeDispatchMark(first, instance, methodName) {
-    const marks = dispatched.get(markKey(first, instance));
-    const remaining = marks?.get(methodName);
-    if (!marks || !remaining) return false;
-    if (remaining > 1) marks.set(methodName, remaining - 1);
-    else marks.delete(methodName);
+ * The pass of the guarded call running. Kept per call, so a concurrent call with the same object and method runs its own
+ * guards, and closed when the call returns, so work it leaves running, such as a timer, does not carry it.
+ */ const guardedPasses = new node_async_hooks.AsyncLocalStorage();
+/** Takes the pass for `wrapper` when it belongs to a call whose guards have already run and has not let it through yet. */ function takeGuardedPass(wrapper, first, instance, methodName) {
+    const pass = guardedPasses.getStore();
+    if (!pass?.open || pass.instance !== instance || pass.methodName !== methodName || pass.first !== first) return false;
+    if (pass.entered.has(wrapper)) return false;
+    pass.entered.add(wrapper);
     return true;
 }
+/** Runs a call whose guards have run, with its pass; `wrapper` is the one that ran them, which it has entered. */ async function runWithPass(instance, methodName, args, call, wrapper) {
+    const pass = {
+        instance,
+        methodName,
+        first: args[0],
+        entered: new Set(wrapper ? [
+            wrapper
+        ] : []),
+        open: true
+    };
+    try {
+        return await guardedPasses.run(pass, call);
+    } finally{
+        pass.open = false;
+    }
+}
+/**
+ * Adds guards to a method's class or method list, then republishes the effective list under
+ * `META.guards`, in the order they run: the bases' before the class's own, and within one class or method the
+ * latest decorator first, since it wraps outermost.
+ */ function recordGuards(key, guards, prototype, methodName) {
+    const existing = Reflect.getOwnMetadata(key, prototype, methodName) ?? [];
+    const bases = key === controller_decorator.META.classGuards ? Reflect.getOwnMetadata(controller_decorator.META.baseClassGuards, prototype, methodName) ?? 0 : 0;
+    Reflect.defineMetadata(key, [
+        ...existing.slice(0, bases),
+        ...guards,
+        ...existing.slice(bases)
+    ], prototype, methodName);
+    const [classGuards, inheritedGuards] = [
+        controller_decorator.META.classGuards,
+        controller_decorator.META.inheritedGuards
+    ].map((list)=>Reflect.getOwnMetadata(list, prototype, methodName) ?? []);
+    // The method's guards and those of the methods it overrides, base first, as dispatch runs them
+    const methodGuards = methodStages(prototype, methodName, controller_decorator.META.methodGuards);
+    Reflect.defineMetadata(controller_decorator.META.guards, [
+        ...inheritedGuards,
+        ...classGuards,
+        ...methodGuards
+    ], prototype, methodName);
+}
+/** The classes {@link guardOwnHandlersWithBaseGuards} has handled, as `@Controller` and each app's startup both call it. */ const guardedWithBases = new WeakSet();
+/**
+ * Gives each handler a class declares itself the class-level guards of the classes it extends,
+ * as its inherited handlers have: recorded under `META.guards`, and wrapped so a direct call
+ * runs them when no other guard wraps the handler. `@Controller` calls this as it decorates, and
+ * {@link prepareDirectCalls} for every class an app runs, a service included. Once per class.
+ */ function guardOwnHandlersWithBaseGuards(target) {
+    if (guardedWithBases.has(target)) return;
+    guardedWithBases.add(target);
+    const prototype = target.prototype;
+    for (const methodName of handlerMethods$1(prototype)){
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+        // Inherited handlers have the chain of the class that declares them
+        if (typeof descriptor?.value !== 'function' || Reflect.getOwnMetadata(controller_decorator.META.inheritedFrom, prototype, methodName)) continue;
+        // Base first, as dispatch runs them
+        const guards = classChain(prototype, prototype).slice(1).reverse().flatMap(classLevelGuards);
+        if (guards.length === 0) continue;
+        if (!Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, prototype, methodName)) {
+            applyGuards(descriptor, prototype, methodName);
+            Object.defineProperty(prototype, methodName, descriptor);
+        }
+        recordGuards(controller_decorator.META.inheritedGuards, guards, prototype, methodName);
+    }
+}
 /** The container that made each instance, so a direct call runs in its own app or testing module. */ const instanceContainers = new WeakMap();
 /**
- * Records each instance `container` makes of `classes` as its own. Two testing modules made from one class each run a
- * direct call on their own instance in themselves, where the class's metadata names only the last.
- */ function recordInstanceContainers(container, classes) {
+ * Readies direct calls to the handlers of the classes an app or testing module runs, controllers and services alike:
+ * - stamps each class with the container, and records each instance the container makes as its own, so two testing
+ *   modules made from one class each run a direct call on their own instance in themselves;
+ * - gives each handler a class declares itself the class-level guards of the classes it extends, and wraps each
+ *   override of a guarded handler, so a direct call to it runs the guards it inherits before its body.
+ */ function prepareDirectCalls(container, classes) {
     for (const cls of classes){
+        Reflect.defineMetadata(controller_decorator.META.container, container, cls);
+        // Each class on the chain, base first, so an override above the one the app runs is wrapped too
+        for (const owner of classesOf(cls).reverse())guardOwnHandlersWithBaseGuards(owner);
+        wrapGuardedOverrides(cls.prototype);
         container.onActivation(cls, (_context, instance)=>{
             if (typeof instance === 'object' && instance !== null) instanceContainers.set(instance, container);
             return instance;
         });
     }
 }
+/** `cls` and the classes it extends, innermost first. */ function classesOf(cls) {
+    const classes = [];
+    for(let current = cls.prototype; current && current !== Object.prototype; current = Object.getPrototypeOf(current)){
+        classes.push(current.constructor);
+    }
+    return classes;
+}
+/** Wraps each method on the chain that overrides a handler a base method guards and is not wrapped itself. */ function wrapGuardedOverrides(prototype) {
+    for (const methodName of handlerMethods$1(prototype)){
+        let guardedBelow = false;
+        for (const owner of stageOwners(prototype, methodName)){
+            const descriptor = Object.getOwnPropertyDescriptor(owner, methodName);
+            if (guardedBelow && typeof descriptor?.value === 'function' && !Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, owner, methodName)) {
+                applyGuards(descriptor, owner, methodName);
+                Object.defineProperty(owner, methodName, descriptor);
+            }
+            if ((Reflect.getOwnMetadata(controller_decorator.META.methodGuards, owner, methodName) ?? []).length > 0) guardedBelow = true;
+        }
+    }
+}
+/**
+ * Wraps a method so a direct call runs its guards first: the wrapper entered first runs the whole
+ * chain dispatch resolves for the handler, and lets the ones inside it through. A call from dispatch,
+ * which has already run the guards, passes through every wrapper.
+ */ function applyGuards(descriptor, prototype, propertyKey) {
+    const originalMethod = descriptor.value;
+    // Which wrapper a call has passed, so it passes each once
+    const wrapper = {};
+    descriptor.value = controller_decorator.wrapsMethod(async function(...args) {
+        if (takeGuardedPass(wrapper, args[0], this, propertyKey)) return originalMethod.apply(this, args);
+        return runDirectCall(this, propertyKey, args, ()=>originalMethod.apply(this, args), wrapper);
+    }, originalMethod);
+    const wrappers = Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, prototype, propertyKey) ?? 0;
+    Reflect.defineMetadata(controller_decorator.META.guardWrappers, wrappers + 1, prototype, propertyKey);
+}
 /**
- * Runs a direct call to a guarded handler: the handler's guards, as dispatch resolves them, then the
- * call with a pass for each wrapper inside the one entered, so no guard runs twice.
- */ async function runDirectCall(instance, methodName, args, call) {
+ * Runs a direct call to a guarded handler: the handler's guards, as dispatch resolves and types them, then
+ * the call with a pass every wrapper inside the one entered takes, so no guard runs twice.
+ */ async function runDirectCall(instance, methodName, args, call, wrapper) {
     const prototype = Object.getPrototypeOf(instance);
     const controller = instance.constructor;
     // The container that made the instance, or else the app that made the class or a class it extends: a subclass the
@@ -530,48 +664,30 @@ const wrapperCount = perHandler((prototype, methodName)=>{
     if (!container) {
         throw new Error(`${controller.name}.${methodName}: @UseGuard runs its guards through the app that made ${controller.name}, and this ` + `instance was made outside one. Inject ${controller.name}, or call it on an instance the app made.`);
     }
+    const type = directCallType(prototype, methodName);
     if (!await runGuards(handlerGuards(prototype, methodName), {
         container,
         controller,
         methodName,
-        args
+        args,
+        type
     })) return undefined;
-    const inner = wrapperCount(prototype, methodName) - 1;
-    if (inner <= 0) return call();
-    const key = markKey(args[0], instance);
-    let marks = dispatched.get(key);
-    if (!marks) dispatched.set(key, marks = new Map());
-    marks.set(methodName, inner);
-    try {
-        return await call();
-    } finally{
-        marks.delete(methodName);
-    }
+    return runWithPass(instance, methodName, args, call, wrapper);
 }
 /**
- * Calls a handler dispatch has already guarded. Its wrappers let this one call through; the passes
- * are removed afterwards, so a later direct call with the same (cached) object runs its guards.
+ * Calls a handler dispatch has already guarded. Its wrappers let this one call through; the pass
+ * closes afterwards, so a later direct call with the same (cached) object runs its guards.
  */ async function callGuardedHandler(instance, methodName, args) {
-    const count = wrapperCount(Object.getPrototypeOf(instance), methodName);
-    if (count === 0) return instance[methodName](...args);
-    const key = markKey(args[0], instance);
-    let marks = dispatched.get(key);
-    if (!marks) dispatched.set(key, marks = new Map());
-    marks.set(methodName, count);
-    try {
-        return await instance[methodName](...args);
-    } finally{
-        marks.delete(methodName);
-    }
+    if (!isWrapped(Object.getPrototypeOf(instance), methodName)) return instance[methodName](...args);
+    return runWithPass(instance, methodName, args, ()=>instance[methodName](...args));
 }
 
-/** The cooldowns on a handler: each class's, base first, then the method's. */ const handlerCooldowns = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    if (!source) return [];
+/** The cooldowns on a handler: each class's, base first, then the method's and its overrides', base first. */ const handlerCooldowns = perHandler((prototype, methodName)=>{
+    if (!sourcePrototype(prototype, methodName)) return [];
     return [
         // Base first, as guards run
         ...stageClasses(prototype, methodName).flatMap((cls)=>Reflect.getOwnMetadata(controller_decorator.META.classCooldowns, cls) ?? []),
-        ...Reflect.getOwnMetadata(controller_decorator.META.methodCooldowns, source, methodName) ?? []
+        ...methodCooldowns(prototype, methodName)
     ];
 });
 /** The counted cooldowns of each list {@link handlerCooldowns} gives, which is the same for a handler. */ const countedCooldowns = new WeakMap();
@@ -612,9 +728,8 @@ const wrapperCount = perHandler((prototype, methodName)=>{
     }
     return counted;
 }
-/** The cooldowns declared on a method itself. */ function methodCooldowns(prototype, methodName) {
-    const source = sourcePrototype(prototype, methodName);
-    return source ? Reflect.getOwnMetadata(controller_decorator.META.methodCooldowns, source, methodName) ?? [] : [];
+/** The cooldowns declared on a method itself and on the methods it overrides, base first. */ function methodCooldowns(prototype, methodName) {
+    return methodStages(prototype, methodName, controller_decorator.META.methodCooldowns);
 }
 /** Who and where a call came from: an interaction's or a message's user, server and channel. */ function caller(first) {
     if (first instanceof discord_js.BaseInteraction) return {
@@ -651,7 +766,7 @@ const DEFAULT_POLICY = {
 /** The app's cooldown policy, else refusing calls after a second without an answer. */ function cooldownPolicyOf(container) {
     return container.isBound(COOLDOWN_POLICY) ? container.get(COOLDOWN_POLICY) : DEFAULT_POLICY;
 }
-const logger$3 = new controller_decorator.Logger('Cooldown');
+const logger$4 = new controller_decorator.Logger('Cooldown');
 /**
  * How long after its last failure a store must answer for its outage to end. A store that fails some calls and answers
  * others, as a cluster with one node down does, stays in one outage rather than starting a new one with each failure.
@@ -672,15 +787,15 @@ const logger$3 = new controller_decorator.Logger('Cooldown');
     });
     const name = store.constructor.name;
     const reason = error.timedOut ? `did not answer within ${timeoutMs} ms` : `failed: ${String(error.cause?.message ?? error.cause)}`;
-    if (failure === 'allow') logger$3.warn(`The cooldown store ${name} ${reason}. Calls run uncounted until it answers again.`);
-    else logger$3.error(`The cooldown store ${name} ${reason}. Calls with a cooldown are refused until it answers again.`, error.cause ?? '');
+    if (failure === 'allow') logger$4.warn(`The cooldown store ${name} ${reason}. Calls run uncounted until it answers again.`);
+    else logger$4.error(`The cooldown store ${name} ${reason}. Calls with a cooldown are refused until it answers again.`, error.cause ?? '');
 }
 /** Logs that a store answers again, once it has gone {@link OUTAGE_QUIET_MS} without a failure. */ function reportRecovery(store) {
     const outage = outages.get(store);
     if (!outage || Date.now() - outage.last < OUTAGE_QUIET_MS) return;
     outages.delete(store);
     const seconds = Math.round((outage.last - outage.since) / 1000);
-    logger$3.log(`The cooldown store ${store.constructor.name} answers again, after ${outage.failures} failed call(s) over ${seconds}s.`);
+    logger$4.log(`The cooldown store ${store.constructor.name} answers again, after ${outage.failures} failed call(s) over ${seconds}s.`);
 }
 /** What a container's calls wait for before asking its store: the store's own `onReady`, which may connect it. */ const storesReady = new WeakMap();
 /** The store operations a container's calls have under way, which its store's `onShutdown` waits for. */ const storeOperations = new WeakMap();
@@ -742,7 +857,7 @@ const logger$3 = new controller_decorator.Logger('Cooldown');
     } catch (error) {
         if (error instanceof controller_decorator.CooldownStoreError && error.timedOut && !peek && !keepLate) {
             // Under way from now, so the store does not shut down before the call it counted is given back
-            const release = attempt.then((verdict)=>verdict.allowed ? verdict.release?.() : undefined).catch((failure)=>logger$3.debug(`Could not release a call the cooldown store counted too late: ${String(failure)}`));
+            const release = attempt.then((verdict)=>verdict.allowed ? verdict.release?.() : undefined).catch((failure)=>logger$4.debug(`Could not release a call the cooldown store counted too late: ${String(failure)}`));
             trackStoreOperation(container, release);
         }
         throw error instanceof controller_decorator.CooldownStoreError ? error : new controller_decorator.CooldownStoreError(error, false);
@@ -885,7 +1000,7 @@ const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[
     try {
         return (await askWithin(container, cooldownStoreOf(container), notices, cooldownPolicyOf(container).timeoutMs, false)).allowed;
     } catch (error) {
-        logger$3.debug(`Could not ask the cooldown store whether to tell a refused caller: ${String(error.cause ?? error)}`);
+        logger$4.debug(`Could not ask the cooldown store whether to tell a refused caller: ${String(error.cause ?? error)}`);
         return false;
     }
 }
@@ -1059,6 +1174,7 @@ function describeLength(value) {
                 if (existing === undefined) {
                     const name = typeof body.name === 'string' ? body.name : commandName;
                     unlocalizable.push(...localizationProblems(name, body));
+                    const builderName = builderClass?.name;
                     byKey.set(key, {
                         builderClass: builderClass ?? builder,
                         command: {
@@ -1066,6 +1182,9 @@ function describeLength(value) {
                             body,
                             ...guilds && {
                                 guilds
+                            },
+                            ...typeof builderName === 'string' && builderName && {
+                                builder: builderName
                             }
                         }
                     });
@@ -1103,6 +1222,14 @@ const scopeKey = (scope)=>scope === 'global' ? 'global' : `guild-${scope.guild}`
 }
 /** Whether a command is an activity's primary entry point, which Discord takes only globally. */ const isEntryPoint = (command)=>command.body.type === discord_js.ApplicationCommandType.PrimaryEntryPoint;
 /** What a blank guild to register every command to says, as an unset variable gives one. */ const BLANK_GUILD = 'No commands were registered: the guild to register to is blank. Give a guild id, or leave it out to register where commands.* says.';
+/**
+ * Names every command whose builder lists guilds but no guild id, each with its builder, and says the run registers
+ * none of them yet still succeeds.
+ */ function blankGuildsWarning(commands) {
+    const one = commands.length === 1;
+    const lines = commands.map((command)=>`  ${command.builder ? `${command.builder}: ` : ''}"${command.name}"`);
+    return `${commands.length} ${one ? 'command is' : 'commands are'} not registered: ${one ? 'its builder lists' : 'their builders list'} ` + 'no guild ids, as when the variable holding them is unset.\n' + `${lines.join('\n')}\n` + 'Set the guild ids; a builder without guilds registers where commands.* says. `meocord register` still exits 0 for ' + 'these; the next major version (5.0) exits 1.';
+}
 /**
  * Where each command is sent: one bulk update per scope. A scope's update replaces everything the application has
  * there, so the default scope is included even when it ends up empty, unless `commands.guilds` lists no guild id.
@@ -1146,6 +1273,7 @@ const scopeKey = (scope)=>scope === 'global' ? 'global' : `guild-${scope.guild}`
         guild
     });
     const unregistered = [];
+    const blankGuilds = [];
     for (const command of commands){
         if (isEntryPoint(command)) {
             if (command.guilds) {
@@ -1155,7 +1283,7 @@ const scopeKey = (scope)=>scope === 'global' ? 'global' : `guild-${scope.guild}`
         } else if (command.guilds) {
             const own = ids(command.guilds);
             // Falling back to the default scope could publish a staff-only command everywhere.
-            if (own.length === 0) logger.warn(`Command "${command.name}" lists no guild ids in its builder, so it is not registered.`);
+            if (own.length === 0) blankGuilds.push(command);
             for (const guild of own)add({
                 guild
             }, command);
@@ -1169,6 +1297,7 @@ const scopeKey = (scope)=>scope === 'global' ? 'global' : `guild-${scope.guild}`
             }, command);
         }
     }
+    if (blankGuilds.length > 0) logger.warn(blankGuildsWarning(blankGuilds));
     if (nowhere) {
         const outcome = unregistered.length === 0 ? targets.has('global') ? 'only the entry point command is registered globally' : 'nothing is registered globally' : `${unregistered.join(', ')} ${unregistered.length === 1 ? 'is' : 'are'} not registered, rather than registered globally`;
         logger.warn(`commands.guilds lists no guild id, as an unset environment variable leaves it, so ${outcome}. ` + `Set the guild ids, or remove commands.guilds to register globally.`);
@@ -1379,10 +1508,7 @@ function logRegistered(target, logger) {
 
 /** How long `@Defer({ mode: 'auto' })` waits for an answer by default. */ const AUTO_DEFER_AFTER_MS = 1500;
 /** The latest `'auto'` acknowledges, counted from the interaction's creation: Discord allows three seconds. */ const AUTO_DEFER_LIMIT_MS = 2500;
-/** The `@Defer` options of a handler, read where the handler is declared. */ const handlerDefer = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    return source ? Reflect.getOwnMetadata(controller_decorator.META.deferOptions, source, methodName) : undefined;
-});
+/** The `@Defer` options of a handler: its own, or else those of the nearest method it overrides that has them. */ const handlerDefer = perHandler((prototype, methodName)=>nearestMethodStage(prototype, methodName, controller_decorator.META.deferOptions));
 /** The kind of non-interaction handler a method is, if any: `@Defer` cannot apply to one. */ function nonInteractionHandler(prototype, methodName) {
     if (controller_decorator.getMessageHandlers(prototype).some((handler)=>handler.method === methodName)) return 'message';
     if (controller_decorator.getReactionHandlers(prototype).some((handler)=>handler.method === methodName)) return 'reaction';
@@ -1439,21 +1565,8 @@ function logRegistered(target, logger) {
  */ function isAppClassToken(token) {
     return typeof token === 'function' && token !== discord_js.Client && !NATIVE_SOURCE$1.test(Function.prototype.toString.call(token));
 }
-/**
- * The bound classes `cls` injects, by constructor type or `@inject` token: the classes whose hooks
- * run before its own.
- */ function lifecycleDependencies(container, cls) {
-    return injectedTokens(cls).filter((token)=>isAppClassToken(token) && container.isBound(token));
-}
-/** The units for a list of classes already in dependency order, as the app runs them without providers. */ function classUnits(container, classes) {
-    return classes.map((cls)=>({
-            token: cls,
-            name: cls.name,
-            dependencies: lifecycleDependencies(container, cls)
-        }));
-}
 
-const logger$2 = new controller_decorator.Logger('Interceptor');
+const logger$3 = new controller_decorator.Logger('Interceptor');
 /** A function's source when the engine wrote it, as for a bound function, a built-in, or what `await` hands a promise. */ const NATIVE_SOURCE = /\{\s*\[native code\]\s*\}$/;
 /**
  * Whether `onRejected` is the app's own handling of a rejection, rather than an engine's step passing it on. The
@@ -1469,13 +1582,12 @@ function isInterceptorWithParams(entry) {
 }
 /**
  * The interceptors around a handler: each class's, base first, down to the controller it is dispatched on, then the
- * method's.
+ * method's and its overrides', base first.
  */ const handlerInterceptors = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    if (!source) return [];
+    if (!sourcePrototype(prototype, methodName)) return [];
     return [
         ...stageClasses(prototype, methodName).flatMap((cls)=>Reflect.getOwnMetadata(controller_decorator.META.classInterceptors, cls) ?? []),
-        ...Reflect.getOwnMetadata(controller_decorator.META.methodInterceptors, source, methodName) ?? []
+        ...methodStages(prototype, methodName, controller_decorator.META.methodInterceptors)
     ];
 });
 /** Binds `cls` and its unbound dependencies as singletons, refusing any that injects `ExecutionContext`. */ function bindShared(container, cls) {
@@ -1624,7 +1736,7 @@ function isInterceptorWithParams(entry) {
             // Once the handlers chained from it have had their turn, and those the app's code returned a promise from settled
             void taken.settled.then(()=>new Promise((resolve)=>setTimeout(resolve, 0))).then(()=>Promise.all(taken.disposing)).then(()=>{
                 if (!taken.failure || taken.caught) return;
-                logger$2.warn(`${cls.name} returned before ${context.getController().name}.${context.getHandlerName()} finished, which then threw; ` + 'nothing caught it, so the call could not report it:', taken.failure.error);
+                logger$3.warn(`${cls.name} returned before ${context.getController().name}.${context.getHandlerName()} finished, which then threw; ` + 'nothing caught it, so the call could not report it:', taken.failure.error);
             });
         }
         // Only a run left on a chain that ends unhandled is the call's; one the interceptor took on, as a timeout
@@ -1660,13 +1772,13 @@ function isInterceptorWithParams(entry) {
     ];
 }
 /** A handler's method and class filters, the classes innermost first, resolved once. */ const ownFilterLevels = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    if (!source) return {
+    if (!sourcePrototype(prototype, methodName)) return {
         method: [],
         classes: []
     };
     return {
-        method: Reflect.getOwnMetadata(controller_decorator.META.methodFilters, source, methodName) ?? [],
+        // An override's filters before those of the methods it overrides, innermost first as the classes are
+        method: stageOwners(prototype, methodName).reverse().flatMap((owner)=>Reflect.getOwnMetadata(controller_decorator.META.methodFilters, owner, methodName) ?? []),
         classes: [
             ...stageClasses(prototype, methodName)
         ].reverse().flatMap((cls)=>Reflect.getOwnMetadata(controller_decorator.META.classFilters, cls) ?? [])
@@ -1710,17 +1822,16 @@ function isPipeWithParams(entry) {
 const asList = (entries)=>Array.isArray(entries) ? entries : [
         entries
     ];
-/** The validation and pipes that run on a handler's input: `@Validate`'s first, then `@UsePipe`'s. */ const handlerInputStages = perHandler((prototype, methodName)=>{
-    const source = sourcePrototype(prototype, methodName);
-    if (!source) return {
-        pipes: []
-    };
-    const validation = Reflect.getOwnMetadata(controller_decorator.META.methodValidation, source, methodName);
+/**
+ * The validation and pipes that run on a handler's input: `@Validate`'s first, then `@UsePipe`'s. The `@Validate` is the
+ * handler's own, or else that of the nearest method it overrides that has one; `@UsePipe`'s are every one's, base first.
+ */ const handlerInputStages = perHandler((prototype, methodName)=>{
+    const validation = nearestMethodStage(prototype, methodName, controller_decorator.META.methodValidation);
     const inline = Object.entries(validation?.pipes ?? {}).flatMap(([key, entries])=>asList(entries).map((entry)=>({
                 key,
                 entry
             })));
-    const used = Reflect.getOwnMetadata(controller_decorator.META.methodPipes, source, methodName) ?? [];
+    const used = methodStages(prototype, methodName, controller_decorator.META.methodPipes);
     return {
         schema: validation?.schema,
         pipes: [
@@ -1786,7 +1897,7 @@ const asList = (entries)=>Array.isArray(entries) ? entries : [
 }
 
 /** Where a container keeps the observers its calls are reported to, in order. */ const OBSERVERS = Symbol('observers');
-const logger$1 = new controller_decorator.Logger('Observer');
+const logger$2 = 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)) {
@@ -1832,7 +1943,7 @@ function observersOf(container) {
  */ function notifyStart(container, context) {
     const pending = [];
     for (const observer of observersFor(container, context)){
-        const report = (error)=>logger$1.error(`Observer ${observer.name} threw while starting ${describeCall(context)}:`, error);
+        const report = (error)=>logger$2.error(`Observer ${observer.name} threw while starting ${describeCall(context)}:`, error);
         try {
             const instance = container.get(observer);
             if (typeof instance.onStart !== 'function') continue;
@@ -1846,8 +1957,9 @@ function observersOf(container) {
 }
 /**
  * Where an interaction's answer stands: a repliable one's `ResponseState`, and an autocomplete answered
- * or not. `undefined` for anything that is not an interaction.
+ * or not. `undefined` for anything that is not an interaction's call, an event carrying one included.
  */ function responsePhaseOf(context) {
+    if (context.getType() === 'event') return undefined;
     const interaction = context.getInteraction();
     if (!interaction) return undefined;
     if (interaction.isAutocomplete()) return interaction.responded ? 'replied' : 'unanswered';
@@ -1869,13 +1981,14 @@ function observersOf(container) {
         try {
             await container.get(observer).onSettled(context, result);
         } catch (error) {
-            logger$1.error(`Observer ${observer.name} threw while observing ${describeCall(context)}:`, error);
+            logger$2.error(`Observer ${observer.name} threw while observing ${describeCall(context)}:`, error);
         }
     }
 }
 
-/** Classes with a `@UseTheme`, on the class or one of its methods. */ const THEMED_CLASSES = new WeakSet();
-const apps = new WeakMap();
+/** Classes with a `@UseTheme`, on the class or one of its methods, from either build of this version. */ const THEMED_CLASSES = controller_decorator.shared('themedClasses', ()=>new WeakSet());
+// One per process for this meocord version, so an app started through one build finds its theme from the other
+const apps = controller_decorator.shared('appThemes', ()=>new WeakMap());
 /** The classes on `cls`'s prototype chain, itself first. */ function chainOf(cls) {
     const chain = [];
     for(let prototype = cls.prototype; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)){
@@ -1906,6 +2019,13 @@ const apps = new WeakMap();
     }
     controller_decorator.attachThemeCache(container.get(controller_decorator.ThemeCache), resolvers);
 }
+/** Counts `classes`, whose handlers are prepared once the app's providers are made, among those a theme can vary by. */ function prepareLateThemes(container, classes) {
+    const themes = apps.get(container);
+    if (!themes || themes.varies || !classes.some((cls)=>chainOf(cls).some((link)=>THEMED_CLASSES.has(link)))) return;
+    themes.varies = true;
+    // Built again on its next read, with each handler's own theme
+    themes.version = -1;
+}
 /** The app's themes, built again when the layers beneath the app's have changed. */ function current(container) {
     const themes = apps.get(container);
     if (themes && themes.version !== controller_decorator.themeLayersVersion()) {
@@ -1920,13 +2040,12 @@ const apps = new WeakMap();
 }
 /**
  * Decides whether the app's calls need a scope, again whenever the layers beneath it or the app read outside a call
- * change. They do when the handlers can differ in theme. Otherwise a call reads the theme outside a call, so it
- * needs one unless that is its own theme: when the app owns it, or when no app does and the app's theme is MeoCord's
- * defaults.
+ * change. They do when the handlers can differ in theme. Otherwise a call reads the theme outside a call, so it needs
+ * one unless its app owns that theme: another app may claim it while the call runs, and the call keeps the theme it
+ * started with.
  */ function rescope(container, themes) {
     themes.ambientVersion = controller_decorator.ambientThemeVersion();
-    const readsOwnTheme = controller_decorator.ownsAmbientTheme(container) || !controller_decorator.hasAmbientTheme() && themes.app === controller_decorator.defaultTheme();
-    themes.scoped = themes.varies || !readsOwnTheme ? themes.app : undefined;
+    themes.scoped = themes.varies || !controller_decorator.ownsAmbientTheme(container) ? themes.app : undefined;
 }
 /** The app's theme: MeoCord's defaults and the app's `@MeoCord({ theme })`, or the defaults for a container with none. */ function appTheme(container) {
     return current(container)?.app ?? controller_decorator.defaultTheme();
@@ -1944,8 +2063,10 @@ const apps = new WeakMap();
     for (const cls of stageClasses(prototype, methodName)){
         theme = controller_decorator.mergeTheme(theme, Reflect.getOwnMetadata(controller_decorator.META.classTheme, cls));
     }
-    const source = sourcePrototype(prototype, methodName);
-    if (source) theme = controller_decorator.mergeTheme(theme, Reflect.getOwnMetadata(controller_decorator.META.methodTheme, source, methodName));
+    // The method's layer over its class's, and an override's over the method it overrides
+    for (const owner of stageOwners(prototype, methodName)){
+        theme = controller_decorator.mergeTheme(theme, Reflect.getOwnMetadata(controller_decorator.META.methodTheme, owner, methodName));
+    }
     byMethod.set(methodName, theme);
     return theme;
 }
@@ -1984,7 +2105,7 @@ const apps = new WeakMap();
         ready
     };
 }
-const clientApps = new WeakMap();
+const clientApps = controller_decorator.shared('clientThemes', ()=>new WeakMap());
 /** Records which app a client's interactions come to, so an answer outside any call can find its theme. */ function registerClientTheme(client, container) {
     clientApps.set(client, container);
 }
@@ -2155,19 +2276,35 @@ const stagesByGlobals = new WeakMap();
     for (const entry of globals.filters)prepareFilter(container, entry);
     for (const controller of controllers){
         const prototype = controller.prototype;
-        for (const method of handlerMethods(prototype)){
-            const kind = handlerDefer(prototype, method) ? nonInteractionHandler(prototype, method) : undefined;
-            if (kind) {
-                controller_decorator.startupError(deferMisuseError(controller.name, method, kind));
-                continue;
-            }
-            for (const entry of handlerInterceptors(prototype, method))prepareInterceptor(container, entry);
-            for (const entry of handlerFilterLevels(prototype, method, []).flat())prepareFilter(container, entry);
-            for (const { entry } of handlerInputStages(prototype, method).pipes)preparePipe(container, entry);
-        }
+        for (const method of handlerMethods(prototype))prepareHandler(container, controller, method);
         assertInputStagesOnInteractions(controller, prototype);
     }
 }
+/**
+ * Prepares one `@On` or `@Once` handler of a class the app reaches only as something it makes, as
+ * {@link prepareHandlerStages} prepares a controller's.
+ *
+ * @returns The errors a controller's handler would be refused with; none when the handler is ready to run.
+ */ function prepareEventHandler(container, cls, method) {
+    try {
+        controller_decorator.collectStartupErrors(()=>{
+            prepareHandler(container, cls, method);
+            assertInputStages(cls, cls.prototype, method, 'event');
+        });
+        return [];
+    } catch (error) {
+        if (!controller_decorator.isRefusal(error)) throw error;
+        return controller_decorator.startupErrorsOf(error);
+    }
+}
+/** Binds what one handler's interceptors, filters and pipes need, refusing `@Defer` where it cannot apply. */ function prepareHandler(container, controller, method) {
+    const prototype = controller.prototype;
+    const kind = handlerDefer(prototype, method) ? nonInteractionHandler(prototype, method) : undefined;
+    if (kind) return controller_decorator.startupError(deferMisuseError(controller.name, method, kind));
+    for (const entry of handlerInterceptors(prototype, method))prepareInterceptor(container, entry);
+    for (const entry of handlerFilterLevels(prototype, method, []).flat())prepareFilter(container, entry);
+    for (const { entry } of handlerInputStages(prototype, method).pipes)preparePipe(container, entry);
+}
 /** Records the app's theme for the handlers of `controllers`, once the startup checks have passed: it makes the theme cache. */ function prepareThemes(container, controllers) {
     const globals = globalStagesOf(container);
     configureThemes(container, globals.theme, controllers, globals.themeFor);
@@ -2213,17 +2350,17 @@ const stagesByGlobals = new WeakMap();
                 'event'
             ])
     ];
-    for (const [method, kind] of others){
-        const { schema, pipes } = handlerInputStages(prototype, method);
-        const handler = kind === 'message' ? 'a message handler without a pattern' : `${kind === 'autocomplete' || kind === 'event' ? 'an' : 'a'} ${kind} handler`;
-        if (schema || pipes.length > 0) {
-            controller_decorator.startupError(new Error(`${controller.name}.${method}: @Validate and @UsePipe are for interaction and patterned message handlers, ` + `whose options, customId params, modal fields and pattern params they check, and this is ${handler}.`));
-            continue;
-        }
-        // A controller's own @Cooldown skips these handlers; one on the method itself is a mistake.
-        if (kind !== 'message' && methodCooldowns(prototype, method).length > 0) {
-            controller_decorator.startupError(new Error(`${controller.name}.${method}: @Cooldown is for interaction and message handlers, and this is ${handler}.`));
-        }
+    for (const [method, kind] of others)assertInputStages(controller, prototype, method, kind);
+}
+/** Refuses `@Validate` and `@UsePipe` on one handler of `kind` with no params to check, and `@Cooldown` where it never counts. */ function assertInputStages(controller, prototype, method, kind) {
+    const { schema, pipes } = handlerInputStages(prototype, method);
+    const handler = kind === 'message' ? 'a message handler without a pattern' : `${kind === 'autocomplete' || kind === 'event' ? 'an' : 'a'} ${kind} handler`;
+    if (schema || pipes.length > 0) {
+        return controller_decorator.startupError(new Error(`${controller.name}.${method}: @Validate and @UsePipe are for interaction and patterned message handlers, ` + `whose options, customId params, modal fields and pattern params they check, and this is ${handler}.`));
+    }
+    // A controller's own @Cooldown skips these handlers; one on the method itself is a mistake.
+    if (kind !== 'message' && methodCooldowns(prototype, method).length > 0) {
+        controller_decorator.startupError(new Error(`${controller.name}.${method}: @Cooldown is for interaction and message handlers, and this is ${handler}.`));
     }
 }
 /**
@@ -2251,7 +2388,7 @@ const stagesByGlobals = new WeakMap();
     if (response) result.response = response;
     return result;
 }
-const logger = new controller_decorator.Logger('ExceptionFilter');
+const logger$1 = new controller_decorator.Logger('ExceptionFilter');
 /**
  * Hands a failed call's error to the first matching filter, level by level, then to the fallback. A
  * filter that throws is logged and the fallback answers the original error; without a fallback, the
@@ -2265,7 +2402,7 @@ const logger = new controller_decorator.Logger('ExceptionFilter');
         } catch (filterError) {
             if (!fallback) throw filterError;
             const name = (typeof filter === 'object' ? filter.provide : filter).name;
-            logger.error(`Filter ${name} threw while handling an error:`, filterError);
+            logger$1.error(`Filter ${name} threw while handling an error:`, filterError);
         }
     }
     if (!fallback) throw error;
@@ -2471,6 +2608,23 @@ const logger = new controller_decorator.Logger('ExceptionFilter');
     }, options);
 }
 
+/** The longest delay a timer keeps: 2^31 - 1 ms, about 24.8 days. Node fires a longer one at once. */ const MAX_TIMER_MS = 2147483647;
+const MS_PER_SECOND = 1000;
+/** The most whole seconds a timer keeps, as a message about an option given in seconds names the limit. */ const MAX_TIMER_SECONDS = Math.floor(MAX_TIMER_MS / MS_PER_SECOND);
+/** Whether a timer keeps a delay given in seconds, a fraction of a second included. */ const timerKeepsSeconds = (seconds)=>seconds * MS_PER_SECOND <= MAX_TIMER_MS;
+/** A value as a refusal quotes it: a number as itself, `Infinity` and `NaN` included, a string in quotes. */ function quoted(value) {
+    if (typeof value === 'string') return JSON.stringify(value);
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null) return String(value);
+    return Array.isArray(value) ? 'an array' : typeof value;
+}
+/**
+ * What is wrong with a timeout option, or `undefined` when it is a number of milliseconds a timer keeps: finite, above
+ * 0, or 0 or more with `allowZero`, and at most `max`, {@link MAX_TIMER_MS} unless less. The caller names the option.
+ */ function timeoutProblem(value, { allowZero = false, max = MAX_TIMER_MS } = {}) {
+    if (typeof value === 'number' && Number.isFinite(value) && (allowZero ? value >= 0 : value > 0) && value <= max) return undefined;
+    return `must be a number of milliseconds ${allowZero ? '0 or more' : 'above 0'}, at most ${max} (got ${quoted(value)})`;
+}
+
 /** Fetches in flight for a client, by kind, server and ID, so callers asking at once share one request. */ const inFlight = new WeakMap();
 /** The one request for `key`: the one in flight, or a new one from `start`, forgotten once it settles. */ function singleFlight(client, key, start) {
     let requests = inFlight.get(client);
@@ -2682,7 +2836,8 @@ const isFlagNameChar = (code, first)=>code >= 97 && code <= 122 || code >= 65 &&
                 }
                 flags.push({
                     name,
-                    value
+                    value,
+                    at: words.length
                 });
                 cuts.push(start, j);
                 i = j;
@@ -2717,6 +2872,33 @@ const isFlagNameChar = (code, first)=>code >= 97 && code <= 122 || code >= 65 &&
     }
     return (rest + text.slice(from)).trimEnd();
 }
+const caseKey = (word, caseSensitive)=>caseSensitive ? word : word.toLowerCase();
+/** Whether a flag, given bare in place `at` among the other words, is a pattern's own `--` word `literal`. */ const isLiteralFlag = (flag, literal, at, caseSensitive)=>flag.at === at && flag.value === undefined && caseKey(`--${flag.name}`, caseSensitive) === caseKey(literal, caseSensitive);
+/**
+ * The flags a pattern's own `--` words take from a message, as indexes into `flags`: where the pattern has such a word,
+ * a flag of that name given bare in that place among the message's other words is the word, not a flag. A word typed in
+ * quotes is matched as any word is, and is taken first.
+ */ function literalFlags(tokens, caseSensitive, words, flags) {
+    const taken = new Set();
+    if (flags.length === 0) return taken;
+    let w = 0;
+    for (const token of tokens){
+        if (!('literal' in token)) {
+            // Literal words come before the optional and rest params, which a pattern ends with
+            if (token.rest || token.optional) break;
+            w++;
+            continue;
+        }
+        if (w < words.length && caseKey(words[w].value, caseSensitive) === caseKey(token.literal, caseSensitive)) {
+            w++;
+            continue;
+        }
+        const index = flags.findIndex((flag, i)=>!taken.has(i) && isLiteralFlag(flag, token.literal, w, caseSensitive));
+        if (index === -1) break;
+        taken.add(index);
+    }
+    return taken;
+}
 
 /** The ID a mention or a bare snowflake names, for the mention's kind. */ function idOf(word, mention) {
     return (mention.exec(word) ?? /^(\d{17,20})$/.exec(word))?.[1];
@@ -2724,6 +2906,10 @@ const isFlagNameChar = (code, first)=>code >= 97 && code <= 122 || code >= 65 &&
 const USER_MENTION = /^<@!?(\d{17,20})>$/;
 const ROLE_MENTION = /^<@&(\d{17,20})>$/;
 const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
+/** The server's role a word names: its mention or ID, else its name in any case. */ function roleNamed(guild, word) {
+    const id = idOf(word, ROLE_MENTION);
+    return id ? guild.roles.cache.get(id) : guild.roles.cache.find((candidate)=>candidate.name.toLowerCase() === word.toLowerCase());
+}
 /** The scalar types, each turning a word into its value or `undefined`, and the Discord ones, which resolve below. */ const BUILT_IN_TYPES = controller_decorator.lookupTable({
     string: (word)=>word,
     int: (word)=>controller_decorator.number(word, true),
@@ -2754,7 +2940,18 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
     'channel'
 ]);
 /** Whether a param type is found only in a server. */ const isGuildType = (type)=>GUILD_TYPES.has(type);
-/** Whether a route's pattern takes a param found only in a server, so a DM gets its usage instead. */ const needsGuild = (route)=>route.tokens.some((token)=>'param' in token && token.type !== undefined && GUILD_TYPES.has(token.type));
+/** Whether a route's pattern takes a `member`, `role` or `channel` param, optional or not. */ const takesGuildParam = (route)=>route.tokens.some((token)=>'param' in token && token.type !== undefined && GUILD_TYPES.has(token.type));
+/**
+ * Whether a route works only in a server, as dispatch decides it: a `member`, `role` or `channel` param, optional or
+ * not, or a required flag of one of those types. An optional flag of those types refuses a DM only when it is given.
+ */ const needsGuild = (route)=>takesGuildParam(route) || route.flags.some((flag)=>!flag.optional && flag.type !== undefined && GUILD_TYPES.has(flag.type));
+/**
+ * Where a route works: its scope, narrowed to servers by a `member`, `role` or `channel` param, or required flag, as
+ * dispatch narrows it.
+ */ function effectiveScope(route) {
+    if (route.scope !== 'any') return route.scope;
+    return needsGuild(route) ? 'guild' : 'any';
+}
 /** Whether a pattern's `{name:type}` names a type: built in, words to choose from, or one the app adds. */ function isKnownParamType(type, types) {
     return type in BUILT_IN_TYPES || Boolean(controller_decorator.choicesOf(type)) || appType(types, type) !== undefined;
 }
@@ -2834,14 +3031,7 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
  */ function assertMessageScope(route, message, start) {
     const inGuild = message.guildId !== null && message.guildId !== undefined;
     if (route.scope === 'guild' && !inGuild) {
-        throw new controller_decorator.MessageUsageError(usageOf(route, start), [
-            controller_decorator.usageIssue({
-                key: 'meocord.usage.serverOnly'
-            })
-        ], {
-            serverOnly: true,
-            quiet: start === ''
-        });
+        throw serverOnly(usageOf(route, start), start === '');
     }
     if (route.scope === 'dm' && inGuild) {
         throw new controller_decorator.MessageUsageError(usageOf(route, start), [
@@ -2854,6 +3044,15 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
         });
     }
 }
+/** The usage error for a message sent outside a server to a command, or with a flag, that only a server has. */ const serverOnly = (usage, quiet)=>new controller_decorator.MessageUsageError(usage, [
+        controller_decorator.usageIssue({
+            key: 'meocord.usage.serverOnly'
+        })
+    ], {
+        serverOnly: true,
+        quiet
+    });
+/** Whether a message gives one of a route's flags of a type only a server has, such as `--in=#general`. */ const givesGuildFlag = (route, flags)=>flags.some((given)=>route.flags.some((flag)=>flag.type !== undefined && GUILD_TYPES.has(flag.type) && caseKey(flag.flag, route.caseSensitive) === caseKey(given.name, route.caseSensitive)));
 /** Whether a value an app's `parse` returned is a ref to resolve after the guards. */ const isRef = (value)=>typeof value === 'object' && value !== null && 'cached' in value && typeof value.resolve === 'function';
 /**
  * The params a matched route's guards see, read from the words with no request to Discord: typed params and lists as
@@ -2876,18 +3075,20 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
     const issues = [];
     const items = [];
     for (const token of route.tokens){
-        if (!('param' in token) || token.type === undefined || raw[token.param] === undefined) continue;
+        // Only a word the message gave is typed: an own one, never what Object.prototype has under the param's name
+        const word = 'param' in token ? controller_decorator.ownValue(raw, token.param) : undefined;
+        if (!('param' in token) || token.type === undefined || word === undefined) continue;
         if (!token.rest) {
             items.push({
                 key: token.param,
                 label: token.param,
                 type: token.type,
-                word: raw[token.param]
+                word
             });
             continue;
         }
-        const words = splitWords(raw[token.param]);
-        params[token.param] = new Array(words.length);
+        const words = splitWords(word);
+        controller_decorator.setOwn(params, token.param, new Array(words.length));
         words.forEach(({ value }, index)=>items.push({
                 key: token.param,
                 label: token.param,
@@ -2897,19 +3098,12 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
             }));
     }
     const flagIssues = route.flags.length > 0 ? readFlags(route, message, start, params, items) : [];
+    // readFlags takes out each flag's key, so one left out whose name Object.prototype has reads as left out again
+    if (route.inheritedNames.length > 0) controller_decorator.shadowInherited(params, route.inheritedNames);
     const guild = message.guild;
-    if (!guild && (needsGuild(route) || items.some((item)=>GUILD_TYPES.has(item.type)))) {
-        throw new controller_decorator.MessageUsageError(usage, [
-            controller_decorator.usageIssue({
-                key: 'meocord.usage.serverOnly'
-            })
-        ], {
-            serverOnly: true,
-            quiet
-        });
-    }
+    if (!guild && (needsGuild(route) || items.some((item)=>GUILD_TYPES.has(item.type)))) throw serverOnly(usage, quiet);
     const put = (item, value)=>{
-        if (item.index === undefined) params[item.key] = value;
+        if (item.index === undefined) controller_decorator.setOwn(params, item.key, value);
         else params[item.key][item.index] = value;
     };
     const refs = [];
@@ -2946,8 +3140,7 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
             }
         } else if (type === 'role') {
             // Roles are cached with the Guilds intent, so a role is known here or not at all
-            const id = idOf(word, ROLE_MENTION);
-            const role = id ? guild.roles.cache.get(id) : guild.roles.cache.find((candidate)=>candidate.name.toLowerCase() === word.toLowerCase());
+            const role = roleNamed(guild, word);
             if (role) {
                 refer(item, 'role', new MessageEntityRef('role', role.id, message.client, guild));
                 continue;
@@ -2987,9 +3180,9 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
     const params = {
         ...parsed.params
     };
-    for (const [key, value] of Object.entries(params))if (Array.isArray(value)) params[key] = [
+    for (const [key, value] of Object.entries(params))if (Array.isArray(value)) controller_decorator.setOwn(params, key, [
         ...value
-    ];
+    ]);
     const issues = [];
     for (const slot of refs){
         const value = slot.ref instanceof MessageEntityRef ? found.get(slot.ref) : await slot.ref.resolve();
@@ -2997,7 +3190,7 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
             issues.push(missingEntity(slot));
             continue;
         }
-        if (slot.index === undefined) params[slot.key] = value;
+        if (slot.index === undefined) controller_decorator.setOwn(params, slot.key, value);
         else params[slot.key][slot.index] = value;
     }
     if (issues.length > 0) throw new controller_decorator.MessageUsageError(usage, issues, {
@@ -3063,7 +3256,11 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
     return {
         parseArgs: async (args)=>{
             assertMessageScope(route, message, start);
-            if (given !== undefined) throw new controller_decorator.MessageUsageError(usageOf(route, start), missingParams(route, given));
+            if (given !== undefined) {
+                // A DM to a command only a server has is told so before what its words lack, as one whose words fit is
+                if (!message.guild && (needsGuild(route) || givesGuildFlag(route, given.flags))) throw serverOnly(usageOf(route, start), start === '');
+                throw new controller_decorator.MessageUsageError(usageOf(route, start), missingParams(route, given, types, message.guild));
+            }
             if (!hasTypedParams(route)) return args;
             parsed = await parseMessageParams(route, params, message, start, types);
             return [
@@ -3114,7 +3311,11 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
     const given = new Map();
     const unknown = new Set();
     const text = (message.content ?? '').trim();
-    for (const flag of splitFlagWords(text.slice(start.length)).flags){
+    const split = splitFlagWords(text.slice(start.length));
+    // A flag the pattern's own `--` word took is that word, and neither one of its flags nor unknown
+    const literal = literalFlags(route.tokens, route.caseSensitive, split.words, split.flags);
+    for (const [index, flag] of split.flags.entries()){
+        if (literal.has(index)) continue;
         const declared = route.flags.find((candidate)=>key(candidate.flag) === key(flag.name));
         if (declared) given.set(declared.flag, flag);
         else if (!unknown.has(flag.name)) {
@@ -3140,7 +3341,7 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
                     value: controller_decorator.userWords(value)
                 }
             }, flag.flag));
-            else params[flag.flag] = on;
+            else controller_decorator.setOwn(params, flag.flag, on);
         } else if (!given.has(flag.flag)) {
             if (!flag.optional) issues.push(controller_decorator.usageIssue({
                 key: 'meocord.usage.missing',
@@ -3168,29 +3369,137 @@ const CHANNEL_MENTION = /^<#(\d{17,20})>$/;
     return issues;
 }
 /**
- * What is wrong with a command whose words a message named but whose pattern it does not fit, given how many
- * words followed the command words: each required param it left out, or words beyond what the pattern takes.
- */ function missingParams(route, given) {
-    const firstParam = route.tokens.findIndex((token)=>!('literal' in token));
-    const after = firstParam === -1 ? [] : route.tokens.slice(firstParam);
-    const missing = after.slice(given).filter((token)=>'param' in token && !token.optional).map((token)=>controller_decorator.usageIssue({
-            key: 'meocord.usage.missing',
-            params: {
-                param: token.param
+ * What is wrong with a command whose words a message named but whose pattern it does not fit, read word by word
+ * against the pattern: each word or required param it left out, a word given another in its place, else words
+ * beyond what the pattern takes, else the first word its param's built-in type does not take; and then each required
+ * flag it left out, as a message whose words fit is told. With none of those true, there are none, and the usage stands
+ * alone.
+ */ function missingParams(route, given, types, guild) {
+    const { words, flags } = given;
+    const missing = [];
+    // The flags given bare in place of the pattern's own `--` words, which are those words and set no flag
+    const literal = new Set();
+    let unfit;
+    let w = 0;
+    for (const token of route.tokens){
+        if ('literal' in token) {
+            if (w < words.length && caseKey(words[w].value, route.caseSensitive) === caseKey(token.literal, route.caseSensitive)) {
+                w++;
+                continue;
             }
-        }, token.param));
-    if (missing.length > 0) return missing;
-    return [
+            // A pattern's own `--` word given bare in its place takes no word; another word in its place is not taken
+            const word = flags.find((flag)=>!literal.has(flag) && isLiteralFlag(flag, token.literal, w, route.caseSensitive));
+            if (word) literal.add(word);
+            else missing.push(controller_decorator.usageIssue({
+                key: 'meocord.usage.missing',
+                params: {
+                    param: token.literal
+                }
+            }));
+        } else if (w === words.length) {
+            if (!token.optional) missing.push(controller_decorator.usageIssue({
+                key: 'meocord.usage.missing',
+                params: {
+                    param: token.param
+                }
+            }, token.param));
+        } else if (token.rest) {
+            w = words.length;
+        } else {
+            // Words fill the params in order, as the usage shows them
+            const word = words[w++].value;
+            const type = token.type;
+            if (!unfit && type !== undefined && isUnfit(type, word, route.caseSensitive, guild)) {
+                unfit = {
+                    key: token.param,
+                    label: token.param,
+                    type,
+                    word
+                };
+            }
+        }
+    }
+    // With none of these, the reason may be one MeoCord has no text for, as a role's name the matcher takes only as a
+    // mention or an ID
+    const reasons = missing.length > 0 ? missing : w < words.length ? [
         controller_decorator.usageIssue({
             key: 'meocord.usage.tooManyWords'
         })
+    ] : unfit ? [
+        wrongType(unfit, types)
+    ] : [];
+    // So one reply names all the message lacks, rather than the flags only once its words fit
+    const missingFlags = route.flags.filter((flag)=>flag.type !== undefined && !flag.optional && !flags.some((sent)=>!literal.has(sent) && caseKey(sent.name, route.caseSensitive) === caseKey(flag.flag, route.caseSensitive))).map((flag)=>controller_decorator.usageIssue({
+            key: 'meocord.usage.missing',
+            params: {
+                param: `--${flag.flag}`
+            }
+        }, flag.flag));
+    return [
+        ...reasons,
+        ...missingFlags
     ];
 }
+/**
+ * Whether a param of a type is known not to take a word: a built-in type or words to choose from that the word doesn't
+ * fit. A role is also found by its name, so only a word that names none of the server's roles is unfit.
+ */ function isUnfit(type, word, caseSensitive, guild) {
+    if (type === 'role') return guild !== null && roleNamed(guild, word) === undefined;
+    return (type in BUILT_IN_TYPES || Boolean(controller_decorator.choicesOf(type))) && !fitsParamType(type, word, caseSensitive);
+}
 /** Whether a route's params need resolving: it declares a type for one, or has flags. */ const hasTypedParams = (route)=>route.flags.length > 0 || route.tokens.some((token)=>'param' in token && token.type !== undefined);
 
+const logger = new controller_decorator.Logger('MeoCord');
 /** Whether a route's scope lets it run where the message was sent. */ const fitsScope = (scope, inGuild)=>inGuild === undefined || scope === 'any' || scope === 'guild' === inGuild;
 const PARAM = /^\{(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\.\.\.)?(\?)?\}$/;
 const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
+/**
+ * A whole brace pair that PARAM or FLAG refused, read loosely to tell its name from its type: anything up to `:` or `}`,
+ * then the marks a param ends with, `...` and `?`, wherever they were written.
+ */ const LOOSE_FLAG = /^\{--([^:}]*?)(?::([^}]*?))?(\.\.\.)?(\?)?\}$/;
+const LOOSE_PARAM = /^\{([^:}]*?)(?::([^}]*?))?(\.\.\.)?(\?)?\}$/;
+/** A name or type with marks after it, as one written out of order carries them. */ const MARKED = /^(.*?)((?:\.\.\.|\?)+)$/;
+/** A param's name, and a flag's, which also starts with a letter, as a message could not give it otherwise. */ const PARAM_NAME = /^\w+$/;
+const FLAG_NAME = /^[A-Za-z]\w*$/;
+/** A param as its pattern writes it, which the grammar spells only one way. */ const writtenParam = (token)=>`{${token.param}${token.type ? `:${token.type}` : ''}${token.rest ? '...' : ''}${token.optional ? '?' : ''}}`;
+/** A flag as its pattern writes it. */ const writtenFlag = (flag)=>`{--${flag.flag}${flag.type ? `:${flag.type}` : ''}${flag.optional ? '?' : ''}}`;
+/**
+ * Why a word with a brace in it is no param or flag: text around its braces, or a whole pair whose name, type or marks
+ * the syntax doesn't take. Each names the rule broken, with the word mended as an example.
+ */ function notAParam(word) {
+    const flag = LOOSE_FLAG.exec(word);
+    if (flag) {
+        const [, name, type, rest] = flag;
+        if (rest || word.includes('...')) {
+            return `"${word}" is not a flag: a flag doesn't take the rest of the message; a param does, such as {${mended(unmarked(name), 'param')}...}.`;
+        }
+        if (unmarked(name) !== name || type !== undefined && unmarked(type) !== type) {
+            const typed = type === undefined ? '' : `:${unmarked(type)}`;
+            return `"${word}" is not a flag: its ? goes last, as in {--${unmarked(name)}${typed}?}.`;
+        }
+        if (!FLAG_NAME.test(name)) {
+            return `"${word}" is not a flag: a flag's name starts with a letter, then letters, digits or _, such as {--${mended(name, 'flag')}}.`;
+        }
+        return `"${word}" is not a flag: a type is a name, or words to choose from joined by |, such as {--${name}:on|off}.`;
+    }
+    const param = LOOSE_PARAM.exec(word);
+    if (param) {
+        const [, name, type] = param;
+        if (unmarked(name) !== name || type !== undefined && unmarked(type) !== type) {
+            const typed = type === undefined ? '' : `:${unmarked(type)}`;
+            const ordered = `{${unmarked(name)}${typed}${word.includes('...') ? '...' : ''}${word.includes('?') ? '?' : ''}}`;
+            return `"${word}" is not a param: its marks go last, ... then ?, as in ${ordered}.`;
+        }
+        if (!PARAM_NAME.test(name)) return `"${word}" is not a param: a param's name is ASCII letters, digits and _, such as {${mended(name, 'param')}}.`;
+        return `"${word}" is not a param: a type is a name, or words to choose from joined by |, such as {${name}:on|off}.`;
+    }
+    return `"${word}" is not a param: a param is a whole word, such as {name}, {name:type}, {name...}, {name?} or a flag, {--name}.`;
+}
+/** A name or type without the marks written after it, `...` and `?`. */ const unmarked = (text)=>MARKED.exec(text)?.[1] ?? text;
+/** A name with each character the syntax doesn't take as `_`, and a flag's led by a letter, for an example. */ function mended(name, kind) {
+    const word = name.replace(/\W/g, '_') || kind;
+    return kind === 'flag' && !/^[A-Za-z]/.test(word) ? `flag${word}` : word;
+}
 /**
  * Reads a pattern into its words and flags. Throws for a pattern of flags alone, a param that is not a whole word, a
  * name given twice, a rest param that is not last, a word after an optional param that is not optional too, an untyped
@@ -3226,9 +3535,7 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
     words.forEach((word, index)=>{
         const match = PARAM.exec(word);
         if (!match) {
-            if (/[{}]/.test(word)) {
-                throw new Error(`"${word}" is not a param: a param is a whole word, such as {name}, {name:type}, {name...}, {name?} or a flag, {--name}.`);
-            }
+            if (/[{}]/.test(word)) throw new Error(notAParam(word));
             tokens.push({
                 literal: word
             });
@@ -3251,7 +3558,7 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
         const next = tokens[index + 1];
         if (!('param' in token) || !token.optional || !next) return;
         if (!('param' in next) || !next.optional) {
-            throw new Error(`{${token.param}?} is optional, so only optional params may follow it; "${'param' in next ? `{${next.param}}` : next.literal}" is not.`);
+            throw new Error(`${writtenParam(token)} is optional, so only optional params may follow it; "${'param' in next ? writtenParam(next) : next.literal}" is not.`);
         }
         if (token.type === undefined || token.type === 'string') {
             throw new Error(`{${token.param}${token.type ? ':string' : ''}?} comes before another optional param, so it needs a type that tells its words ` + `from the next param's, such as {${token.param}:int?}: as text, it would take every word.`);
@@ -3264,10 +3571,15 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
         rest: params.some((token)=>token.rest),
         optional: params.some((token)=>token.optional)
     });
+    const inheritedNames = [
+        ...params.map((token)=>token.param),
+        ...flags.map((flag)=>flag.flag)
+    ].filter((name)=>name in Object.prototype);
     return {
         tokens,
         flags,
-        specificity
+        specificity,
+        inheritedNames
     };
 }
 /** A prefix setting as a list, where `''` stands for none. */ function prefixList(prefix) {
@@ -3318,7 +3630,20 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
         ...mention
     ]);
 }
-/** Whether two routes accept some of the same messages: a start they share, and words that match alike. */ function sameMessages(a, b, options) {
+/** Where two routes of equal rank and shape part: the one with a required param where the other has an optional one comes first. */ function compareOptional(a, b) {
+    for(let i = 0; i < Math.min(a.length, b.length); i++){
+        const [aToken, bToken] = [
+            a[i],
+            b[i]
+        ];
+        if ('param' in aToken && 'param' in bToken && aToken.optional !== bToken.optional) return aToken.optional ? 1 : -1;
+    }
+    return 0;
+}
+/**
+ * Whether two routes accept some of the same messages: a start they share, and words that match alike. `'optional'`
+ * when they do only because a required param and an optional one, in one position, both take a word there.
+ */ function sameMessages(a, b, options) {
     // A case-insensitive word matches every message the case-sensitive one does
     const exact = a.caseSensitive && b.caseSensitive;
     const key = (start)=>typeof start === 'string' && !exact ? start.toLowerCase() : start;
@@ -3336,13 +3661,55 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
         ].some((start)=>theirs.has(key(start)));
     });
     if (!startAlike || a.tokens.length !== b.tokens.length) return false;
-    return a.tokens.every((token, i)=>{
+    let byOptional = false;
+    const alike = a.tokens.every((token, i)=>{
         const other = b.tokens[i];
         if ('literal' in token) {
             return 'literal' in other && (exact ? token.literal === other.literal : token.literal.toLowerCase() === other.literal.toLowerCase());
         }
-        return 'param' in other && token.rest === other.rest && token.optional === other.optional;
+        if (!('param' in other) || token.rest !== other.rest) return false;
+        if (token.optional !== other.optional) byOptional = true;
+        return true;
     });
+    return alike && (byOptional ? 'optional' : true);
+}
+/** What a static empty prefix list does now, which a prefix function's `[]` doesn't: take messages as they are. */ const EMPTY_PREFIX_LIST = "`[]` takes messages as they are, with no prefix; write `''` for that";
+/**
+ * The warnings for message handlers a bot starts with today though a message can't reach them as written, each once,
+ * for the app or the handler: a static empty prefix list, which takes messages as they are, where a prefix function's
+ * `[]` starts no command; and two flags of a command that reads flags in any case whose names differ only in case, the
+ * second of which is never set. The next major version (5.0) changes the first and refuses the second.
+ */ function messageRouteWarnings(routes, options) {
+    const warnings = [];
+    if (Array.isArray(options.prefix) && options.prefix.length === 0) {
+        warnings.push(`@MeoCord({ messages: { prefix: [] } }): ${EMPTY_PREFIX_LIST}. In the next major version (5.0), \`[]\` starts no command, ` + "as a prefix function's `[]` does.");
+    }
+    const seen = new Map();
+    for (const route of routes){
+        // A handler's aliases share its options and flags, so each is read once; one method can carry several handlers
+        const pattern = route.aliasOf ?? route.pattern;
+        const methods = seen.get(route.controllerClass) ?? seen.set(route.controllerClass, new Map()).get(route.controllerClass);
+        const patterns = methods.get(route.method) ?? methods.set(route.method, new Set()).get(route.method);
+        if (patterns.has(pattern)) continue;
+        patterns.add(pattern);
+        const handler = `${route.controllerClass.name}.${route.method}: @MessageHandler('${pattern}'`;
+        const own = controller_decorator.getMessageHandlers(route.controllerClass.prototype).find((candidate)=>candidate.method === route.method && candidate.pattern === pattern)?.options;
+        if (Array.isArray(own?.prefix) && own.prefix.length === 0) {
+            warnings.push(`${handler}, { prefix: [] }): ${EMPTY_PREFIX_LIST}, or \`false\` for no prefix and no mention. In the next major ` + 'version (5.0), `[]` starts no command.');
+        }
+        if (route.caseSensitive) continue;
+        const first = new Map();
+        for (const flag of route.flags){
+            const same = first.get(flag.flag.toLowerCase());
+            if (!same) {
+                first.set(flag.flag.toLowerCase(), flag);
+                continue;
+            }
+            warnings.push(`${handler}): ${writtenFlag(same)} and ${writtenFlag(flag)} differ only in case, and this command reads flags in any ` + `case, so --${flag.flag} always sets ${writtenFlag(same)} and ${writtenFlag(flag)} is never set. Rename one, or set ` + 'caseSensitive: true. The next major version (5.0) refuses this.');
+            break;
+        }
+    }
+    return warnings;
 }
 /**
  * Every patterned message handler of the given controllers, most specific first, read from metadata
@@ -3411,14 +3778,21 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
             });
         }
     }
-    routes.sort((a, b)=>b.specificity - a.specificity || compareShapes(a.tokens, b.tokens) || Number(takesAppStart(a)) - Number(takesAppStart(b)));
+    routes.sort((a, b)=>b.specificity - a.specificity || compareShapes(a.tokens, b.tokens) || compareOptional(a.tokens, b.tokens) || Number(takesAppStart(a)) - Number(takesAppStart(b)));
     for(let i = 0; i < routes.length; i++){
         for(let j = i + 1; j < routes.length; j++){
             const [a, b] = [
                 routes[i],
                 routes[j]
             ];
-            if (!sameMessages(a, b, options)) continue;
+            const same = sameMessages(a, b, options);
+            if (!same) continue;
+            // Ranked by their params, so the same one answers whatever the order; 5.0 refuses these as it does the rest
+            if (same === 'optional') {
+                if (a.controllerClass === b.controllerClass && a.method === b.method) continue;
+                controller_decorator.warnOnce(logger, `${a.controllerClass.name}.${a.method}: ${describeRoute(a)} and ${describeRoute(b)} in ${b.controllerClass.name}.${b.method} can ` + `take the same messages, as one takes a word where the other has an optional param; ${a.controllerClass.name}.${a.method} ` + 'answers those. Change one pattern, or give one its own prefix. The next major version (5.0) stops the bot at startup for these.');
+                continue;
+            }
             // One handler under two spellings, such as 'hello' and 'Hello', is one route, its pattern's over an alias's
             if (a.controllerClass === b.controllerClass && a.method === b.method) {
                 if (a.aliasOf && !b.aliasOf) routes[i] = b;
@@ -3463,7 +3837,7 @@ const FLAG = /^\{--(\w+)(?::([\w-]+(?:\|[\w-]+)*))?(\?)?\}$/;
     if (scope !== 'dm') return;
     const param = tokens.find((token)=>'param' in token && token.type !== undefined && isGuildType(token.type));
     const flag = flags.find((candidate)=>candidate.type !== undefined && isGuildType(candidate.type));
-    const shown = param ? `{${param.param}:${param.type}}` : flag && `{--${flag.flag}:${flag.type}}`;
+    const shown = param ? writtenParam(param) : flag && writtenFlag(flag);
     if (shown) throw new Error(`scope is 'dm', but ${shown} is found only in a server.`);
 }
 /** Refuses a handler's `mention` other than `'only'`. */ function assertMention({ mention }) {
@@ -3575,11 +3949,11 @@ const trieNode = ()=>({
     for(let t = 0; t < tail.length && w < words.length; t++){
         const token = tail[t];
         if (token.rest) {
-            params[token.param] = restFrom(text, words[w].start, cuts);
+            controller_decorator.setOwn(params, token.param, restFrom(text, words[w].start, cuts));
             return params;
         }
         if (t < tail.length - 1 && !fitsParamType(token.type, words[w].value, caseSensitive)) continue;
-        params[token.param] = words[w++].value;
+        controller_decorator.setOwn(params, token.param, words[w++].value);
     }
     return w === words.length ? params : undefined;
 }
@@ -3624,9 +3998,12 @@ const wordKey = (word, caseSensitive)=>caseSensitive ? word : word.toLowerCase()
                 return;
             }
             if ('literal' in token) {
+                var _node1;
                 const key = wordKey(token.literal, route.caseSensitive);
                 let next = node.words.get(key);
                 if (!next) node.words.set(key, next = trieNode());
+                // Such a word typed bare is taken out as a flag before the words are walked, so it is matched as one too
+                if (route.flags.length > 0 && token.literal.startsWith('--')) ((_node1 = node).flagWords ?? (_node1.flagWords = new Map())).set(key, next);
                 node = next;
                 continue;
             }
@@ -3645,6 +4022,8 @@ const wordKey = (word, caseSensitive)=>caseSensitive ? word : word.toLowerCase()
     ];
     for (const group of all){
         const flagged = group.flagged;
+        // A pattern's own leading `--` word stays reachable there: given bare, it is taken out as a flag, so the message
+        // seems to start with one
         if (flagged) group.flaggedAfterFlag = {
             ...flagged,
             words: new Map()
@@ -3685,7 +4064,16 @@ const wordKey = (word, caseSensitive)=>caseSensitive ? word : word.toLowerCase()
     if (first === undefined || node.param || node.rests.length > 0 || node.tails.length > 0 || node.ends.length > 0) return true;
     return node.words.has(first);
 }
-/** The ranks of every route the words reach from `node`. Each node sits at one word depth, so each is visited once. */ function reach(node, words, i, text, cuts, caseSensitive, found) {
+/**
+ * The ranks of every route the words reach from `node`. A pattern's own `--` word is reached by that word, or by a flag
+ * of its name given bare in its place, which takes no word.
+ */ function reach(node, words, i, text, cuts, caseSensitive, flags, found) {
+    if (node.flagWords) {
+        for (const flag of flags){
+            const next = flag.at === i && flag.value === undefined ? node.flagWords.get(wordKey(`--${flag.name}`, caseSensitive)) : undefined;
+            if (next) reach(next, words, i, text, cuts, caseSensitive, flags, found);
+        }
+    }
     for (const tail of node.tails)if (assignTail(tail.tokens, words, i, text, cuts, caseSensitive)) found.push(tail.rank);
     if (i === words.length) {
         for (const rank of node.ends)found.push(rank);
@@ -3693,22 +4081,34 @@ const wordKey = (word, caseSensitive)=>caseSensitive ? word : word.toLowerCase()
     }
     for (const rank of node.rests)found.push(rank);
     const next = node.words.get(wordKey(words[i].value, caseSensitive));
-    if (next) reach(next, words, i + 1, text, cuts, caseSensitive, found);
-    if (node.param) reach(node.param, words, i + 1, text, cuts, caseSensitive, found);
+    if (next) reach(next, words, i + 1, text, cuts, caseSensitive, flags, found);
+    if (node.param) reach(node.param, words, i + 1, text, cuts, caseSensitive, flags, found);
 }
-/** The params a route's words capture, given words its pattern is known to match. */ function paramsOf$1(route, words, text, cuts) {
+/**
+ * The params a route's words capture, given words its pattern is known to match. A pattern's own `--` word that the
+ * message gave as a flag, one of `taken`, takes no word.
+ */ function paramsOf$1(route, words, text, cuts, taken) {
     const tail = tailStart(route.tokens);
-    const params = tail === -1 ? {} : assignTail(route.tokens.slice(tail), words, tail, text, cuts, route.caseSensitive);
-    for(let i = 0; i < (tail === -1 ? route.tokens.length : tail) && i < words.length; i++){
+    const params = {};
+    let left = taken;
+    let w = 0;
+    for(let i = 0; i < (tail === -1 ? route.tokens.length : tail) && w < words.length; i++){
         const token = route.tokens[i];
-        if ('literal' in token) continue;
+        if ('literal' in token) {
+            if (left > 0 && token.literal.startsWith('--') && wordKey(words[w].value, route.caseSensitive) !== wordKey(token.literal, route.caseSensitive)) left--;
+            else w++;
+            continue;
+        }
         if (token.rest) {
-            params[token.param] = restFrom(text, words[i].start, cuts);
-            break;
+            controller_decorator.setOwn(params, token.param, restFrom(text, words[w].start, cuts));
+            return params;
         }
-        params[token.param] = words[i].value;
+        controller_decorator.setOwn(params, token.param, words[w++].value);
     }
-    return params;
+    return tail === -1 ? params : {
+        ...params,
+        ...assignTail(route.tokens.slice(tail), words, w, text, cuts, route.caseSensitive)
+    };
 }
 /**
  * The text after the start a message used for the group's routes, or `undefined` when it used none: a mention
@@ -3761,7 +4161,7 @@ const indexes = new WeakMap();
         const found = [];
         if (mayEnter(group.root, first)) {
             const words = wordsOf(rest);
-            reach(group.root, words, 0, rest, NONE, group.caseSensitive, found);
+            reach(group.root, words, 0, rest, NONE, group.caseSensitive, NONE, found);
             for (const rank of found){
                 if (fitsScope(routes[rank].scope, starts.inGuild)) {
                     if (!best || rank < best.rank) best = {
@@ -3790,7 +4190,7 @@ const indexes = new WeakMap();
         };
         found.length = 0;
         const from = scanned.words[0]?.start === 0 ? flagged : group.flaggedAfterFlag;
-        reach(from, scanned.words, 0, rest, scanned.cuts, group.caseSensitive, found);
+        reach(from, scanned.words, 0, rest, scanned.cuts, group.caseSensitive, scanned.flags, found);
         for (const rank of found){
             const candidate = {
                 rank,
@@ -3807,11 +4207,16 @@ const indexes = new WeakMap();
     const chosen = best ?? outside;
     if (!chosen) return undefined;
     const route = routes[chosen.rank];
-    const params = paramsOf$1(route, chosen.words, chosen.rest, chosen.cuts);
-    for (const { name, value } of chosen.flags){
+    // The flags the pattern's own `--` words took are those words, and set none of its flags
+    const taken = literalFlags(route.tokens, route.caseSensitive, chosen.words, chosen.flags);
+    const params = paramsOf$1(route, chosen.words, chosen.rest, chosen.cuts, taken.size);
+    chosen.flags.forEach(({ name, value }, index)=>{
+        if (taken.has(index)) return;
         const declared = route.flags.find((flag)=>wordKey(flag.flag, route.caseSensitive) === wordKey(name, route.caseSensitive));
-        if (declared) params[declared.flag] = value ?? '';
-    }
+        if (declared) controller_decorator.setOwn(params, declared.flag, value ?? '');
+    });
+    // A param or flag left out reads as left out, not as what Object.prototype has under its name
+    if (route.inheritedNames.length > 0) controller_decorator.shadowInherited(params, route.inheritedNames);
     return {
         route,
         params,
@@ -3841,19 +4246,28 @@ const indexes = new WeakMap();
         if (first !== undefined && !group.commands.has(first)) continue;
         const plain = splitWords(rest);
         // A route with flags counts the words left once the message's flags are taken out
-        const positional = mayEnter(group.flagged, first) && rest.includes('--') ? splitFlagWords(rest).words : plain;
+        const scanned = mayEnter(group.flagged, first) && rest.includes('--') ? splitFlagWords(rest) : {
+            words: plain,
+            flags: NONE
+        };
         const candidates = group.commands.get(wordKey(plain[0]?.value ?? '', group.caseSensitive)) ?? [];
         for (const rank of candidates){
             if (best && rank >= best.rank) break;
-            const words = routes[rank].flags.length > 0 ? positional : plain;
-            const command = commandWordsOf(routes[rank].tokens);
-            if (command.every((word, i)=>words[i] && wordKey(words[i].value, group.caseSensitive) === wordKey(word, group.caseSensitive))) {
+            const flagged = routes[rank].flags.length > 0;
+            const words = flagged ? scanned.words : plain;
+            const flags = flagged ? scanned.flags : NONE;
+            const taken = commandWordsTaken(commandWordsOf(routes[rank].tokens), words, flags, group.caseSensitive);
+            if (taken !== -1) {
                 const named = {
                     rank,
                     start: text.slice(0, text.length - rest.length),
-                    given: words.length - command.length
+                    given: {
+                        words,
+                        flags
+                    }
                 };
-                if (fitsScope(routes[rank].scope, starts.inGuild)) {
+                // Where it works as dispatch answers it, so a DM's usage comes from a route that works there
+                if (fitsScope(effectiveScope(routes[rank]), starts.inGuild)) {
                     best = named;
                     break;
                 }
@@ -3868,6 +4282,17 @@ const indexes = new WeakMap();
         given: chosen.given
     };
 }
+/**
+ * How many of a message's words a route's command words take, or -1 when the message names another command. A
+ * command's own `--` word may be given bare as a flag in its place, and takes no word.
+ */ function commandWordsTaken(command, words, flags, caseSensitive) {
+    let w = 0;
+    for (const word of command){
+        if (words[w] && wordKey(words[w].value, caseSensitive) === wordKey(word, caseSensitive)) w++;
+        else if (!flags.some((flag)=>isLiteralFlag(flag, word, w, caseSensitive))) return -1;
+    }
+    return w;
+}
 /**
  * The subcommands a message names the parent of, when no pattern matches it and it names no command: the routes whose
  * command words begin with the most of the message's words, short of all of them, as `!config` does for `config set …`
@@ -3910,11 +4335,18 @@ const indexes = new WeakMap();
     }
     return found.length > 0 ? found : undefined;
 }
+/**
+ * Whether a message has text a handler could take; dispatch runs no handler for one without. Content that isn't a
+ * string, as a mock's placeholder without strict mocks, is no text.
+ */ function hasMessageText(content) {
+    return typeof content === 'string' && content.trim() !== '';
+}
 /**
  * What a test calling a handler with a message alone passes as its params, as dispatch builds them: `undefined` for a
- * listener, `{}` for a message without content, else what the pattern captures with the route and start; for one naming
- * the command without fitting it, the route, start and `given`, the words after the command words. Either only when
- * dispatch would give the message to this handler among `controllers`; otherwise why it does not reach the handler.
+ * listener, `{}` for a message whose content isn't a string, as a mock's without strict mocks, else what the pattern
+ * captures with the route and start; for one naming the command without fitting it, the route, start and `given`, the
+ * message's words and flags. Either only when dispatch would give the message to this handler among
+ * `controllers`; otherwise why it does not reach the handler, a message with no text included.
  */ async function messageParamsFor(controllerClass, methodName, message, options, controllers = [
     controllerClass
 ]) {
@@ -3926,6 +4358,13 @@ const indexes = new WeakMap();
     if (typeof message.content !== 'string') return {
         params: {}
     };
+    const handler = `${controllerClass.name}.${methodName}`;
+    const pattern = routes.find((route)=>!route.aliasOf)?.pattern ?? routes[0].pattern;
+    if (!hasMessageText(message.content)) {
+        return {
+            mismatch: `message has no text, so dispatch runs no handler for it: give the mock the content ${handler}'s pattern '${pattern}' takes.`
+        };
+    }
     const botId = message.client?.user?.id;
     const all = buildMessageRoutes(controllers, options);
     const starts = await messageStartsFor(all, options, message, typeof botId === 'string' ? botId : undefined);
@@ -3934,7 +4373,7 @@ const indexes = new WeakMap();
     if (target && (target.route.controllerClass !== controllerClass || target.route.method !== methodName)) {
         const other = `${target.route.controllerClass.name}.${target.route.method}`;
         return {
-            mismatch: `message '${message.content}' does not reach ${controllerClass.name}.${methodName}: dispatch runs ${other}.`
+            mismatch: `message '${message.content}' does not reach ${handler}: dispatch runs ${other}.`
         };
     }
     if (target && 'params' in target) return {
@@ -3948,9 +4387,8 @@ const indexes = new WeakMap();
         start: target.start,
         given: target.given
     };
-    const pattern = routes.find((route)=>!route.aliasOf)?.pattern ?? routes[0].pattern;
     return {
-        mismatch: `message '${message.content}' does not match ${controllerClass.name}.${methodName}'s pattern '${pattern}'.`
+        mismatch: `message '${message.content}' does not match ${handler}'s pattern '${pattern}'.`
     };
 }
 
@@ -3979,12 +4417,13 @@ const indexes = new WeakMap();
     const text = content.trim();
     const rest = afterStart(text, starts.prefixes.filter((prefix)=>prefix !== ''), starts.mention, caseSensitive);
     if (!rest) return undefined;
-    const [first] = splitWords(rest);
+    const [first, second] = splitWords(rest);
     const key = (word)=>caseSensitive ? word : word.toLowerCase();
     if (!first || !words.some((word)=>key(word) === key(first.value))) return undefined;
+    // From where the next word starts, as the help word may have been written in quotes
     return {
         start: text.slice(0, text.length - rest.length),
-        query: rest.slice(first.value.length).trim()
+        query: second ? rest.slice(second.start).trim() : ''
     };
 }
 /** The start a caller would type a route with here: its own prefix, a mention, or the start the help message used. */ function displayStart(route, start, starts) {
@@ -3993,11 +4432,6 @@ const indexes = new WeakMap();
     if (route.prefix !== undefined) return route.prefix[0] ?? '';
     return start;
 }
-/** Where a route works: its scope, narrowed to servers by a `member`, `role` or `channel` param or flag. */ function effectiveScope(route) {
-    if (route.scope !== 'any') return route.scope;
-    const guildOnly = route.tokens.some((token)=>'param' in token && token.type !== undefined && isGuildType(token.type)) || route.flags.some((flag)=>flag.type !== undefined && isGuildType(flag.type));
-    return guildOnly ? 'guild' : 'any';
-}
 /** A route's params and flags, each with what it takes in words. */ function paramsOf(route, types, render) {
     const params = route.tokens.flatMap((token)=>{
         if (!('param' in token)) return [];
@@ -4298,6 +4732,28 @@ const COMMAND_TYPES = new Set([
     };
 }
 /** The message routes the app's dispatcher reads, by the app's registry, so its help and dispatch read one table. */ const dispatchedRoutes = new WeakMap();
+/** What every entry has: its class and method, and the metadata on them. */ function entryBase(controller, method) {
+    const context = new controller_decorator.HandlerExecutionContext({
+        controller,
+        methodName: method,
+        args: []
+    });
+    return {
+        controller,
+        method,
+        get: context.get.bind(context),
+        getAll: context.getAll.bind(context)
+    };
+}
+const lateEventSources = new WeakMap();
+// The late sources each registry's cached entries were read with, so a list made before they arrived is read again
+const collectedWith = new WeakMap();
+/**
+ * Has `registry` list the `@On` and `@Once` handlers that run on `sources`, the instances the app attaches them for,
+ * where they are on a class it does not list already.
+ */ function listEventSources(registry, sources) {
+    lateEventSources.set(registry, sources);
+}
 /** Has `registry` work out message help from `routes`, the table the app's dispatcher routes messages with. */ function shareMessageRoutes(registry, routes) {
     dispatchedRoutes.set(registry, routes);
 }
@@ -4338,7 +4794,11 @@ const COMMAND_TYPES = new Set([
    * @param filter - Narrows the list by kind, controller, or both.
    * @returns The handlers, class by class in the order the app makes its classes, each after what it injects.
    */ list(filter = {}) {
-        this.entries ?? (this.entries = this.collect());
+        const late = lateEventSources.get(this);
+        if (!this.entries || collectedWith.get(this) !== late) {
+            this.entries = this.collect();
+            collectedWith.set(this, late);
+        }
         return this.entries.filter((entry)=>(filter.kind === undefined || entry.kind === filter.kind) && (filter.controller === undefined || entry.controller === filter.controller));
     }
     /**
@@ -4362,8 +4822,9 @@ const COMMAND_TYPES = new Set([
    * }
    * ```
    */ async messageHelp(message, query) {
+        // Until a dispatcher shares its table, the same one built from the same controllers, so help lists what dispatch reaches
         const routes = dispatchedRoutes.get(this) ?? this.messageRoutes ?? (this.messageRoutes = buildMessageRoutes([
-            ...this.classes
+            ...this.controllers
         ], this.messages));
         const starts = await messageStarts(this.messages, message, message.client?.user?.id);
         const text = (message.content ?? '').trim();
@@ -4393,19 +4854,7 @@ const COMMAND_TYPES = new Set([
         const entries = [];
         for (const controller of this.classes){
             const prototype = controller.prototype;
-            const base = (method)=>{
-                const context = new controller_decorator.HandlerExecutionContext({
-                    controller,
-                    methodName: method,
-                    args: []
-                });
-                return {
-                    controller,
-                    method,
-                    get: context.get.bind(context),
-                    getAll: context.getAll.bind(context)
-                };
-            };
+            const base = (method)=>entryBase(controller, method);
             for (const [name, metas] of Object.entries(controller_decorator.getCommandMap(prototype) ?? {})){
                 for (const { methodName, type, builder } of metas){
                     if (COMMAND_TYPES.has(type)) {
@@ -4468,34 +4917,35 @@ const COMMAND_TYPES = new Set([
                 });
             }
         }
+        // The classes the app reaches only as something it makes, listed once each, with the handlers that run on them
+        const listed = new Set(this.classes);
+        for (const { cls, handlers } of lateEventSources.get(this) ?? []){
+            if (listed.has(cls)) continue;
+            listed.add(cls);
+            for (const { event, method, once } of handlers)entries.push({
+                ...entryBase(cls, method),
+                kind: 'event',
+                name: event,
+                once
+            });
+        }
         return entries;
     }
     /**
-   * @param classes - The app's classes to read handlers from. The factory fills the list
-   *   once the app is bound; entries are read on the first {@link list}.
+   * @param classes - The app's classes to read handlers from, controllers and services alike. The factory fills the
+   *   list once the app is bound; entries are read on the first {@link list}.
    * @param messages - The app's `messages` options, whose `caseSensitive` message entries' `matches` follows.
    * @param translator - The app's translator, read when {@link messageHelp} words its labels; none for English.
-   */ constructor(classes, messages = {}, translator = ()=>undefined){
+   * @param controllers - The app's controllers, the classes dispatch routes messages to, which {@link messageHelp}
+   *   lists; `classes` when not given.
+   */ constructor(classes, messages = {}, translator = ()=>undefined, controllers = classes){
         this.classes = classes;
         this.messages = messages;
         this.translator = translator;
+        this.controllers = controllers;
     }
 }
 
-/** The longest delay a timer keeps: 2^31 - 1 ms, about 24.8 days. Node fires a longer one at once. */ const MAX_TIMER_MS = 2147483647;
-/** A value as a refusal quotes it: a number as itself, `Infinity` and `NaN` included, a string in quotes. */ function quoted(value) {
-    if (typeof value === 'string') return JSON.stringify(value);
-    if (typeof value === 'number' || typeof value === 'boolean' || value === null) return String(value);
-    return Array.isArray(value) ? 'an array' : typeof value;
-}
-/**
- * What is wrong with a timeout option, or `undefined` when it is a number of milliseconds a timer keeps: finite, above
- * 0, or 0 or more with `allowZero`, and at most `max`, {@link MAX_TIMER_MS} unless less. The caller names the option.
- */ function timeoutProblem(value, { allowZero = false, max = MAX_TIMER_MS } = {}) {
-    if (typeof value === 'number' && Number.isFinite(value) && (allowZero ? value >= 0 : value > 0) && value <= max) return undefined;
-    return `must be a number of milliseconds ${allowZero ? '0 or more' : 'above 0'}, at most ${max} (got ${quoted(value)})`;
-}
-
 /** 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({
         length: args.length
@@ -4603,11 +5053,11 @@ async function withTimeout(promise, ms, what) {
    *
    * With process sharding that is one result per shard; with one process, a single result listing every
    * shard. The arguments and the result pass as JSON in every mode, one process and tests included, so a
-   * `Date` arrives as a string and a `Map` as `{}` wherever it runs, and a value JSON cannot carry, such as a
-   * `BigInt`, fails the call. A method whose params JSON would change, such as one taking a `Date`, cannot be called:
-   * the argument is refused, naming what to declare instead. An `undefined` argument arrives as `undefined`. A process
-   * that throws, lacks the service, or does not answer within 10 seconds gives an error result instead of failing the
-   * others.
+   * `Date` arrives as a string, a `Map` as `{}` and a class instance as its own fields, without its getters, wherever
+   * it runs, and a value JSON cannot carry, such as a `BigInt`, fails the call. A method whose params JSON would
+   * change, such as one taking a `Date`, cannot be called: the argument is refused, naming what to declare instead. An
+   * `undefined` argument arrives as `undefined`. A process that throws, lacks the service, or does not answer within
+   * 10 seconds gives an error result instead of failing the others.
    *
    * @param service - The controller, the service, or a class a provider stands in for; each process resolves its own
    *   instance.
@@ -4713,6 +5163,18 @@ async function withTimeout(promise, ms, what) {
         controller_decorator.ThemeCache,
         controller_decorator.Translator
     ];
+/**
+ * The tokens the bot binds before an app's providers, which `@MeoCord({ providers })` cannot provide: `Translator` too
+ * when the app gives `i18n`.
+ */ const boundBeforeProviders = (i18n)=>[
+        discord_js.Client,
+        HandlerRegistry,
+        ShardContext,
+        controller_decorator.CooldownStore,
+        ...i18n ? [
+            controller_decorator.Translator
+        ] : []
+    ];
 const created = (cls)=>`create it with \`new ${cls.name}(…)\``;
 /** What to do in place of injecting each of MeoCord's classes an app makes itself; the testing module adds its own. */ const advice = new Map([
     [
@@ -4751,6 +5213,18 @@ const isFactoryProvider = (provider)=>'useFactory' in provider;
     return `'${String(token)}'`;
 }
 const isToken = (value)=>typeof value === 'function' || typeof value === 'string' || typeof value === 'symbol';
+/**
+ * Checks one of an app's own `@MeoCord({ providers })` as the bot does. A provider of a token MeoCord binds later, or
+ * for each call, is warned about until 5.0 refuses it; one of a token `isOwn` names, which MeoCord binds before the
+ * providers, is refused.
+ *
+ * @returns The refusal, for the caller to report, or `undefined`.
+ */ function appProviderRefusal(appName, token, isOwn, logger) {
+    if (token === controller_decorator.ThemeCache || token === controller_decorator.ExecutionContext) {
+        controller_decorator.warnOnce(logger, `${appName}: @MeoCord({ providers }) provides ${tokenName(token)}, which MeoCord binds itself; ` + 'the next major version (5.0) refuses it. Remove the provider.');
+    }
+    return isOwn(token) ? new Error(`${appName}: @MeoCord({ providers }) cannot provide ${tokenName(token)}, which MeoCord binds itself.`) : undefined;
+}
 /**
  * Checks each provider's shape and indexes them by token, reporting each that cannot be bound, such as one with no
  * token, not exactly one of `useValue`, `useClass` and `useFactory`, one that injects `ExecutionContext`, or a token
@@ -4810,6 +5284,10 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     }
     return map;
 }
+/** For each container, how to forget the value each factory provider made, so a start that failed is made afresh. */ const madeValues = new WeakMap();
+/** Forgets every value `container`'s factory providers made, so the next resolve runs each factory again. */ function forgetFactoryValues(container) {
+    for (const forget of madeValues.get(container) ?? [])forget();
+}
 /**
  * Binds one provider into `container` as a singleton. `bindClass` binds a class a provider depends
  * on, as the app binds its own, so a provided class or a factory's `inject` can name any class.
@@ -4830,6 +5308,10 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
     // Made once, as a singleton, but kept only once made: a factory that throws or rejects runs again on the next
     // resolve, so a start() after it failed tries it again. Resolves while one is pending share it.
     let kept;
+    madeValues.set(container, [
+        ...madeValues.get(container) ?? [],
+        ()=>kept = undefined
+    ]);
     container.bind(token).toDynamicValue((context)=>{
         if (kept) return kept.value;
         // Resolved in dependency order before anything needs it, so each injected value is already made
@@ -5001,11 +5483,13 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
  * Runs every factory in `order`, awaiting those that return a promise, so each value is made before
  * anything that injects it is resolved. Rejects with {@link providerFailure} for the first that fails. With `control`,
  * it makes no further value once the app is stopping.
+ *
+ * @returns Whether every factory was made: `false` when the app began stopping first.
  */ async function resolveProviders(container, providers, order, control) {
     for (const token of order){
         const provider = providers.get(token);
         if (!provider || !isFactoryProvider(provider)) continue;
-        if (control?.stopped()) return;
+        if (control?.stopped()) return false;
         control?.pending(tokenName(token));
         try {
             await container.getAsync(token);
@@ -5015,12 +5499,14 @@ const isToken = (value)=>typeof value === 'function' || typeof value === 'string
             control?.pending(undefined);
         }
     }
+    return true;
 }
 
 exports.BUILT_IN_TYPES = BUILT_IN_TYPES;
 exports.COOLDOWN_POLICY = COOLDOWN_POLICY;
 exports.HandlerRegistry = HandlerRegistry;
 exports.MAX_TIMER_MS = MAX_TIMER_MS;
+exports.MAX_TIMER_SECONDS = MAX_TIMER_SECONDS;
 exports.On = On;
 exports.Once = Once;
 exports.SENT_AS = SENT_AS;
@@ -5030,7 +5516,11 @@ exports.THEMED_CLASSES = THEMED_CLASSES;
 exports.adviseInPlaceOfInjecting = adviseInPlaceOfInjecting;
 exports.appObservers = appObservers;
 exports.appPresenterOf = appPresenterOf;
+exports.appProviderRefusal = appProviderRefusal;
 exports.appStages = appStages;
+exports.appTheme = appTheme;
+exports.appliesTo = appliesTo;
+exports.applyGuards = applyGuards;
 exports.assertObservers = assertObservers;
 exports.assertProvided = assertProvided;
 exports.assertProvidedServices = assertProvidedServices;
@@ -5042,37 +5532,41 @@ exports.bindGlobalStages = bindGlobalStages;
 exports.bindObservers = bindObservers;
 exports.bindProvider = bindProvider;
 exports.bindsOwnToken = bindsOwnToken;
+exports.boundBeforeProviders = boundBeforeProviders;
 exports.buildMessageRoutes = buildMessageRoutes;
 exports.claimAmbientAppTheme = claimAmbientAppTheme;
 exports.claimCooldownNotice = claimCooldownNotice;
 exports.claimStoreDownNotice = claimStoreDownNotice;
-exports.classChain = classChain;
 exports.classDecorators = classDecorators;
 exports.classLevelGuards = classLevelGuards;
-exports.classUnits = classUnits;
 exports.commandNameOf = commandNameOf;
 exports.commandWordsOf = commandWordsOf;
 exports.computeMessageHelp = computeMessageHelp;
-exports.consumeDispatchMark = consumeDispatchMark;
 exports.cooldownPolicyFrom = cooldownPolicyFrom;
 exports.declaringPrototype = declaringPrototype;
 exports.deferMisuseError = deferMisuseError;
 exports.defineStageTypes = defineStageTypes;
 exports.fitsScope = fitsScope;
+exports.forgetFactoryValues = forgetFactoryValues;
 exports.getEventHandlers = getEventHandlers;
 exports.globalStagesOf = globalStagesOf;
+exports.guardOwnHandlersWithBaseGuards = guardOwnHandlersWithBaseGuards;
 exports.handleUnroutedError = handleUnroutedError;
 exports.handlerCooldowns = handlerCooldowns;
 exports.handlerMethods = handlerMethods$1;
 exports.handlerStageClasses = handlerStageClasses;
 exports.handlerStages = handlerStages;
+exports.hasMessageText = hasMessageText;
 exports.helpInvocation = helpInvocation;
 exports.helpWords = helpWords;
 exports.injectedTokens = injectedTokens;
 exports.isAppClassToken = isAppClassToken;
 exports.isClassProvider = isClassProvider;
 exports.isGuardWithParams = isGuardWithParams;
+exports.isGuildType = isGuildType;
 exports.isListable = isListable;
+exports.isValueProvider = isValueProvider;
+exports.listEventSources = listEventSources;
 exports.makeInjectable = makeInjectable;
 exports.markStartupChecked = markStartupChecked;
 exports.matchHelpRequest = matchHelpRequest;
@@ -5082,17 +5576,21 @@ exports.matchMessageSubcommands = matchMessageSubcommands;
 exports.meocordClasses = meocordClasses;
 exports.messageCommandHooks = messageCommandHooks;
 exports.messageParamsFor = messageParamsFor;
+exports.messageRouteWarnings = messageRouteWarnings;
 exports.messageStarts = messageStarts;
 exports.messageStartsFor = messageStartsFor;
 exports.needsGuild = needsGuild;
 exports.nonInteractionHandler = nonInteractionHandler;
 exports.observeUnclaimed = observeUnclaimed;
 exports.prepareAppPresenter = prepareAppPresenter;
+exports.prepareDirectCalls = prepareDirectCalls;
+exports.prepareEventHandler = prepareEventHandler;
 exports.prepareHandlerStages = prepareHandlerStages;
+exports.prepareLateThemes = prepareLateThemes;
 exports.prepareThemes = prepareThemes;
 exports.providerMap = providerMap;
 exports.reachableClasses = reachableClasses;
-exports.recordInstanceContainers = recordInstanceContainers;
+exports.recordGuards = recordGuards;
 exports.registerClientTheme = registerClientTheme;
 exports.registerCommands = registerCommands;
 exports.registrationKey = registrationKey;
@@ -5100,7 +5598,6 @@ exports.releaseAmbientAppTheme = releaseAmbientAppTheme;
 exports.renderMessageHelp = renderMessageHelp;
 exports.resolutionOrder = resolutionOrder;
 exports.resolveProviders = resolveProviders;
-exports.runDirectCall = runDirectCall;
 exports.runGuards = runGuards;
 exports.runHandler = runHandler;
 exports.runInAppTheme = runInAppTheme;
@@ -5114,7 +5611,9 @@ exports.stageTypes = stageTypes;
 exports.staticMessageStarts = staticMessageStarts;
 exports.storeOperationsSettled = storeOperationsSettled;
 exports.subcommandUsageError = subcommandUsageError;
+exports.takesGuildParam = takesGuildParam;
 exports.timeoutProblem = timeoutProblem;
+exports.timerKeepsSeconds = timerKeepsSeconds;
 exports.tokenDependencies = tokenDependencies;
 exports.tokenName = tokenName;
 exports.usesAppPrefix = usesAppPrefix;