@seedcord/gateway 0.8.0 → 0.9.0-next.2

package/dist/index.mjs

@@ -1,23 +1,21 @@
 import "reflect-metadata";
 import { DRAIN_TASK_TIMEOUT_MS, DRAIN_WINDOW_MS, HealthCheck, InFlight, ShutdownPhase, StartupPhase, setEnvaptBaseDir, shutdownOf } from "@seedcord/core/node/internal";
 import { WinstonConsoleSink, WinstonFileSink, installNodeConsole } from "@seedcord/logger/node";
-import { COMMAND_DEPLOY_TIMEOUT_MS, CommandRegistry, EventMetadataKey, EventMiddlewareMetadataKey, FixedScope, GateNotice, GatedMetadataKey, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, MiddlewareRegistry, MissingPermissions, NoticeCard, PermissionNames, PublishDefault, SubscriberLoader, accessorStore, attachmentsOf, bindBotColor, busLoggerOf, clearStore, connectDevChannel, decodeComponentRoute, deferFlags, eventResultFor, guardedAccessor, interactionMiddleware, interactionRoutesOf, isEmojiTuple, logUnknownFault, outcomeFor, pickNotice, queuedMsFor, readBotToken, reportDispatch, reportedWrite, resultFor, runAfter, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { AutocompleteResponder, COMMAND_DEPLOY_TIMEOUT_MS, CommandRegistry, DispatchContext, EventMetadataKey, EventMiddlewareMetadataKey, FaultBoundary, FixedScope, GatedMetadataKey, HandlerLoader, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, InteractionRun, MiddlewareRegistry, NoticeCard, OnceTracker, PublishDefault, RouteRegistry, SubscriberLoader, accessorStore, assertUniqueKeys, attachmentsOf, bindBotColor, busLoggerOf, clearStore, componentKindOf, connectDevChannel, decodeComponentRoute, deferFlags, eventResultFor, guardedAccessor, interactionFaultSource, interactionMiddleware, isEmojiTuple, matchRoute, readBotToken, resultFor, runAfter, runCase, runHandlerGates, sendFlags } from "@seedcord/core/internal";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
 import { SeedcordError, SeedcordTypeError, throwSingleOrAggregate } from "@seedcord/errors/internal";
-import { ArraySourceBase, BaseHandler as BaseHandler$1, BaseReplySender, BuilderComponent, Bus, CursorSourceBase, CustomId, DispatchContext, Fault, InteractionKind, Notice, PaginatorBase, RepliableHandler as RepliableHandler$1, ResolvedEmoji, RowComponent, Silence, Subscriber as Subscriber$1, WebhookLog as WebhookLog$1, assertPermissions, defineGate } from "@seedcord/core";
+import { ArraySourceBase, BaseHandler as BaseHandler$1, BaseReplySender, BuilderComponent, CursorSourceBase, CustomId, InteractionKind, Notice, PaginatorBase, RepliableHandler as RepliableHandler$1, ResolvedEmoji, RowComponent, Silence, Subscriber as Subscriber$1, WebhookLog as WebhookLog$1, assertPermissions, defineGate } from "@seedcord/core";
+import { ButtonStyle, Client, ComponentType, DiscordAPIError, Events, FormattingPatterns, GatewayIntentBits, Guild, GuildMember, IntentsBitField, InteractionContextType, Message, MessageFlags, PermissionFlagsBits, Role, User } from "discord.js";
 import { Logger } from "@seedcord/logger";
-import { ButtonStyle, Client, ComponentType, DiscordAPIError, Events, GatewayIntentBits, Guild, GuildMember, IntentsBitField, InteractionContextType, Message, MessageFlags, PermissionFlagsBits, RESTJSONErrorCodes, Role, User } from "discord.js";
 import { ButtonBuilder, TextDisplayBuilder } from "@discordjs/builders";
-import { asError, buildSlashRoute, isStringArray } from "@seedcord/utils/internal";
 import { Plugin as Plugin$1 } from "@seedcord/core/plugin";
 import { CoordinatedShutdown, CoordinatedStartup, ServerHost } from "@seedcord/core/node";
-import { MemoryRateLimiter } from "@seedcord/rate-limiter";
 import { HostAugmentTarget, HostVersion, SeedcordBrand } from "@seedcord/types/internal";
 import { Envapter } from "envapt";
-import { HmrModuleHandler, HmrModuleHandler as HmrModuleHandler$1 } from "@seedcord/core/hmr";
-import { formatFilePath, hasKeys, importFiles } from "@seedcord/utils";
-import * as crypto from "node:crypto";
+import { hasKeys } from "@seedcord/utils";
+import { asError, buildSlashRoute } from "@seedcord/utils/internal";
 import { prefixOf } from "@seedcord/custom-id";
+import { HmrModuleHandler } from "@seedcord/core/hmr";
 
 export * from "@seedcord/errors"
 
@@ -25,8 +23,6 @@ export * from "@seedcord/core"
 
 export * from "@seedcord/logger"
 
-export * from "@seedcord/rate-limiter"
-
 export * from "@seedcord/utils"
 
 export * from "@seedcord/event-emitter"
@@ -82,12 +78,12 @@ installNodeConsole();
 */
 function RegisterEvent(...defs) {
 	return function(constructor) {
-		const existing = Reflect.getMetadata(EventMetadataKey, constructor) ?? [];
 		const entries = defs.map(([event, options]) => ({
 			event,
 			frequency: options?.frequency ?? "on"
 		}));
-		Reflect.defineMetadata(EventMetadataKey, [...existing, ...entries], constructor);
+		assertUniqueKeys("@RegisterEvent", constructor, entries.map((entry) => entry.event));
+		Reflect.defineMetadata(EventMetadataKey, entries, constructor);
 	};
 }
 
@@ -97,10 +93,10 @@ function RegisterEvent(...defs) {
 * 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
@@ -193,19 +189,55 @@ const IgnoreBots = defineGate("IgnoreBots", (ctx) => {
 	if (ctx.user?.bot) throw new Silence("actor is a bot");
 });
 
+//#endregion
+//#region src/bot/gates/catalog/MentionPrefix.ts
+function startsWithBotMention(message) {
+	const match = FormattingPatterns.User.exec(message.content?.trimStart() ?? "");
+	return match?.index === 0 && match.groups?.id === message.client.user.id;
+}
+/**
+* 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() {
+*         // ...
+*     }
+* }
+* ```
+*/
+const MentionPrefix = defineGate("MentionPrefix", ({ payload }) => {
+	if (!(payload.length === 1 ? startsWithBotMention(payload[0]) : !startsWithBotMention(payload[0]) && startsWithBotMention(payload[1]))) throw new Silence("message does not start with a mention of the bot");
+});
+
 //#endregion
 //#region src/bot/notices/index.ts
-var NotNsfw = class extends GateNotice {
-	constructor(message = "This can only be used in an age-restricted channel.") {
-		super(message);
+var NotNsfw = class extends Notice {
+	constructor() {
+		super("This can only be used in an age-restricted channel.");
 		this.summary = "be in an age-restricted channel";
 	}
 };
 var RoleHigherThanMe = class extends Notice {
 	role;
 	botRole;
-	constructor(message, role, botRole) {
-		super(message);
+	constructor(role, botRole) {
+		super("Role is higher than me");
 		this.role = role;
 		this.botRole = botRole;
 	}
@@ -214,11 +246,13 @@ var RoleHigherThanMe = class extends Notice {
 	}
 };
 var CannotAssignBotRole = class extends Notice {
-	constructor(message = "I cannot assign a managed role.") {
-		super(message);
+	role;
+	constructor(role) {
+		super(`Cannot assign managed role ${role.name}`);
+		this.role = role;
 	}
 	render() {
-		return { components: [new NoticeCard("I cannot assign a managed role.").component] };
+		return { components: [new NoticeCard(`I cannot assign <@&${this.role.id}>, a managed role.`).component] };
 	}
 };
 
@@ -230,11 +264,11 @@ function channelIsNsfw(channel) {
 	return "nsfw" in channel ? channel.nsfw : false;
 }
 /**
-* 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}
 *
@@ -252,7 +286,7 @@ function channelIsNsfw(channel) {
 function Nsfw(options) {
 	return defineGate("Nsfw", (ctx) => {
 		if (channelIsNsfw(ctx.interaction.channel)) return;
-		throw pickNotice(options, (message) => new NotNsfw(message));
+		throw new ((options?.notice) ?? NotNsfw)();
 	});
 }
 
@@ -353,57 +387,68 @@ function mentionFor(subject) {
 
 //#endregion
 //#region src/bot/utilities/permissions/checkPermissions.ts
-function checkPermissions(a, b, c, d, e) {
-	const { for: pFor, in: pIn, scope, inverse = false, missingNotice, dangerousNotice } = a instanceof Role || a instanceof GuildMember ? {
-		for: a,
-		in: b,
-		scope: c,
-		inverse: d ?? false,
-		...e
-	} : a;
-	const perms = pIn instanceof Guild ? pFor.permissions : pIn.permissionsFor(pFor, true);
+/**
+* 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({ for: member, scope: [PermissionFlagsBits.KickMembers] });
+* checkPermissions({ for: role, in: channel, scope: [PermissionFlagsBits.SendMessages] });
+* ```
+*
+* @example
+* ```ts
+* // refuse when the member holds Administrator, with your own Notice class
+* checkPermissions({ for: member, scope: [PermissionFlagsBits.Administrator], inverse: true, notice: TooPowerful });
+* ```
+*/
+function checkPermissions({ for: target, in: channel, scope, inverse = false, notice }) {
+	const held = channel ? channel.permissionsFor(target, true) : target.permissions;
 	assertPermissions({
-		subject: mentionFor(pFor),
-		permissions: perms.bitfield,
+		subject: mentionFor(target),
+		permissions: held.bitfield,
 		scope,
 		inverse,
-		...missingNotice && { missingNotice },
-		...dangerousNotice && { dangerousNotice }
+		notice
 	});
 }
 
 //#endregion
 //#region src/bot/utilities/permissions/checkBotPermissions.ts
+function botMemberOf(guild) {
+	const me = guild.members.me;
+	if (!me) throw new SeedcordError(SeedcordErrorCode.CoreBotMemberMissing, [guild.id]);
+	return me;
+}
 /**
-* 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.
+* 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.
+*
+* @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 { checkBotPermissions } from '@seedcord/gateway';
 *
-* checkBotPermissions(textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
+* checkBotPermissions({ in: channel, scope: [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel] });
 * ```
 */
-function checkBotPermissions(target, scope, inverse = false, errors) {
-	if (target instanceof Guild) {
-		const me = target.members.me;
-		if (!me) {
-			const names = scope.map((bit) => PermissionNames.get(bit) ?? String(bit));
-			throw new ((errors?.missingNotice) ?? MissingPermissions)(void 0, "The bot", names);
-		}
-		checkPermissions(me, target, scope, inverse, errors);
-		return;
-	}
-	const me = target.guild.members.me;
-	if (!me) {
-		new Logger("checkBotPermissions", { channel: "errors" }).warn(`Bot member is unavailable in guild ${target.guild.id} while checking permissions in channel ${target.id}`);
-		const names = scope.map((bit) => PermissionNames.get(bit) ?? String(bit));
-		throw new ((errors?.missingNotice) ?? MissingPermissions)(void 0, "The bot", names);
-	}
-	checkPermissions(me, target, scope, inverse, errors);
+function checkBotPermissions({ in: where, ...check }) {
+	const [guild, channel] = where instanceof Guild ? [where, void 0] : [where.guild, where];
+	checkPermissions({
+		for: botMemberOf(guild),
+		in: channel,
+		...check
+	});
 }
 
 //#endregion
@@ -414,42 +459,31 @@ function botRoleOf(guild) {
 	return botRole;
 }
 /**
-* 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 });
 * ```
 */
-function hasPermsToAssign(roleOrOptions) {
-	const { targetRole, noticeOverrides: errors } = roleOrOptions instanceof Role ? {
-		targetRole: roleOrOptions,
-		noticeOverrides: void 0
-	} : roleOrOptions;
-	const HigherNotice = errors?.higherNotice ?? RoleHigherThanMe;
-	const ManagedNotice = errors?.managedNotice ?? CannotAssignBotRole;
-	const MissingNotice = errors?.missingNotice ?? MissingPermissions;
-	const botRole = botRoleOf(targetRole.guild);
-	if (targetRole.comparePositionTo(botRole) >= 0) throw new HigherNotice("Role is higher than me", targetRole, botRole);
-	if (targetRole.managed) throw new ManagedNotice(`Cannot assign managed role ${targetRole.name}`);
-	checkBotPermissions(targetRole.guild, [PermissionFlagsBits.ManageRoles], false, { missingNotice: MissingNotice });
+function hasPermsToAssign({ role, higher, managed, missing }) {
+	const botRole = botRoleOf(role.guild);
+	if (role.comparePositionTo(botRole) >= 0) throw new (higher ?? RoleHigherThanMe)(role, botRole);
+	if (role.managed) throw new (managed ?? CannotAssignBotRole)(role);
+	checkBotPermissions({
+		in: role.guild,
+		scope: [PermissionFlagsBits.ManageRoles],
+		notice: missing
+	});
 }
 
 //#endregion
@@ -514,126 +548,6 @@ async function getConfirmation(handler, prompt, options) {
 	return confirmed;
 }
 
-//#endregion
-//#region src/bot/ReplySender.ts
-function isReplyFile(file) {
-	return typeof file === "object" && "data" in file && ArrayBuffer.isView(file.data);
-}
-function toDjsFile(file) {
-	if (!isReplyFile(file)) return file;
-	return {
-		attachment: Buffer.from(file.data),
-		name: file.name,
-		...file.description !== void 0 && { description: file.description },
-		...file.title !== void 0 && { title: file.title }
-	};
-}
-function seedState(interaction) {
-	if (interaction.deferred && interaction.ephemeral === null) return "deferred-update";
-	if (interaction.replied) return "replied";
-	if (interaction.deferred) return "deferred-reply";
-	return "unacked";
-}
-/** Writes interaction responses through discord.js. The repliable handler bases and the dispatcher construct it. */
-var ReplySender = class extends BaseReplySender {
-	interaction;
-	constructor(interaction, dispatch, bus) {
-		super({
-			bus,
-			dispatch,
-			interactionId: interaction.id
-		}, seedState(interaction));
-		this.interaction = interaction;
-	}
-	async writeReply(response, opts) {
-		const result = await this.interaction.reply({
-			...this.replyOptions(response, sendFlags(opts)),
-			withResponse: true
-		});
-		return this.createdMessage(result);
-	}
-	async writeDefer(opts) {
-		await this.interaction.deferReply({ flags: deferFlags(opts) });
-	}
-	async writeDeferUpdate() {
-		await this.sourceInteraction("deferUpdate").deferUpdate();
-	}
-	async writeUpdate(response) {
-		const result = await this.sourceInteraction("update").update({
-			...this.updateOptions(response),
-			withResponse: true
-		});
-		return this.createdMessage(result);
-	}
-	async writeFollowUp(response, opts) {
-		return await this.interaction.followUp(this.replyOptions(response, sendFlags(opts)));
-	}
-	async writeEditOriginal(response) {
-		return await this.interaction.editReply(this.editOptions(response));
-	}
-	async writeEditTarget(targetId, response) {
-		return await this.interaction.webhook.editMessage(targetId, this.editOptions(response));
-	}
-	async writeDeleteOriginal() {
-		await this.interaction.deleteReply();
-	}
-	async writeDeleteTarget(targetId) {
-		await this.interaction.deleteReply(targetId);
-	}
-	async writeModal(data) {
-		const { interaction } = this;
-		if (interaction.isModalSubmit()) this.rejectModalSubmit();
-		await interaction.showModal(data);
-	}
-	guardModalSource() {
-		if (this.interaction.isModalSubmit()) this.rejectModalSubmit();
-	}
-	rejectModalSubmit() {
-		throw new SeedcordError(SeedcordErrorCode.ReplyIllegalAckState, [
-			"showModal",
-			"this interaction is a modal submit",
-			"A modal cannot open another modal.",
-			this.routeId
-		]);
-	}
-	sourceInteraction(method) {
-		const { interaction } = this;
-		if (interaction.isMessageComponent()) return interaction;
-		if (interaction.isModalSubmit() && interaction.isFromMessage()) return interaction;
-		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
-	}
-	replyOptions(response, flags) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: reply.files.map(toDjsFile) }
-		};
-	}
-	editOptions(response) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags: MessageFlags.IsComponentsV2,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: reply.files.map(toDjsFile) }
-		};
-	}
-	updateOptions(response) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags: MessageFlags.IsComponentsV2,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: reply.files.map(toDjsFile) }
-		};
-	}
-	createdMessage(result) {
-		return result.resource?.message ?? void 0;
-	}
-};
-
 //#endregion
 //#region src/handlers/RepliableHandler.ts
 /**
@@ -650,8 +564,9 @@ var RepliableHandler = class extends RepliableHandler$1 {
 	getEvent() {
 		return this.event;
 	}
-	buildSender(event, core, dispatch) {
-		return new ReplySender(event, dispatch, core.bus);
+	/** The user who sent this interaction. */
+	get user() {
+		return this.event.user;
 	}
 };
 
@@ -694,8 +609,8 @@ var InteractionMiddleware = class extends RepliableHandler {
 * @typeParam Repliable - The interaction type this handler processes
 */
 var InteractionHandler = class extends RepliableHandler {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
+	constructor(event, core, dispatch, sender) {
+		super(event, core, dispatch, sender);
 	}
 	/**
 	* Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
@@ -706,14 +621,6 @@ var InteractionHandler = class extends RepliableHandler {
 	}
 };
 
-//#endregion
-//#region src/bot/utilities/miscellaneous/slashRouteOf.ts
-function slashRouteOf(interaction) {
-	const group = interaction.options.getSubcommandGroup(false) ?? void 0;
-	const subcommand = interaction.options.getSubcommand(false) ?? void 0;
-	return buildSlashRoute(interaction.commandName, subcommand, group);
-}
-
 //#endregion
 //#region src/handlers/interaction/SlashHandler.ts
 /**
@@ -721,7 +628,7 @@ function slashRouteOf(interaction) {
 *
 * 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.
@@ -742,28 +649,28 @@ var SlashHandler = class extends InteractionHandler {
 	* 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.
 	*/
 	get options() {
 		return this.event.options;
 	}
 	/**
-	* 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
@@ -778,29 +685,13 @@ var SlashHandler = class extends InteractionHandler {
 	* }
 	* ```
 	*/
-	async match(arms) {
-		const route = slashRouteOf(this.event);
-		const arm = Object.hasOwn(arms, route) ? arms[route] : void 0;
-		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
-			this.constructor.name,
-			"command route",
-			route
-		]);
-		return await arm(this.options);
+	async match(cases) {
+		return await runCase(this, cases, "command route", this.route, this.options);
 	}
 };
 
 //#endregion
 //#region src/handlers/interaction/ContextMenuHandler.ts
-function armFor(handler, arms, name) {
-	const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-	if (typeof arm !== "function") throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
-		handler.constructor.name,
-		"context menu command",
-		name
-	]);
-	return arm;
-}
 /**
 * Base class for a user context-menu command handler (right-click a user).
 *
@@ -828,21 +719,18 @@ var UserContextMenuHandler = class extends InteractionHandler {
 	get targetMember() {
 		return this.event.targetMember;
 	}
-	/** Which of the registered commands fired. */
-	get commandName() {
-		return this.event.commandName;
-	}
 	/**
-	* 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
@@ -857,8 +745,8 @@ var UserContextMenuHandler = class extends InteractionHandler {
 	* }
 	* ```
 	*/
-	async match(arms) {
-		return await armFor(this, arms, this.event.commandName)(this.target, this.targetMember);
+	async match(cases) {
+		return await runCase(this, cases, "context menu command", this.route, this.target, this.targetMember);
 	}
 };
 /**
@@ -884,20 +772,17 @@ var MessageContextMenuHandler = class extends InteractionHandler {
 	get target() {
 		return this.event.targetMessage;
 	}
-	/** Which of the registered commands fired. */
-	get commandName() {
-		return this.event.commandName;
-	}
 	/**
-	* 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
@@ -912,8 +797,8 @@ var MessageContextMenuHandler = class extends InteractionHandler {
 	* }
 	* ```
 	*/
-	async match(arms) {
-		return await armFor(this, arms, this.event.commandName)(this.target);
+	async match(cases) {
+		return await runCase(this, cases, "context menu command", this.route, this.target);
 	}
 };
 
@@ -936,7 +821,7 @@ var BaseHandler = class extends BaseHandler$1 {
 *
 * 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.
@@ -954,8 +839,14 @@ var BaseHandler = class extends BaseHandler$1 {
 * ```
 */
 var AutocompleteHandler = class extends BaseHandler {
-	constructor(event, core, dispatch) {
+	constructor(event, core, dispatch, responder) {
 		super(event, core, dispatch, "interactions");
+		this.#responder = responder;
+	}
+	#responder;
+	/** The user who sent this interaction. */
+	get user() {
+		return this.event.user;
 	}
 	decodedFocused;
 	/**
@@ -973,16 +864,17 @@ var AutocompleteHandler = class extends BaseHandler {
 		return focused;
 	}
 	/**
-	* 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
@@ -997,28 +889,14 @@ var AutocompleteHandler = class extends BaseHandler {
 	* }
 	* ```
 	*/
-	async match(arms) {
+	async match(cases) {
 		const { name, value } = this.focused;
 		const respond = (choices) => this.respond(choices);
-		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
-			this.constructor.name,
-			"focused field",
-			name
-		]);
-		return await arm(value, respond);
+		return await runCase(this, cases, "focused field", name, value, respond);
 	}
 	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
-	async respond(choices) {
-		await reportedWrite({
-			bus: this.core.bus,
-			dispatch: this.dispatch,
-			interactionId: this.event.id
-		}, "respond", () => this.event.respond(choices));
-	}
-	/** The firing command route, for a field whose completion differs per registered command. */
-	get route() {
-		return slashRouteOf(this.event);
+	respond(choices) {
+		return this.#responder.respond(choices);
 	}
 	/**
 	* The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
@@ -1051,7 +929,7 @@ var ComponentHandler = class extends InteractionHandler {
 		return this.sender.deferUpdate();
 	}
 	decoded;
-	get route() {
+	get decodedRoute() {
 		this.decoded ??= decodeComponentRoute(this.constructor, this.event.customId);
 		return this.decoded;
 	}
@@ -1065,20 +943,21 @@ var ComponentHandler = class extends InteractionHandler {
 	* @throws An **InvalidCustomId** when the wire is corrupt. The controller boundary turns it into a reply.
 	*/
 	get params() {
-		return this.route.params;
+		return this.decodedRoute.params;
 	}
 	/**
-	* 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.
 	*
@@ -1095,15 +974,9 @@ var ComponentHandler = class extends InteractionHandler {
 	* }
 	* ```
 	*/
-	async match(arms) {
-		const { prefix, params } = this.route;
-		const arm = Object.hasOwn(arms, prefix) ? arms[prefix] : void 0;
-		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
-			this.constructor.name,
-			"component route",
-			prefix
-		]);
-		return await arm(params);
+	async match(cases) {
+		const { prefix, params } = this.decodedRoute;
+		return await runCase(this, cases, "component route", prefix, params);
 	}
 };
 
@@ -1175,7 +1048,7 @@ var ModalHandler = class extends ComponentHandler {
 	}
 	ensureSourceMessage(method) {
 		if (this.event.isFromMessage()) return;
-		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
+		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.dispatch.routeId]);
 	}
 };
 
@@ -1338,8 +1211,8 @@ var MentionableMenuHandler = class extends SelectMenuHandler {
 /**
 * 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`.
@@ -1358,22 +1231,21 @@ var MentionableMenuHandler = class extends SelectMenuHandler {
 * ```
 */
 var EventHandler = class extends BaseHandler {
-	firedEvent;
-	constructor(event, core, dispatch, eventName) {
+	constructor(event, core, dispatch) {
 		super(event, core, dispatch, "events");
-		this.firedEvent = eventName;
 	}
 	/**
-	* 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
@@ -1388,16 +1260,8 @@ var EventHandler = class extends BaseHandler {
 	* }
 	* ```
 	*/
-	async match(arms) {
-		const name = this.firedEvent;
-		if (name === void 0) throw new SeedcordError(SeedcordErrorCode.EventNameUnavailable, [this.constructor.name, "match()"]);
-		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-		if (typeof arm !== "function") throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
-			this.constructor.name,
-			"event",
-			name
-		]);
-		return await arm(...this.getEvent());
+	async match(cases) {
+		return await runCase(this, cases, "event", this.route, ...this.getEvent());
 	}
 };
 
@@ -1408,26 +1272,135 @@ var EventHandler = class extends BaseHandler {
 *
 * 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).
 */
 var EventMiddleware = class extends BaseHandler {
-	firedEvent;
-	constructor(event, core, dispatch, eventName) {
+	constructor(event, core, dispatch) {
 		super(event, core, dispatch, "events");
-		this.firedEvent = 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.
-	*/
-	get eventName() {
-		if (this.firedEvent === void 0) throw new SeedcordError(SeedcordErrorCode.EventNameUnavailable, [this.constructor.name, "this.eventName"]);
-		return this.firedEvent;
+};
+
+//#endregion
+//#region src/bot/ReplySender.ts
+function isReplyFile(file) {
+	return typeof file === "object" && "data" in file && ArrayBuffer.isView(file.data);
+}
+function toDjsFile(file) {
+	if (!isReplyFile(file)) return file;
+	return {
+		attachment: Buffer.from(file.data),
+		name: file.name,
+		...file.description !== void 0 && { description: file.description },
+		...file.title !== void 0 && { title: file.title }
+	};
+}
+function seedState(interaction) {
+	if (interaction.deferred && interaction.ephemeral === null) return "deferred-update";
+	if (interaction.replied) return "replied";
+	if (interaction.deferred) return "deferred-reply";
+	return "unacked";
+}
+/** Writes interaction responses through discord.js. The repliable handler bases and the dispatcher construct it. */
+var ReplySender = class extends BaseReplySender {
+	interaction;
+	constructor(interaction, dispatch, bus) {
+		super({
+			bus,
+			dispatch,
+			interactionId: interaction.id
+		}, seedState(interaction));
+		this.interaction = interaction;
+	}
+	async writeReply(response, opts) {
+		const result = await this.interaction.reply({
+			...this.replyOptions(response, sendFlags(opts)),
+			withResponse: true
+		});
+		return this.createdMessage(result);
+	}
+	async writeDefer(opts) {
+		await this.interaction.deferReply({ flags: deferFlags(opts) });
+	}
+	async writeDeferUpdate() {
+		await this.sourceInteraction("deferUpdate").deferUpdate();
+	}
+	async writeUpdate(response) {
+		const result = await this.sourceInteraction("update").update({
+			...this.updateOptions(response),
+			withResponse: true
+		});
+		return this.createdMessage(result);
+	}
+	async writeFollowUp(response, opts) {
+		return await this.interaction.followUp(this.replyOptions(response, sendFlags(opts)));
+	}
+	async writeEditOriginal(response) {
+		return await this.interaction.editReply(this.editOptions(response));
+	}
+	async writeEditTarget(targetId, response) {
+		return await this.interaction.webhook.editMessage(targetId, this.editOptions(response));
+	}
+	async writeDeleteOriginal() {
+		await this.interaction.deleteReply();
+	}
+	async writeDeleteTarget(targetId) {
+		await this.interaction.deleteReply(targetId);
+	}
+	async writeModal(data) {
+		const { interaction } = this;
+		if (interaction.isModalSubmit()) this.rejectModalSubmit();
+		await interaction.showModal(data);
+	}
+	guardModalSource() {
+		if (this.interaction.isModalSubmit()) this.rejectModalSubmit();
+	}
+	rejectModalSubmit() {
+		throw new SeedcordError(SeedcordErrorCode.ReplyIllegalAckState, [
+			"showModal",
+			"this interaction is a modal submit",
+			"A modal cannot open another modal.",
+			this.routeId
+		]);
+	}
+	sourceInteraction(method) {
+		const { interaction } = this;
+		if (interaction.isMessageComponent()) return interaction;
+		if (interaction.isModalSubmit() && interaction.isFromMessage()) return interaction;
+		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
+	}
+	replyOptions(response, flags) {
+		const reply = this.serialize(response);
+		return {
+			components: reply.components,
+			flags,
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: reply.files.map(toDjsFile) }
+		};
+	}
+	editOptions(response) {
+		const reply = this.serialize(response);
+		return {
+			components: reply.components,
+			flags: MessageFlags.IsComponentsV2,
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: reply.files.map(toDjsFile) }
+		};
+	}
+	updateOptions(response) {
+		const reply = this.serialize(response);
+		return {
+			components: reply.components,
+			flags: MessageFlags.IsComponentsV2,
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: reply.files.map(toDjsFile) }
+		};
+	}
+	createdMessage(result) {
+		return result.resource?.message ?? void 0;
 	}
 };
 
@@ -1520,14 +1493,14 @@ var CursorSource = class extends CursorSourceBase {};
 /**
 * 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`
 */
 var Subscriber = class extends Subscriber$1 {};
 /**
 * 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`
 */
 var WebhookLog = class extends WebhookLog$1 {};
 
@@ -1540,8 +1513,8 @@ 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.
 */
@@ -1552,15 +1525,23 @@ var Plugin = class extends Plugin$1 {
 
 //#endregion
 //#region src/miscellaneous/deriveEventActor.ts
+function actorOf(message) {
+	return {
+		guild: message.guild,
+		member: message.member,
+		user: message.author,
+		channelId: message.channelId
+	};
+}
 function deriveEventActor(args) {
 	const tuple = Array.isArray(args) ? args : [args];
+	let partial;
 	for (const arg of tuple) {
-		if (arg instanceof Message) return {
-			guild: arg.guild,
-			member: arg.member,
-			user: arg.author,
-			channelId: arg.channelId
-		};
+		if (arg instanceof Message) {
+			const message = arg;
+			if (!message.partial) return actorOf(message);
+			partial ??= message;
+		}
 		if (arg instanceof GuildMember) return {
 			guild: arg.guild,
 			member: arg,
@@ -1574,7 +1555,7 @@ function deriveEventActor(args) {
 			channelId: null
 		};
 	}
-	return {
+	return partial ? actorOf(partial) : {
 		guild: null,
 		member: null,
 		user: null,
@@ -1583,7 +1564,8 @@ function deriveEventActor(args) {
 }
 
 //#endregion
-//#region src/bot/gates/runGates.ts
+//#region src/bot/gates/context.ts
+const NO_PERMISSIONS = 0n;
 function interactionGateContext(interaction, core, dispatch) {
 	const rawMember = interaction.member;
 	const memberRoleIds = rawMember instanceof GuildMember ? [...rawMember.roles.cache.keys()].filter((id) => id !== interaction.guildId) : rawMember?.roles ?? [];
@@ -1602,8 +1584,7 @@ function interactionGateContext(interaction, core, dispatch) {
 		memberPermissions: interaction.memberPermissions?.bitfield ?? null,
 		appPermissions: interaction.appPermissions.bitfield,
 		memberGuildPermissions: rawMember instanceof GuildMember ? rawMember.permissions.bitfield : null,
-		appGuildPermissions: interaction.guild?.members.me?.permissions.bitfield ?? null,
-		declaredRoute: null
+		appGuildPermissions: interaction.guild ? interaction.guild.members.me?.permissions.bitfield ?? null : NO_PERMISSIONS
 	};
 }
 function eventGateContext(eventName, args, core, dispatch) {
@@ -1622,161 +1603,76 @@ function eventGateContext(eventName, args, core, dispatch) {
 		channelId: actor.channelId,
 		memberRoleIds: actor.member ? [...actor.member.roles.cache.keys()].filter((id) => id !== actor.guild?.id) : [],
 		memberPermissions: actor.member?.permissions.bitfield ?? null,
-		appPermissions: null,
 		memberGuildPermissions: actor.member?.permissions.bitfield ?? null,
-		appGuildPermissions: actor.guild?.members.me?.permissions.bitfield ?? null,
-		declaredRoute: null
+		appGuildPermissions: actor.guild?.members.me?.permissions.bitfield ?? null
 	};
 }
 
 //#endregion
-//#region src/miscellaneous/extractErrorResponse.ts
-const logger$2 = new Logger("ErrorsHandling", { channel: "errors" });
-function extractErrorResponse(error, core, fault) {
-	const uuid = crypto.randomUUID();
-	const { dispatch } = fault;
-	const developerUsername = core.config.notifications?.developerUsername;
-	const ctx = developerUsername === void 0 ? {
-		uuid,
-		dispatch
-	} : {
-		uuid,
-		developerUsername,
-		dispatch
-	};
-	if (error instanceof Notice) {
-		if (error.report) reportFault(error, core, fault, uuid);
-		return {
-			uuid,
-			response: error.render(ctx)
-		};
-	}
-	reportRawFault(error, core, fault, uuid);
-	const Override = core.config.errors?.defaultError;
-	return {
-		uuid,
-		response: Override ? new Override(uuid).render(ctx) : new Fault().render(ctx)
-	};
-}
-function reportFault(denial, core, fault, uuid) {
-	logger$2.error(`${denial.name}: ${uuid}`, denial);
-	if (fault.interaction) core.bus[PublishDefault]("handledException", {
-		denial,
-		uuid,
-		dispatchId: fault.dispatch.id,
-		origin: fault.origin,
-		source: buildInteractionSource(fault.interaction)
-	});
-	else if (fault.event) core.bus[PublishDefault]("handledException", {
-		denial,
-		uuid,
-		dispatchId: fault.dispatch.id,
-		origin: fault.origin,
-		source: buildEventSource(fault.event, fault)
-	});
-	else core.bus[PublishDefault]("unknownException", {
-		uuid,
-		dispatchId: fault.dispatch.id,
-		error: denial,
-		origin: fault.origin,
-		...scalarActors(fault),
-		metadata: metadataFor(fault)
-	});
-}
-function reportRawFault(error, core, fault, uuid) {
-	logUnknownFault(logger$2, uuid, error, core.config.errors);
-	core.bus[PublishDefault]("unknownException", {
-		uuid,
-		dispatchId: fault.dispatch.id,
-		error,
-		origin: fault.origin,
-		...scalarActors(fault),
-		metadata: metadataFor(fault)
-	});
-}
-function scalarActors(fault) {
+//#region src/miscellaneous/faultReports.ts
+function interactionFaultReport(interaction, dispatch) {
 	return {
-		guild: fault.guild ? {
-			id: fault.guild.id,
-			name: fault.guild.name
-		} : void 0,
-		user: fault.user ? {
-			id: fault.user.id,
-			username: fault.user.username
-		} : void 0
-	};
-}
-function metadataFor(fault) {
-	if (fault.event) return {
-		eventName: fault.event.name,
-		handler: fault.event.handler,
-		args: fault.event.args
+		origin: dispatch.routeId,
+		source: interactionFaultSource(dispatch, {
+			customId: "customId" in interaction ? interaction.customId : null,
+			userId: interaction.user.id,
+			guildId: interaction.guildId,
+			channelId: interaction.channelId,
+			interactionId: interaction.id,
+			raw: interaction
+		}),
+		...scalarActors(interaction.guild, interaction.user),
+		metadata: interaction
 	};
-	return fault.metadata;
 }
-function buildEventSource(event, fault) {
+function eventFaultReport(event) {
 	return {
-		kind: "event",
-		eventName: event.name,
-		handler: event.handler,
-		userId: fault.user?.id ?? null,
-		guildId: fault.guild?.id ?? null,
-		channelId: event.channelId,
-		raw: event.args
+		origin: `event:${event.name}:${event.handler}`,
+		source: {
+			kind: "event",
+			eventName: event.name,
+			handler: event.handler,
+			userId: event.user?.id ?? null,
+			guildId: event.guild?.id ?? null,
+			channelId: event.channelId,
+			raw: event.args
+		},
+		...scalarActors(event.guild, event.user),
+		metadata: {
+			eventName: event.name,
+			handler: event.handler,
+			args: event.args
+		}
 	};
 }
-function buildInteractionSource(interaction) {
-	const command = interaction.isChatInputCommand() ? slashRouteOf(interaction) : interaction.isContextMenuCommand() ? interaction.commandName : null;
-	const customId = interaction.isButton() || interaction.isAnySelectMenu() || interaction.isModalSubmit() ? interaction.customId : null;
+function scalarActors(guild, user) {
 	return {
-		kind: "interaction",
-		interactionKind: interactionKind(interaction),
-		command,
-		customId,
-		userId: interaction.user.id,
-		guildId: interaction.guildId,
-		channelId: interaction.channelId,
-		interactionId: interaction.id,
-		raw: interaction
+		guild: guild ? {
+			id: guild.id,
+			name: guild.name
+		} : void 0,
+		user: user ? {
+			id: user.id,
+			username: user.username
+		} : void 0
 	};
 }
-function interactionKind(interaction) {
-	if (interaction.isChatInputCommand()) return "slash";
-	if (interaction.isContextMenuCommand()) return "context-menu";
-	if (interaction.isButton()) return "button";
-	if (interaction.isAnySelectMenu()) return "select";
-	return "modal";
-}
 
 //#endregion
 //#region src/bot/handleEventFault.ts
-const logger$1 = new Logger("Faults", { channel: "errors" });
 function handleEventFault(caught, fault, core) {
-	const { eventName, handlerName, args, dispatch } = fault;
-	if (caught instanceof Silence) {
-		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger$1.debug(`Silence: ${caught.reason}`);
-		return;
-	}
-	const error = asError(caught);
-	const ignore = new Set(core.config.errors?.ignoreEventApiCodes ?? []);
-	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
-		logger$1.debug(`swallowed api code ${error.code}`);
-		return;
-	}
-	if (error instanceof Notice && !error.report) return;
-	const actor = deriveEventActor(args);
-	extractErrorResponse(error, core, {
-		event: {
-			name: eventName,
+	const { handlerName, args, dispatch } = fault;
+	new FaultBoundary(core, core.config.errors?.ignoreEventApiCodes, DiscordAPIError, dispatch, () => {
+		const { channelId, guild, user } = deriveEventActor(args);
+		return eventFaultReport({
+			name: dispatch.route,
 			handler: handlerName,
 			args,
-			channelId: actor.channelId
-		},
-		origin: `event:${eventName}:${handlerName}`,
-		dispatch,
-		guild: actor.guild,
-		user: actor.user
-	});
+			channelId,
+			guild,
+			user
+		});
+	}).report(caught);
 }
 
 //#endregion
@@ -1818,33 +1714,29 @@ const eventMiddleware = (ctor) => {
 */
 var EventDispatcher = class {
 	core;
+	inFlight;
 	logger = new Logger("Events", { channel: "events" });
 	isInitialized = false;
 	eventMap = /* @__PURE__ */ new Map();
 	middlewares = new MiddlewareRegistry(eventMiddleware);
-	executedOnceHandlers = /* @__PURE__ */ new Set();
+	onceRuns = new OnceTracker();
 	attachedEvents = /* @__PURE__ */ new Set();
-	inFlight = new InFlight(this.logger, "Events");
-	loading = false;
-	loadedHandlers = [];
-	loadedMiddlewares = [];
-	hmrHandler;
-	constructor(core) {
+	loader;
+	constructor(core, inFlight) {
 		this.core = core;
+		this.inFlight = inFlight;
 		const eventsDir = this.core.config.bot.events.path;
 		if (!eventsDir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["EventDispatcher", "events"]);
-		if (!Envapter.isDevelopment && !Envapter.isTest) return;
-		this.hmrHandler = new HmrModuleHandler$1({
+		this.loader = new HandlerLoader({
 			handlersDir: eventsDir,
-			...hasKeys(this.core.config.bot.events, ["middlewares"]) && { middlewaresDir: this.core.config.bot.events.middlewares },
-			isHandler: this.isEventHandlerClass.bind(this),
-			isMiddleware: this.isMiddlewareClass.bind(this),
-			registerHandler: this.registerHandler.bind(this),
-			registerMiddleware: this.registerMiddleware.bind(this),
-			unregisterHandler: this.unregisterHandler.bind(this),
-			unregisterMiddleware: this.unregisterMiddleware.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
-			logger: this.logger
+			middlewaresDir: hasKeys(this.core.config.bot.events, ["middlewares"]) ? this.core.config.bot.events.middlewares : void 0,
+			middlewares: this.middlewares,
+			logger: this.logger,
+			isHandler: (value) => this.isEventHandlerClass(value),
+			isMiddleware: (value) => this.isMiddlewareClass(value),
+			storeHandler: (ctor) => this.storeHandler(ctor),
+			removeHandler: (ctor, events) => this.unregisterHandler(ctor, events),
+			artifactsOf: (ctor) => this.getArtifacts(ctor)
 		});
 	}
 	getArtifacts(ctor) {
@@ -1855,49 +1747,25 @@ var EventDispatcher = class {
 	async init() {
 		if (this.isInitialized) return;
 		this.isInitialized = true;
-		const handlersDir = this.core.config.bot.events.path;
-		if (!handlersDir) return;
-		const middlewareDir = hasKeys(this.core.config.bot.events, ["middlewares"]) ? this.core.config.bot.events.middlewares : void 0;
-		this.loading = true;
-		this.loadedHandlers.length = 0;
-		this.loadedMiddlewares.length = 0;
-		try {
-			if (middlewareDir) await this.loadMiddlewares(middlewareDir);
-			await this.loadHandlers(handlersDir);
-		} finally {
-			this.loading = false;
-		}
+		await this.loader.load();
 		this.attachToClient();
 		this.reportLoad();
 	}
 	reportLoad() {
 		const { utils } = this.logger;
+		const { loadedHandlers, loadedMiddlewares } = this.loader;
 		utils.summary("Loaded", {
-			"event handlers": this.loadedHandlers.length,
-			middlewares: this.loadedMiddlewares.length
+			"event handlers": loadedHandlers.length,
+			middlewares: loadedMiddlewares.length
 		}, "debug");
-		if (this.loadedMiddlewares.length > 0) utils.block("Loaded event middlewares", utils.entries(this.loadedMiddlewares), "debug");
+		if (loadedMiddlewares.length > 0) utils.block("Loaded event middlewares", utils.entries(loadedMiddlewares), "debug");
 		const perEvent = {};
 		for (const [event, handlers] of this.eventMap) perEvent[event] = handlers.length;
-		utils.block("Loaded event handlers", [...utils.entries(this.loadedHandlers), ...utils.counts(perEvent)], "debug");
-	}
-	async loadHandlers(dir) {
-		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const val of Object.values(imported)) {
-			if (!this.isEventHandlerClass(val)) continue;
-			this.registerHandler(val, relativePath);
-			this.hmrHandler?.trackHandler(fullPath, val);
-		}
-	}
-	async loadMiddlewares(dir) {
-		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const val of Object.values(imported)) {
-			if (!this.isMiddlewareClass(val)) continue;
-			this.registerMiddleware(val, relativePath);
-			this.hmrHandler?.trackMiddleware(fullPath, val);
-		}
+		utils.block("Loaded event handlers", [...utils.entries(loadedHandlers), ...utils.counts(perEvent)], "debug");
 	}
 	/** @internal */
 	async onHmr(event) {
-		await this.hmrHandler?.handle(event);
+		await this.loader.onHmr(event);
 	}
 	unregisterHandler(handlerClass, artifacts) {
 		const events = artifacts ?? [...this.eventMap.keys()];
@@ -1910,26 +1778,13 @@ var EventDispatcher = class {
 			if (handlers.length === 0) this.eventMap.delete(event);
 		}
 	}
-	unregisterMiddleware(middlewareCtor) {
-		this.middlewares.unregister(middlewareCtor);
-	}
-	registerMiddleware(middlewareCtor, relativePath) {
-		const registration = this.middlewares.register(middlewareCtor);
-		if (!registration || !this.loading) return;
-		const scope = registration.keys ? `${registration.priority}, ${registration.keys.join(", ")}` : registration.priority;
-		this.loadedMiddlewares.push({
-			name: `${middlewareCtor.name} (${String(scope)})`,
-			from: formatFilePath(relativePath)
-		});
-	}
 	async runMiddlewares(eventName, args, dispatch, ran) {
 		for (const Middleware of this.middlewares.chainFor(eventName)) try {
-			const middleware = new Middleware(args, this.core, dispatch, eventName);
+			const middleware = new Middleware(args, this.core, dispatch);
 			ran.push(middleware);
 			await middleware.execute();
 		} catch (caught) {
 			handleEventFault(caught, {
-				eventName: String(eventName),
 				handlerName: Middleware.name,
 				args,
 				dispatch
@@ -1946,8 +1801,8 @@ var EventDispatcher = class {
 		if (typeof obj !== "function") return false;
 		return obj.prototype instanceof EventMiddleware && Reflect.hasMetadata(EventMiddlewareMetadataKey, obj);
 	}
-	registerHandler(handlerClass, relativePath) {
-		const raw = Reflect.getMetadata(EventMetadataKey, handlerClass);
+	storeHandler(handlerClass) {
+		const entries = Reflect.getMetadata(EventMetadataKey, handlerClass);
 		const register = (key, frequency) => {
 			let handlers = this.eventMap.get(key);
 			if (!handlers) {
@@ -1960,16 +1815,8 @@ var EventDispatcher = class {
 			});
 			if (this.isInitialized && !this.attachedEvents.has(key)) this.attachListener(key);
 		};
-		if (Array.isArray(raw)) for (const entry of raw) register(entry.event, entry.frequency);
-		else {
-			const names = isStringArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
-			for (const name of names) register(name, "on");
-		}
-		const from = formatFilePath(relativePath);
-		if (this.loading) this.loadedHandlers.push({
-			name: handlerClass.name,
-			from
-		});
+		for (const entry of entries) register(entry.event, entry.frequency);
+		return true;
 	}
 	attachToClient() {
 		for (const [eventName] of this.eventMap) this.attachListener(eventName);
@@ -1980,28 +1827,21 @@ var EventDispatcher = class {
 		const handlerEntries = this.eventMap.get(eventName);
 		this.logger.debug(`Attaching ${paint.sky.bold(eventName)} to the client with ${paint.mute(handlerEntries?.length ?? 0)} handler(s)`);
 		this.core.bot.client.on(eventName, (...args) => {
-			if (this.inFlight.closed) return;
-			const run = this.processEvent(eventName, args).catch((caught) => {
-				const error = asError(caught);
-				this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
-				this.core.bus[PublishDefault]("unhandledEventError", { error });
-			});
-			this.inFlight.track(run);
+			this.inFlight.admit(() => this.processEvent(eventName, args).catch((caught) => this.reportUnhandled(caught)));
 		});
 	}
-	stopAccepting() {
-		this.inFlight.close();
-	}
-	drain(timeoutMs) {
-		return this.inFlight.drain(timeoutMs);
+	reportUnhandled(caught) {
+		const error = asError(caught);
+		this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
+		this.core.bus[PublishDefault]("unhandledEventError", { error });
 	}
 	async processEvent(eventName, args) {
 		const startedAt = performance.now();
 		const handlerEntries = this.eventMap.get(eventName);
 		if (!handlerEntries || handlerEntries.length === 0) return;
-		const handlersToExecute = handlerEntries.filter((entry) => entry.frequency !== "once" || !this.executedOnceHandlers.has(entry.ctor));
+		const handlersToExecute = handlerEntries.filter((entry) => !this.onceRuns.isSpent(entry, eventName));
 		if (handlersToExecute.length === 0) return;
-		const dispatch = new DispatchContext(`event:${String(eventName)}`);
+		const dispatch = new DispatchContext("event", eventName);
 		reportEventDispatching(this.core, dispatch.id, eventName, args);
 		const ran = [];
 		const handlers = [];
@@ -2009,13 +1849,8 @@ var EventDispatcher = class {
 		try {
 			stopped = await this.runMiddlewares(eventName, args, dispatch, ran);
 			if (stopped) return;
-			for (const entry of handlersToExecute) {
-				if (entry.frequency === "once") {
-					if (this.executedOnceHandlers.has(entry.ctor)) continue;
-					this.executedOnceHandlers.add(entry.ctor);
-				}
-				handlers.push(await this.processHandler(eventName, entry.ctor, args, dispatch));
-			}
+			const results = handlersToExecute.filter((entry) => this.onceRuns.claim(entry, eventName)).map((entry) => this.processHandler(eventName, entry.ctor, args, dispatch));
+			handlers.push(...await Promise.all(results));
 		} finally {
 			const result = eventResultFor(stopped, handlers);
 			reportEventDispatched(this.core, dispatch.id, eventName, result, startedAt);
@@ -2024,8 +1859,8 @@ var EventDispatcher = class {
 	}
 	async processHandler(eventName, Ctor, args, dispatch) {
 		try {
-			this.logger.debug(`Processing ${paint.sky.bold(eventName)} with ${paint.mute(Ctor.name)}`);
-			const handler = new Ctor(args, this.core, dispatch, eventName);
+			this.logger.trace(`Processing ${paint.sky.bold(eventName)} with ${paint.mute(Ctor.name)}`);
+			const handler = new Ctor(args, this.core, dispatch);
 			const eventCtx = eventGateContext(eventName, args, this.core, dispatch);
 			await runHandlerGates(Ctor, eventCtx);
 			await handler.execute();
@@ -2035,7 +1870,6 @@ var EventDispatcher = class {
 			};
 		} catch (caught) {
 			handleEventFault(caught, {
-				eventName: String(eventName),
 				handlerName: Ctor.name,
 				args,
 				dispatch
@@ -2048,6 +1882,40 @@ var EventDispatcher = class {
 	}
 };
 
+//#endregion
+//#region src/bot/autocompleteResponder.ts
+function autocompleteResponder(interaction, core, dispatch) {
+	return new AutocompleteResponder({
+		bus: core.bus,
+		dispatch,
+		interactionId: interaction.id
+	}, (choices) => interaction.respond(choices));
+}
+
+//#endregion
+//#region src/bot/controllers/gatewayRunConfig.ts
+function gatewayRunConfig(run) {
+	const { interaction, core, dispatch, HandlerCtor, middlewares, logger } = run;
+	return {
+		dispatch,
+		core,
+		event: interaction,
+		HandlerCtor,
+		middlewares,
+		apiError: DiscordAPIError,
+		logger,
+		interactionId: interaction.id,
+		userId: interaction.user.id,
+		guildId: interaction.guildId,
+		customId: "customId" in interaction ? interaction.customId : null,
+		faultDetails: () => interactionFaultReport(interaction, dispatch),
+		target: interaction.isAutocomplete() ? { responder: autocompleteResponder(interaction, core, dispatch) } : {
+			gateContext: () => interactionGateContext(interaction, core, dispatch),
+			sender: new ReplySender(interaction, dispatch, core.bus)
+		}
+	};
+}
+
 //#endregion
 //#region src/bot/defaults/UnhandledRepliable.ts
 var UnhandledRepliable = class extends InteractionHandler {
@@ -2065,166 +1933,73 @@ var UnhandledAutocomplete = class extends AutocompleteHandler {
 };
 
 //#endregion
-//#region src/bot/harmlessApiCodes.ts
-/**
-* Discord API error codes that mean a dead end on an interaction, a dead token, a double ack, or a gone
-* message. Nothing to show the user and no bug to report, so the boundary's fault-card send drops them.
-*
-* @internal
-*/
-const HARMLESS_API_CODES = /* @__PURE__ */ new Set([
-	RESTJSONErrorCodes.UnknownInteraction,
-	RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
-	RESTJSONErrorCodes.UnknownMessage
-]);
-
-//#endregion
-//#region src/bot/handleInteractionFault.ts
-const logger = new Logger("Faults", { channel: "errors" });
-async function handleInteractionFault(caught, interaction, core, dispatch, sender) {
-	const { routeId } = dispatch;
-	if (caught instanceof Silence) {
-		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger.debug(`Silence: ${caught.reason}`);
-		return;
-	}
-	const error = asError(caught);
-	const ignore = new Set(core.config.errors?.ignoreApiCodes ?? []);
-	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
-		logger.debug(`swallowed api code ${error.code}`);
-		return;
-	}
-	if (interaction.isAutocomplete()) {
-		extractErrorResponse(error, core, {
-			origin: routeId,
-			dispatch,
-			guild: interaction.guild,
-			user: interaction.user,
-			metadata: interaction
-		});
-		await sendEmptyChoices(interaction, core, dispatch);
-		return;
-	}
-	const { response } = extractErrorResponse(error, core, {
-		interaction,
-		origin: routeId,
-		dispatch,
-		guild: interaction.guild,
-		user: interaction.user,
-		metadata: interaction
-	});
-	await sendGuarded(sender ?? new ReplySender(interaction, dispatch, core.bus), response, error instanceof Notice ? error.ephemeral : true);
-}
-async function sendEmptyChoices(interaction, core, dispatch) {
-	const telemetry = {
-		bus: core.bus,
-		dispatch,
-		interactionId: interaction.id
-	};
-	try {
-		await reportedWrite(telemetry, "respond", () => interaction.respond([]));
-	} catch (error) {
-		logger.debug(`autocomplete empty-choices send failed: ${String(error)}`);
-	}
-}
-async function sendGuarded(sender, response, ephemeral) {
-	try {
-		await sender.send(response, { ephemeral });
-	} catch (error) {
-		if (error instanceof DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
-			logger.debug(`reply send hit harmless code ${error.code}`);
-			return;
-		}
-		logger.error("reply send failed", error);
-	}
+//#region src/bot/utilities/miscellaneous/slashRouteOf.ts
+function slashRouteOf(interaction) {
+	const group = interaction.options.getSubcommandGroup(false) ?? void 0;
+	const subcommand = interaction.options.getSubcommand(false) ?? void 0;
+	return buildSlashRoute(interaction.commandName, subcommand, group);
 }
 
 //#endregion
 //#region src/bot/controllers/InteractionDispatcher.ts
+const UNHANDLED = {
+	repliable: UnhandledRepliable,
+	autocomplete: UnhandledAutocomplete
+};
 var InteractionDispatcher = class {
 	core;
+	inFlight;
 	logger = new Logger("Interactions", { channel: "interactions" });
 	isInitialized = false;
-	maps = {
-		[InteractionKind.Slash]: /* @__PURE__ */ new Map(),
-		[InteractionKind.Button]: /* @__PURE__ */ new Map(),
-		[InteractionKind.Modal]: /* @__PURE__ */ new Map(),
-		[InteractionKind.StringMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.UserMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.RoleMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.ChannelMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.MentionableMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.MessageContextMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.UserContextMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.Autocomplete]: /* @__PURE__ */ new Map()
-	};
-	handlerFiles = /* @__PURE__ */ new Map();
+	routes = new RouteRegistry();
+	get maps() {
+		return this.routes.maps;
+	}
 	keysToIgnore = /* @__PURE__ */ new Set();
 	middlewares = new MiddlewareRegistry(interactionMiddleware);
-	inFlight = new InFlight(this.logger, "Interactions");
-	loading = false;
-	loadedHandlers = [];
-	loadedMiddlewares = [];
-	hmrHandler;
-	constructor(core) {
+	loader;
+	constructor(core, inFlight) {
 		this.core = core;
+		this.inFlight = inFlight;
 		const ignoredKeysFromConfig = hasKeys(this.core.config.bot.interactions, ["ignoreCustomIds"]) ? this.core.config.bot.interactions.ignoreCustomIds : void 0;
 		if (ignoredKeysFromConfig) for (const ignoredKey of ignoredKeysFromConfig) this.keysToIgnore.add(ignoredKey);
 		this.keysToIgnore.add(CONFIRM_DEF);
 		const interactionsDir = this.core.config.bot.interactions.path;
 		if (!interactionsDir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["InteractionDispatcher", "interactions"]);
-		if (!Envapter.isDevelopment && !Envapter.isTest) return;
-		this.hmrHandler = new HmrModuleHandler$1({
+		this.loader = new HandlerLoader({
 			handlersDir: interactionsDir,
-			...hasKeys(this.core.config.bot.interactions, ["middlewares"]) && this.core.config.bot.interactions.middlewares && { middlewaresDir: this.core.config.bot.interactions.middlewares },
-			isHandler: this.isHandlerClass.bind(this),
-			isMiddleware: this.isMiddlewareClass.bind(this),
-			registerHandler: this.registerHandler.bind(this),
-			registerMiddleware: this.registerMiddleware.bind(this),
-			unregisterHandler: this.unregisterHandler.bind(this),
-			unregisterMiddleware: this.unregisterMiddleware.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
-			logger: this.logger
+			middlewaresDir: hasKeys(this.core.config.bot.interactions, ["middlewares"]) ? this.core.config.bot.interactions.middlewares : void 0,
+			middlewares: this.middlewares,
+			logger: this.logger,
+			isHandler: (value) => this.isHandlerClass(value),
+			isMiddleware: (value) => this.isMiddlewareClass(value),
+			storeHandler: (ctor, from) => this.routes.register(ctor, from),
+			removeHandler: (ctor, routes) => this.routes.unregister(ctor, routes),
+			artifactsOf: (ctor) => this.routes.routesOf(ctor)
 		});
 	}
 	warnUnhandledRoutes(commandLeaves) {
-		for (const route of commandLeaves) if (!this.maps[InteractionKind.Slash].has(route)) this.logger.warn(`Slash route ${paint.sky.bold(route)} has no registered ${paint.bold("@SlashRoute")} handler.`);
+		this.routes.warnUnhandledRoutes(this.logger, commandLeaves);
 	}
 	warnUnhandledContextMenuRoutes(leaves) {
-		for (const name of leaves.user) if (!this.maps[InteractionKind.UserContextMenu].has(name)) this.logger.warn(`User context menu ${paint.sky.bold(name)} has no registered ${paint.bold("@ContextMenuRoute")} handler.`);
-		for (const name of leaves.message) if (!this.maps[InteractionKind.MessageContextMenu].has(name)) this.logger.warn(`Message context menu ${paint.sky.bold(name)} has no registered ${paint.bold("@ContextMenuRoute")} handler.`);
-	}
-	getArtifacts(handlerClass) {
-		return interactionRoutesOf(handlerClass).map(([routeType, routes]) => ({
-			routeType,
-			routes
-		}));
+		this.routes.warnUnhandledContextMenuRoutes(this.logger, leaves);
 	}
 	async init() {
 		if (this.isInitialized) return;
 		this.isInitialized = true;
-		const handlersDir = this.core.config.bot.interactions.path;
-		if (!handlersDir) return;
-		const middlewareDir = hasKeys(this.core.config.bot.interactions, ["middlewares"]) ? this.core.config.bot.interactions.middlewares : void 0;
-		this.loading = true;
-		this.loadedHandlers.length = 0;
-		this.loadedMiddlewares.length = 0;
-		try {
-			if (middlewareDir) await this.loadMiddlewares(middlewareDir);
-			await this.loadHandlers(handlersDir);
-		} finally {
-			this.loading = false;
-		}
+		await this.loader.load();
 		this.attachToClient();
 		this.reportLoad();
 	}
 	reportLoad() {
 		const { utils } = this.logger;
+		const { loadedHandlers, loadedMiddlewares } = this.loader;
 		utils.summary("Loaded", {
-			"interaction handlers": this.loadedHandlers.length,
-			middlewares: this.loadedMiddlewares.length
+			"interaction handlers": loadedHandlers.length,
+			middlewares: loadedMiddlewares.length
 		}, "debug");
-		if (this.loadedMiddlewares.length > 0) utils.block("Loaded middlewares", utils.entries(this.loadedMiddlewares), "debug");
-		utils.block("Loaded interaction handlers", [...utils.entries(this.loadedHandlers), ...utils.counts({
+		if (loadedMiddlewares.length > 0) utils.block("Loaded middlewares", utils.entries(loadedMiddlewares), "debug");
+		utils.block("Loaded interaction handlers", [...utils.entries(loadedHandlers), ...utils.counts({
 			slash: this.maps[InteractionKind.Slash].size,
 			buttons: this.maps[InteractionKind.Button].size,
 			modals: this.maps[InteractionKind.Modal].size,
@@ -2238,29 +2013,6 @@ var InteractionDispatcher = class {
 			autocomplete: this.maps[InteractionKind.Autocomplete].size
 		})], "debug");
 	}
-	async loadHandlers(dir) {
-		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const val of Object.values(imported)) {
-			if (!this.isHandlerClass(val)) continue;
-			this.registerHandler(val, relativePath);
-			this.hmrHandler?.trackHandler(fullPath, val);
-		}
-	}
-	async loadMiddlewares(dir) {
-		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const val of Object.values(imported)) {
-			if (!this.isMiddlewareClass(val)) continue;
-			this.registerMiddleware(val, relativePath);
-			this.hmrHandler?.trackMiddleware(fullPath, val);
-		}
-	}
-	registerMiddleware(middlewareCtor, relativePath) {
-		const metadata = this.middlewares.register(middlewareCtor);
-		if (!metadata || !this.loading) return;
-		const scope = metadata.keys ? `${metadata.priority}, ${metadata.keys.join(", ")}` : metadata.priority;
-		this.loadedMiddlewares.push({
-			name: `${middlewareCtor.name} (${String(scope)})`,
-			from: formatFilePath(relativePath)
-		});
-	}
 	isHandlerClass(obj) {
 		if (typeof obj !== "function") return false;
 		return obj.prototype instanceof InteractionHandler && Reflect.hasMetadata(InteractionMetadataKey, obj) || obj.prototype instanceof AutocompleteHandler && Reflect.hasMetadata(InteractionMetadataKey, obj);
@@ -2269,239 +2021,47 @@ var InteractionDispatcher = class {
 		if (typeof obj !== "function") return false;
 		return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(InteractionMiddlewareMetadataKey, obj);
 	}
-	registerHandler(handlerClass, relativePath) {
-		const from = formatFilePath(relativePath);
-		const writes = [];
-		for (const [kind, routes] of interactionRoutesOf(handlerClass)) for (const route of routes) {
-			const existing = this.maps[kind].get(route);
-			if (existing && existing !== handlerClass) throw new SeedcordTypeError(SeedcordErrorCode.CoreDuplicateName, [
-				"route",
-				`${kind}:${route}`,
-				[`${paint.bold(existing.name)} (${paint.path(this.handlerFiles.get(existing) ?? "unknown file")})`, `${paint.bold(handlerClass.name)} (${paint.path(from)})`]
-			]);
-			writes.push({
-				kind,
-				route
-			});
-		}
-		if (writes.length === 0) return;
-		for (const { kind, route } of writes) this.maps[kind].set(route, handlerClass);
-		this.handlerFiles.set(handlerClass, from);
-		if (this.loading) this.loadedHandlers.push({
-			name: handlerClass.name,
-			from
-		});
-	}
 	async onHmr(event) {
-		await this.hmrHandler?.handle(event);
-	}
-	unregisterHandler(handlerClass, artifacts) {
-		this.handlerFiles.delete(handlerClass);
-		for (const { routeType, routes } of artifacts ?? this.getArtifacts(handlerClass)) for (const route of routes) this.maps[routeType].delete(route);
-	}
-	unregisterMiddleware(middlewareCtor) {
-		this.middlewares.unregister(middlewareCtor);
+		await this.loader.onHmr(event);
 	}
 	attachToClient() {
 		this.core.bot.client.on(Events.InteractionCreate, (interaction) => {
-			if (this.inFlight.closed) return;
-			this.core.bus[PublishDefault]("anyInteraction", { interaction });
-			const run = this.handleInteraction(interaction).catch((caught) => {
-				const error = asError(caught);
-				this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
-				this.core.bus[PublishDefault]("unhandledInteractionError", { error });
+			this.inFlight.admit(() => {
+				this.core.bus[PublishDefault]("anyInteraction", { interaction });
+				return this.handleInteraction(interaction).catch((caught) => {
+					const error = asError(caught);
+					this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
+					this.core.bus[PublishDefault]("unhandledInteractionError", { error });
+				});
 			});
-			this.inFlight.track(run);
 		});
 	}
-	stopAccepting() {
-		this.inFlight.close();
-	}
-	drain(timeoutMs) {
-		return this.inFlight.drain(timeoutMs);
-	}
 	async handleCustomIdInteraction(interaction, kind) {
 		if ([...this.keysToIgnore].some((matcher) => matcher.owns(interaction.customId))) return;
-		const prefix = prefixOf(interaction.customId);
-		if (!prefix) this.logger.warn(`${paint.sky.bold(kind)} has invalid customId: ${paint.mute(interaction.customId)}`);
-		await this.processInteraction(interaction, kind, () => prefix);
+		await this.processInteraction(interaction, kind, prefixOf(interaction.customId));
 	}
-	async processInteraction(interaction, kind, extractKey, fallback = UnhandledRepliable) {
-		const key = extractKey(interaction);
-		const startedAt = performance.now();
-		const queuedMs = queuedMsFor(interaction.id);
-		const matched = this.maps[kind].get(key);
-		const HandlerCtor = matched ?? fallback;
-		const dispatch = new DispatchContext(`${kind}:${key || "unrouted"}`);
-		const report = this.reporterFor({
+	async processInteraction(interaction, kind, key) {
+		const { fallback, ctor: HandlerCtor } = matchRoute(this.maps, kind, key, UNHANDLED);
+		const config = gatewayRunConfig({
 			interaction,
-			kind,
-			fallback: !matched,
-			startedAt,
-			queuedMs,
-			dispatchId: dispatch.id,
-			routeId: dispatch.routeId
+			core: this.core,
+			dispatch: new DispatchContext(kind, key, fallback),
+			HandlerCtor,
+			middlewares: this.middlewares,
+			logger: this.logger
 		});
-		let sender;
-		const ran = [];
-		let result = { outcome: "handled" };
-		try {
-			const handler = this.buildHandler(HandlerCtor, interaction, dispatch, key, !matched);
-			if (handler instanceof RepliableHandler) sender = handler.sender;
-			const refusal = await this.refusalBeforeHandler({
-				HandlerCtor,
-				kind,
-				interaction,
-				dispatch,
-				sender,
-				ran,
-				declaredRoute: matched ? dispatch.routeId : void 0
-			});
-			if (refusal) {
-				result = resultFor(refusal.caught);
-				await this.answer(refusal.caught, interaction, dispatch, sender, report);
-				return;
-			}
-			await handler.execute();
-			report("handled");
-		} catch (caught) {
-			if (result.outcome === "handled") result = resultFor(caught);
-			await this.answer(caught, interaction, dispatch, sender, report);
-		} finally {
-			await runAfter(ran, result, this.logger);
-		}
-	}
-	async answer(caught, interaction, dispatch, sender, report) {
-		try {
-			await handleInteractionFault(caught, interaction, this.core, dispatch, sender);
-		} finally {
-			report(outcomeFor(caught));
-		}
-	}
-	buildHandler(HandlerCtor, interaction, dispatch, key, isFallback) {
-		if (isFallback) this.logger.warn(`No handler found for key ${paint.sky.bold(key)}. Falling back to ${HandlerCtor.name}.`);
-		this.logger.debug(`Processing ${paint.sky.bold(key)} with ${paint.mute(HandlerCtor.name)}`);
-		return new HandlerCtor(interaction, this.core, dispatch);
-	}
-	reporterFor(row) {
-		let reported = false;
-		return (outcome) => {
-			if (reported) return;
-			reported = true;
-			reportDispatch(this.core.bus, {
-				dispatchId: row.dispatchId,
-				routeId: row.routeId,
-				interactionId: row.interaction.id,
-				kind: row.kind,
-				outcome,
-				startedAt: row.startedAt,
-				fallback: row.fallback,
-				userId: row.interaction.user.id,
-				guildId: row.interaction.guildId,
-				queuedMs: row.queuedMs
-			});
-		};
-	}
-	async refusalBeforeHandler(step) {
-		const { HandlerCtor, kind, interaction, dispatch, sender, ran, declaredRoute } = step;
-		if (kind !== InteractionKind.Autocomplete && sender) try {
-			await this.runMiddlewares(kind, interaction, dispatch, sender, ran);
-		} catch (caught) {
-			return { caught };
-		}
-		if (interaction.isAutocomplete()) return null;
-		return this.gateRefusal(HandlerCtor, interaction, dispatch, declaredRoute);
-	}
-	async runMiddlewares(kind, interaction, dispatch, sender, ran) {
-		for (const Middleware of this.middlewares.chainFor(kind)) {
-			const middleware = new Middleware(interaction, this.core, dispatch, sender);
-			ran.push(middleware);
-			await middleware.execute();
-		}
-	}
-	async gateRefusal(HandlerCtor, interaction, dispatch, declaredRoute) {
-		const monitor = slowGateMonitor();
-		try {
-			await runHandlerGates(HandlerCtor, interactionGateContext(interaction, this.core, dispatch), declaredRoute, monitor?.observe);
-			return null;
-		} catch (caught) {
-			return { caught };
-		} finally {
-			monitor?.report(declaredRoute ?? null);
-		}
+		await (await new InteractionRun(config).prepare())?.();
 	}
 	async handleInteraction(interaction) {
-		switch (true) {
-			case interaction.isChatInputCommand():
-				await this.handleSlashCommand(interaction);
-				break;
-			case interaction.isButton():
-				await this.handleButton(interaction);
-				break;
-			case interaction.isModalSubmit():
-				await this.handleModal(interaction);
-				break;
-			case interaction.isStringSelectMenu():
-				await this.handleStringSelectMenu(interaction);
-				break;
-			case interaction.isUserSelectMenu():
-				await this.handleUserSelectMenu(interaction);
-				break;
-			case interaction.isRoleSelectMenu():
-				await this.handleRoleSelectMenu(interaction);
-				break;
-			case interaction.isChannelSelectMenu():
-				await this.handleChannelSelectMenu(interaction);
-				break;
-			case interaction.isMentionableSelectMenu():
-				await this.handleMentionableSelectMenu(interaction);
-				break;
-			case interaction.isMessageContextMenuCommand():
-				await this.handleMessageContextMenu(interaction);
-				break;
-			case interaction.isUserContextMenuCommand():
-				await this.handleUserContextMenu(interaction);
-				break;
-			case interaction.isAutocomplete():
-				await this.handleAutocomplete(interaction);
-				break;
-			default: this.logger.warn(`Unhandled interaction type: ${interaction.type}`);
-		}
-	}
-	async handleSlashCommand(interaction) {
-		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, InteractionKind.Slash, () => route);
-	}
-	async handleButton(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.Button);
-	}
-	async handleModal(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.Modal);
-	}
-	async handleStringSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.StringMenu);
-	}
-	async handleUserSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.UserMenu);
-	}
-	async handleRoleSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.RoleMenu);
-	}
-	async handleChannelSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.ChannelMenu);
-	}
-	async handleMentionableSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, InteractionKind.MentionableMenu);
-	}
-	async handleMessageContextMenu(interaction) {
-		await this.processInteraction(interaction, InteractionKind.MessageContextMenu, () => interaction.commandName);
-	}
-	async handleUserContextMenu(interaction) {
-		await this.processInteraction(interaction, InteractionKind.UserContextMenu, () => interaction.commandName);
-	}
-	async handleAutocomplete(interaction) {
-		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, InteractionKind.Autocomplete, () => route, UnhandledAutocomplete);
+		if (interaction.isChatInputCommand()) await this.processInteraction(interaction, InteractionKind.Slash, slashRouteOf(interaction));
+		else if (interaction.isAutocomplete()) await this.processInteraction(interaction, InteractionKind.Autocomplete, slashRouteOf(interaction));
+		else if (interaction.isModalSubmit()) await this.handleCustomIdInteraction(interaction, InteractionKind.Modal);
+		else if (interaction.isButton() || interaction.isAnySelectMenu()) {
+			const kind = componentKindOf(interaction.componentType);
+			if (kind) await this.handleCustomIdInteraction(interaction, kind);
+		} else if (interaction.isMessageContextMenuCommand()) await this.processInteraction(interaction, InteractionKind.MessageContextMenu, interaction.commandName);
+		else if (interaction.isUserContextMenuCommand()) await this.processInteraction(interaction, InteractionKind.UserContextMenu, interaction.commandName);
+		else this.logger.warn(`Unhandled interaction type: ${interaction.type}`);
 	}
 };
 
@@ -2535,6 +2095,7 @@ var Bot = class {
 	#logger = new Logger("Bot", { channel: "bot" });
 	/** @internal */
 	[loggerSlot] = this.#logger;
+	#inFlight = new InFlight(this.#logger, "Dispatch");
 	#isInitialized = false;
 	#readyToDeploy = Promise.withResolvers();
 	#intents;
@@ -2553,8 +2114,8 @@ var Bot = class {
 	constructor(core) {
 		this.#intents = core.config.bot.clientOptions.intents;
 		this.#client = new Client(core.config.bot.clientOptions);
-		if (core.config.bot.interactions.path) this.#interactions = new InteractionDispatcher(core);
-		if (core.config.bot.events.path) this.#events = new EventDispatcher(core);
+		if (core.config.bot.interactions.path) this.#interactions = new InteractionDispatcher(core, this.#inFlight);
+		if (core.config.bot.events.path) this.#events = new EventDispatcher(core, this.#inFlight);
 		if (core.config.bot.commands.path) this.#commandRegistry = new CommandRegistry(core);
 		this.#emojiInjector = new EmojiInjector(core);
 		this.#registerStartupTasks(core);
@@ -2575,39 +2136,36 @@ var Bot = class {
 		return application.id;
 	}
 	#registerStartupTasks(core) {
+		const interactions = this.#interactions;
+		if (interactions) core.startup.addTask(StartupPhase.Configuration, "interactions-initialization", () => interactions.init());
+		const events = this.#events;
+		if (events) core.startup.addTask(StartupPhase.Configuration, "events-initialization", () => events.init());
 		core.startup.addTask(StartupPhase.Login, "bot-initialization", async (signal) => {
 			this.#logger.utils.initialization("Bot", "start");
 			await this.#init(signal);
 			this.#logger.utils.initialization("Bot", "end");
 		});
 		const registry = this.#commandRegistry;
-		if (!registry) return;
-		core.startup.addTask(StartupPhase.Login, "command-deploy", (signal) => this.#deployCommands(registry, signal), COMMAND_DEPLOY_TIMEOUT_MS);
+		if (registry) core.startup.addTask(StartupPhase.Login, "command-deploy", (signal) => this.#deployCommands(registry, signal), COMMAND_DEPLOY_TIMEOUT_MS);
+		core.startup.addTask(StartupPhase.Ready, "start-dispatch", () => {
+			this.#inFlight.open();
+			return Promise.resolve();
+		});
 	}
 	#registerShutdownTasks(core) {
 		core.shutdown.addTask(ShutdownPhase.Unbind, "stop-dispatch", () => {
-			this.#stopAccepting();
+			this.#inFlight.close();
 			return Promise.resolve();
 		}, UNBIND_TIMEOUT_MS);
-		core.shutdown.addTask(ShutdownPhase.Drain, "drain-dispatch", () => this.#drain(), DRAIN_TASK_TIMEOUT_MS);
+		core.shutdown.addTask(ShutdownPhase.Drain, "drain-dispatch", () => this.#inFlight.drain(DRAIN_WINDOW_MS), DRAIN_TASK_TIMEOUT_MS);
 		core.shutdown.addTask(ShutdownPhase.Logout, "stop-bot", async () => await this.#stop(), LOGOUT_TIMEOUT_MS);
 	}
-	#stopAccepting() {
-		this.#interactions?.stopAccepting();
-		this.#events?.stopAccepting();
-	}
-	async #drain() {
-		await Promise.allSettled([this.#interactions?.drain(DRAIN_WINDOW_MS), this.#events?.drain(DRAIN_WINDOW_MS)]);
-	}
 	async #init(signal) {
 		if (this.#isInitialized) return;
 		this.#isInitialized = true;
 		signal.addEventListener("abort", () => this.#readyToDeploy.resolve(false), { once: true });
 		try {
-			const token = this.botToken;
-			if (this.#interactions) await this.#interactions.init();
-			if (this.#events) await this.#events.init();
-			await this.#login(token);
+			await this.#login(this.botToken);
 			await this.#emojiInjector.init();
 		} catch (error) {
 			this.#readyToDeploy.resolve(false);
@@ -2629,8 +2187,7 @@ var Bot = class {
 	async #login(token) {
 		const ready = Promise.withResolvers();
 		this.#client.once(Events.ClientReady, () => ready.resolve());
-		this.#client.login(token);
-		await ready.promise;
+		await Promise.all([this.#client.login(token), ready.promise]);
 		this.#logger.info(`Logged in as ${paint.sky.bold(this.#client.user?.username)}!`);
 		return this;
 	}
@@ -2646,7 +2203,7 @@ var Bot = class {
 //#endregion
 //#region src/version.ts
 /** Package version */
-const version = "0.8.0";
+const version = "0.9.0-next.2";
 
 //#endregion
 //#region src/Seedcord.ts
@@ -2664,8 +2221,6 @@ var Seedcord = class extends ServerHost {
 	[HostVersion] = version;
 	#healthCheck;
 	#hmrManager;
-	/** @see {@link Bus} */
-	bus;
 	#subscribers;
 	/** @see {@link Bot} */
 	bot;
@@ -2675,24 +2230,20 @@ var Seedcord = class extends ServerHost {
 	get applicationId() {
 		return this.bot.applicationId;
 	}
-	/** @see {@link IRateLimiter} */
-	rateLimiter;
 	/**
 	* @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.
 	* @throws A **SeedcordError** when the running Node or Bun is older than the range in `engines`.
 	*/
 	constructor(config) {
-		super("gateway", new CoordinatedShutdown(config.lifecycle?.shutdownDeadline), new CoordinatedStartup());
+		super("gateway", new CoordinatedShutdown(config.lifecycle?.shutdownDeadline), new CoordinatedStartup(), config.kv);
 		this.config = config;
 		bindBotColor(() => this.config.botColor);
 		this.#hmrManager = new HmrManager();
 		this.#hmrManager.init(connectDevChannel());
-		this.bus = new Bus(this);
 		this.#subscribers = new SubscriberLoader(this.bus, config.subscribers.path);
 		this.bot = new Bot(this);
 		this.rest = this.bot.client.rest;
-		this.rateLimiter = config.store ?? new MemoryRateLimiter();
 		this.#healthCheck = HealthCheck.fromOption(shutdownOf(this), config.healthCheck);
 		this.#registerStartupTasks();
 	}
@@ -2735,5 +2286,5 @@ var Seedcord = class extends ServerHost {
 };
 
 //#endregion
-export { ArraySource, AutocompleteHandler, BaseHandler, ButtonHandler, ChannelMenuHandler, ComponentHandler, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, GatewayEmoji, HmrModuleHandler, IgnoreBots, InteractionHandler, InteractionMiddleware, MentionableMenuHandler, MessageContextMenuHandler, ModalHandler, Nsfw, Paginator, Plugin, RegisterEvent, RegisterEventMiddleware, RepliableHandler, ReplySender, RoleMenuHandler, Seedcord, SelectMenuHandler, SlashHandler, StringMenuHandler, Subscriber, UserContextMenuHandler, UserMenuHandler, WebhookLog, WinstonConsoleSink, WinstonFileSink, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
+export { ArraySource, AutocompleteHandler, BaseHandler, ButtonHandler, ChannelMenuHandler, ComponentHandler, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, GatewayEmoji, HmrModuleHandler, IgnoreBots, InteractionHandler, InteractionMiddleware, MentionPrefix, MentionableMenuHandler, MessageContextMenuHandler, ModalHandler, Nsfw, Paginator, Plugin, RegisterEvent, RegisterEventMiddleware, RepliableHandler, ReplySender, RoleMenuHandler, Seedcord, SelectMenuHandler, SlashHandler, StringMenuHandler, Subscriber, UserContextMenuHandler, UserMenuHandler, WebhookLog, WinstonConsoleSink, WinstonFileSink, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
 //# sourceMappingURL=index.mjs.map