@seedcord/gateway 0.1.0-next.1 → 0.1.0-next.3

package/dist/index.d.mts

@@ -1,17 +1,19 @@
-import { BuilderComponent, CoreBase, DispatchContext, Gate, GateContextBase, GateNoticeOptions, MessageContextMenuRegistry, Notice, OptionKind, PageView, RegisterCommand, RequiredOf, SlashOptionRegistry, UserContextMenuRegistry } from "@seedcord/core";
-import { AnyCustomId, DecodedParams, GateFitsWith, HasComponentDefs, PageCursor } from "@seedcord/core/internal";
-import { APIInteractionGuildMember, APIMessageComponentEmoji, AnySelectMenuInteraction, ApplicationCommand, ApplicationCommandOptionChoiceData, ApplicationCommandType, ApplicationEmoji, AutocompleteInteraction, BooleanCache, ButtonInteraction, ButtonStyle, CacheType, CacheTypeReducer, ChannelSelectMenuInteraction, ChannelType, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Collection, CommandInteractionOption, ContextMenuCommandInteraction, Events, Guild, GuildEmoji, GuildMember, Interaction, MentionableSelectMenuInteraction, Message, MessageContextMenuCommandInteraction, ModalSubmitInteraction, Role, RoleSelectMenuInteraction, Snowflake, StringSelectMenuInteraction, TextChannel, TextChannelResolvable, User, UserContextMenuCommandInteraction, UserSelectMenuInteraction, WebhookClient } from "discord.js";
-import { CoordinatedShutdown, CoordinatedStartup, Logger, StartupPhase } from "@seedcord/services";
+import { AnyCustomId, AutocompletableNames, BaseReplySender, ChoiceValueOf, EntryFor, FocusedField, GateFitsWith, HasComponentDefs, MatchArms, ModalLike, PageCursor, SingleParams, SlashOptions as SlashOptions$1 } from "@seedcord/core/internal";
+import { AutocompleteOptions, BaseHandler, BuilderComponent, CoreBase, DispatchContext, Gate, GateContextBase, GateNoticeOptions, GuildPermissionsContext, Notice, PageView, PermissionScope, RepliableHandler as RepliableHandler$1, RequiredOf, SelectMenuKind, SlashOptionRegistry } from "@seedcord/core";
+import { Logger } from "@seedcord/logger";
 import { ActionRowBuilder, ButtonBuilder, ContextMenuCommandBuilder, SlashCommandBuilder } from "@discordjs/builders";
-import { EventMap, NoEvents, TypedEventEmitter } from "@seedcord/event-emitter";
-import { HmrAware, HmrUpdateEvent, SeedcordBrand, SeedcordInstance } from "@seedcord/types/internal";
+import { APIInteractionGuildMember, APIMessageComponentEmoji, APIModalInteractionResponseCallbackData, AnySelectMenuInteraction, ApplicationCommand, ApplicationCommandOptionChoiceData, ApplicationCommandType, ApplicationEmoji, AutocompleteInteraction, BooleanCache, ButtonInteraction, ButtonStyle, CacheType, CacheTypeReducer, ChannelSelectMenuInteraction, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Collection, CommandInteractionOption, ContextMenuCommandInteraction, Events, Guild, GuildEmoji, GuildMember, Interaction, MentionableSelectMenuInteraction, Message, MessageContextMenuCommandInteraction, ModalSubmitInteraction, Role, RoleSelectMenuInteraction, Snowflake, StringSelectMenuInteraction, TextChannel, TextChannelResolvable, User, UserContextMenuCommandInteraction, UserSelectMenuInteraction } from "discord.js";
 import { UUID } from "node:crypto";
-import { BotConfig, Config, EmojiMap, IRateLimiter, Nullable, ReplyResponse, Tail, V2Component } from "@seedcord/types";
-export * from "@seedcord/core";
+import { EventMap, NoEvents, TypedEventEmitter } from "@seedcord/event-emitter";
+import { APIMessageTopLevelComponent } from "discord-api-types/v10";
+import { CoordinatedShutdown, CoordinatedStartup, ShutdownPhase, StartupPhase, StartupPhase as StartupPhase$1 } from "@seedcord/core/node";
+import { SeedcordBrand, SeedcordInstance } from "@seedcord/types/internal";
+import { BotConfig, Config, DeferOpts, EmojiMap, HmrAware, HmrUpdateEvent, IRateLimiter, ReplyResponse, SendOpts, Tail, V2Component } from "@seedcord/types";
 export * from "@seedcord/errors";
-export * from "@seedcord/utils";
-export * from "@seedcord/services";
+export * from "@seedcord/core";
+export * from "@seedcord/logger";
 export * from "@seedcord/event-emitter";
+export * from "@seedcord/utils";
 export * from "@seedcord/rate-limiter";
 export type * from "@seedcord/types";
 
@@ -57,7 +59,6 @@ interface GatewayConfig extends Config {
 }
 //#endregion
 //#region src/interfaces/Plugin.d.ts
-/** Interface for objects that can be initialized asynchronously */
 interface Initializeable {
   init(): Promise<void>;
 }
@@ -69,14 +70,10 @@ interface Initializeable {
  */
 declare abstract class Plugin<TPluginEvents extends EventMap<TPluginEvents> = NoEvents> extends TypedEventEmitter<TPluginEvents> implements Initializeable, HmrAware {
   protected pluggable: Core;
-  /** Logger instance for this plugin. */
   abstract logger: Logger;
   name: string;
   constructor(pluggable: Core);
-  /**
-   * Initialize the plugin.
-   * @virtual
-   */
+  /** @virtual */
   abstract init(): Promise<void>;
   /**
    * Reloads plugin state on an HMR update. The base implementation is a no-op, override it in your plugin.
@@ -94,15 +91,13 @@ declare abstract class Plugin<TPluginEvents extends EventMap<TPluginEvents> = No
   removeAllListeners(event?: Extract<keyof TPluginEvents, string | symbol>): this;
 }
 /**
- * Constructor type for plugins that can accept additional arguments after Core
- * @typeParam TPlugin - The plugin type being constructed
+ * Constructor type for plugins that can accept extra arguments after Core.
  *
  * @internal
  */
 type PluginCtor<TPlugin extends Plugin = Plugin> = new (core: Core, ...args: any[]) => TPlugin;
 /**
- * Extracts the argument types for a plugin constructor (excluding the Core parameter)
- * @typeParam Ctor - The plugin constructor to extract arguments from
+ * Extracts the argument types for a plugin constructor, excluding the Core parameter.
  *
  * @internal
  */
@@ -143,7 +138,7 @@ declare class Pluggable<TPluggableEvents extends EventMap<TPluggableEvents> = No
    * seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
    * ```
    */
-  attach<Key extends string, Ctor extends PluginCtor>(this: this, key: Key, Plugin: Ctor, startupPhase: StartupPhase, ...args: PluginArgs<Ctor>): this & Record<Key, InstanceType<Ctor>>;
+  attach<Key extends string, Ctor extends PluginCtor>(this: this, key: Key, Plugin: Ctor, startupPhase: StartupPhase$1, ...args: PluginArgs<Ctor>): this & Record<Key, InstanceType<Ctor>>;
   /** @internal */
   removeListener<TEventKey extends Extract<keyof TPluggableEvents, string | symbol>>(event: TEventKey, listener: (...args: TPluggableEvents[TEventKey]) => void): this;
   /** @internal */
@@ -152,7 +147,7 @@ declare class Pluggable<TPluggableEvents extends EventMap<TPluggableEvents> = No
 //#endregion
 //#region src/subscribers/types/Subscriptions.d.ts
 /**
- * Where a reported fault came from. A union over `kind`.
+ * Where a reported fault came from.
  */
 type FaultSource = InteractionFaultSource | EventFaultSource;
 /**
@@ -160,19 +155,16 @@ type FaultSource = InteractionFaultSource | EventFaultSource;
  */
 interface InteractionFaultSource {
   kind: 'interaction';
-  /** Which interaction kind produced the fault. */
   interactionKind: 'slash' | 'context-menu' | 'button' | 'select' | 'modal';
   /** Slash or context-menu command name, null for component and modal interactions. */
   command: string | null;
   /** Component or modal customId, null for slash and context-menu interactions. */
   customId: string | null;
-  /** User who triggered the interaction. */
   userId: string;
   /** Guild the interaction came from, null in DMs. */
   guildId: string | null;
   /** Channel the interaction came from, null when unavailable. */
   channelId: string | null;
-  /** The interaction's own id. */
   interactionId: string;
   /** The raw interaction, made JSON-safe at serialization with filterCirculars. */
   raw: unknown;
@@ -185,25 +177,26 @@ interface EventFaultSource {
   kind: 'event';
   eventName: string;
   handler: string;
-  /** Actor derived from the event args, null when none is present. */
   userId: string | null;
-  /** Guild derived from the event args, null outside a guild. */
+  /** Null outside a guild. */
   guildId: string | null;
-  /** Channel derived from the event args, null when none is present. */
   channelId: string | null;
   /** The raw event args, made JSON-safe at serialization with filterCirculars. */
   raw: unknown;
 }
-/**
- * Default subscribers that are always available in the framework.
- */
 interface DefaultSubscriptions {
   /** Triggered when an unhandled exception (a raw non-Notice throw) occurs */
   unknownException: {
     uuid: UUID;
     error: Error;
-    guild: Nullable<Guild>;
-    user: Nullable<User>;
+    guild?: {
+      id: string;
+      name: string;
+    } | undefined;
+    user?: {
+      id: string;
+      username: string;
+    } | undefined;
     metadata?: unknown;
   };
   /** Triggered when a reported Notice (`report: true`) is caught */
@@ -214,51 +207,35 @@ interface DefaultSubscriptions {
   };
 }
 /**
- * Custom subscribers defined by the application.
- *
- * This interface can be augmented via declaration merging to add
- * type-safe custom subscriber definitions for emitting custom subscribers anywhere in the application.
+ * Custom subscribers defined by the application. Augment it via declaration merging to type your
+ * own subscriber payloads.
  *
  * @example
  * ```typescript
  * declare module '@seedcord/gateway' {
  *   interface Subscriptions {
- *     'userJoin': { user: User; guild: Guild };
- *     'levelUp': { user: User; level: number; guild: Guild };
+ *     'userJoin': { userId: string; guildId: string };
+ *     'levelUp': { userId: string; level: number };
  *   }
  * }
  * ```
  */
 interface Subscriptions {}
-/**
- * Combined subscribers interface containing both default and custom subscribers.
- */
 interface AllSubscriptions extends DefaultSubscriptions, Subscriptions {}
-/**
- * Helper type to extract all available subscriber event names.
- */
+/** All subscriber event names available to publish and augment. */
 type SubscriptionKey = keyof AllSubscriptions;
 /**
- * Helper type to get parameters for a specific subscriber event.
+ * The payload type for a subscriber event.
  *
  * @typeParam KeyOfSubscribers - The subscriber event name
  */
 type SubscriptionData<KeyOfSubscribers extends SubscriptionKey> = AllSubscriptions[KeyOfSubscribers];
-/**
- * Event map for Bus, compatible with TypedEventEmitter.
- *
- * @internal
- */
 type SubscriptionTuples = { [K in SubscriptionKey]: [AllSubscriptions[K]] };
 //#endregion
 //#region src/subscribers/Bus.d.ts
 /**
- * Manages application subscribers and event handling
- *
- * Provides a centralized system for registering and executing custom subscribers
- * throughout the application lifecycle. Bus subscribers are loaded from configured directories
- * and can be triggered programmatically or by framework events. Accessed via `core.bus`. Do not
- * construct it directly.
+ * Registers and dispatches subscribers. Subscribers load from the configured directories and run
+ * on a programmatic or framework-event publish. Accessed via `core.bus`. Do not construct it directly.
  */
 declare class Bus extends Plugin<SubscriptionTuples> {
   protected core: Core;
@@ -268,12 +245,15 @@ declare class Bus extends Plugin<SubscriptionTuples> {
   private isInitialized;
   private readonly subscribersMap;
   private readonly executedOnceHandlers;
+  private readonly webhookProbes;
   private readonly hmrHandler?;
   constructor(core: Core);
   private getArtifacts;
   /** @internal */
   init(): Promise<void>;
-  /** @internal For use in dev mode */
+  /** @internal Exposed for tests. */
+  verifyWebhooks(): Promise<void>;
+  /** @internal */
   onHmr(event: HmrUpdateEvent): Promise<void>;
   private loadSubscribers;
   private registerSubscriber;
@@ -343,12 +323,15 @@ declare class CommandRegistry implements Initializeable, HmrAware {
   readonly globalCommands: (SlashCommandBuilder | ContextMenuCommandBuilder)[];
   readonly guildCommands: Collection<string, (SlashCommandBuilder | ContextMenuCommandBuilder)[]>;
   private readonly ctorToCommand;
+  private loading;
+  private readonly loadedCommands;
   private readonly hmrHandler?;
   private readonly pendingEvents;
   constructor(core: Core, onDeployed?: ((result: DeployResult) => void) | undefined);
   private getArtifacts;
   /** @internal */
   init(): Promise<void>;
+  private reportLoad;
   /** @internal */
   refresh(shouldRefresh?: boolean): Promise<void>;
   /** @internal */
@@ -402,6 +385,8 @@ interface BotEvents {
   'any:event': { [K in keyof ClientEvents]: [K, ...ClientEvents[K]] }[keyof ClientEvents];
   /** Emitted for any interaction */
   'any:interaction': [interaction: Interaction];
+  /** @internal */
+  ready: [];
 }
 /**
  * Discord bot implementation that manages client and controllers
@@ -459,30 +444,19 @@ declare class Bot extends Plugin<BotEvents> {
   protected onListenerError(error: unknown, event: string | symbol): void;
 }
 //#endregion
-//#region src/handlers/BaseHandler.d.ts
+//#region src/handlers/interactionTypes.d.ts
 type ValidInteractionTypes = ChatInputCommandInteraction | ButtonInteraction | ModalSubmitInteraction | AutocompleteInteraction | AnySelectMenuInteraction | ContextMenuCommandInteraction;
 type ValidNonInteractionKeys = Exclude<keyof ClientEvents, Events.InteractionCreate>;
 type ValidEventTypes = ValidInteractionTypes | ClientEvents[ValidNonInteractionKeys];
 type Repliables = Exclude<ValidInteractionTypes, AutocompleteInteraction>;
 type NonModalInteraction = Exclude<Repliables, ModalSubmitInteraction>;
-/** @internal */
-interface Handler {
-  execute(): Promise<void>;
-}
+//#endregion
+//#region src/handlers/BaseHandler.d.ts
 /**
- * Base class for a Discord event or interaction handler. Don't register handlers directly, use the more specific handler subclasses.
+ * The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
+ * gate hook.
  */
-declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> implements Handler {
-  readonly core: Core;
-  protected readonly event: ValidEvent;
-  protected readonly logger: Logger;
-  protected readonly dispatch?: DispatchContext | undefined;
-  protected constructor(event: ValidEvent, core: Core, dispatch?: DispatchContext);
-  /**
-   * Holds the main logic of your handler. The dispatcher calls it after the handler's gates pass, so a
-   * gate that refuses stops `execute()` from running.
-   */
-  abstract execute(): Promise<void>;
+declare abstract class BaseHandler$1<ValidEvent extends ValidEventTypes> extends BaseHandler<ValidEvent, Core> {
   /** @internal */
   getEvent(): ValidEvent;
 }
@@ -685,7 +659,7 @@ type EventMatchArms<Names extends ValidNonInteractionKeys, Ret> = { [Name in Nam
  * }
  * ```
  */
-declare abstract class EventHandler<Names extends ValidNonInteractionKeys> extends BaseHandler<ClientEvents[Names]> implements Handler {
+declare abstract class EventHandler<Names extends ValidNonInteractionKeys> extends BaseHandler$1<ClientEvents[Names]> {
   private readonly firedEvent;
   constructor(event: ClientEvents[Names], core: Core, eventName?: Names);
   protected readonly event: SingleEventPayload<Names>;
@@ -729,7 +703,7 @@ declare abstract class EventHandler<Names extends ValidNonInteractionKeys> exten
  *
  * @typeParam EventName - One or more `ClientEvents` keys. Defaults to every event (catchall).
  */
-declare abstract class EventMiddleware<in out EventName extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends BaseHandler<ClientEvents[EventName]> implements Handler {
+declare abstract class EventMiddleware<in out EventName extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends BaseHandler$1<ClientEvents[EventName]> {
   private readonly firedEvent;
   constructor(event: ClientEvents[EventName], core: Core, eventName?: EventName);
   protected readonly event: SingleEventPayload<EventName>;
@@ -803,8 +777,8 @@ declare function RegisterEvent<const Defs extends readonly EventSpec<ValidNonInt
 //#endregion
 //#region src/bot/gates/Gate.d.ts
 /**
- * The interaction arm. It extends the scalar {@link GateContextBase} with the live interaction and
- * the rich djs objects the gateway cache provides. `Repliable` is the interaction type the gate
+ * The interaction arm. 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
  * {@link NonModalInteraction} to exclude ModalSubmit when the gate needs a reliable caller member or
@@ -822,8 +796,8 @@ declare function RegisterEvent<const Defs extends readonly EventSpec<ValidNonInt
  * });
  * ```
  */
-interface InteractionGateContext<Repliable extends Repliables = Repliables> extends GateContextBase {
-  /** Marks the interaction arm, narrow on it before reading `interaction`. */
+interface InteractionGateContext<Repliable extends Repliables = Repliables> extends GuildPermissionsContext {
+  /** The literal `'interaction'`. Narrow on it before reading `interaction`. */
   readonly kind: 'interaction';
   /** The running framework, with the gateway's bot and bus. */
   readonly core: Core;
@@ -837,7 +811,7 @@ interface InteractionGateContext<Repliable extends Repliables = Repliables> exte
   readonly member: GuildMember | null;
 }
 /**
- * The event arm. It extends the scalar {@link GateContextBase} with the event payload and the djs
+ * The event arm. 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.
@@ -854,8 +828,8 @@ interface InteractionGateContext<Repliable extends Repliables = Repliables> exte
  * });
  * ```
  */
-interface EventGateContext<Names extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends GateContextBase {
-  /** Marks the event arm, narrow on it before reading `payload`. */
+interface EventGateContext<Names extends ValidNonInteractionKeys = ValidNonInteractionKeys> extends GuildPermissionsContext {
+  /** The literal `'event'`, narrow on it before reading `payload`. */
   readonly kind: 'event';
   /** The running framework, with the gateway's bot and bus. */
   readonly core: Core;
@@ -888,18 +862,68 @@ interface EventGateContext<Names extends ValidNonInteractionKeys = ValidNonInter
  */
 type GateContext = InteractionGateContext | EventGateContext;
 //#endregion
+//#region src/bot/ReplySender.d.ts
+/** The created message a gateway reply resolves to. */
+type SentMessage = Message;
+/**
+ * Writes interaction responses through the discord.js interaction. Construction is internal to the repliable
+ * handler bases and the dispatcher.
+ */
+declare class ReplySender extends BaseReplySender<SentMessage> {
+  private readonly interaction;
+  constructor(interaction: Repliables, routeId: string);
+  protected writeReply(response: ReplyResponse | string, opts?: SendOpts): Promise<SentMessage | undefined>;
+  protected writeDefer(opts?: DeferOpts): Promise<void>;
+  protected writeDeferUpdate(): Promise<void>;
+  protected writeUpdate(response: ReplyResponse | string): Promise<SentMessage | undefined>;
+  protected writeFollowUp(response: ReplyResponse | string, opts?: SendOpts): Promise<SentMessage>;
+  protected writeEditOriginal(response: ReplyResponse | string): Promise<SentMessage>;
+  protected writeEditTarget(targetId: string, response: ReplyResponse | string): Promise<SentMessage>;
+  protected writeDeleteOriginal(): Promise<void>;
+  protected writeDeleteTarget(targetId: string): Promise<void>;
+  protected writeModal(data: APIModalInteractionResponseCallbackData): Promise<void>;
+  protected guardModalSource(): void;
+  private rejectModalSubmit;
+  private sourceInteraction;
+  private replyOptions;
+  private editOptions;
+  private updateOptions;
+  private createdMessage;
+}
+//#endregion
+//#region src/handlers/RepliableHandler.d.ts
+/**
+ * Shared base the repliable interaction handlers extend.
+ *
+ * Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+ * {@link SelectMenuHandler}, or {@link ContextMenuHandler} instead. This class binds the core reply base
+ * to the gateway sender.
+ *
+ * @typeParam Event - The repliable interaction type this handler processes
+ */
+declare abstract class RepliableHandler<Event extends Repliables> extends RepliableHandler$1<Event, Core, SentMessage, ReplySender> {
+  /** @internal */
+  getEvent(): Event;
+  protected buildSender(event: Event, _core: Core, routeId: string): ReplySender;
+}
+//#endregion
 //#region src/handlers/interaction/InteractionHandler.d.ts
 /**
  * Shared base the typed interaction handlers extend.
  *
- * Not a public entry point. You should be using {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
- * or {@link SelectMenuHandler} instead. This class only carries the repliable-event plumbing those bases share,
- * so DO NOT use it directly.
+ * Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+ * or {@link SelectMenuHandler} instead. This class adds `showModal` on top of the reply members those bases
+ * share.
  *
  * @typeParam Repliable - The interaction type this handler processes
  */
-declare abstract class InteractionHandler<Repliable extends Repliables> extends BaseHandler<Repliable> implements Handler {
+declare abstract class InteractionHandler<Repliable extends Repliables> extends RepliableHandler<Repliable> {
   constructor(event: Repliable, core: Core, dispatch?: DispatchContext);
+  /**
+   * 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).
+   */
+  protected showModal(this: InteractionHandler<NonModalInteraction>, modal: ModalLike): Promise<void>;
 }
 //#endregion
 //#region src/bot/gates/matching.d.ts
@@ -949,189 +973,28 @@ type FitAll<TCtor extends AnyHandlerCtor, Gates extends readonly Gate<GateContex
  */
 declare function Gated<const Gates extends NonEmptyTuple<Gate<GateContextBase>>>(...gates: Gates): <TCtor extends AnyHandlerCtor>(ctor: FitAll<TCtor, Gates> extends Gates ? TCtor : FitAll<TCtor, Gates>) => void;
 //#endregion
-//#region src/inputs/AutocompleteOptions.d.ts
-type Row$2<Route extends keyof SlashOptionRegistry> = SlashOptionRegistry[Route];
-type EntryFor$1<Route extends keyof SlashOptionRegistry, Name extends PropertyKey> = Route extends unknown ? Name extends keyof Row$2<Route> ? Row$2<Route>[Name] : never : never;
-type NamesOfKind$1<Route extends keyof SlashOptionRegistry, Kind extends OptionKind> = Route extends unknown ? { [Name in keyof Row$2<Route>]: Row$2<Route>[Name] extends {
-  kind: Kind;
-} ? Name : never }[keyof Row$2<Route>] : never;
-type ResolvedValue$1<Entry> = Entry extends {
-  choices: readonly (infer Choice)[];
-} ? Choice : Entry extends {
-  kind: 'string';
-} ? string : Entry extends {
-  kind: 'integer' | 'number';
-} ? number : Entry extends {
-  kind: 'boolean';
-} ? boolean : never;
-type Getter$1<Route extends keyof SlashOptionRegistry, Kind extends OptionKind, Method extends string> = IsNever<NamesOfKind$1<Route, Kind>> extends true ? unknown : Record<Method, <Name extends NamesOfKind$1<Route, Kind>>(name: Name) => ResolvedValue$1<EntryFor$1<Route, Name>> | null>;
-/**
- * The sibling-option view for an autocomplete handler. Only the four kinds Discord resolves during autocomplete
- * appear (string, integer, number, boolean), every read is `T | null` because a sibling is partial while the
- * user types the focused field, and a getter appears only when a registered command has an option of that kind.
- * Across several registered commands the view is the union of their options, so a getter for an option absent on
- * the firing command returns null. Read the focused field from `this.focused`.
- *
- * @typeParam Route - One or more route keys from {@link SlashOptionRegistry}.
- */
-type AutocompleteOptions<Route extends keyof SlashOptionRegistry> = Getter$1<Route, 'string', 'getString'> & Getter$1<Route, 'integer', 'getInteger'> & Getter$1<Route, 'number', 'getNumber'> & Getter$1<Route, 'boolean', 'getBoolean'>;
-//#endregion
-//#region src/handlers/interaction/AutocompleteHandler.d.ts
-type Row$1<Route extends keyof SlashOptionRegistry> = SlashOptionRegistry[Route];
-type AutocompletableNames<Route extends keyof SlashOptionRegistry> = Route extends unknown ? { [Name in keyof Row$1<Route>]: Row$1<Route>[Name] extends {
-  autocomplete: true;
-} ? Name : never }[keyof Row$1<Route>] : never;
-type EntryFor<Route extends keyof SlashOptionRegistry, Name extends PropertyKey> = Route extends unknown ? Name extends keyof Row$1<Route> ? Row$1<Route>[Name] : never : never;
-type ChoiceValueOf<Entry> = Entry extends {
-  kind: 'string';
-} ? string : Entry extends {
-  kind: 'integer' | 'number';
-} ? number : never;
-/** The focused option. `value` is the raw partial Discord delivers mid-type, always a string regardless of kind. */
-interface FocusedField<Route extends keyof SlashOptionRegistry> {
-  name: AutocompletableNames<Route>;
-  value: string;
-}
-/** One arm per autocompletable field, `value` is the focused partial, `respond` is pinned to the field's choice type. */
-type FocusedArms<Route extends keyof SlashOptionRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly ApplicationCommandOptionChoiceData<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<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`.
- *
- * @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'search'` or `'search' | 'find'`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
- *
- * @example
- * ```ts
- * \@AutocompleteRoute('search')
- * class SearchAutocomplete extends AutocompleteHandler<'search'> {
- *     async execute() {
- *         await this.match({
- *             query: (value, respond) => respond([{ name: value, value }])
- *         });
- *     }
- * }
- * ```
- */
-declare abstract class AutocompleteHandler<Route extends keyof SlashOptionRegistry, Cache extends CacheType = 'cached'> extends BaseHandler<AutocompleteInteraction<Cache>> implements Handler {
-  constructor(event: AutocompleteInteraction<Cache>, core: Core, dispatch?: DispatchContext);
-  /**
-   * The focused option for this interaction. `value` is always the raw partial string the user is typing,
-   * even for an integer or number option, so coerce it yourself when you need a number.
-   */
-  private decodedFocused?;
-  protected get focused(): FocusedField<Route>;
-  /**
-   * Run the arm for the focused field. An autocomplete always dispatches by which field is focused, so
-   * 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` pinned to that field's choice value type. The
-   * arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
-   * focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
-   *
-   * @param arms - One handler per autocompletable field, keyed by field name.
-   * @returns The result of the arm that ran.
-   *
-   * @example
-   * ```ts
-   * \@AutocompleteRoute('search')
-   * class SearchAutocomplete extends AutocompleteHandler<'search'> {
-   *     async execute() {
-   *         await this.match({
-   *             query: (value, respond) => respond(titles(value).map((s) => ({ name: s, value: s }))),
-   *             tag: (value, respond) => respond(tags(value).map((s) => ({ name: s, value: s })))
-   *         });
-   *     }
-   * }
-   * ```
-   */
-  protected match<Ret>(arms: FocusedArms<Route, Ret>): Promise<Ret>;
-  /** The firing command route, for a field whose completion differs per registered command. */
-  protected get 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
-   * types the focused field. Read the focused field from `this.focused`, not here.
-   */
-  protected get options(): AutocompleteOptions<Route>;
-}
-//#endregion
-//#region src/handlers/interaction/ContextMenuHandler.d.ts
-type ContextMenuKind = ApplicationCommandType.User | ApplicationCommandType.Message;
-type InteractionFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<Cache> : MessageContextMenuCommandInteraction<Cache>;
-type TargetFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? User : Message<BooleanCache<Cache>>;
-type TargetMemberFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? CacheTypeReducer<Cache, GuildMember, APIInteractionGuildMember> | null : never;
+//#region src/handlers/interaction/InteractionMiddleware.d.ts
 /**
- * Base class for a context-menu command handler (right-click a user or a message).
- *
- * Pass the kind from `discord.js`'s {@link ApplicationCommandType} as the generic, the same value as
- * `@ContextMenuRoute`. Read the right-clicked entity from `this.target`, a `User` for a user menu and a
- * `Message` for a message menu. Context menus carry no options, so a handler registered for several names
- * reads `this.target` uniformly with no per-name branch.
+ * Base class for interaction middleware
  *
- * @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
- * @typeParam Cache - The interaction cache state, `'cached'` by default.
+ * Middleware runs before interaction handlers and can modify behavior or block execution.
+ * Unlike handlers, middleware should not send responses directly.
  *
- * @example
- * ```ts
- * \@ContextMenuRoute(ApplicationCommandType.Message, 'Report Message')
- * class ReportMessage extends ContextMenuHandler<ApplicationCommandType.Message> {
- *     async execute() {
- *         const message = this.target;
- *     }
- * }
- * ```
+ * @typeParam Repliable - The interaction type this middleware processes
  */
-declare abstract class ContextMenuHandler<Kind extends ContextMenuKind, Cache extends CacheType = 'cached'> extends InteractionHandler<InteractionFor<Kind, Cache>> {
-  protected get target(): TargetFor<Kind, Cache>;
-  /**
-   * The invoking guild member, resolved only on user menus. Reading it on a message menu is a compile
-   * error since the type is `never` there.
-   */
-  protected get targetMember(): TargetMemberFor<Kind, Cache>;
+declare abstract class InteractionMiddleware<Repliable extends Repliables> extends BaseHandler$1<Repliable> {
+  constructor(event: Repliable, core: Core);
 }
 //#endregion
 //#region src/inputs/SlashOptions.d.ts
-type Row<Route extends keyof SlashOptionRegistry> = SlashOptionRegistry[Route];
-type NamesOfKind<Route extends keyof SlashOptionRegistry, Kind extends OptionKind> = { [Name in keyof Row<Route>]: Row<Route>[Name] extends {
-  kind: Kind;
-} ? Name : never }[keyof Row<Route>];
-type ChannelWireType<Types extends number> = Types extends ChannelType.PublicThread | ChannelType.AnnouncementThread ? ChannelType.PublicThread | ChannelType.AnnouncementThread : Types;
-type ResolvedChannel<Cache extends CacheType, Entry> = Entry extends {
-  channelTypes: readonly (infer Types extends number)[];
-} ? Extract<NonNullable<CommandInteractionOption<Cache>['channel']>, {
-  type: ChannelWireType<Types>;
-}> : NonNullable<CommandInteractionOption<Cache>['channel']>;
-type ResolvedValue<Cache extends CacheType, Entry> = Entry extends {
-  choices: readonly (infer Choice)[];
-} ? Choice : Entry extends {
-  kind: 'string';
-} ? string : Entry extends {
-  kind: 'integer' | 'number';
-} ? number : Entry extends {
-  kind: 'boolean';
-} ? boolean : Entry extends {
-  kind: 'user';
-} ? NonNullable<CommandInteractionOption<Cache>['user']> : Entry extends {
-  kind: 'channel';
-} ? ResolvedChannel<Cache, Entry> : Entry extends {
-  kind: 'role';
-} ? NonNullable<CommandInteractionOption<Cache>['role']> : Entry extends {
-  kind: 'mentionable';
-} ? NonNullable<CommandInteractionOption<Cache>['member' | 'role' | 'user']> : Entry extends {
-  kind: 'attachment';
-} ? NonNullable<CommandInteractionOption<Cache>['attachment']> : never;
-type Returned<Cache extends CacheType, Entry> = Entry extends {
-  required: true;
-} ? ResolvedValue<Cache, Entry> : ResolvedValue<Cache, Entry> | null;
-type Getter<Route extends keyof SlashOptionRegistry, Cache extends CacheType, Kind extends OptionKind, Method extends string> = IsNever<NamesOfKind<Route, Kind>> extends true ? unknown : Record<Method, <Name extends NamesOfKind<Route, Kind>>(name: Name) => Returned<Cache, Row<Route>[Name]>>;
-type MemberGetter<Route extends keyof SlashOptionRegistry, Cache extends CacheType> = IsNever<NamesOfKind<Route, 'user'>> extends true ? unknown : {
-  getMember: <Name extends NamesOfKind<Route, 'user'>>(name: Name) => NonNullable<CommandInteractionOption<Cache>['member']> | null;
-};
+interface GatewayLens<Cache extends CacheType> {
+  user: NonNullable<CommandInteractionOption<Cache>['user']>;
+  member: NonNullable<CommandInteractionOption<Cache>['member']>;
+  channel: NonNullable<CommandInteractionOption<Cache>['channel']>;
+  role: NonNullable<CommandInteractionOption<Cache>['role']>;
+  mentionable: NonNullable<CommandInteractionOption<Cache>['member' | 'role' | 'user']>;
+  attachment: NonNullable<CommandInteractionOption<Cache>['attachment']>;
+}
 /**
  * The typed view over a chat-input command's options for one route. Each getter mirrors the discord.js
  * resolver method but restricts its `name` to that route's options of the matching kind, drops the null
@@ -1144,7 +1007,7 @@ type MemberGetter<Route extends keyof SlashOptionRegistry, Cache extends CacheTy
  * @typeParam Route - A route key from the generated {@link SlashOptionRegistry}.
  * @typeParam Cache - The interaction cache state, `'cached'` by default.
  */
-type SlashOptions<Route extends keyof SlashOptionRegistry, Cache extends CacheType = 'cached'> = Getter<Route, Cache, 'string', 'getString'> & Getter<Route, Cache, 'integer', 'getInteger'> & Getter<Route, Cache, 'number', 'getNumber'> & Getter<Route, Cache, 'boolean', 'getBoolean'> & Getter<Route, Cache, 'user', 'getUser'> & Getter<Route, Cache, 'channel', 'getChannel'> & Getter<Route, Cache, 'role', 'getRole'> & Getter<Route, Cache, 'mentionable', 'getMentionable'> & Getter<Route, Cache, 'attachment', 'getAttachment'> & MemberGetter<Route, Cache>;
+type SlashOptions<Route extends keyof SlashOptionRegistry, Cache extends CacheType = 'cached'> = SlashOptions$1<Route, GatewayLens<Cache>>;
 //#endregion
 //#region src/handlers/interaction/SlashHandler.d.ts
 type SlashMatchArms<Route extends keyof SlashOptionRegistry, Cache extends CacheType, Ret> = { [Key in Route]: (options: SlashOptions<Key, Cache>) => Promisable<Ret> };
@@ -1170,6 +1033,8 @@ type SlashMatchArms<Route extends keyof SlashOptionRegistry, Cache extends Cache
  * ```
  */
 declare abstract class SlashHandler<Route extends keyof SlashOptionRegistry, Cache extends CacheType = 'cached'> extends InteractionHandler<ChatInputCommandInteraction<Cache>> {
+  /** @internal */
+  readonly __slashRoute?: Route;
   /**
    * The typed options for this command's route. Required options drop the null, choices narrow to their
    * literal union, and only the getters for kinds this command actually uses appear. Use `this.event.options`
@@ -1178,7 +1043,7 @@ declare abstract class SlashHandler<Route extends keyof SlashOptionRegistry, Cac
   protected get options(): SlashOptions<Route, Cache>;
   /**
    * Run the arm for whichever command fired. Use this only when the handler is registered for several
-   * routes. A single-route handler reads `this.options` directly instead, match buys nothing there.
+   * 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
@@ -1203,211 +1068,122 @@ declare abstract class SlashHandler<Route extends keyof SlashOptionRegistry, Cac
   protected match<Ret>(arms: SlashMatchArms<Route, Cache, Ret>): Promise<Ret>;
 }
 //#endregion
-//#region src/bot/decorators/Interactions.d.ts
-/**
- * Types of select menus supported for routing
- */
-declare enum SelectMenuKind {
-  String = "string",
-  User = "user",
-  Role = "role",
-  Channel = "channel",
-  Mentionable = "mentionable"
-}
-/** @internal */
-type HandlerEventType<TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = InstanceType<TCtor> extends InteractionHandler<infer TEvent> ? TEvent : never;
-/**
- * Compile-time assertion that the required event type(s) `TRequired` are included in the handler event union.
- *
- * @internal
- */
-type AssertHandles<TRequired, TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = Extract<HandlerEventType<TCtor>, TRequired> extends never ? Constructor<['Handler event generic must include', TRequired]> : TCtor;
-/**
- * The slash route(s) a handler serves, read off its `SlashHandler` generic.
- *
- * @internal
- */
-type SlashRouteOf<TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = InstanceType<TCtor> extends SlashHandler<infer Route, CacheType> ? Route : never;
-/**
- * On a route/generic mismatch, resolves to a non-constructor type so applying the decorator is a TS1238.
- *
- * @internal
- */
-type AssertSlashRoute<Route extends string, TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = [Route] extends [SlashRouteOf<TCtor>] ? [SlashRouteOf<TCtor>] extends [Route] ? TCtor : Constructor<['SlashHandler declares a route the SlashRoute decorator does not list', SlashRouteOf<TCtor>]> : Constructor<['SlashRoute does not match the SlashHandler generic', Route]>;
-/**
- * Routes one or more slash commands to a {@link SlashHandler}.
- *
- * Pass the same route string(s) as the handler's generic. A single command reads `this.options`, several
- * commands branch with `this.match`. The decorator routes and the generic must match exactly, so listing
- * fewer or more than the handler declares is a compile error. Subcommands use a slash path.
- *
- * @param routes - The route string(s) this handler serves, e.g. `'ban'`, `'ban', 'kick'`, or `'demo/setup'`.
- * @decorator
- * @example
- * ```ts
- * \@SlashRoute('ban')
- * class BanHandler extends SlashHandler<'ban'> {
- *     async execute() {
- *         const target = this.options.getUser('target');
- *     }
- * }
- * ```
- *
- * @example
- * ```ts
- * \@SlashRoute('ban', 'kick')
- * class ModerationHandler extends SlashHandler<'ban' | 'kick'> {
- *     async execute() {
- *         await this.match({ ban: (o) => o.getUser('target'), kick: (o) => o.getUser('member') });
- *     }
- * }
- * ```
- */
-declare function SlashRoute<const Route extends keyof SlashOptionRegistry>(...routes: Route[]): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables>>(constructor: AssertSlashRoute<Route, TCtor>) => void;
-/**
- * Routes button interactions to handler classes.
- *
- * Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
- * generic. Passing different definitions to the decorator and the generic is a compile error. Routing
- * matches the stable prefix, so a wire minted from an older shape still reaches the handler, where
- * reading this.params throws StaleCustomId and the controller boundary turns it into a reply.
- *
- * @param defs - The customId definition(s) this handler decodes, one per route.
- * @decorator
- */
-declare function ButtonRoute<const Defs extends readonly AnyCustomId[]>(...defs: Defs): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables> & HasComponentDefs<Defs>>(constructor: AssertHandles<ButtonInteraction, TCtor>) => void;
-/**
- * Routes modal submissions to handler classes.
- *
- * Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
- * generic. Passing different definitions to the decorator and the generic is a compile error. Routing
- * matches the stable prefix, so an older-shape wire still reaches the handler and throws StaleCustomId
- * on read, the same as a button route.
- *
- * @param defs - The customId definition(s) this handler decodes, one per route.
- * @decorator
- */
-declare function ModalRoute<const Defs extends readonly AnyCustomId[]>(...defs: Defs): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables> & HasComponentDefs<Defs>>(constructor: AssertHandles<ModalSubmitInteraction, TCtor>) => void;
-/** The context-menu command names valid for a kind, read off the matching registry. @internal */
-type NamesFor<Kind extends ApplicationCommandType.User | ApplicationCommandType.Message> = Kind extends ApplicationCommandType.User ? keyof UserContextMenuRegistry : keyof MessageContextMenuRegistry;
-/**
- * The context-menu kind a handler serves, read off its event's `commandType` discriminant. Direct
- * inference from the `ContextMenuHandler` generic widens the kind to the whole union because the handler's
- * conditional members blur it, so this uses the event literal to keep it narrow.
- *
- * @internal
- */
-type ContextMenuKindOf<TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = InstanceType<TCtor> extends ContextMenuHandler<infer Kind, CacheType> ? [Kind] extends [ApplicationCommandType.User | ApplicationCommandType.Message] ? HandlerEventType<TCtor> extends {
-  commandType: infer K;
-} ? Extract<K, ApplicationCommandType.User | ApplicationCommandType.Message> : never : never : never;
+//#region src/handlers/interaction/ContextMenuHandler.d.ts
+type ContextMenuKind = ApplicationCommandType.User | ApplicationCommandType.Message;
+type InteractionFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<Cache> : MessageContextMenuCommandInteraction<Cache>;
+type TargetFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? User : Message<BooleanCache<Cache>>;
+type TargetMemberFor<Kind extends ContextMenuKind, Cache extends CacheType> = Kind extends ApplicationCommandType.User ? CacheTypeReducer<Cache, GuildMember, APIInteractionGuildMember> | null : never;
 /**
- * On a kind mismatch between the decorator and the handler generic, resolves to a non-constructor type so
- * applying the decorator is a TS1238. Cross-checks both directions, mirroring {@link AssertSlashRoute}.
+ * Base class for a context-menu command handler (right-click a user or a message).
  *
- * @internal
- */
-type AssertContextMenuRoute<Kind extends ApplicationCommandType.User | ApplicationCommandType.Message, TCtor extends new (...args: any[]) => InteractionHandler<Repliables>> = [Kind] extends [ContextMenuKindOf<TCtor>] ? [ContextMenuKindOf<TCtor>] extends [Kind] ? TCtor : Constructor<['ContextMenuHandler declares a kind the ContextMenuRoute decorator does not match', ContextMenuKindOf<TCtor>]> : Constructor<['ContextMenuRoute does not match the ContextMenuHandler generic', Kind]>;
-/**
- * Routes one or more context-menu commands to a {@link ContextMenuHandler}.
+ * Pass the kind from `discord.js`'s {@link ApplicationCommandType} as the generic, the same value as
+ * `@ContextMenuRoute`. Read the right-clicked entity from `this.target`, a `User` for a user menu and a
+ * `Message` for a message menu. Context menus carry no options, so a handler registered for several names
+ * reads `this.target` uniformly with no per-name branch.
  *
- * Pass the kind (`ApplicationCommandType.User` or `ApplicationCommandType.Message`) and the command name(s),
- * each checked against that kind's registry, so a typo is a compile error. The same kind must sit on the
- * handler's generic, cross-checked both directions. Context menus carry no options, so a multi-name handler
- * reads `this.target` uniformly with no branch.
+ * @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
- * @param kind - The context-menu kind, `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
- * @param names - The command name(s) this handler serves, keyed off the matching registry.
- * @decorator
  * @example
  * ```ts
- * \@ContextMenuRoute(ApplicationCommandType.User, 'View Profile')
- * class ViewProfile extends ContextMenuHandler<ApplicationCommandType.User> {
+ * \@ContextMenuRoute(ApplicationCommandType.Message, 'Report Message')
+ * class ReportMessage extends ContextMenuHandler<ApplicationCommandType.Message> {
  *     async execute() {
- *         const user = this.target;
+ *         const message = this.target;
  *     }
  * }
  * ```
  */
-declare function ContextMenuRoute<const Kind extends ApplicationCommandType.User | ApplicationCommandType.Message>(kind: Kind, ...names: NamesFor<Kind>[]): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables>>(constructor: AssertContextMenuRoute<Kind, TCtor>) => void;
-/**
- * The command route(s) an autocomplete handler serves, read off its `AutocompleteHandler` generic.
- *
- * @internal
- */
-type AutocompleteRouteOf<TCtor extends new (...args: any[]) => BaseHandler<AutocompleteInteraction<CacheType>>> = InstanceType<TCtor> extends AutocompleteHandler<infer Route, CacheType> ? Route : never;
+declare abstract class ContextMenuHandler<Kind extends ContextMenuKind, Cache extends CacheType = 'cached'> extends InteractionHandler<InteractionFor<Kind, Cache>> {
+  /** @internal */
+  readonly __ctxKind?: Kind;
+  protected get target(): TargetFor<Kind, Cache>;
+  /**
+   * The invoking guild member, resolved only on user menus. Reading it on a message menu is a compile
+   * error since the type is `never` there.
+   */
+  protected get targetMember(): TargetMemberFor<Kind, Cache>;
+}
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.d.ts
+type FocusedArms<Route extends keyof SlashOptionRegistry, Ret> = { [Name in AutocompletableNames<Route>]: (value: string, respond: (choices: readonly ApplicationCommandOptionChoiceData<ChoiceValueOf<EntryFor<Route, Name>>>[]) => Promise<void>) => Promisable<Ret> };
 /**
- * On a route/generic mismatch, resolves to a non-constructor type so applying the decorator is a TS1238.
+ * Base class for a Discord autocomplete handler.
  *
- * @internal
- */
-type AssertAutocompleteRoute<Route extends keyof SlashOptionRegistry, TCtor extends new (...args: any[]) => BaseHandler<AutocompleteInteraction<CacheType>>> = [Route] extends [AutocompleteRouteOf<TCtor>] ? [AutocompleteRouteOf<TCtor>] extends [Route] ? TCtor : Constructor<['AutocompleteHandler declares a command the AutocompleteRoute decorator does not list', AutocompleteRouteOf<TCtor>]> : Constructor<['AutocompleteRoute does not match the AutocompleteHandler generic', Route]>;
-/**
- * Routes one or more commands' autocomplete to an {@link AutocompleteHandler}.
+ * 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`.
  *
- * Pass the same command route string(s) as the handler's generic. One command branches with `this.match`
- * over its autocompletable fields, several commands share one handler whose arms span every command's
- * fields. The decorator routes and the generic must match exactly, so listing fewer or more than the
- * handler declares is a compile error.
+ * @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'search'` or `'search' | 'find'`.
+ * @typeParam Cache - The interaction cache state, `'cached'` by default.
  *
- * @param routes - The command route string(s) this handler serves, e.g. `'search'` or `'search', 'find'`.
- * @decorator
  * @example
  * ```ts
  * \@AutocompleteRoute('search')
  * class SearchAutocomplete extends AutocompleteHandler<'search'> {
  *     async execute() {
- *         await this.match({ query: (value, respond) => respond([{ name: value, value }]) });
+ *         await this.match({
+ *             query: (value, respond) => respond([{ name: value, value }])
+ *         });
  *     }
  * }
  * ```
  */
-declare function AutocompleteRoute<const Route extends keyof SlashOptionRegistry>(...routes: Route[]): <TCtor extends new (...args: any[]) => BaseHandler<AutocompleteInteraction<CacheType>>>(constructor: AssertAutocompleteRoute<Route, TCtor>) => void;
-/** @internal */
-type SelectMenuInteractionFor<SelectMenu extends SelectMenuKind, Cache extends CacheType = CacheType> = SelectMenu extends SelectMenuKind.String ? StringSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.User ? UserSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Role ? RoleSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Channel ? ChannelSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Mentionable ? MentionableSelectMenuInteraction<Cache> : never;
-/**
- * Routes select menu interactions to handler classes.
- *
- * Pass the select kind and the {@link CustomId} definition(s) this handler decodes. The handler's
- * generic must list the same definitions, and its second generic argument must be the matching select
- * interaction type, or it is a compile error.
- *
- * @param type - Select menu kind from {@link SelectMenuKind}.
- * @param defs - The customId definition(s) this handler decodes, one per route.
- * @decorator
- *
- * @example
- * ```typescript
- * \@SelectMenuRoute(SelectMenuKind.User, AssignId)
- * class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
- *   // handles user select menus minted from AssignId
- * }
- * ```
- */
-declare function SelectMenuRoute<SelectMenu extends SelectMenuKind, const Defs extends readonly AnyCustomId[]>(type: SelectMenu, ...defs: Defs): <TCtor extends new (...args: any[]) => InteractionHandler<Repliables> & HasComponentDefs<Defs>>(constructor: AssertHandles<SelectMenuInteractionFor<SelectMenu>, TCtor>) => void;
-//#endregion
-//#region src/handlers/interaction/InteractionMiddleware.d.ts
-/**
- * Base class for interaction middleware
- *
- * Middleware runs before interaction handlers and can modify behavior or block execution.
- * Unlike handlers, middleware should not send responses directly.
- *
- * @typeParam Repliable - The interaction type this middleware processes
- */
-declare abstract class InteractionMiddleware<Repliable extends Repliables> extends BaseHandler<Repliable> implements Handler {
-  constructor(event: Repliable, core: Core);
+declare abstract class AutocompleteHandler<Route extends keyof SlashOptionRegistry, Cache extends CacheType = 'cached'> extends BaseHandler$1<AutocompleteInteraction<Cache>> {
+  /** @internal */
+  readonly __autocompleteRoute?: Route;
+  constructor(event: AutocompleteInteraction<Cache>, core: Core, dispatch?: DispatchContext);
+  private decodedFocused?;
+  /**
+   * The focused option for this interaction. `value` is always the raw partial string the user is typing,
+   * even for an integer or number option, so coerce it yourself when you need a number.
+   */
+  protected get focused(): FocusedField<Route>;
+  /**
+   * Run the arm for the focused field. An autocomplete always dispatches by which field is focused, so
+   * 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. A
+   * focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
+   *
+   * @param arms - One handler per autocompletable field, keyed by field name.
+   * @returns The result of the arm that ran.
+   *
+   * @example
+   * ```ts
+   * \@AutocompleteRoute('search')
+   * class SearchAutocomplete extends AutocompleteHandler<'search'> {
+   *     async execute() {
+   *         await this.match({
+   *             query: (value, respond) => respond(titles(value).map((s) => ({ name: s, value: s }))),
+   *             tag: (value, respond) => respond(tags(value).map((s) => ({ name: s, value: s })))
+   *         });
+   *     }
+   * }
+   * ```
+   */
+  protected match<Ret>(arms: FocusedArms<Route, Ret>): Promise<Ret>;
+  /** 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 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
+   * types the focused field. The focused field is on `this.focused`.
+   */
+  protected get options(): AutocompleteOptions<Route>;
 }
 //#endregion
 //#region src/handlers/interaction/components/ComponentHandler.d.ts
 type ComponentInteraction = ButtonInteraction | ModalSubmitInteraction | AnySelectMenuInteraction;
-type SingleParams<Defs extends readonly AnyCustomId[]> = Defs extends readonly [infer One extends AnyCustomId] ? DecodedParams<One['shape']> : never;
-type MatchArms<Defs extends readonly AnyCustomId[], Ret> = { [Def in Defs[number] as Def['prefix']]: (params: DecodedParams<Def['shape']>) => Promisable<Ret> };
 /**
  * Shared base the customId-routed component handlers extend.
  *
- * Not a public entry point. You should be using {@link ButtonHandler}, {@link SelectMenuHandler}, or
- * {@link ModalHandler} instead. This class only carries the customId decode and route-matching plumbing
- * those bases share, so DO NOT use it directly.
+ * Not a public entry point. Extend {@link ButtonHandler}, {@link SelectMenuHandler}, or {@link ModalHandler}
+ * instead. This class defines the customId decode and the route matching those bases share.
  *
  * @typeParam Event - The component interaction type this handler processes
  * @typeParam Defs - The customId route definitions registered on the concrete handler
@@ -1415,7 +1191,10 @@ type MatchArms<Defs extends readonly AnyCustomId[], Ret> = { [Def in Defs[number
 declare abstract class ComponentHandler<Event extends ComponentInteraction, Defs extends readonly AnyCustomId[]> extends InteractionHandler<Event> implements HasComponentDefs<Defs> {
   /** @internal */
   readonly __componentDefs?: Defs;
-  private get registeredDefs();
+  /** Rewrite the source message this component interaction came from. */
+  protected update(response: ReplyResponse | string): Promise<SentMessage>;
+  /** Acknowledge the component without changing the source message. */
+  protected deferUpdate(): Promise<void>;
   private decoded?;
   private get route();
   /**
@@ -1433,10 +1212,11 @@ declare abstract class ComponentHandler<Event extends ComponentInteraction, Defs
    * handler `this.params` is `never`, so match is 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 arms must cover every registered def, a missing prefix or an unknown key is a
-   * compile error. Decoding runs before any arm, so a stale or corrupt wire throws before an arm body executes.
+   * decoded params. The arms cover every registered route prefix, checked at compile time, and a prefix
+   * unmatched at runtime throws `CustomIdMatchArmMissing`. Decoding runs before any arm, so a stale or
+   * corrupt wire throws before an arm body executes.
    *
-   * @param arms - One handler per registered route, keyed by prefix.
+   * @param arms - One callback per registered route, keyed by prefix.
    * @returns The result of the arm that ran.
    *
    * @example
@@ -1445,8 +1225,8 @@ declare abstract class ComponentHandler<Event extends ComponentInteraction, Defs
    * class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
    *     async execute() {
    *         await this.match({
-   *             approve: ({ userId }) => this.event.reply(`approved <@${userId}>`),
-   *             reject: ({ userId }) => this.event.reply(`rejected <@${userId}>`)
+   *             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
+   *             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
    *         });
    *     }
    * }
@@ -1460,8 +1240,9 @@ declare abstract class ComponentHandler<Event extends ComponentInteraction, Defs
  * Base class for a button interaction handler.
  *
  * Register the customId definitions this handler decodes with `@ButtonRoute`, list the same ones in the
- * generic, then read `this.params` for a single route or `this.match` for several. Passing different
- * definitions to the decorator and the generic is a compile error.
+ * generic, then read `this.params` for a single route or `this.match` for several. Reply through the handler
+ * members, or rewrite the source message with `this.update`. Passing different definitions to the decorator
+ * and the generic is a compile error.
  *
  * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ApproveId]`.
  * @typeParam Cache - The interaction cache state, `'cached'` by default.
@@ -1472,12 +1253,15 @@ declare abstract class ComponentHandler<Event extends ComponentInteraction, Defs
  * class ApproveButton extends ButtonHandler<[typeof ApproveId]> {
  *     async execute() {
  *         const { userId } = this.params;
- *         await this.event.reply(`approved <@${userId}>`);
+ *         await this.reply(`approved <@${userId}>`);
  *     }
  * }
  * ```
  */
-declare abstract class ButtonHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<ButtonInteraction<Cache>, Defs> {}
+declare abstract class ButtonHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<ButtonInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly __component?: 'button';
+}
 //#endregion
 //#region src/handlers/interaction/components/ModalHandler.d.ts
 /**
@@ -1485,7 +1269,8 @@ declare abstract class ButtonHandler<Defs extends readonly AnyCustomId[], Cache
  *
  * Register the customId definitions this handler decodes with `@ModalRoute`, list the same ones in the
  * generic, then read `this.params` for a single route or `this.match` for several. Read the submitted
- * inputs from `this.event.fields`.
+ * inputs from `this.event.fields`, and reply through the handler members. Discord forbids opening a modal in
+ * response to a modal, so `showModal` fails compilation on this kind.
  *
  * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
  * @typeParam Cache - The interaction cache state, `'cached'` by default.
@@ -1497,20 +1282,25 @@ declare abstract class ButtonHandler<Defs extends readonly AnyCustomId[], Cache
  *     async execute() {
  *         const { guildId } = this.params;
  *         const name = this.event.fields.getTextInputValue('name');
- *         await this.event.reply(`saved ${name} for ${guildId}`);
+ *         await this.reply(`saved ${name} for ${guildId}`);
  *     }
  * }
  * ```
  */
-declare abstract class ModalHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<ModalSubmitInteraction<Cache>, Defs> {}
+declare abstract class ModalHandler<Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<ModalSubmitInteraction<Cache>, Defs> {
+  /** @internal */
+  readonly __component?: 'modal';
+}
 //#endregion
 //#region src/handlers/interaction/components/SelectMenuHandler.d.ts
+type SelectMenuInteractionFor<SelectMenu extends SelectMenuKind, Cache extends CacheType = CacheType> = SelectMenu extends SelectMenuKind.String ? StringSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.User ? UserSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Role ? RoleSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Channel ? ChannelSelectMenuInteraction<Cache> : SelectMenu extends SelectMenuKind.Mentionable ? MentionableSelectMenuInteraction<Cache> : never;
 /**
  * Base class for a select menu handler.
  *
  * Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
  * so `this.event` and `this.event.values` are narrowed to that kind. Read `this.params` for a single
- * route or `this.match` for several.
+ * route or `this.match` for several, and reply through the handler members or rewrite the source message
+ * with `this.update`.
  *
  * @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
  * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
@@ -1522,12 +1312,15 @@ declare abstract class ModalHandler<Defs extends readonly AnyCustomId[], Cache e
  * class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
  *     async execute() {
  *         const { roleId } = this.params;
- *         await this.event.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
+ *         await this.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
  *     }
  * }
  * ```
  */
-declare abstract class SelectMenuHandler<Kind extends SelectMenuKind, Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<SelectMenuInteractionFor<Kind, Cache>, Defs> {}
+declare abstract class SelectMenuHandler<Kind extends SelectMenuKind, Defs extends readonly AnyCustomId[], Cache extends CacheType = 'cached'> extends ComponentHandler<SelectMenuInteractionFor<Kind, Cache>, Defs> {
+  /** @internal */
+  readonly __component?: Kind;
+}
 //#endregion
 //#region src/bot/decorators/Middlewares.d.ts
 /**
@@ -1615,36 +1408,37 @@ declare const IgnoreBots: import("@seedcord/core").Gate<EventGateContext<ValidNo
  */
 declare function Nsfw(options?: GateNoticeOptions): Gate<InteractionGateContext<NonModalInteraction>, 'Nsfw'>;
 //#endregion
-//#region src/bot/notices/utils.d.ts
-/** Whose permissions a check ran against, used to mention and label the subject in a refusal. */
-type PermSubject = Role | TextChannel | Guild | GuildMember;
-//#endregion
-//#region src/bot/utilities/permissions/checkPermissions.d.ts
+//#region src/bot/utilities/channels/fetchText.d.ts
 /**
- * Array of permission bits for permission validation.
- * Import any of the predefined sets or pass a custom bigint[].
+ * Fetches and validates a text channel. Refuses when the channel doesn't exist or isn't a text channel.
+ *
+ * @param client - The Discord client instance
+ * @param channelId - Channel ID or TextChannel instance
+ * @returns Promise resolving to the text channel
  */
-type BotPermissionScope = readonly bigint[];
+declare function fetchText(client: Client, channelId: TextChannelResolvable): Promise<TextChannel>;
+//#endregion
+//#region src/bot/utilities/permissions/checkPermissions.d.ts
 /**
  * Optional custom error constructors for {@link CheckPermissionOptions}.
  */
-interface PermissionErrorCtors {
-  missing?: new (message: string, where: PermSubject, missingPerms: string[]) => Notice;
-  dangerous?: new (message: string, target: PermSubject, dangerousPerms: string[]) => Notice;
+interface PermissionErrorNoticeOverrides {
+  missingNotice?: new (message: string | undefined, subject: string, missingPerms: readonly string[]) => Notice;
+  dangerousNotice?: new (message: string | undefined, subject: string, dangerousPerms: readonly string[]) => Notice;
 }
 /**
  * Options for {@link checkPermissions}.
  *
- * @see {@link PermissionErrorCtors}
+ * @see {@link PermissionErrorNoticeOverrides}
  */
-interface CheckPermissionOptions extends PermissionErrorCtors {
+interface CheckPermissionOptions extends PermissionErrorNoticeOverrides {
   /** Role or member whose permissions will be checked */
   for: Role | GuildMember;
-  /** Context where permissions apply, guild or channel */
+  /** Context where permissions apply */
   in: Guild | TextChannel;
   /** Permission bits to validate */
-  scope: BotPermissionScope;
-  /** When true, ensure target does not have the given permissions */
+  scope: PermissionScope;
+  /** When true, ensure target does NOT have the given permissions */
   inverse?: boolean;
 }
 /**
@@ -1684,7 +1478,7 @@ interface CheckPermissionOptions extends PermissionErrorCtors {
  * });
  * ```
  */
-declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope: BotPermissionScope, inverse?: boolean, errors?: PermissionErrorCtors): void;
+declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope: PermissionScope, inverse?: boolean, errors?: PermissionErrorNoticeOverrides): void;
 /**
  * Checks permissions for a {@link Role} or a {@link GuildMember} in a {@link TextChannel}. Refuses when a
  * permission in `scope` is missing, or with `inverse` when one is present.
@@ -1722,7 +1516,7 @@ declare function checkPermissions(target: Role | GuildMember, ctx: Guild, scope:
  * });
  * ```
  */
-declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel, scope: BotPermissionScope, inverse?: boolean, errors?: PermissionErrorCtors): void;
+declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionErrorNoticeOverrides): void;
 /**
  * Checks permissions using an options object. Refuses when a permission in {@link CheckPermissionOptions.scope} is missing,
  * or with `options.inverse` when one is present.
@@ -1766,123 +1560,6 @@ declare function checkPermissions(target: Role | GuildMember, ctx: TextChannel,
  */
 declare function checkPermissions(options: CheckPermissionOptions): void;
 //#endregion
-//#region src/bot/gates/catalog/permissions.d.ts
-/**
- * Options for {@link RequirePermissions} and {@link RequireBotPermissions}, one override per refusal the gate
- * can show.
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- * import type { Guild, GuildMember, Role, TextChannel } from 'discord.js';
- *
- * // `missing` is a Notice ctor: (message, where, missingPerms)
- * class MissingPermsNotice extends Notice {
- *     public constructor(message: string, where: Role | TextChannel | Guild | GuildMember, missing: string[]) {
- *         super(`${message} (${missing.join(', ')})`);
- *     }
- * }
- *
- * RequirePermissions([PermissionFlagsBits.BanMembers], { missing: MissingPermsNotice });
- * ```
- */
-interface RequirePermissionsOptions {
-  /** Reword or replace the refusal shown outside a guild. */
-  notInGuild?: GateNoticeOptions;
-  /** Replace the missing-permissions refusal with a ctor that receives the where and the missing perm names. */
-  missing?: PermissionErrorCtors['missing'];
-}
-/**
- * Options for {@link RequireRole}, one override per refusal the gate can show.
- */
-interface RequireRoleOptions {
-  /** Reword or replace the refusal shown outside a guild. */
-  notInGuild?: GateNoticeOptions;
-  /** Reword or replace the refusal shown when the caller lacks the role. */
-  missingRole?: GateNoticeOptions;
-}
-/**
- * Requires the caller to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
- *
- * Interaction-only and excludes ModalSubmit, since a modal lacks a reliable cached caller member.
- *
- * @param scope - The permission flag bits the caller must all hold.
- * @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
- *
- * @see {@link Gated}
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- *
- * \@Gated(RequirePermissions([PermissionFlagsBits.BanMembers]))
- * \@SlashRoute('ban')
- * class BanHandler extends SlashHandler<'ban'> {
- *     async execute() {
- *         const target = this.options.getUser('target');
- *     }
- * }
- * ```
- */
-declare function RequirePermissions(scope: BotPermissionScope, options?: RequirePermissionsOptions): Gate<InteractionGateContext<NonModalInteraction>, 'RequirePermissions'>;
-/**
- * Requires the bot to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
- *
- * It reads the bot's own member, so it attaches to modal handlers as well.
- *
- * @param scope - The permission flag bits the bot must all hold.
- * @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
- *
- * @see {@link Gated}
- *
- * @example
- * ```ts
- * import { PermissionFlagsBits } from 'discord.js';
- *
- * \@Gated(RequireBotPermissions([PermissionFlagsBits.BanMembers]))
- * \@ModalRoute(MyModalId)
- * class MyModalHandler extends ModalHandler<[typeof MyModalId]> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- */
-declare function RequireBotPermissions(scope: BotPermissionScope, options?: RequirePermissionsOptions): Gate<InteractionGateContext, 'RequireBotPermissions'>;
-/**
- * Requires the caller to have `roleId`, read from the member's role cache. Refuses outside a guild first, then
- * when the role is missing.
- *
- * Interaction-only and excludes ModalSubmit.
- *
- * @param roleId - The role snowflake the caller must hold, read from the member's role cache.
- * @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-role one with `missingRole`.
- *
- * @see {@link Gated}
- *
- * @example
- * ```ts
- * \@Gated(RequireRole('123456789012345678'))
- * \@SlashRoute('vip')
- * class VipHandler extends SlashHandler<'vip'> {
- *     async execute() {
- *         // ...
- *     }
- * }
- * ```
- */
-declare function RequireRole(roleId: string, options?: RequireRoleOptions): Gate<InteractionGateContext<NonModalInteraction>, 'RequireRole'>;
-//#endregion
-//#region src/bot/utilities/channels/fetchText.d.ts
-/**
- * Fetches and validates a text channel. Refuses when the channel doesn't exist or isn't a text channel.
- *
- * @param client - The Discord client instance
- * @param channelId - Channel ID or TextChannel instance
- * @returns Promise resolving to the text channel
- */
-declare function fetchText(client: Client, channelId: TextChannelResolvable): Promise<TextChannel>;
-//#endregion
 //#region src/bot/utilities/permissions/checkBotPermissions.d.ts
 /**
  * Checks if the bot has required permissions in a {@link Guild} or {@link TextChannel}. Refuses when a
@@ -1905,28 +1582,23 @@ declare function fetchText(client: Client, channelId: TextChannelResolvable): Pr
  * ]);
  * ```
  */
-declare function checkBotPermissions(target: Guild | TextChannel, scope: BotPermissionScope, inverse?: boolean, errors?: PermissionErrorCtors): void;
+declare function checkBotPermissions(target: Guild | TextChannel, scope: PermissionScope, inverse?: boolean, errors?: PermissionErrorNoticeOverrides): void;
 //#endregion
 //#region src/bot/utilities/permissions/hasPermsToAssign.d.ts
 /**
  * Optional custom error constructors for {@link HasPermsToAssignOptions}.
  */
-interface AssignRoleErrorCtors {
-  /** Custom error for role higher than bot */
-  higher?: new (message: string, role: Role, botRole: Role) => Notice;
-  /** Custom error for managed role assignment */
-  managed?: new (message: string) => Notice;
-  /** Custom error for missing Manage Roles permission */
-  missing?: new (message: string, where: Role | TextChannel | Guild | GuildMember, missingPerms: string[]) => Notice;
+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}.
  */
 interface HasPermsToAssignOptions {
-  /** Target role to validate for assignment */
   targetRole: Role;
-  /** Optional custom error constructors */
-  errors?: AssignRoleErrorCtors;
+  noticeOverrides?: AssignRoleNoticeOverrides;
 }
 /**
  * Validates if 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.
@@ -1943,10 +1615,10 @@ interface HasPermsToAssignOptions {
  * // Check with custom error handling
  * hasPermsToAssign({
  *   targetRole: role,
- *   errors: {
- *     higher: CustomHigherError,
- *     managed: CustomManagedError,
- *     missing: CustomMissingPermissionsError
+ *   noticeOverrides: {
+ *     higherNotice: CustomHigherNotice,
+ *     managedNotice: CustomManagedNotice,
+ *     missingNotice: CustomMissingPermissionsNotice
  *   }
  * });
  * ```
@@ -2033,41 +1705,7 @@ declare function fetchManyUsers(client: Client, userIds: string[], options?: Fet
  */
 declare function updateMemberRoles(rolesToAdd: Snowflake[], rolesToRemove: Snowflake[], member: GuildMember): Promise<void>;
 //#endregion
-//#region src/bot/ReplySender.d.ts
-/**
- * Sends a {@link ReplyResponse} to an interaction, picking reply, editReply, or followUp from the live
- * acknowledgement state. Logs and drops its own send failures so a dead token never escapes into the
- * controller.
- */
-declare class ReplySender {
-  private readonly interaction;
-  private readonly logger;
-  constructor(interaction: Repliables);
-  /**
-   * Sends the reply and returns the sent message so a caller can attach a collector to it. Never throws,
-   * a failed send is logged and dropped and resolves to `undefined`.
-   *
-   * @param response - The ComponentsV2 reply to show.
-   * @param ephemeral - Whether the reply is ephemeral. {@default `true`}
-   * @returns The sent {@link Message}, or `undefined` when the send was swallowed.
-   */
-  send(response: ReplyResponse, ephemeral?: boolean): Promise<Message | undefined>;
-  /**
-   * Edits an already-sent message to a new {@link ReplyResponse}. Used to swap a confirmation prompt for
-   * its outcome. Never throws, a failed edit is logged and dropped.
-   *
-   * @param message - The message to edit (the handle a prior {@link send} returned).
-   * @param response - The reply to replace it with.
-   */
-  edit(message: Message, response: ReplyResponse): Promise<void>;
-  private dispatch;
-  private replyOptions;
-  private editBody;
-  private logSwallowed;
-}
-//#endregion
 //#region src/bot/confirm/getConfirmation.d.ts
-/** A confirm outcome to show, the reply itself or a factory for it. */
 type Outcome = ReplyResponse | (() => Promisable<ReplyResponse>);
 /** Options shared by both confirmation forms. */
 interface ConfirmOptions {
@@ -2115,7 +1753,7 @@ interface DefaultConfirmOptions extends ConfirmOptions {
 /**
  * Shows a confirm/cancel prompt with built-in Confirm and Cancel buttons and resolves to `true` only if the
  * invoking user clicks confirm. A cancel click or a timeout resolves to `false`. Gate the action behind it
- * with an early return. Never throws, a swallowed send resolves to `false`. Not usable from a
+ * with an early return. A failed prompt send throws into the fault boundary. Not usable from a
  * {@link ModalHandler}, the `interaction` parameter excludes a modal submit at compile time.
  *
  * @param interaction - The repliable interaction to prompt on, `this.event` inside a non-modal handler.
@@ -2141,8 +1779,9 @@ interface DefaultConfirmOptions extends ConfirmOptions {
 declare function getConfirmation(interaction: NonModalInteraction, prompt: string, options?: DefaultConfirmOptions): Promise<boolean>;
 /**
  * Shows a confirm/cancel prompt you build yourself and resolves to `true` only if the invoking user clicks
- * confirm. The factory receives the two minted button ids, set them on your own buttons. A cancel click or a
- * timeout resolves to `false`. Never throws. Not usable from a {@link ModalHandler}.
+ * confirm. The factory receives the two minted button ids. Set them on your own buttons. A cancel click or a
+ * timeout resolves to `false`. A failed prompt send throws into the fault boundary. Not usable from a
+ * {@link ModalHandler}.
  *
  * @param interaction - The repliable interaction to prompt on, `this.event` inside a non-modal handler.
  * @param prompt - A factory given the minted `{ confirm, cancel }` ids that returns the reply to show. Build
@@ -2296,7 +1935,11 @@ interface PaginatorConfig<Item, Prefix extends string> {
   renderItem?: ItemRender<Item>;
   /** Take over the whole page tree. Receives the page data and the controls factory. */
   render?: PageRender<Item>;
-  /** Whether the first page is ephemeral. {@default false} */
+  /**
+   * Whether the first page is ephemeral.
+   *
+   * @defaultValue `false`
+   */
   ephemeral?: boolean;
 }
 type PaginatorHandlerCtor<Prefix extends string> = new (event: ButtonInteraction<'cached'>, core: Core) => ButtonHandler<[PageCursor<Prefix>]> & {
@@ -2329,7 +1972,7 @@ declare class Paginator<Item, const Prefix extends string> {
   private readonly config;
   constructor(config: PaginatorConfig<Item, Prefix>);
   /** Render page 0 and send it, picking reply or followUp from the interaction's state. */
-  start(interaction: Repliables, core?: Core): Promise<Message | undefined>;
+  start(interaction: Repliables, core?: Core): Promise<Message>;
   /** Render a page as a {@link ReplyResponse}. To post it elsewhere, add `flags: MessageFlags.IsComponentsV2`. */
   page(ctx: PageContext, n: number): Promise<ReplyResponse>;
 }
@@ -2400,86 +2043,98 @@ interface SubscribeOptions {
  */
 declare function Subscribe<TSubscriber extends SubscriptionKey>(subscriber: TSubscriber, options?: SubscribeOptions): <HandlerCtor extends Constructor<Subscriber<TSubscriber>>>(constructor: HandlerCtor) => void;
 //#endregion
+//#region src/subscribers/bases/WebhookSender.d.ts
+/**
+ * A file attached to a webhook report.
+ */
+interface WebhookFile {
+  name: string;
+  description: string;
+  data: Buffer;
+}
+/**
+ * The payload {@link WebhookSender.send} posts.
+ */
+interface WebhookSendOptions {
+  flags: number;
+  username: string;
+  components: readonly {
+    toJSON(): APIMessageTopLevelComponent;
+  }[];
+  files?: readonly WebhookFile[] | undefined;
+}
+/**
+ * Sends component messages to a Discord webhook through `@discordjs/rest`.
+ *
+ * @throws A `SeedcordError` when the url does not carry a webhook id and token.
+ */
+declare class WebhookSender {
+  private readonly rest;
+  private readonly route;
+  constructor(url: string);
+  /**
+   * Fetches the webhook object, sending no message. Returns `missing` on a 404 or 401 from
+   * Discord and `unreachable` on any other failure.
+   */
+  verify(): Promise<'ok' | 'missing' | 'unreachable'>;
+  send(options: WebhookSendOptions): Promise<void>;
+}
+//#endregion
 //#region src/subscribers/bases/WebhookLog.d.ts
 /**
- * Abstract webhook logging handler for subscriber events.
+ * The content a reporter returns from {@link WebhookLog.report}.
+ */
+interface WebhookReport {
+  /** Shown as the webhook message author. Defaults to the reporter's class name. */
+  username?: string;
+  components: readonly {
+    toJSON(): APIMessageTopLevelComponent;
+  }[];
+  files?: readonly WebhookFile[] | undefined;
+}
+/**
+ * Base class for subscribers that deliver their event to a Discord webhook.
  *
- * Extends Subscriber to provide webhook-based logging capabilities.
- * Implementations must define the webhook client to send messages to by implementing the webhook property.
+ * Declare the url's environment variable with `@WebhookUrl` and implement {@link report}. Url
+ * resolution, validation, sender reuse, and sending run in the base. When the variable is unset
+ * the reporter is skipped at registration with a boot warning.
  *
- * @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+ * @typeParam KeyOfSubscribers - The subscription key this reporter receives
  */
 declare abstract class WebhookLog<KeyOfSubscribers extends SubscriptionKey> extends Subscriber<KeyOfSubscribers> {
-  /** The Discord webhook client for sending log messages */
-  abstract webhook: WebhookClient;
-  constructor(data: AllSubscriptions[KeyOfSubscribers], core: Core);
+  private static readonly senders;
+  /** Builds the message for one published event. */
+  abstract report(): WebhookReport | Promise<WebhookReport>;
+  execute(): Promise<void>;
+  /** @internal */
+  static senderFor(url: string): WebhookSender;
+  /** @internal */
+  static envKeyOf(ctor: NewableFunction): string;
+  /** @internal Returns null when the env var is unset, throws when set but malformed. */
+  static urlOf(envKey: string): string | null;
 }
 //#endregion
-//#region src/hmr/HmrModuleHandler.d.ts
-/**
- * Options for configuring the HmrModuleHandler.
- *
- * This is only useful during development.
- */
-interface HmrModuleHandlerOptions<THandler, TMiddleware = void, TArtifacts = unknown> {
-  /** Directory containing handler modules. */
-  handlersDir: string;
-  /** Directory containing middleware modules. Optional because not all setups use middleware. */
-  middlewaresDir?: string;
-  /** Function to determine if a value is a handler module of type THandler. */
-  isHandler: (val: unknown) => val is THandler;
-  /** Function to determine if a value is a middleware module of type TMiddleware. Optional because not all setups use middleware. */
-  isMiddleware?: (val: unknown) => val is TMiddleware;
-  /** Function to register a handler module. */
-  registerHandler: (handler: THandler, file: string) => void;
-  /** Function to register a middleware module. Optional because not all setups use middleware. */
-  registerMiddleware?: (middleware: TMiddleware, file: string) => void;
-  /** Function to unregister a handler module. */
-  unregisterHandler: (handler: THandler, artifacts?: TArtifacts) => void;
-  /** Function to unregister a middleware module. Optional because not all setups use middleware. */
-  unregisterMiddleware?: (middleware: TMiddleware) => void;
-  /** Function to extract artifacts from a handler to be stored across hmr cache invalidations. */
-  getArtifacts?: (handler: THandler) => TArtifacts;
-  /** Logger instance for logging HMR activities.*/
-  logger: Logger;
-}
+//#region src/subscribers/decorators/WebhookUrl.d.ts
 /**
- * Reloads THandler and optional TMiddleware modules on HMR updates.
+ * Declares the environment variable a {@link WebhookLog} reporter reads its webhook url from.
  *
- * You can either implement a custom `onHmr()` method in your class by extending `HmrAware`, or if it's a plugin, override the existing `onHmr()` with fully custom logic. Or, use this class's `handle()` method inside your `onHmr()` to get standard HMR handling for your modules based on the provided options you give to the constructor.
+ * An unset variable disables the reporter with a boot warning. A set but malformed value throws
+ * at boot.
  *
- * This is only useful during development.
+ * @param envKey - The environment variable name holding the webhook url
+ * @decorator
+ * @example
+ * ```ts
+ * \@Subscribe('memberBanned')
+ * \@WebhookUrl('BAN_LOG_WEBHOOK_URL')
+ * class BanLog extends WebhookLog<'memberBanned'> {
+ *   report() {
+ *     return { components: [new BanCard(this.data).component] };
+ *   }
+ * }
+ * ```
  */
-declare class HmrModuleHandler<THandler, TMiddleware = void, TArtifacts = unknown> {
-  private readonly store;
-  private readonly options;
-  constructor(options: HmrModuleHandlerOptions<THandler, TMiddleware, TArtifacts>);
-  /**
-   * Handles an HMR update event by reloading affected modules based on the event details and config. It receives an {@link HmrUpdateEvent}, then checks the type of update.
-   *
-   * - If it's a deletion, it unloads the module.
-   * - If it's an update/creation, it checks if the file is tracked, unloads it if so, then reloads the file if it is in the handlers or middlewares directory and is a valid handler/middleware.
-   */
-  handle(event: HmrUpdateEvent): Promise<void>;
-  private reloadWithRollback;
-  /**
-   * Tracks a handler module as being loaded from a specific file.
-   * @param file - The file path the handler was loaded from.
-   * @param handler - The handler module instance.
-   */
-  trackHandler(file: string, handler: THandler): void;
-  /**
-   * Tracks a middleware module as being loaded from a specific file.
-   * @param file - The file path the middleware was loaded from.
-   * @param middleware - The middleware module instance.
-   */
-  trackMiddleware(file: string, middleware: TMiddleware): void;
-  private isTracked;
-  private unload;
-  private reloadFile;
-  private snapshotUnits;
-  private restoreUnits;
-}
+declare function WebhookUrl(envKey: string): <HandlerCtor extends Constructor<WebhookLog<SubscriptionKey>>>(constructor: HandlerCtor) => void;
 //#endregion
 //#region src/Seedcord.d.ts
 /**
@@ -2497,6 +2152,8 @@ declare class Seedcord extends Pluggable implements Core {
   /** @internal */
   readonly version: string;
   private static isInstantiated;
+  private readonly healthCheck;
+  private readonly hmrManager;
   /** @see {@link CoordinatedShutdown} */
   readonly shutdown: CoordinatedShutdown;
   /** @see {@link CoordinatedStartup} */
@@ -2507,10 +2164,6 @@ declare class Seedcord extends Pluggable implements Core {
   readonly bot: Bot;
   /** @see {@link IRateLimiter} */
   readonly rateLimiter: IRateLimiter;
-  /** @see {@link HealthCheck} */
-  private readonly healthCheck;
-  /** @see {@link HmrManager} */
-  private readonly hmrManager;
   /**
    * Creates a new Seedcord instance
    *
@@ -2518,12 +2171,9 @@ declare class Seedcord extends Pluggable implements Core {
    * @throws A **SeedcordError** When attempting to create multiple instances (singleton)
    */
   constructor(config: GatewayConfig);
-  /** @internal */
+  /** The bot's discord username, populated after login. */
+  get username(): string | undefined;
   private static reset;
-  /**
-   * Registers default startup tasks
-   * @internal
-   */
   private registerStartupTasks;
   /**
    * Starts the bot and runs all initialization tasks
@@ -2538,5 +2188,5 @@ declare class Seedcord extends Pluggable implements Core {
 /** Package version */
 declare const version: string;
 //#endregion
-export { type AllSubscriptions, ArraySource, AssignRoleErrorCtors, AutocompleteHandler, type AutocompleteOptions, AutocompleteRoute, type BotEvents, type BotPermissionScope, ButtonHandler, ButtonRoute, type CheckPermissionOptions, CommandMentions, type ConfirmOptions, ContextMenuHandler, ContextMenuRoute, type Core, CursorSource, type DefaultConfirmOptions, Emojis, type EventGateContext, EventHandler, EventMiddleware, type EventSpec, type EventsConfig, type FaultSource, FetchUserOptions, type GateContext, Gated, type GatewayBotConfig, type GatewayConfig, HasPermsToAssignOptions, HmrModuleHandler, IgnoreBots, type Initializeable, type InjectedEmojiMap, type InjectedMentionMap, type InteractionGateContext, InteractionHandler, InteractionMiddleware, Middleware, type MiddlewareOptions, MiddlewareType, ModalHandler, ModalRoute, Nsfw, Paginator, type PaginatorControls, type PermissionErrorCtors, Pluggable, Plugin, type PluginArgs, type PluginCtor, RegisterCommand, RegisterEvent, type RegisterEventOptions, type Repliables, ReplySender, RequireBotPermissions, RequirePermissions, type RequirePermissionsOptions, RequireRole, type RequireRoleOptions, Seedcord, SelectMenuHandler, SelectMenuKind, SelectMenuRoute, SlashHandler, type SlashOptions, SlashRoute, Subscribe, type SubscribeOptions, Subscriber, type SubscriptionData, type SubscriptionKey, type Subscriptions, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, WebhookLog, checkBotPermissions, checkPermissions, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, getConfirmation, hasPermsToAssign, updateMemberRoles, version };
+export { ArraySource, AssignRoleNoticeOverrides, AutocompleteHandler, type BotEvents, ButtonHandler, type CheckPermissionOptions, CommandMentions, type ConfirmOptions, ContextMenuHandler, type Core, CursorSource, type DefaultConfirmOptions, Emojis, type EventGateContext, EventHandler, EventMiddleware, type EventSpec, type EventsConfig, type FaultSource, FetchUserOptions, type GateContext, Gated, type GatewayBotConfig, type GatewayConfig, HasPermsToAssignOptions, IgnoreBots, type Initializeable, type InjectedEmojiMap, type InjectedMentionMap, type InteractionGateContext, InteractionHandler, InteractionMiddleware, Middleware, type MiddlewareOptions, MiddlewareType, ModalHandler, Nsfw, Paginator, type PaginatorControls, type PermissionErrorNoticeOverrides, Pluggable, Plugin, type PluginArgs, type PluginCtor, RegisterEvent, type RegisterEventOptions, RepliableHandler, type Repliables, Seedcord, SelectMenuHandler, ShutdownPhase, SlashHandler, type SlashOptions, StartupPhase, Subscribe, type SubscribeOptions, Subscriber, type SubscriptionData, type SubscriptionKey, type Subscriptions, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionKeys, type WebhookFile, WebhookLog, type WebhookReport, WebhookUrl, checkBotPermissions, checkPermissions, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, getConfirmation, hasPermsToAssign, updateMemberRoles, version };
 //# sourceMappingURL=index.d.mts.map