@seedcord/gateway 0.8.0 → 0.9.0-next.2

package/dist/index.d.mts

@@ -1,21 +1,21 @@
 import "reflect-metadata";
+import { InFlight } from "@seedcord/core/node/internal";
 import { WinstonConsoleSink, WinstonFileSink } from "@seedcord/logger/node";
-import { AutocompletableNames, AutocompleteRouteBrand, CacheFor, ChoiceValueOf, CommandRegistry, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, ContextMenuLeaves, ContextMenuNamesBrand, EntryFor, FixedScope, FocusedField, GateFitsWith, HasComponentDefs, Initializeable, MatchArms, MenuCacheFor, MiddlewareKindsBrand, NamesFor, PageCursor, SingleParams, SlashOptions as SlashOptions$1, SlashRouteBrand } from "@seedcord/core/internal";
-import { ArraySourceBase, AutocompleteOptions, BaseHandler as BaseHandler$1, BaseReplySender, Bus, CoreBase, CursorSourceBase, DispatchContext, DispatchOutcome, DispatchResult, EventDispatchResult, Gate, GateContextBase, GateNoticeOptions, GuildPermissionsContext, HandlerOutcome, InteractionKind, MiddlewareKind, ModalLike, Notice, PageSourceBase, PaginatorBase, PaginatorConfig, PermissionNoticeOverrides, PermissionScope, RepliableHandler as RepliableHandler$1, RequiredOf, ResolvedEmoji, SlashRegistry, Subscriber as Subscriber$1, SubscriptionKey, WebhookLog as WebhookLog$1 } from "@seedcord/core";
+import { AutocompletableNames, AutocompleteResponder, AutocompleteRouteBrand, CacheFor, CaseReturn, ChoiceValueOf, CommandRegistry, ComponentDefsBrand, ComponentKindBrand, ContextMenuKindBrand, ContextMenuLeaves, ContextMenuNamesBrand, EntryFor, FixedScope, FocusedField, GateFitsWith, HasComponentDefs, Initializeable, MatchCases, MatchResult, MenuCacheFor, MiddlewareKindsBrand, MiddlewareRoute, NamesFor, OnlyCases, PageCursor, SingleParams, SlashOptions as SlashOptions$1, SlashRouteBrand } from "@seedcord/core/internal";
+import { AppPermissionsContext, ArraySourceBase, AutocompleteOptions, BaseHandler as BaseHandler$1, BaseReplySender, Bus, CoreBase, CursorSourceBase, DispatchContext as DispatchContext$1, DispatchOutcome, DispatchResult, EventDispatchResult, Gate, GateContextBase, GateNoticeOptions, GuildPermissionsContext, HandlerOutcome, InteractionKind, MiddlewareKind, ModalLike, NoticeConstructor, PageSourceBase, PaginatorBase, PaginatorConfig, PermissionNoticeConstructor, PermissionScope, RepliableHandler as RepliableHandler$1, RequiredOf, ResolvedEmoji, SlashRegistry, Subscriber as Subscriber$1, SubscriptionKey, WebhookLog as WebhookLog$1 } from "@seedcord/core";
+import { APIInteractionGuildMember, APIModalInteractionResponseCallbackData, AnySelectMenuInteraction, ApplicationCommandOptionChoiceData, ApplicationCommandType, ApplicationEmoji, AutocompleteInteraction, BaseMessageOptions, BooleanCache, ButtonInteraction, ButtonStyle, CacheType, CacheTypeReducer, ChannelSelectMenuInteraction, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, CommandInteractionOption, ContextMenuCommandInteraction, Events, Guild, GuildBasedChannel, GuildEmoji, GuildMember, Interaction, MentionableSelectMenuInteraction, Message, MessageContextMenuCommandInteraction, ModalSubmitFields, ModalSubmitInteraction, Role, RoleSelectMenuInteraction, StringSelectMenuInteraction, User, UserContextMenuCommandInteraction, UserSelectMenuInteraction } from "discord.js";
 import { Logger } from "@seedcord/logger";
-import { APIInteractionGuildMember, APIModalInteractionResponseCallbackData, AnySelectMenuInteraction, ApplicationCommandOptionChoiceData, ApplicationCommandType, ApplicationEmoji, AutocompleteInteraction, BaseMessageOptions, BooleanCache, ButtonInteraction, ButtonStyle, CacheType, CacheTypeReducer, ChannelSelectMenuInteraction, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, CommandInteractionOption, ContextMenuCommandInteraction, Events, Guild, GuildEmoji, GuildMember, Interaction, MentionableSelectMenuInteraction, Message, MessageContextMenuCommandInteraction, ModalSubmitFields, ModalSubmitInteraction, Role, RoleSelectMenuInteraction, StringSelectMenuInteraction, TextChannel, User, UserContextMenuCommandInteraction, UserSelectMenuInteraction } from "discord.js";
 import { Plugin as Plugin$1, PluginLifecycleSpec, PluginOptions, PluginOptions as PluginOptions$1 } from "@seedcord/core/plugin";
-import { CoordinatedShutdown, CoordinatedStartup, ServerHost } from "@seedcord/core/node";
+import { ServerHost, ShutdownTasks, StartupTasks } from "@seedcord/core/node";
 import { HostAugmentTarget, HostVersion, SeedcordBrand, SeedcordInstance } from "@seedcord/types/internal";
-import { HmrModuleHandler } from "@seedcord/core/hmr";
 import { AnyCustomId } from "@seedcord/custom-id";
-import { BotConfig, Config, DeferOpts, EmojiMap, EventFrequency, HealthCheckOption, HmrAware, HmrUpdateEvent, IRateLimiter, ReplyResponse, SendOpts, TypedOmit } from "@seedcord/types";
+import { HmrModuleHandler } from "@seedcord/core/hmr";
+import { BotConfig, Config, DeferOpts, EmojiMap, EventFrequency, HealthCheckOption, HmrAware, HmrUpdateEvent, ReplyResponse, SendOpts, TypedOmit } from "@seedcord/types";
 import { Constructor, IsUnion, NonEmptyTuple, Promisable } from "type-fest";
 import { REST } from "@discordjs/rest";
 export * from "@seedcord/errors";
 export * from "@seedcord/core";
 export * from "@seedcord/logger";
-export * from "@seedcord/rate-limiter";
 export * from "@seedcord/utils";
 export * from "@seedcord/event-emitter";
 export type * from "@seedcord/types";
@@ -33,11 +33,11 @@ declare module '@seedcord/core/internal' {
       args: ClientEvents[Name];
     }; }[keyof ClientEvents];
     /**
-     * Triggered once an event's handlers settle, pairing with `eventDispatching`. A fire that runs no
-     * handler triggers neither.
+     * Published once an event's handlers settle, pairing with `eventDispatching`. When no handlers
+     * are registered, neither key is published.
      */
     eventDispatched: {
-      /** The same id `eventDispatching` published for this fire. */
+      /** The same id `eventDispatching` published for this dispatch. */
       dispatchId: string;
       name: keyof ClientEvents;
       /** How the middleware chain ended. A chain that refused the event leaves `handlers` empty. */
@@ -102,36 +102,28 @@ interface GatewayConfig extends Config {
  */
 declare class EventDispatcher implements Initializeable, HmrAware {
   protected core: Core;
+  private readonly inFlight;
   private readonly logger;
   private isInitialized;
   private readonly eventMap;
   private readonly middlewares;
-  private readonly executedOnceHandlers;
+  private readonly onceRuns;
   private readonly attachedEvents;
-  private readonly inFlight;
-  private loading;
-  private readonly loadedHandlers;
-  private readonly loadedMiddlewares;
-  private readonly hmrHandler?;
-  constructor(core: Core);
+  private readonly loader;
+  constructor(core: Core, inFlight: InFlight);
   private getArtifacts;
   init(): Promise<void>;
   private reportLoad;
-  private loadHandlers;
-  private loadMiddlewares;
   /** @internal */
   onHmr(event: HmrUpdateEvent): Promise<void>;
   private unregisterHandler;
-  private unregisterMiddleware;
-  private registerMiddleware;
   private runMiddlewares;
   private isEventHandlerClass;
   private isMiddlewareClass;
-  private registerHandler;
+  private storeHandler;
   private attachToClient;
   private attachListener;
-  stopAccepting(): void;
-  drain(timeoutMs: number): Promise<void>;
+  private reportUnhandled;
   private processEvent;
   private processHandler;
 }
@@ -139,55 +131,26 @@ declare class EventDispatcher implements Initializeable, HmrAware {
 //#region src/bot/controllers/InteractionDispatcher.d.ts
 declare class InteractionDispatcher implements Initializeable, HmrAware {
   protected core: Core;
+  private readonly inFlight;
   private readonly logger;
   private isInitialized;
-  private readonly maps;
-  private readonly handlerFiles;
+  private readonly routes;
+  private get maps();
   private readonly keysToIgnore;
   private readonly middlewares;
-  private readonly inFlight;
-  private loading;
-  private readonly loadedHandlers;
-  private readonly loadedMiddlewares;
-  private readonly hmrHandler?;
-  constructor(core: Core);
+  private readonly loader;
+  constructor(core: Core, inFlight: InFlight);
   warnUnhandledRoutes(commandLeaves: Iterable<string>): void;
   warnUnhandledContextMenuRoutes(leaves: ContextMenuLeaves): void;
-  private getArtifacts;
   init(): Promise<void>;
   private reportLoad;
-  private loadHandlers;
-  private loadMiddlewares;
-  private registerMiddleware;
   private isHandlerClass;
   private isMiddlewareClass;
-  private registerHandler;
   onHmr(event: HmrUpdateEvent): Promise<void>;
-  private unregisterHandler;
-  private unregisterMiddleware;
   private attachToClient;
-  stopAccepting(): void;
-  drain(timeoutMs: number): Promise<void>;
   private handleCustomIdInteraction;
   private processInteraction;
-  private answer;
-  private buildHandler;
-  private reporterFor;
-  private refusalBeforeHandler;
-  private runMiddlewares;
-  private gateRefusal;
   private handleInteraction;
-  private handleSlashCommand;
-  private handleButton;
-  private handleModal;
-  private handleStringSelectMenu;
-  private handleUserSelectMenu;
-  private handleRoleSelectMenu;
-  private handleChannelSelectMenu;
-  private handleMentionableSelectMenu;
-  private handleMessageContextMenu;
-  private handleUserContextMenu;
-  private handleAutocomplete;
 }
 //#endregion
 //#region src/bot/Bot.d.ts
@@ -236,8 +199,8 @@ declare class Bot implements HmrAware {
  * ```
  * */
 interface Core extends CoreBase {
-  readonly shutdown: Pick<CoordinatedShutdown, 'addTask'>;
-  readonly startup: Pick<CoordinatedStartup, 'addTask'>;
+  readonly shutdown: ShutdownTasks;
+  readonly startup: StartupTasks;
   readonly bot: Bot;
   readonly config: GatewayConfig;
 }
@@ -285,12 +248,12 @@ export declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> ex
 type SingleEventPayload<Names extends ValidNonInteractionKeys> = IsUnion<Names> extends true ? never : ClientEvents[Names];
 //#endregion
 //#region src/handlers/event/EventHandler.d.ts
-type EventMatchArms<Names extends ValidNonInteractionKeys, Ret> = { [Name in Names]: (...args: ClientEvents[Name]) => Promisable<Ret>; };
+type EventMatchCases<Names extends ValidNonInteractionKeys, Ret> = { [Name in Names]: (...args: ClientEvents[Name]) => CaseReturn<Ret>; };
 /**
  * Base class for a Discord client event handler.
  *
- * Pass the event name(s) as the generic, the same one(s) as `@RegisterEvent`. A single-event handler reads
- * `this.event` (the payload tuple) directly. A handler registered for several events branches with `this.match`,
+ * Pass the event name(s) as the generic, the same one(s) as `@RegisterEvent`. On a single-event handler, read
+ * `this.event` (the payload tuple) directly. On a handler registered for several events, branch with `this.match`,
  * keyed by event name, since the union of payload tuples is not directly readable.
  *
  * @typeParam Names - One or more `ClientEvents` keys, e.g. `Events.MessageCreate` or `Events.MessageCreate | Events.MessageUpdate`.
@@ -309,20 +272,22 @@ type EventMatchArms<Names extends ValidNonInteractionKeys, Ret> = { [Name in Nam
  * ```
  */
 export declare abstract class EventHandler<in out Names extends ValidNonInteractionKeys> extends BaseHandler<ClientEvents[Names]> {
-  private readonly firedEvent;
-  constructor(event: ClientEvents[Names], core: Core, dispatch: DispatchContext, eventName?: Names);
+  constructor(event: ClientEvents[Names], core: Core, dispatch: DispatchContext$1);
   protected readonly event: SingleEventPayload<Names>;
+  /** The event that started this dispatch, one of the names in the generic. */
+  protected readonly route: Names;
   /**
-   * Run the arm for whichever event fired. Use this only when the handler is registered for several
-   * events. A single-event handler reads `this.event` directly. On a multi-event handler `this.event` is
+   * Run the case for the current event. Use this only when the handler is registered for several
+   * events. On a single-event handler, read `this.event` directly. On a multi-event handler `this.event` is
    * `never`, so match is the only way to read the payload.
    *
-   * Provide one arm per registered event, keyed by its name, and each arm receives that event's own
-   * payload tuple. The arms must cover every event in the generic, a missing event or an unknown key is a
+   * Provide one case per registered event, keyed by its name, and each case receives that event's own
+   * payload tuple. The cases must cover every event in the generic. A missing event or an unknown key is a
    * compile error.
    *
-   * @param arms - One handler per registered event, keyed by event name.
-   * @returns The result of the arm that ran.
+   * @param cases - One handler per registered event, keyed by event name.
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @returns The result of the case that ran.
    *
    * @example
    * ```ts
@@ -337,7 +302,7 @@ export declare abstract class EventHandler<in out Names extends ValidNonInteract
    * }
    * ```
    */
-  protected match<Ret>(arms: EventMatchArms<Names, Ret>): Promise<Ret>;
+  protected match<Ret = never, Cases extends EventMatchCases<Names, Ret> = EventMatchCases<Names, Ret>>(cases: OnlyCases<Cases, EventMatchCases<Names, Ret>>): Promise<MatchResult<Ret, Cases>>;
 }
 //#endregion
 //#region src/handlers/event/EventMiddleware.d.ts
@@ -346,22 +311,20 @@ export declare abstract class EventHandler<in out Names extends ValidNonInteract
  *
  * Middleware runs before event handlers and can stop the event by throwing a `Silence`. Unlike `EventHandler`, it
  * runs the SAME for every event it is registered for, so it has no `match`. Specify a single event in the
- * generic and `{ events }` to read `this.event` fully typed. Span several events (or omit `{ events }` for a
- * catchall) and `this.event` narrows to `never`, read `this.eventName` and do work that does not depend on the
- * payload shape. A middleware that needs each event's payload is written one event per class.
+ * generic and `{ events }` to read `this.event` fully typed. If you span several events (or omit `{ events }` for
+ * a catchall), `this.event` narrows to `never`. Read `this.route` there, for work that doesn't depend on the
+ * payload shape. Write one class per event for a middleware that needs each event's payload.
  *
  * @typeParam EventName - One or more `ClientEvents` keys. Defaults to every event (catchall).
  */
 export declare abstract class EventMiddleware<in out EventName extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends BaseHandler<ClientEvents[EventName]> {
-  private readonly firedEvent;
-  constructor(event: ClientEvents[EventName], core: Core, dispatch: DispatchContext, eventName?: EventName);
+  constructor(event: ClientEvents[EventName], core: Core, dispatch: DispatchContext$1);
   protected readonly event: SingleEventPayload<EventName>;
   /**
-   * The event that fired this middleware. Read it on a catchall or multi-event middleware, where `this.event`
-   * is `never`, to do work that does not depend on the payload shape. A single-event middleware reads
-   * `this.event` directly and does not need this.
+   * The event that started this dispatch, one of the names in the generic. Read it on a catchall or multi-event
+   * middleware, where `this.event` is `never`, to do work that doesn't depend on the payload shape.
    */
-  protected get eventName(): EventName;
+  protected readonly route: EventName;
   /**
    * Runs once the event finishes, newest middleware first. Every middleware whose `execute()`
    * started gets the call, a stopped chain and a throw included. Implement it to release something
@@ -378,7 +341,7 @@ export declare abstract class EventMiddleware<in out EventName extends ValidNonI
    * }
    * ```
    */
-  after?(result: EventDispatchResult): Promise<void>;
+  after?(result: EventDispatchResult): Promisable<void>;
 }
 //#endregion
 //#region src/bot/decorators/Events.d.ts
@@ -440,7 +403,7 @@ type SentMessage = Message;
 /** Writes interaction responses through discord.js. The repliable handler bases and the dispatcher construct it. */
 export declare class ReplySender extends BaseReplySender<SentMessage, GatewayFile> {
   private readonly interaction;
-  constructor(interaction: Repliables, dispatch: DispatchContext, bus: Bus);
+  constructor(interaction: Repliables, dispatch: DispatchContext$1, bus: Bus);
   protected writeReply(response: GatewayReplyResponse | string, opts?: SendOpts): Promise<SentMessage | undefined>;
   protected writeDefer(opts?: DeferOpts): Promise<void>;
   protected writeDeferUpdate(): Promise<void>;
@@ -473,7 +436,8 @@ export declare class ReplySender extends BaseReplySender<SentMessage, GatewayFil
 export declare abstract class RepliableHandler<Event extends Repliables> extends RepliableHandler$1<Event, Core, SentMessage, GatewayFile, ReplySender> {
   /** @internal */
   getEvent(): Event;
-  protected buildSender(event: Event, core: Core, dispatch: DispatchContext): ReplySender;
+  /** The user who sent this interaction. */
+  protected get user(): User;
 }
 //#endregion
 //#region src/handlers/interaction/InteractionHandler.d.ts
@@ -487,7 +451,7 @@ export declare abstract class RepliableHandler<Event extends Repliables> extends
  * @typeParam Repliable - The interaction type this handler processes
  */
 export declare abstract class InteractionHandler<Repliable extends Repliables> extends RepliableHandler<Repliable> {
-  constructor(event: Repliable, core: Core, dispatch: DispatchContext);
+  constructor(event: Repliable, core: Core, dispatch: DispatchContext$1, sender: ReplySender);
   /**
    * Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
    * compile time (Discord forbids a modal in response to a modal).
@@ -497,7 +461,7 @@ export declare abstract class InteractionHandler<Repliable extends Repliables> e
 //#endregion
 //#region src/bot/gates/Gate.d.ts
 /**
- * The interaction arm. It extends {@link GuildPermissionsContext} with the live interaction and
+ * The context a gate gets on an interaction. It extends {@link GuildPermissionsContext} with the live interaction and
  * the djs objects resolved from the gateway cache. `Repliable` is the interaction type the gate
  * supports, inferred from the `ctx` annotation, so a gate reading button-specific fields is rejected
  * on a slash handler. `interaction` is the reply target, so `user` is always present. Use
@@ -516,7 +480,7 @@ export declare abstract class InteractionHandler<Repliable extends Repliables> e
  * });
  * ```
  */
-interface InteractionGateContext<Repliable extends Repliables = Repliables> extends GuildPermissionsContext {
+interface InteractionGateContext<Repliable extends Repliables = Repliables> extends GuildPermissionsContext, AppPermissionsContext {
   /** The literal `'interaction'`. Narrow on it before reading `interaction`. */
   readonly kind: 'interaction';
   /** The running framework, with the gateway's bot and bus. */
@@ -531,12 +495,12 @@ interface InteractionGateContext<Repliable extends Repliables = Repliables> exte
   readonly member: GuildMember | null;
 }
 /**
- * The event arm. It extends {@link GuildPermissionsContext} with the event payload and the djs
+ * The context a gate gets on an event. It extends {@link GuildPermissionsContext} with the event payload and the djs
  * objects derived from it. `Names` is the event(s) the gate supports, inferred from the `ctx`
  * annotation, so a gate that reads one event's `payload` is rejected on a handler for a different
  * event. The default supports every event.
  *
- * @typeParam Names - The event name or names the gate reads, typing `payload` to that event's args tuple.
+ * @typeParam Names - One event or a union of the events the gate reads. `payload` gets that event's args tuple.
  *
  * @example
  * ```ts
@@ -573,7 +537,7 @@ interface EventGateContext<Names extends ValidNonInteractionKeys = ValidNonInter
  *
  * @example
  * ```ts
- * // a gate that handles either arm narrows on ctx.kind
+ * // a gate that takes either context narrows on ctx.kind
  * const Either = defineGate('either', (ctx: GateContext) => {
  *     if (ctx.kind === 'interaction') void ctx.interaction;
  *     else void ctx.payload;
@@ -592,7 +556,7 @@ interface Ungateable {
   readonly [UngateableBrand]: true;
 }
 type ProvidedContext<TCtor extends AnyHandlerCtor> = InstanceType<TCtor> extends InteractionHandler<infer Repliable> ? InteractionGateContext<Repliable> : InstanceType<TCtor> extends EventHandler<infer Names> ? EventGateContext<Names> : Ungateable;
-type KindName<Ctx> = Ctx extends Ungateable ? 'autocomplete' : Ctx extends InteractionGateContext<infer R> ? R extends ChatInputCommandInteraction ? 'Slash' : R extends MessageContextMenuCommandInteraction ? 'MessageContextMenu' : R extends UserContextMenuCommandInteraction ? 'UserContextMenu' : R extends StringSelectMenuInteraction ? 'StringMenu' : R extends UserSelectMenuInteraction ? 'UserMenu' : R extends RoleSelectMenuInteraction ? 'RoleMenu' : R extends ChannelSelectMenuInteraction ? 'ChannelMenu' : R extends MentionableSelectMenuInteraction ? 'MentionableMenu' : R extends ButtonInteraction ? 'Button' : R extends ModalSubmitInteraction ? 'Modal' : 'an interaction' : Ctx extends EventGateContext<infer N> ? `${N & string} event` : 'an agnostic';
+type KindName<Ctx> = Ctx extends Ungateable ? 'autocomplete' : Ctx extends InteractionGateContext<infer R> ? Repliables extends R ? 'generic interaction' : R extends ChatInputCommandInteraction ? 'Slash' : R extends MessageContextMenuCommandInteraction ? 'MessageContextMenu' : R extends UserContextMenuCommandInteraction ? 'UserContextMenu' : R extends StringSelectMenuInteraction ? 'StringMenu' : R extends UserSelectMenuInteraction ? 'UserMenu' : R extends RoleSelectMenuInteraction ? 'RoleMenu' : R extends ChannelSelectMenuInteraction ? 'ChannelMenu' : R extends MentionableSelectMenuInteraction ? 'MentionableMenu' : R extends ButtonInteraction ? 'Button' : R extends ModalSubmitInteraction ? 'Modal' : 'generic interaction' : Ctx extends EventGateContext<infer N> ? `${N & string} event` : Ctx extends AppPermissionsContext ? 'generic interaction' : 'any';
 type FitAll<TCtor extends AnyHandlerCtor, Gates extends readonly Gate<GateContextBase>[]> = { [Index in keyof Gates]: GateFitsWith<ProvidedContext<TCtor>, KindName<ProvidedContext<TCtor>>, Gates[Index], KindName<RequiredOf<Gates[Index]>>>; };
 //#endregion
 //#region src/bot/decorators/Gated.d.ts
@@ -600,10 +564,10 @@ type FitAll<TCtor extends AnyHandlerCtor, Gates extends readonly Gate<GateContex
  * Attaches gates to a handler. The gates run before `execute`, and a gate refusing stops the handler with
  * the reply or drop the gate threw. Multiple gates are ANDed, so each must pass. A gate that requires a
  * context the handler does not provide (a button gate on a slash handler, an interaction gate on an event
- * handler) is a compile error at this line, and the error names the gate and the handler kind. Place it
+ * handler) is a compile error at this line, and the error message shows the gate and the handler kind. Place it
  * above the route decorator.
  *
- * Combine gates with {@link and} or {@link or} to build a single gate from multiple arms.
+ * Combine gates into a single gate with {@link and} or {@link or}.
  *
  * @example
  * ```ts
@@ -686,13 +650,42 @@ export declare function RegisterEventMiddleware<const Events extends NonEmptyTup
  */
 export declare const IgnoreBots: import("@seedcord/core").Gate<EventGateContext<ValidNonInteractionKeys>, "IgnoreBots">;
 //#endregion
+//#region src/bot/gates/catalog/MentionPrefix.d.ts
+/**
+ * Passes only a message that starts with a mention of the bot, like `@bot ping`. It ignores every other message
+ * with a {@link Silence}, including a reply that pings the bot, a role mention, and a mention later in the text.
+ *
+ * On `messageUpdate` it passes only when the edit adds the mention. An edit that keeps the mention doesn't run the
+ * handler again. With `Partials.Message` on, discord.js also emits an edit to a message it didn't cache. That edit
+ * runs the handler again. Attach the gate without calling it, since it doesn't take options.
+ *
+ * A handler behind this gate can read `content` without the Message Content intent, because Discord sends the text of
+ * a message that mentions the bot.
+ *
+ * @see {@link Gated}
+ *
+ * @example
+ * ```ts
+ * import { Events } from 'discord.js';
+ *
+ * \@Gated(IgnoreBots, MentionPrefix)
+ * \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+ * class MentionCommands extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+ *     async execute() {
+ *         // ...
+ *     }
+ * }
+ * ```
+ */
+export declare const MentionPrefix: import("@seedcord/core").Gate<EventGateContext<"messageCreate" | "messageUpdate">, "MentionPrefix">;
+//#endregion
 //#region src/bot/gates/catalog/Nsfw.d.ts
 /**
- * Requires an age-restricted channel, else refuses. Pass {@link GateNoticeOptions} to reword or replace the refusal.
+ * Requires an age-restricted channel, else refuses. Pass a Notice class as `notice` to replace the refusal.
  *
  * A thread inherits its parent channel's nsfw flag. ModalSubmit has no reliable channel, so it is excluded.
  *
- * @param options - Reword the default refusal with `message`, or replace it with `notice`.
+ * @param options - Replace the refusal with a Notice class as `notice`.
  *
  * @see {@link Gated}
  *
@@ -731,130 +724,97 @@ type InjectedEmojiMap = { [K in keyof EmojiMap]: EmojiMap[K] extends 'guild' ? G
  */
 export declare const Emojis: InjectedEmojiMap;
 //#endregion
-//#region src/bot/utilities/permissions/checkBotPermissions.d.ts
-/**
- * Checks the bot's own permissions in a {@link Guild} or {@link TextChannel}. Refuses when a permission in
- * `scope` is missing, or with `inverse` when one is present. When the bot member is uncached, the refusal
- * reports every permission in `scope` as missing.
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import { checkBotPermissions } from '@seedcord/gateway';
- *
- * checkBotPermissions(textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
- * ```
- */
-export declare function checkBotPermissions(target: Guild | TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
-//#endregion
 //#region src/bot/utilities/permissions/checkPermissions.d.ts
 /** Options for {@link checkPermissions}. */
-interface CheckPermissionOptions extends PermissionNoticeOverrides {
+interface CheckPermissionOptions {
   /** The role or member to check. */
   for: Role | GuildMember;
-  /** A guild reads the base bits from roles, a text channel reads the overwrite-resolved set. */
-  in: Guild | TextChannel;
+  /** A channel or thread, to read the set after its overwrites. Leave it out to read the base set from roles. */
+  in?: GuildBasedChannel | undefined;
   /** The permission flag bits to check. */
   scope: PermissionScope;
   /** Refuse when the target holds a scope bit. */
   inverse?: boolean;
+  /** Your Notice class, thrown in place of the default refusal. seedcord constructs it with the target's mention and the refused names. */
+  notice?: PermissionNoticeConstructor | undefined;
 }
 /**
- * Checks a {@link Role} or a {@link GuildMember} against the base permission bits in a {@link Guild},
- * before channel overwrites. Refuses when a permission in `scope` is missing, or with `inverse` when one
- * is present.
+ * Checks a {@link Role} or a {@link GuildMember} against the base permission set from roles, or against a
+ * channel's set when `in` is given. Refuses when a permission in `scope` is missing, or with `inverse` when
+ * one is present.
+ *
+ * @throws A {@link Notice} when the check refuses. It lists the missing or present permissions.
  *
  * @example
  * ```ts
  * import { PermissionFlagsBits } from 'discord.js';
  * import { checkPermissions } from '@seedcord/gateway';
  *
- * checkPermissions(role, guild, [PermissionFlagsBits.ManageMessages, PermissionFlagsBits.KickMembers]);
+ * checkPermissions({ for: member, scope: [PermissionFlagsBits.KickMembers] });
+ * checkPermissions({ for: role, in: channel, scope: [PermissionFlagsBits.SendMessages] });
  * ```
  *
  * @example
  * ```ts
- * // refuse when the member holds Administrator, and replace the refusal
- * checkPermissions(member, guild, [PermissionFlagsBits.Administrator], true, {
- *   dangerousNotice: CustomDangerousNotice
- * });
+ * // refuse when the member holds Administrator, with your own Notice class
+ * checkPermissions({ for: member, scope: [PermissionFlagsBits.Administrator], inverse: true, notice: TooPowerful });
  * ```
  */
-export declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
+export declare function checkPermissions({ for: target, in: channel, scope, inverse, notice }: CheckPermissionOptions): void;
+//#endregion
+//#region src/bot/utilities/permissions/checkBotPermissions.d.ts
+/** Options for {@link checkBotPermissions}. */
+interface CheckBotPermissionOptions extends TypedOmit<CheckPermissionOptions, 'for' | 'in'> {
+  /** A guild, to read the bot's base set from roles, or a channel or thread, to read its set there. */
+  in: Guild | GuildBasedChannel;
+}
 /**
- * Checks a {@link Role} or a {@link GuildMember} against the overwrite-resolved set in a
- * {@link TextChannel}. Refuses when a permission in `scope` is missing, or with `inverse` when one is
- * present.
+ * Checks the bot's own permissions in a {@link Guild}, or in a channel or thread. Refuses when a permission
+ * in `scope` is missing, or with `inverse` when one is present.
  *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import { checkPermissions } from '@seedcord/gateway';
- *
- * checkPermissions(role, textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
- * ```
- */
-export declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionNoticeOverrides): void;
-/**
- * Checks permissions with an options object. Refuses when a permission in
- * {@link CheckPermissionOptions.scope} is missing, or with `options.inverse` when one is present.
+ * @throws A {@link Notice} when the check refuses. It lists the missing or present permissions.
+ * @throws A **SeedcordError** when the guild's member cache doesn't hold the bot's member.
  *
  * @example
  * ```ts
  * import { PermissionFlagsBits } from 'discord.js';
- * import { checkPermissions } from '@seedcord/gateway';
+ * import { checkBotPermissions } from '@seedcord/gateway';
  *
- * checkPermissions({
- *   for: member,
- *   in: textChannel,
- *   scope: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]
- * });
+ * checkBotPermissions({ in: channel, scope: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel] });
  * ```
  */
-export declare function checkPermissions(options: CheckPermissionOptions): void;
+export declare function checkBotPermissions({ in: where, ...check }: CheckBotPermissionOptions): void;
 //#endregion
 //#region src/bot/utilities/permissions/hasPermsToAssign.d.ts
-/**
- * Optional custom error constructors for {@link HasPermsToAssignOptions}.
- */
-export interface AssignRoleNoticeOverrides {
-  higherNotice?: new (message: string, role: Role, botRole: Role) => Notice;
-  managedNotice?: new (message: string) => Notice;
-  missingNotice?: new (message: string | undefined, subject: string, missingPerms: readonly string[]) => Notice;
-}
-/**
- * Options for {@link hasPermsToAssign}.
- */
+/** Options for {@link hasPermsToAssign}. */
 export interface HasPermsToAssignOptions {
-  targetRole: Role;
-  noticeOverrides?: AssignRoleNoticeOverrides;
+  /** The role the bot would assign. */
+  role: Role;
+  /** Your Notice class, constructed with both roles and thrown in place of the refusal when the role is at or above the bot's. */
+  higher?: NoticeConstructor<[role: Role, botRole: Role]>;
+  /** Your Notice class, constructed with the role and thrown in place of the refusal when an integration manages the role. */
+  managed?: NoticeConstructor<[role: Role]>;
+  /** Your Notice class, thrown when the bot lacks Manage Roles. seedcord constructs it with the bot's mention and that permission's name. */
+  missing?: PermissionNoticeConstructor;
 }
 /**
- * Validates that the bot can assign a target role. Refuses when the target role is above the bot's, is managed, or the bot lacks Manage Roles.
+ * Validates that the bot can assign a role. Refuses when the role is at or above the bot's, when an
+ * integration manages it, or when the bot lacks Manage Roles.
  *
- * @param roleOrOptions - Target role or complete options for the check
  * @throws A {@link Notice} when the check refuses.
- * @throws A **SeedcordError** when the bot has no role in the guild's role cache.
+ * @throws A **SeedcordError** when the guild's caches don't hold the bot's role or member.
  *
  * @example
  * ```ts
  * import { hasPermsToAssign } from '@seedcord/gateway';
  *
- * // Check if the bot can assign a specific role
- * hasPermsToAssign(role);
+ * hasPermsToAssign({ role });
  *
- * // Check with custom error handling
- * hasPermsToAssign({
- *   targetRole: role,
- *   noticeOverrides: {
- *     higherNotice: CustomHigherNotice,
- *     managedNotice: CustomManagedNotice,
- *     missingNotice: CustomMissingPermissionsNotice
- *   }
- * });
+ * // with your own Notice classes
+ * hasPermsToAssign({ role, higher: RoleTooHigh, managed: RoleIsManaged, missing: CannotManageRoles });
  * ```
  */
-export declare function hasPermsToAssign(roleOrOptions: Role | HasPermsToAssignOptions): void;
+export declare function hasPermsToAssign({ role, higher, managed, missing }: HasPermsToAssignOptions): void;
 //#endregion
 //#region src/bot/confirm/getConfirmation.d.ts
 type Outcome = ReplyResponse | (() => Promisable<ReplyResponse>);
@@ -1025,7 +985,15 @@ type InteractionOf<Kind extends MiddlewareKind> = InteractionForKind[Kind];
 export declare abstract class InteractionMiddleware<in out Kind extends MiddlewareKind = MiddlewareKind> extends RepliableHandler<InteractionOf<Kind>> {
   /** @internal */
   readonly [MiddlewareKindsBrand]?: Kind;
-  constructor(event: InteractionOf<Kind>, core: Core, dispatch: DispatchContext, sender: ReplySender);
+  constructor(event: InteractionOf<Kind>, core: Core, dispatch: DispatchContext$1, sender: ReplySender);
+  /**
+   * What started this dispatch: a slash command path like `config/set`, a context menu command's
+   * name, or a custom-ID prefix. When the generic lists only slash or context menu kinds, your editor
+   * offers your registered commands. It can still be any string, since middleware also runs when no
+   * handler matched, like on a deleted command that Discord still shows. For a custom ID that seedcord
+   * didn't make, it can be empty or a cut-off piece of that ID.
+   */
+  protected readonly route: MiddlewareRoute<Kind>;
   /**
    * Runs once the handler settles, newest middleware first. A refusal or a throw still reaches it,
    * since seedcord calls it on every middleware whose `execute()` started. Implement it to release
@@ -1042,7 +1010,7 @@ export declare abstract class InteractionMiddleware<in out Kind extends Middlewa
    * }
    * ```
    */
-  after?(result: DispatchResult): Promise<void>;
+  after?(result: DispatchResult): Promisable<void>;
 }
 //#endregion
 //#region src/inputs/SlashOptions.d.ts
@@ -1069,13 +1037,14 @@ interface GatewayLens<Cache extends CacheType> {
 type SlashOptions<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> = SlashOptions$1<Route, GatewayLens<Cache>>;
 //#endregion
 //#region src/handlers/interaction/SlashHandler.d.ts
-type SlashMatchArms<Route extends keyof SlashRegistry, Cache extends CacheType, Ret> = { [Key in Route]: (options: SlashOptions<Key, Cache>) => Promisable<Ret>; };
+type CaseCache<Route extends keyof SlashRegistry, Cache extends CacheType, Key extends Route> = [Cache] extends [CacheFor<Route>] ? CacheFor<Key> : Cache;
+type SlashMatchCases<Route extends keyof SlashRegistry, Cache extends CacheType, Ret> = { [Key in Route]: (options: SlashOptions<Key, CaseCache<Route, Cache, Key>>) => CaseReturn<Ret>; };
 /**
  * Base class for a chat-input (slash) command handler.
  *
  * Pass the route from the generated registry as the generic, the same string as `@SlashRoute`, then read
  * `this.options` for a single command or `this.match` for several. Command authoring stays plain
- * discord.js, `seedcord codegen` reads its `toJSON()` to type these options.
+ * discord.js. `seedcord codegen` reads its `toJSON()` to type these options.
  *
  * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
  * @typeParam Cache - The interaction cache state. The command's contexts set it.
@@ -1094,30 +1063,32 @@ type SlashMatchArms<Route extends keyof SlashRegistry, Cache extends CacheType,
 export declare abstract class SlashHandler<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> extends InteractionHandler<ChatInputCommandInteraction<Cache>> {
   /** @internal */
   readonly [SlashRouteBrand]?: Route;
+  /** The selected command's path, such as `search/docs`. */
+  protected readonly route: Route;
   /**
    * The typed options for this command's route. Only the getters for kinds this command declares appear.
    * Each getter's name argument is restricted to that command's options of its kind.
    *
-   * - A required option drops the null.
+   * - A required option's getter never returns `null`.
    *
    * - Choices narrow to their literal union.
    *
    * - A channel option declared with `addChannelTypes` narrows to those types.
    *
    * Use `this.event.options` directly for anything outside this view, such as `getSubcommand()`.
-   * However, for the common case, the methods in this would suffice.
    */
   protected get options(): SlashOptions<Route, Cache>;
   /**
-   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * Run the case for the selected command. Use this only when the handler is registered for several
    * routes.
    *
-   * Provide one arm per registered route, keyed by its route string, and each arm receives that route's
-   * own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
+   * Provide one case per registered route, keyed by its route string, and each case receives that route's
+   * own narrowed options. The cases must cover every route in the generic. A missing route or an unknown
    * key is a compile error.
    *
-   * @param arms - One handler per registered route, keyed by route string.
-   * @returns The result of the arm that ran.
+   * @param cases - One handler per registered route, keyed by route string.
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @returns The result of the case that ran.
    *
    * @example
    * ```ts
@@ -1132,12 +1103,12 @@ export declare abstract class SlashHandler<Route extends keyof SlashRegistry, Ca
    * }
    * ```
    */
-  protected match<Ret>(arms: SlashMatchArms<Route, Cache, Ret>): Promise<Ret>;
+  protected match<Ret = never, Cases extends SlashMatchCases<Route, Cache, Ret> = SlashMatchCases<Route, Cache, Ret>>(cases: OnlyCases<Cases, SlashMatchCases<Route, Cache, Ret>>): Promise<MatchResult<Ret, Cases>>;
 }
 //#endregion
 //#region src/handlers/interaction/ContextMenuHandler.d.ts
-type UserMenuArms<Names extends NamesFor<ApplicationCommandType.User>, Ret> = { [Name in Names]: (target: User, member: CacheTypeReducer<MenuCacheFor<ApplicationCommandType.User, Name>, GuildMember, APIInteractionGuildMember> | null) => Promisable<Ret>; };
-type MessageMenuArms<Names extends NamesFor<ApplicationCommandType.Message>, Ret> = { [Name in Names]: (target: Message<BooleanCache<MenuCacheFor<ApplicationCommandType.Message, Name>>>) => Promisable<Ret>; };
+type UserMenuCases<Names extends NamesFor<ApplicationCommandType.User>, Ret> = { [Name in Names]: (target: User, member: CacheTypeReducer<MenuCacheFor<ApplicationCommandType.User, Name>, GuildMember, APIInteractionGuildMember> | null) => CaseReturn<Ret>; };
+type MessageMenuCases<Names extends NamesFor<ApplicationCommandType.Message>, Ret> = { [Name in Names]: (target: Message<BooleanCache<MenuCacheFor<ApplicationCommandType.Message, Name>>>) => CaseReturn<Ret>; };
 /**
  * Base class for a user context-menu command handler (right-click a user).
  *
@@ -1165,19 +1136,20 @@ export declare abstract class UserContextMenuHandler<Names extends NamesFor<Appl
   protected get target(): User;
   /** The right-clicked user's guild member, null outside a guild. */
   protected get targetMember(): CacheTypeReducer<Cache, GuildMember, APIInteractionGuildMember> | null;
-  /** Which of the registered commands fired. */
-  protected get commandName(): Names;
+  /** The selected context-menu command's name, without the interaction-kind prefix. */
+  protected readonly route: Names;
   /**
-   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * Run the case for the selected command. Use this only when the handler is registered for several
    * names.
    *
-   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
-   * arm receives the clicked user and that user's guild member, both narrowed to the cache state of that
-   * one command. The arms must cover every name in the generic. A missing name or an unknown key is a
+   * Provide one case per registered name, keyed by the name Discord shows in the right-click menu. Each
+   * case receives the clicked user and that user's guild member, both narrowed to the cache state of that
+   * one command. The cases must cover every name in the generic. A missing name or an unknown key is a
    * compile error.
    *
-   * @param arms - One handler per registered command name.
-   * @returns The result of the arm that ran.
+   * @param cases - One handler per registered command name.
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @returns The result of the case that ran.
    *
    * @example
    * ```ts
@@ -1192,7 +1164,7 @@ export declare abstract class UserContextMenuHandler<Names extends NamesFor<Appl
    * }
    * ```
    */
-  protected match<Ret>(arms: UserMenuArms<Names, Ret>): Promise<Ret>;
+  protected match<Ret = never, Cases extends UserMenuCases<Names, Ret> = UserMenuCases<Names, Ret>>(cases: OnlyCases<Cases, UserMenuCases<Names, Ret>>): Promise<MatchResult<Ret, Cases>>;
 }
 /**
  * Base class for a message context-menu command handler (right-click a message).
@@ -1219,18 +1191,19 @@ export declare abstract class MessageContextMenuHandler<Names extends NamesFor<A
   /** @internal */
   readonly [ContextMenuNamesBrand]?: Names;
   protected get target(): Message<BooleanCache<Cache>>;
-  /** Which of the registered commands fired. */
-  protected get commandName(): Names;
+  /** The selected context-menu command's name, without the interaction-kind prefix. */
+  protected readonly route: Names;
   /**
-   * Run the arm for whichever command fired. Use this only when the handler is registered for several
+   * Run the case for the selected command. Use this only when the handler is registered for several
    * names.
    *
-   * Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
-   * arm receives the clicked message, narrowed to the cache state of that one command. The arms must
+   * Provide one case per registered name, keyed by the name Discord shows in the right-click menu. Each
+   * case receives the clicked message, narrowed to the cache state of that one command. The cases must
    * cover every name in the generic. A missing name or an unknown key is a compile error.
    *
-   * @param arms - One handler per registered command name.
-   * @returns The result of the arm that ran.
+   * @param cases - One handler per registered command name.
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @returns The result of the case that ran.
    *
    * @example
    * ```ts
@@ -1245,17 +1218,17 @@ export declare abstract class MessageContextMenuHandler<Names extends NamesFor<A
    * }
    * ```
    */
-  protected match<Ret>(arms: MessageMenuArms<Names, Ret>): Promise<Ret>;
+  protected match<Ret = never, Cases extends MessageMenuCases<Names, Ret> = MessageMenuCases<Names, Ret>>(cases: OnlyCases<Cases, MessageMenuCases<Names, Ret>>): Promise<MatchResult<Ret, Cases>>;
 }
 //#endregion
 //#region src/handlers/interaction/AutocompleteHandler.d.ts
-type FocusedArms<Route extends keyof SlashRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly ApplicationCommandOptionChoiceData<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<Ret>; };
+type FocusedCases<Route extends keyof SlashRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly ApplicationCommandOptionChoiceData<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => CaseReturn<Ret>; };
 /**
  * Base class for a Discord autocomplete handler.
  *
  * Pass the command route(s) from the generated registry as the generic, the same string(s) as
  * `@AutocompleteRoute`. Branch on the focused field with `this.match`, read already-entered sibling options
- * with `this.options`, and find which command fired with `this.route`.
+ * with `this.options`, and read the selected command's path from `this.route`.
  *
  * @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'search'` or `'search' | 'find'`.
  * @typeParam Cache - The interaction cache state. The command's contexts set it.
@@ -1273,9 +1246,12 @@ type FocusedArms<Route extends keyof SlashRegistry, Ret> = { [Name in Autocomple
  * ```
  */
 export declare abstract class AutocompleteHandler<Route extends keyof SlashRegistry, Cache extends CacheType = CacheFor<Route>> extends BaseHandler<AutocompleteInteraction<Cache>> {
+  #private;
   /** @internal */
   readonly [AutocompleteRouteBrand]?: Route;
-  constructor(event: AutocompleteInteraction<Cache>, core: Core, dispatch: DispatchContext);
+  constructor(event: AutocompleteInteraction<Cache>, core: Core, dispatch: DispatchContext$1, responder: AutocompleteResponder<ApplicationCommandOptionChoiceData>);
+  /** The user who sent this interaction. */
+  protected get user(): User;
   private decodedFocused?;
   /**
    * The focused option for this interaction. `value` is always the raw partial string the user is typing,
@@ -1283,16 +1259,17 @@ export declare abstract class AutocompleteHandler<Route extends keyof SlashRegis
    */
   protected get focused(): FocusedField<Route>;
   /**
-   * Run the arm for the focused field. Because an autocomplete always dispatches by which field is
+   * Run the case for the focused field. Because an autocomplete always dispatches by which field is
    * focused, match is how you read it. There is no single-field shortcut the way slash/component handlers have one.
    *
-   * Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
-   * arm receives the focused partial value and a `respond` typed to that field's choice value. The
-   * arms must cover every autocompletable field. A missing field or an unknown key is a compile error.
+   * Provide one case per autocompletable field across the registered commands, keyed by field name. Each
+   * case receives the focused partial value and a `respond` typed to that field's choice value. The
+   * cases must cover every autocompletable field. A missing field or an unknown key is a compile error.
    *
-   * @param arms - One handler per autocompletable field, keyed by field name.
-   * @returns The result of the arm that ran.
-   * @throws A **SeedcordTypeError** with `MatchArmMissing` when the focused field has no arm. Only a stale-deployed command can send one.
+   * @param cases - One handler per autocompletable field, keyed by field name.
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @returns The result of the case that ran.
+   * @throws A **SeedcordTypeError** with `MatchCaseMissing` when the focused field doesn't have a case. Only a stale-deployed command can send one.
    *
    * @example
    * ```ts
@@ -1307,11 +1284,11 @@ export declare abstract class AutocompleteHandler<Route extends keyof SlashRegis
    * }
    * ```
    */
-  protected match<Ret>(arms: FocusedArms<Route, Ret>): Promise<Ret>;
+  protected match<Ret = never, Cases extends FocusedCases<Route, Ret> = FocusedCases<Route, Ret>>(cases: OnlyCases<Cases, FocusedCases<Route, Ret>>): Promise<MatchResult<Ret, Cases>>;
   /** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
   protected respond(choices: readonly ApplicationCommandOptionChoiceData[]): Promise<void>;
-  /** The firing command route, for a field whose completion differs per registered command. */
-  protected get route(): Route;
+  /** The selected command's path, such as `search/docs`, without the interaction-kind prefix. */
+  protected readonly route: Route;
   /**
    * The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
    * (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
@@ -1339,7 +1316,9 @@ export declare abstract class ComponentHandler<Event extends ComponentInteractio
   /** Acknowledge the component without changing the source message. */
   protected deferUpdate(): Promise<void>;
   private decoded?;
-  private get route();
+  private get decodedRoute();
+  /** The matched custom-ID prefix, such as `approve`, without encoded params. */
+  protected readonly route: Defs[number]['prefix'];
   /**
    * The decoded params of the single route this handler is registered for.
    *
@@ -1351,17 +1330,18 @@ export declare abstract class ComponentHandler<Event extends ComponentInteractio
    */
   protected get params(): SingleParams<Defs>;
   /**
-   * Run the arm for whichever route the component was minted from. Use this only when the handler is
-   * registered for several routes. A single-route handler reads `this.params` directly. On a multi-route
+   * Run the case for whichever route the component was minted from. Use this only when the handler is
+   * registered for several routes. On a single-route handler, read `this.params` directly. On a multi-route
    * handler `this.params` is `never`, leaving match as the only way to read the decoded params.
    *
-   * Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
-   * decoded params. The compiler checks that the arms cover every registered route prefix. `match`
-   * decodes the wire before it runs an arm.
+   * Provide one case per registered route, keyed by its prefix, and each case receives that route's own
+   * decoded params. The compiler checks that the cases cover every registered route prefix. `match`
+   * decodes the wire before it runs a case.
    *
-   * @param arms - One callback per registered route, keyed by prefix.
-   * @returns The result of the arm that ran.
-   * @throws A **SeedcordTypeError** with `MatchArmMissing` when the wire's prefix has no arm.
+   * @param cases - One callback per registered route, keyed by prefix.
+   * @typeParam Ret - The type that every case must return. Leave it out to get the union of what the cases return.
+   * @returns The result of the case that ran.
+   * @throws A **SeedcordTypeError** with `MatchCaseMissing` when the wire's prefix doesn't have a case.
    * @throws A **StaleCustomId** when the wire was encoded under an older shape.
    * @throws An **InvalidCustomId** when the wire is corrupt.
    *
@@ -1378,7 +1358,7 @@ export declare abstract class ComponentHandler<Event extends ComponentInteractio
    * }
    * ```
    */
-  protected match<Ret>(arms: MatchArms<Defs, Ret>): Promise<Ret>;
+  protected match<Ret = never, Cases extends MatchCases<Defs, Ret> = MatchCases<Defs, Ret>>(cases: OnlyCases<Cases, MatchCases<Defs, Ret>>): Promise<MatchResult<Ret, Cases>>;
 }
 //#endregion
 //#region src/handlers/interaction/components/ButtonHandler.d.ts
@@ -1681,14 +1661,14 @@ export declare class CursorSource<Item> extends CursorSourceBase<Item, PageConte
 /**
  * Base class for a gateway subscriber, binding `this.core` to the gateway {@link Core}.
  *
- * @typeParam KeyOfSubscribers - The subscription key this handler receives
+ * @typeParam KeyOfSubscribers - The subscription key or keys that this handler receives, the same ones as `@Subscribe`
  */
 export declare abstract class Subscriber<KeyOfSubscribers extends SubscriptionKey> extends Subscriber$1<KeyOfSubscribers, Core> {}
 /**
  * Base class for a gateway subscriber that delivers its event to a Discord webhook, binding
  * `this.core` to the gateway {@link Core}.
  *
- * @typeParam KeyOfSubscribers - The subscription key this reporter receives
+ * @typeParam KeyOfSubscribers - The subscription key or keys that this reporter receives, the same ones as `@Subscribe`
  */
 export declare abstract class WebhookLog<KeyOfSubscribers extends SubscriptionKey> extends WebhookLog$1<KeyOfSubscribers, Core> {}
 //#endregion
@@ -1708,8 +1688,8 @@ declare const GATEWAY_SCOPE: {
 /**
  * Base class for a gateway plugin, binding `this.core` to the gateway {@link Core}.
  *
- * A plugin that runs on either transport extends the base from `@seedcord/core/plugin`, whose
- * `this.core` is typed to the shared members only.
+ * To run on either transport, extend the base from `@seedcord/core/plugin`. Its `this.core` carries
+ * only the shared members.
  *
  * @typeParam Opts - The transport and runtime the plugin declares.
  */
@@ -1738,16 +1718,12 @@ export declare class Seedcord extends ServerHost<'gateway'> implements SeedcordI
   readonly [HostAugmentTarget] = "@seedcord/gateway";
   /** @internal */
   readonly [HostVersion]: string;
-  /** @see {@link Bus} */
-  readonly bus: Bus;
   /** @see {@link Bot} */
   readonly bot: Bot;
   /** The discord.js client's REST client. Its token is set during the Login phase. */
   readonly rest: REST;
   /** The bot's Discord application id. Throws if you read it before login. */
   get applicationId(): string;
-  /** @see {@link IRateLimiter} */
-  readonly rateLimiter: IRateLimiter;
   /**
    * @param config - Bot configuration including paths and Discord client options
    * @throws A **SeedcordError** when another `Seedcord` exists in this process and has not shut down.
@@ -1770,5 +1746,5 @@ export declare class Seedcord extends ServerHost<'gateway'> implements SeedcordI
 /** Package version */
 export declare const version: string;
 //#endregion
-export { type CheckPermissionOptions, type ConfirmOptions, type Core, type DefaultConfirmOptions, type EventGateContext, type EventMiddlewareOptions, type EventSpec, type EventsConfig, type GateContext, type GatewayBotConfig, type GatewayConfig, type GatewayFile, type GatewayPluginOptions, type GatewayReplyResponse, HmrModuleHandler, type InjectedEmojiMap, type InteractionGateContext, type PageContext, type PageSource, type PluginLifecycleSpec, type PluginOptions, type RegisterEventOptions, type Repliables, type SentMessage, type SlashOptions, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, WinstonConsoleSink, WinstonFileSink };
+export { type CheckBotPermissionOptions, type CheckPermissionOptions, type ConfirmOptions, type Core, type DefaultConfirmOptions, type EventGateContext, type EventMiddlewareOptions, type EventSpec, type EventsConfig, type GateContext, type GatewayBotConfig, type GatewayConfig, type GatewayFile, type GatewayPluginOptions, type GatewayReplyResponse, HmrModuleHandler, type InjectedEmojiMap, type InteractionGateContext, type PageContext, type PageSource, type PluginLifecycleSpec, type PluginOptions, type RegisterEventOptions, type Repliables, type SentMessage, type SlashOptions, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, WinstonConsoleSink, WinstonFileSink };
 //# sourceMappingURL=index.d.mts.map