@seedcord/gateway 0.1.0-next.4 → 0.1.0-next.6

package/dist/index.mjs

@@ -1,27 +1,24 @@
 import "reflect-metadata";
 import { installNodeDefaults } from "@seedcord/logger/node";
-import { BaseReplySender, CommandMetadataKey, EventMetadataKey, GateNotice, GatedMetadataKey, HmrManager, InteractionMetadataKey, InteractionRouteKeys, InteractionRoutes, MiddlewareMetadataKey, MissingPermissions, NoticeCard, PAGE_MAX, PermissionNames, SubscribeMetadataKey, WebhookUrlMetadataKey, areRoutes, decodeComponentRoute, deferFlags, getDevChannel, pageCursor, pickNotice, prefixOf, routeIdOf, runHandlerGates, sendFlags, setBotColor, slowGateMonitor } from "@seedcord/core/internal";
+import { BaseReplySender, CommandInjector, EventMetadataKey, FaultThrottle, GateNotice, GatedMetadataKey, HmrManager, InteractionMetadataKey, InteractionRouteKeys, InteractionRoutes, MiddlewareMetadataKey, MissingPermissions, NoticeCard, PermissionNames, PublishDefault, accessorStore, areRoutes, asError, clearStore, decodeComponentRoute, deferFlags, dispatchedPayload, guardedAccessor, isEmojiTuple, outcomeFor, pickNotice, prefixOf, queuedMsFor, reportedWrite, routeIdOf, runHandlerGates, sendFlags, setBotColor, slowGateMonitor } from "@seedcord/core/internal";
 import { SeedcordErrorCode } from "@seedcord/errors";
-import { SeedcordError, SeedcordRangeError, SeedcordTypeError, validateDiscordToken } from "@seedcord/errors/internal";
-import { BaseHandler, BuilderComponent, CustomId, DispatchContext, Fault, Notice, RepliableHandler as RepliableHandler$1, RowComponent, Silence, defineGate, paginate } from "@seedcord/core";
+import { SeedcordError, SeedcordTypeError, validateDiscordToken } from "@seedcord/errors/internal";
+import { ArraySource as ArraySource$1, BaseHandler, BuilderComponent, Bus, CursorSource as CursorSource$1, CustomId, DispatchContext, Fault, Notice, PaginatorBase, RepliableHandler as RepliableHandler$1, RowComponent, Silence, Subscriber as Subscriber$1, WebhookLog as WebhookLog$1, assertPermissions, defineGate } from "@seedcord/core";
 import { Logger, LoggerChannelRegistry, paint } from "@seedcord/logger";
-import { ActionRowBuilder, ButtonBuilder, ContextMenuCommandBuilder, SlashCommandBuilder, TextDisplayBuilder } from "@discordjs/builders";
-import { buildSlashRoute, routeLeavesOf } from "@seedcord/utils/internal";
-import { ApplicationCommandType, ButtonStyle, Client, Collection, ComponentType, DiscordAPIError, Events, Guild, GuildMember, Message, MessageFlags, PermissionFlagsBits, RESTJSONErrorCodes, Role, TextChannel, User, chatInputApplicationCommandMention } from "discord.js";
-import * as crypto from "node:crypto";
-import chalk from "chalk";
-import { Converters, Envapter } from "envapt";
-import { MessageFlags as MessageFlags$1, Routes, SeparatorSpacingSize } from "discord-api-types/v10";
-import { filterCirculars, formatFilePath, hasKeys, stripAnsi, timestampFromSnowflake } from "@seedcord/utils";
-import { DiscordAPIError as DiscordAPIError$1, REST } from "@discordjs/rest";
-import { CoordinatedShutdown, CoordinatedStartup, HealthCheck, Pluggable, ShutdownPhase, StartupPhase, settleWithin } from "@seedcord/core/node/internal";
+import { ButtonStyle, Client, ComponentType, DiscordAPIError, Events, Guild, GuildMember, Message, MessageFlags, PermissionFlagsBits, RESTJSONErrorCodes, Role, User } from "discord.js";
+import { ButtonBuilder, TextDisplayBuilder } from "@discordjs/builders";
+import { buildSlashRoute } from "@seedcord/utils/internal";
+import { Plugin as Plugin$1 } from "@seedcord/core/plugin";
+import { CommandRegistry, CoordinatedShutdown, CoordinatedStartup, HealthCheck, Pluggable, ShutdownPhase, StartupPhase, SubscriberLoader, settleWithin } from "@seedcord/core/node/internal";
 import { MemoryRateLimiter } from "@seedcord/rate-limiter";
 import { SeedcordBrand } from "@seedcord/types/internal";
-import { TypedEventEmitter } from "@seedcord/event-emitter";
+import { Envapter } from "envapt";
+import chalk from "chalk";
 import { Envapt } from "envapt/legacy";
-import { resolve } from "node:path";
 import { HmrModuleHandler } from "@seedcord/core/hmr";
+import { formatFilePath, hasKeys } from "@seedcord/utils";
 import { traverseDirectory } from "@seedcord/utils/node";
+import * as crypto from "node:crypto";
 
 export * from "@seedcord/errors"
 
@@ -29,10 +26,10 @@ export * from "@seedcord/core"
 
 export * from "@seedcord/logger"
 
-export * from "@seedcord/utils"
-
 export * from "@seedcord/rate-limiter"
 
+export * from "@seedcord/utils"
+
 export * from "@seedcord/event-emitter"
 
 //#region src/logger-bootstrap.ts
@@ -147,7 +144,7 @@ let MiddlewareType = /* @__PURE__ */ function(MiddlewareType) {
 * Interaction middleware cannot specify event filters.
 *
 * @param type - Middleware kind from {@link MiddlewareType}
-* @param priority - Ordering value where lower runs earlier. {@default `0`}
+* @param priority - Ordering value where lower runs earlier. {@default `0` }
 * @param options - Additional registration options
 *
 * @decorator
@@ -226,59 +223,6 @@ var CannotAssignBotRole = class extends Notice {
 		return { components: [new NoticeCard("I cannot assign a managed role.").component] };
 	}
 };
-var HasDangerousPermissions = class extends Notice {
-	subject;
-	dangerousPerms;
-	customLead;
-	constructor(message, subject, dangerousPerms) {
-		super(message ?? "A dangerous permission is enabled.");
-		this.subject = subject;
-		this.dangerousPerms = dangerousPerms;
-		this.customLead = message;
-	}
-	render() {
-		const bullets = this.dangerousPerms.map((perm) => `• ${perm}`).join("\n");
-		return { components: [new NoticeCard(`${this.customLead ?? `${this.subject} has the following permission entries that must not be enabled:`}\n\n${bullets}`).component] };
-	}
-};
-var UserNotFound = class extends Notice {
-	userArg;
-	constructor(userArg) {
-		super(`User not found: ${userArg}`);
-		this.userArg = userArg;
-	}
-	render() {
-		return { components: [new NoticeCard(`User probably doesn't exist or was deleted.\n**User Argument:** \`${this.userArg}\`\nPlease check the user ID and try again. Only pass valid user IDs as the argument.`, "User Not Found").component] };
-	}
-};
-var UserNotInGuild = class extends Notice {
-	constructor(message = "User is not in the guild.") {
-		super(message);
-	}
-	render() {
-		return { components: [new NoticeCard(this.message).component] };
-	}
-};
-var RoleDoesNotExist = class extends Notice {
-	roleId;
-	constructor(message, roleId) {
-		super(message);
-		this.roleId = roleId;
-	}
-	render() {
-		return { components: [new NoticeCard(`The role with ID \`${this.roleId}\` does not exist.`).component] };
-	}
-};
-var CouldNotFindChannel = class extends Notice {
-	channelId;
-	constructor(message, channelId) {
-		super(message);
-		this.channelId = channelId;
-	}
-	render() {
-		return { components: [new NoticeCard(`Could not find channel with ID \`${this.channelId}\`. It could also be that the channel is not a text channel.`).component] };
-	}
-};
 
 //#endregion
 //#region src/bot/gates/catalog/Nsfw.ts
@@ -316,26 +260,21 @@ function Nsfw(options) {
 
 //#endregion
 //#region src/bot/injectors/EmojiInjector.ts
-const emojiStorage = {};
-function isEmojiTuple(v) {
-	return Array.isArray(v) && v.length === 2 && typeof v[0] === "string" && typeof v[1] === "string";
-}
+const emojiStorage = accessorStore();
 /**
-* Global emoji mappings object
-*
-* @see {@link EmojiMap}
+* The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
+* A read before that throws.
 */
-const Emojis = emojiStorage;
+const Emojis = guardedAccessor("Emojis", emojiStorage);
 /**
-* Loads and injects emojis based on bot configuration.
-*
-* For emojis injected from specific guilds, ensure that the Guilds intent is provided in client options.
+* Loads and injects emojis based on bot configuration. A guild emoji requires the Guilds intent in the client
+* options.
 *
 * @internal
 */
 var EmojiInjector = class {
 	core;
-	logger = new Logger("Emojis");
+	logger = new Logger("Emojis", { channel: "bot" });
 	constructor(core) {
 		this.core = core;
 	}
@@ -382,126 +321,10 @@ var EmojiInjector = class {
 		emojiStorage[key] = appEmoji;
 	}
 	clearEmojis() {
-		for (const key of Object.keys(emojiStorage)) Reflect.deleteProperty(emojiStorage, key);
+		clearStore(emojiStorage);
 	}
 };
 
-//#endregion
-//#region src/bot/injectors/CommandMentionInjector.ts
-const mentionStorage = {};
-/**
-* Ready-to-send command mention strings, keyed by {@link SlashOptionRegistry}.
-*
-* A value is a clickable `</name:id>` when the command's id resolved from the deploy, otherwise the plain
-* `/name` text. Populated by {@link CommandMentionInjector} after each deploy.
-*/
-const CommandMentions = mentionStorage;
-const MULTI_GUILD = Symbol("seedcord:commandmentions:multi-guild");
-/**
-* Turns each deployed slash route into a clickable command mention exposed through {@link CommandMentions}.
-*
-* Consumes the ids {@link DeployResult} carries, so it runs after a deploy rather than resolving from a name
-* cache (discord.js offers none for command ids). A global command is clickable everywhere by its app-wide id.
-* A guild command deployed to one guild is clickable by that guild's id. A command deployed to two or more
-* guilds mints a different id per guild, so one accessor key cannot resolve it, and it falls back to plain
-* `/name` text with one warn. On a non-owning shard a guild command also falls back to plain text.
-*
-* @internal
-*/
-var CommandMentionInjector = class {
-	core;
-	logger = new Logger("CommandMentions");
-	constructor(core) {
-		this.core = core;
-	}
-	inject(deploy) {
-		this.clear();
-		const globalIds = this.indexByName(deploy.global);
-		const guildIds = this.indexGuilds(deploy.guilds);
-		const warned = /* @__PURE__ */ new Set();
-		let clickable = 0;
-		for (const command of this.allSlashBuilders()) {
-			const id = this.resolveId(command.name, globalIds, guildIds, warned);
-			for (const leaf of routeLeavesOf(command.toJSON())) {
-				mentionStorage[leaf.route] = id ? this.toMention(leaf.route, id) : this.toPlain(leaf.route);
-				if (id) clickable++;
-			}
-		}
-		this.logger.utils.summary("Linked mentions", {
-			clickable,
-			plain: Object.keys(mentionStorage).length - clickable
-		});
-	}
-	allSlashBuilders() {
-		const registry = this.core.bot.commands;
-		if (!registry) return [];
-		const slash = [...registry.globalCommands, ...registry.guildCommands.values()].flat().filter((command) => command instanceof SlashCommandBuilder);
-		return [...new Set(slash)];
-	}
-	indexByName(collection) {
-		const map = /* @__PURE__ */ new Map();
-		for (const command of collection.values()) map.set(command.name, command.id);
-		return map;
-	}
-	indexGuilds(guilds) {
-		const map = /* @__PURE__ */ new Map();
-		for (const collection of guilds.values()) for (const command of collection.values()) {
-			const existing = map.get(command.name);
-			if (existing === void 0) map.set(command.name, command.id);
-			else if (existing !== command.id) map.set(command.name, MULTI_GUILD);
-		}
-		return map;
-	}
-	resolveId(name, globalIds, guildIds, warned) {
-		const global = globalIds.get(name);
-		if (global) return global;
-		const guild = guildIds.get(name);
-		if (guild === void 0) return void 0;
-		if (guild === MULTI_GUILD) {
-			if (!warned.has(name)) {
-				this.logger.warn(`${name} is deployed to multiple guilds, falling back to plain text (not clickable).`);
-				warned.add(name);
-			}
-			return;
-		}
-		return guild;
-	}
-	toMention(route, id) {
-		const [name, middle, sub] = route.split("/");
-		if (name && middle && sub) return chatInputApplicationCommandMention(name, middle, sub, id);
-		if (name && middle) return chatInputApplicationCommandMention(name, middle, id);
-		return chatInputApplicationCommandMention(name ?? route, id);
-	}
-	toPlain(route) {
-		return `/${route.replaceAll("/", " ")}`;
-	}
-	clear() {
-		for (const key of Object.keys(mentionStorage)) Reflect.deleteProperty(mentionStorage, key);
-	}
-};
-
-//#endregion
-//#region src/bot/utilities/channels/fetchText.ts
-/**
-* Fetches and validates a text channel. Refuses when the channel doesn't exist or isn't a text channel.
-*
-* @param client - The Discord client instance
-* @param channelId - Channel ID or TextChannel instance
-* @returns Promise resolving to the text channel
-*/
-async function fetchText(client, channelId) {
-	if (channelId instanceof TextChannel) return channelId;
-	let channel = client.channels.cache.get(channelId);
-	if (!channel) try {
-		channel = await client.channels.fetch(channelId);
-	} catch (err) {
-		if (err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownChannel) throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
-		throw err;
-	}
-	if (channel?.isTextBased()) return channel;
-	throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
-}
-
 //#endregion
 //#region src/bot/notices/utils.ts
 function mentionFor(subject) {
@@ -512,48 +335,37 @@ 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: missingCtor, dangerousNotice: dangerousCtor } = a instanceof Role || a instanceof GuildMember ? {
+	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 Missing = missingCtor ?? MissingPermissions;
-	const Dangerous = dangerousCtor ?? HasDangerousPermissions;
-	const subject = mentionFor(pFor);
 	const perms = pIn instanceof Guild ? pFor.permissions : pIn.permissionsFor(pFor, true);
-	const names = (bits) => bits.map((bit) => PermissionNames.get(bit) ?? String(bit));
-	if (inverse) {
-		const present = scope.filter((bit) => perms.has(bit, true));
-		if (present.length > 0) throw new Dangerous(void 0, subject, names(present));
-		return;
-	}
-	const missingBits = scope.filter((bit) => !perms.has(bit, true));
-	if (missingBits.length > 0) throw new Missing(void 0, subject, names(missingBits));
+	assertPermissions({
+		subject: mentionFor(pFor),
+		permissions: perms.bitfield,
+		scope,
+		inverse,
+		...missingNotice && { missingNotice },
+		...dangerousNotice && { dangerousNotice }
+	});
 }
 
 //#endregion
 //#region src/bot/utilities/permissions/checkBotPermissions.ts
 /**
-* Checks if the bot has required permissions in a {@link Guild} or {@link TextChannel}. Refuses when a
-* required permission is missing.
-*
-* @param target - Guild or text channel to check in
-* @param scope - Permission bits to validate
-* @param inverse - Whether to check for absence of the given permissions
-* @param errors - Optional custom error constructors
+* Checks the bot's own permissions in a {@link Guild} or {@link TextChannel}. Refuses when a permission in
+* `scope` is missing, or with `inverse` when one is present. When the bot member is uncached, the refusal
+* reports every permission in `scope` as missing.
 *
 * @example
 * ```ts
 * import { PermissionFlagsBits } from 'discord.js';
 * import { checkBotPermissions } from '@seedcord/gateway';
 *
-* // Check if the bot has SendMessages and ViewChannel permissions in a text channel
-* checkBotPermissions(textChannel, [
-*   PermissionFlagsBits.SendMessages,
-*   PermissionFlagsBits.ViewChannel
-* ]);
+* checkBotPermissions(textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
 * ```
 */
 function checkBotPermissions(target, scope, inverse = false, errors) {
@@ -568,7 +380,7 @@ function checkBotPermissions(target, scope, inverse = false, errors) {
 	}
 	const me = target.guild.members.me;
 	if (!me) {
-		new Logger("checkBotPermissions").warn(`Bot member is unavailable in guild ${target.guild.id} while checking permissions in channel ${target.id}`);
+		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);
 	}
@@ -576,26 +388,17 @@ function checkBotPermissions(target, scope, inverse = false, errors) {
 }
 
 //#endregion
-//#region src/bot/utilities/roles/getBotRole.ts
-/**
-* Gets the bot's managed role in a guild.
-*
-* @param guild - The guild to get the bot role from
-* @returns The bot's managed role in the guild
-* @throws A **SeedcordError** if the client user is unavailable or if the bot role is missing
-*/
-function getBotRole(guild) {
+//#region src/bot/utilities/permissions/hasPermsToAssign.ts
+function botRoleOf(guild) {
 	const botRole = guild.roles.botRoleFor(guild.client.user);
 	if (!botRole) throw new SeedcordError(SeedcordErrorCode.CoreBotRoleMissing, [guild.id]);
 	return botRole;
 }
-
-//#endregion
-//#region src/bot/utilities/permissions/hasPermsToAssign.ts
 /**
-* Validates if the bot can assign a target role. Refuses when the target role is above the bot's, is managed, or the bot lacks Manage Roles.
+* 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.
 *
 * @param roleOrOptions - Target role or complete options for the check
+* @throws A `Notice` on refusal, or a `SeedcordError` when the bot has no role in the guild's role cache.
 *
 * @example
 * ```ts
@@ -623,135 +426,108 @@ function hasPermsToAssign(roleOrOptions) {
 	const HigherNotice = errors?.higherNotice ?? RoleHigherThanMe;
 	const ManagedNotice = errors?.managedNotice ?? CannotAssignBotRole;
 	const MissingNotice = errors?.missingNotice ?? MissingPermissions;
-	const botRole = getBotRole(targetRole.guild);
+	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 });
 }
 
 //#endregion
-//#region src/bot/utilities/roles/fetchRole.ts
-function isUnknownRole(err) {
-	return err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownRole;
-}
-async function fetchRoleInGuild(guild, roleId) {
-	const cached = guild.roles.cache.get(roleId);
-	if (cached) return cached;
-	try {
-		return await guild.roles.fetch(roleId);
-	} catch (err) {
-		if (isUnknownRole(err)) throw new RoleDoesNotExist("Role not found in specified guild", roleId);
-		throw err;
-	}
-}
-async function scanGuildsForRole(client, roleId) {
-	const cached = client.guilds.cache.map((guild) => guild.roles.cache.get(roleId)).find(Boolean);
-	if (cached) return cached;
-	for (const guild of client.guilds.cache.values()) try {
-		const role = await guild.roles.fetch(roleId);
-		if (role) return role;
-	} catch (err) {
-		if (isUnknownRole(err)) continue;
-		throw err;
-	}
-	return null;
-}
+//#region src/bot/confirm/reserved.ts
+const RESERVED_CONFIRM_PREFIX = "__seedcord_confirm";
 /**
-* Fetches a role by ID from a client or guild. Refuses when the role doesn't exist.
+* The reserved confirm/cancel codec. It has no route, so the dispatcher ignores its clicks and only the
+* in-process collector reads them. Do not mint a real component from it.
 *
-* @param clientOrGuild - Discord client or guild instance
-* @param roleId - The role ID to fetch
-* @returns Promise resolving to the role
+* @internal
 */
-async function fetchRole(clientOrGuild, roleId) {
-	if (!roleId) throw new RoleDoesNotExist("Role ID is null or undefined", roleId);
-	const role = clientOrGuild instanceof Guild ? await fetchRoleInGuild(clientOrGuild, roleId) : await scanGuildsForRole(clientOrGuild, roleId);
-	if (!role) throw new RoleDoesNotExist("Role not found", roleId);
-	return role;
-}
+const CONFIRM_DEF = new CustomId(RESERVED_CONFIRM_PREFIX).oneOf("choice", ["confirm", "cancel"]);
 
 //#endregion
-//#region src/bot/utilities/users/fetchGuildMember.ts
-/**
-* Fetches a guild member by user ID. Refuses when the user is not in the guild.
-*
-* @param guild - The guild to fetch the member from
-* @param userId - The Discord user ID
-* @returns Promise resolving to the guild member
-*/
-async function fetchGuildMember(guild, userId) {
-	let user = guild.members.cache.get(userId);
-	user ??= await guild.members.fetch(userId).catch((err) => {
-		if (err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownMember) throw new UserNotInGuild(`User with ID ${userId} not found in guild`);
-		throw err;
-	});
-	return user;
+//#region src/bot/confirm/getConfirmation.ts
+const DEFAULT_TIMEOUT_MS = 3e4;
+const CONFIRM_IDS = {
+	confirm: CONFIRM_DEF.encode({ choice: "confirm" }),
+	cancel: CONFIRM_DEF.encode({ choice: "cancel" })
+};
+var ConfirmButtons = class extends RowComponent {
+	constructor(options) {
+		super("button");
+		this.instance.addComponents(new ButtonBuilder().setCustomId(CONFIRM_IDS.confirm).setLabel(options?.confirmLabel ?? "Confirm").setStyle(options?.confirmStyle ?? ButtonStyle.Danger), new ButtonBuilder().setCustomId(CONFIRM_IDS.cancel).setLabel(options?.cancelLabel ?? "Cancel").setStyle(ButtonStyle.Secondary));
+	}
+};
+var ConfirmPromptCard = class extends BuilderComponent {
+	constructor(text, options) {
+		super("container");
+		this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(text)).addActionRowComponents(new ConfirmButtons(options).component);
+	}
+};
+function defaultPrompt(text, options) {
+	return { components: [new ConfirmPromptCard(text, options).component] };
 }
-
-//#endregion
-//#region src/bot/utilities/users/fetchManyGuildMembers.ts
-/**
-* Fetches multiple guild members by user IDs.
-*
-* @param guild - The guild to fetch members from
-* @param userIds - Array of Discord user IDs
-* @returns Promise resolving to array of successfully fetched members
-*/
-async function fetchManyGuildMembers(guild, userIds) {
-	return (await Promise.allSettled(userIds.map((userId) => fetchGuildMember(guild, userId)))).filter((result) => result.status === "fulfilled").map((result) => result.value);
+async function collectChoice(message, userId, timeoutMs) {
+	try {
+		return await message.awaitMessageComponent({
+			componentType: ComponentType.Button,
+			time: timeoutMs,
+			filter: (click) => click.user.id === userId && CONFIRM_DEF.owns(click.customId)
+		});
+	} catch {
+		return null;
+	}
 }
-
-//#endregion
-//#region src/bot/utilities/users/fetchUser.ts
-/**
-* Fetches a Discord user by ID. Refuses when the user doesn't exist, with `options.throwAs` or the default.
-*
-* @param client - The Discord client instance
-* @param userId - The Discord user ID
-* @param options - Optional overrides, including the {@link FetchUserOptions.throwAs} notice
-* @returns Promise resolving to the user
-*/
-async function fetchUser(client, userId, options) {
-	const Throw = options?.throwAs ?? UserNotFound;
-	let user = client.users.cache.get(userId);
-	user ??= await client.users.fetch(userId).catch((err) => {
-		if (err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownUser) throw new Throw(userId);
-		throw err;
-	});
-	return user;
+async function settle(sender, message, outcome) {
+	if (outcome === void 0) {
+		await sender.delete(message).catch(() => void 0);
+		return;
+	}
+	await sender.edit(message, typeof outcome === "function" ? await outcome() : outcome);
+}
+async function getConfirmation(handler, prompt, options) {
+	const { ephemeral = true, timeoutMs = DEFAULT_TIMEOUT_MS } = options ?? {};
+	const response = typeof prompt === "string" ? defaultPrompt(prompt, options) : await prompt(CONFIRM_IDS);
+	const interaction = handler.getEvent();
+	const sender = handler.getSender();
+	const message = await sender.send(response, { ephemeral });
+	const winner = await collectChoice(message, interaction.user.id, timeoutMs);
+	if (!winner) {
+		await settle(sender, message, options?.onTimeout);
+		return false;
+	}
+	await winner.deferUpdate().catch(() => void 0);
+	const confirmed = winner.customId === CONFIRM_IDS.confirm;
+	await settle(sender, message, confirmed ? options?.onConfirm : options?.onCancel);
+	return confirmed;
 }
 
 //#endregion
-//#region src/bot/utilities/users/fetchManyUsers.ts
+//#region src/handlers/BaseHandler.ts
 /**
-* Fetches multiple Discord users by IDs.
-*
-* @param client - The Discord client instance
-* @param userIds - Array of Discord user IDs
-* @param options - Optional overrides threaded to each {@link fetchUser} call
-* @returns Promise resolving to array of successfully fetched users
+* The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
+* gate hook.
 */
-async function fetchManyUsers(client, userIds, options) {
-	return (await Promise.allSettled(userIds.map((userId) => fetchUser(client, userId, options)))).filter((result) => result.status === "fulfilled").map((result) => result.value);
-}
+var BaseHandler$1 = class extends BaseHandler {
+	/** @internal */
+	getEvent() {
+		return this.event;
+	}
+};
 
 //#endregion
-//#region src/bot/utilities/users/updateMemberRoles.ts
+//#region src/handlers/interaction/InteractionMiddleware.ts
 /**
-* Updates a guild member's roles by adding and removing specified roles.
+* Base class for interaction middleware
 *
-* @param rolesToAdd - Array of role IDs to add to the member
-* @param rolesToRemove - Array of role IDs to remove from the member
-* @param member - The guild member to update
-* @returns Promise that resolves when roles are updated
+* Middleware runs before interaction handlers and can modify behavior or block execution.
+* Unlike handlers, middleware should not send responses directly.
+*
+* @typeParam Repliable - The interaction type this middleware processes
 */
-async function updateMemberRoles(rolesToAdd, rolesToRemove, member) {
-	const current = new Set(member.roles.cache.map((r) => r.id));
-	const toAdd = new Set(rolesToAdd);
-	const toRemove = new Set(rolesToRemove);
-	const updated = current.union(toAdd).difference(toRemove);
-	await member.roles.set([...updated]);
-}
+var InteractionMiddleware = class extends BaseHandler$1 {
+	constructor(event, core) {
+		super(event, core, void 0, "interactions");
+	}
+};
 
 //#endregion
 //#region src/bot/ReplySender.ts
@@ -767,8 +543,11 @@ function seedState(interaction) {
 */
 var ReplySender = class extends BaseReplySender {
 	interaction;
-	constructor(interaction, routeId) {
-		super(routeId, seedState(interaction));
+	constructor(interaction, routeId, bus) {
+		super(routeId, seedState(interaction), bus && {
+			bus,
+			interactionId: interaction.id
+		});
 		this.interaction = interaction;
 	}
 	async writeReply(response, opts) {
@@ -837,319 +616,26 @@ var ReplySender = class extends BaseReplySender {
 			...reply.files && { files: [...reply.files] }
 		};
 	}
-	editOptions(response) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags: MessageFlags.IsComponentsV2,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: [...reply.files] }
-		};
-	}
-	updateOptions(response) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags: MessageFlags.IsComponentsV2,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: [...reply.files] }
-		};
-	}
-	createdMessage(result) {
-		return result.resource?.message ?? void 0;
-	}
-};
-
-//#endregion
-//#region src/bot/utilities/miscellaneous/slashRouteOf.ts
-/**
-* Computes the dispatch route for a chat-input or autocomplete interaction. The controller and
-* `seedcord codegen` both assemble route keys through the same {@link buildSlashRoute}, so a dispatched
-* interaction and a generated registry key always match.
-*
-* @internal
-*/
-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/miscellaneous/FaultThrottle.ts
-/**
-* Drops duplicate fault reports inside a fixed window so a recurring fault (a database outage on a
-* hot path) reports once per window instead of flooding the webhook. Keyed on a structural string, so
-* the map stays small, and a stale entry is evicted on the next read of its key.
-*
-* @internal
-*/
-var FaultThrottle = class {
-	windowMs;
-	now;
-	lastReportedAt = /* @__PURE__ */ new Map();
-	constructor(windowMs = 6e4, now = () => Date.now()) {
-		this.windowMs = windowMs;
-		this.now = now;
-	}
-	/** Evicts the entry for this key if it has aged out, so the map never holds stale keys forever. */
-	shouldReport(key) {
-		const last = this.lastReportedAt.get(key);
-		if (last === void 0) return true;
-		if (this.now() - last < this.windowMs) return false;
-		this.lastReportedAt.delete(key);
-		return true;
-	}
-	markReported(key) {
-		this.lastReportedAt.set(key, this.now());
-	}
-	clear() {
-		this.lastReportedAt.clear();
-	}
-};
-
-//#endregion
-//#region src/miscellaneous/extractErrorResponse.ts
-const logger$2 = new Logger("ErrorsHandling");
-const faultThrottle = new FaultThrottle();
-/**
-* Processes an error into a user-facing reply and routes its report.
-*
-* A {@link Notice} always renders its own reply. A reporting denial (`report: true`) additionally
-* publishes `handledException` on the interaction path. A raw, non-denial throw publishes
-* `unknownException` and renders the configured `defaultError` (or a generic {@link Fault}). One uuid is
-* threaded into both the reply and the bus payload.
-*/
-function extractErrorResponse(error, core, origin) {
-	const uuid = crypto.randomUUID();
-	const developerUsername = core.config.notifications?.developerUsername;
-	const ctx = developerUsername === void 0 ? { uuid } : {
-		uuid,
-		developerUsername
-	};
-	if (error instanceof Notice) {
-		if (error.report) reportFault(error, core, origin, uuid);
-		return {
-			uuid,
-			response: error.render(ctx)
-		};
-	}
-	reportRawFault(error, core, origin, uuid);
-	const override = core.config.errors?.defaultError;
-	return {
-		uuid,
-		response: override ? new override(uuid).render(ctx) : new Fault().render(ctx)
-	};
-}
-function withThrottle(origin, error, publish) {
-	const key = faultKey(origin, error);
-	if (!faultThrottle.shouldReport(key)) {
-		logger$2.info(`throttled duplicate fault ${key}`);
-		return;
-	}
-	publish();
-	faultThrottle.markReported(key);
-}
-function reportFault(denial, core, origin, uuid) {
-	withThrottle(origin, denial, () => {
-		logger$2.error(`${denial.name}: ${uuid}`, denial);
-		if (origin.interaction) core.bus.publish("handledException", {
-			denial,
-			uuid,
-			source: buildInteractionSource(origin.interaction)
-		});
-		else if (origin.event) core.bus.publish("handledException", {
-			denial,
-			uuid,
-			source: buildEventSource(origin.event, origin)
-		});
-		else core.bus.publish("unknownException", {
-			uuid,
-			error: denial,
-			...scalarActors(origin),
-			metadata: metadataFor(origin)
-		});
-	});
-}
-function causeLine(error) {
-	const { cause } = error;
-	if (!Error.isError(cause)) return "";
-	const [first] = cause.message.split("\n");
-	return `\ncaused by ${cause.name}: ${first ?? cause.message}`;
-}
-function reportRawFault(error, core, origin, uuid) {
-	withThrottle(origin, error, () => {
-		if (core.config.errors?.errorStack ?? false) logger$2.error(uuid, error);
-		else logger$2.error(`${uuid} | ${error.message}${causeLine(error)}`);
-		core.bus.publish("unknownException", {
-			uuid,
-			error,
-			...scalarActors(origin),
-			metadata: metadataFor(origin)
-		});
-	});
-}
-function scalarActors(origin) {
-	return {
-		guild: origin.guild ? {
-			id: origin.guild.id,
-			name: origin.guild.name
-		} : void 0,
-		user: origin.user ? {
-			id: origin.user.id,
-			username: origin.user.username
-		} : void 0
-	};
-}
-function metadataFor(origin) {
-	if (origin.event) return {
-		eventName: origin.event.name,
-		handler: origin.event.handler,
-		args: origin.event.args
-	};
-	return origin.metadata;
-}
-function buildEventSource(event, origin) {
-	return {
-		kind: "event",
-		eventName: event.name,
-		handler: event.handler,
-		userId: origin.user?.id ?? null,
-		guildId: origin.guild?.id ?? null,
-		channelId: event.channelId,
-		raw: event.args
-	};
-}
-function faultKey(origin, error) {
-	const name = error instanceof Notice ? error.name : error instanceof DiscordAPIError ? String(error.code) : error.constructor.name;
-	if (origin.event) return `${origin.event.name}:${origin.event.handler}:${name}`;
-	if (origin.interaction) return `${interactionRoute(origin.interaction)}:${name}`;
-	if (origin.route) return `autocomplete:${origin.route}:${name}`;
-	return `autocomplete:${name}`;
-}
-/** The stable route id of a repliable interaction, its slash route path, command name, or customId prefix. */
-function interactionRoute(interaction) {
-	if (interaction.isChatInputCommand()) return slashRouteOf(interaction);
-	if (interaction.isContextMenuCommand()) return interaction.commandName;
-	if (interaction.isButton() || interaction.isAnySelectMenu() || interaction.isModalSubmit()) return prefixOf(interaction.customId) || interaction.customId;
-	return "interaction";
-}
-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;
-	return {
-		kind: "interaction",
-		interactionKind: interactionKind(interaction),
-		command,
-		customId,
-		userId: interaction.user.id,
-		guildId: interaction.guildId,
-		channelId: interaction.channelId,
-		interactionId: interaction.id,
-		raw: interaction
-	};
-}
-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/confirm/reserved.ts
-const RESERVED_CONFIRM_PREFIX = "__seedcord_confirm";
-/**
-* The reserved confirm/cancel codec. It has no route, so the dispatcher ignores its clicks and only the
-* in-process collector reads them. Do not mint a real component from it.
-*
-* @internal
-*/
-const CONFIRM_DEF = new CustomId(RESERVED_CONFIRM_PREFIX).oneOf("choice", ["confirm", "cancel"]);
-
-//#endregion
-//#region src/bot/confirm/getConfirmation.ts
-const DEFAULT_TIMEOUT_MS = 3e4;
-const CONFIRM_IDS = {
-	confirm: CONFIRM_DEF.encode({ choice: "confirm" }),
-	cancel: CONFIRM_DEF.encode({ choice: "cancel" })
-};
-var ConfirmButtons = class extends RowComponent {
-	constructor(options) {
-		super("button");
-		this.instance.addComponents(new ButtonBuilder().setCustomId(CONFIRM_IDS.confirm).setLabel(options?.confirmLabel ?? "Confirm").setStyle(options?.confirmStyle ?? ButtonStyle.Danger), new ButtonBuilder().setCustomId(CONFIRM_IDS.cancel).setLabel(options?.cancelLabel ?? "Cancel").setStyle(ButtonStyle.Secondary));
-	}
-};
-var ConfirmPromptCard = class extends BuilderComponent {
-	constructor(text, options) {
-		super("container");
-		this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(text)).addActionRowComponents(new ConfirmButtons(options).component);
-	}
-};
-function defaultPrompt(text, options) {
-	return { components: [new ConfirmPromptCard(text, options).component] };
-}
-async function collectChoice(message, userId, timeoutMs) {
-	try {
-		return await message.awaitMessageComponent({
-			componentType: ComponentType.Button,
-			time: timeoutMs,
-			filter: (click) => click.user.id === userId && CONFIRM_DEF.owns(click.customId)
-		});
-	} catch {
-		return null;
-	}
-}
-async function settle(sender, message, outcome) {
-	if (outcome === void 0) {
-		await sender.delete(message).catch(() => void 0);
-		return;
-	}
-	await sender.edit(message, typeof outcome === "function" ? await outcome() : outcome);
-}
-async function getConfirmation(interaction, prompt, options) {
-	const { ephemeral = true, timeoutMs = DEFAULT_TIMEOUT_MS } = options ?? {};
-	const response = typeof prompt === "string" ? defaultPrompt(prompt, options) : await prompt(CONFIRM_IDS);
-	const sender = new ReplySender(interaction, interactionRoute(interaction));
-	const message = await sender.send(response, { ephemeral });
-	const winner = await collectChoice(message, interaction.user.id, timeoutMs);
-	if (!winner) {
-		await settle(sender, message, options?.onTimeout);
-		return false;
-	}
-	await winner.deferUpdate().catch(() => void 0);
-	const confirmed = winner.customId === CONFIRM_IDS.confirm;
-	await settle(sender, message, confirmed ? options?.onConfirm : options?.onCancel);
-	return confirmed;
-}
-
-//#endregion
-//#region src/handlers/BaseHandler.ts
-/**
-* The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
-* gate hook.
-*/
-var BaseHandler$1 = class extends BaseHandler {
-	/** @internal */
-	getEvent() {
-		return this.event;
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/InteractionMiddleware.ts
-/**
-* Base class for interaction middleware
-*
-* Middleware runs before interaction handlers and can modify behavior or block execution.
-* Unlike handlers, middleware should not send responses directly.
-*
-* @typeParam Repliable - The interaction type this middleware processes
-*/
-var InteractionMiddleware = class extends BaseHandler$1 {
-	constructor(event, core) {
-		super(event, core);
+	editOptions(response) {
+		const reply = this.serialize(response);
+		return {
+			components: reply.components,
+			flags: MessageFlags.IsComponentsV2,
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: [...reply.files] }
+		};
+	}
+	updateOptions(response) {
+		const reply = this.serialize(response);
+		return {
+			components: reply.components,
+			flags: MessageFlags.IsComponentsV2,
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: [...reply.files] }
+		};
+	}
+	createdMessage(result) {
+		return result.resource?.message ?? void 0;
 	}
 };
 
@@ -1169,8 +655,8 @@ var RepliableHandler = class extends RepliableHandler$1 {
 	getEvent() {
 		return this.event;
 	}
-	buildSender(event, _core, routeId) {
-		return new ReplySender(event, routeId);
+	buildSender(event, core, routeId) {
+		return new ReplySender(event, routeId, core.bus);
 	}
 };
 
@@ -1198,6 +684,21 @@ var InteractionHandler = class extends RepliableHandler {
 	}
 };
 
+//#endregion
+//#region src/bot/utilities/miscellaneous/slashRouteOf.ts
+/**
+* Computes the dispatch route for a chat-input or autocomplete interaction. The controller and
+* `seedcord codegen` both assemble route keys through the same {@link buildSlashRoute}, so a dispatched
+* interaction and a generated registry key always match.
+*
+* @internal
+*/
+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
 /**
@@ -1325,7 +826,7 @@ var ContextMenuHandler = class extends InteractionHandler {
 */
 var AutocompleteHandler = class extends BaseHandler$1 {
 	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
+		super(event, core, dispatch, "interactions");
 	}
 	decodedFocused;
 	/**
@@ -1376,7 +877,11 @@ var AutocompleteHandler = class extends BaseHandler$1 {
 	}
 	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
 	async respond(choices) {
-		await this.event.respond(choices);
+		const routeId = this.dispatch?.routeId ?? "autocomplete";
+		await reportedWrite({
+			bus: this.core.bus,
+			interactionId: this.event.id
+		}, routeId, "respond", () => this.event.respond(choices));
 	}
 	/** The firing command route, for a field whose completion differs per registered command. */
 	get route() {
@@ -1513,7 +1018,22 @@ var ButtonHandler = class extends ComponentHandler {};
 * }
 * ```
 */
-var ModalHandler = class extends ComponentHandler {};
+var ModalHandler = class extends ComponentHandler {
+	/** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
+	update(response) {
+		this.ensureSourceMessage("update");
+		return super.update(response);
+	}
+	/** Acknowledge the submit without changing the source message. Throws when a command opened the modal. */
+	deferUpdate() {
+		this.ensureSourceMessage("deferUpdate");
+		return super.deferUpdate();
+	}
+	ensureSourceMessage(method) {
+		if (this.event.isFromMessage()) return;
+		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
+	}
+};
 
 //#endregion
 //#region src/handlers/interaction/components/SelectMenuHandler.ts
@@ -1569,7 +1089,7 @@ var SelectMenuHandler = class extends ComponentHandler {};
 var EventHandler = class extends BaseHandler$1 {
 	firedEvent;
 	constructor(event, core, eventName) {
-		super(event, core);
+		super(event, core, void 0, "events");
 		this.firedEvent = eventName;
 	}
 	/**
@@ -1622,7 +1142,7 @@ var EventHandler = class extends BaseHandler$1 {
 var EventMiddleware = class extends BaseHandler$1 {
 	firedEvent;
 	constructor(event, core, eventName) {
-		super(event, core);
+		super(event, core, void 0, "events");
 		this.firedEvent = eventName;
 	}
 	/**
@@ -1636,130 +1156,6 @@ var EventMiddleware = class extends BaseHandler$1 {
 	}
 };
 
-//#endregion
-//#region src/pagination/controls.ts
-const DEFAULT_LABEL = {
-	first: "First",
-	prev: "Prev",
-	indicator: "",
-	next: "Next",
-	last: "Last"
-};
-const CONTROL_SLOT = {
-	first: 0,
-	prev: 1,
-	indicator: 2,
-	next: 3,
-	last: 4
-};
-const MAX_BUTTONS_PER_ROW = 5;
-var Controls = class {
-	cursor;
-	view;
-	constructor(cursor, view) {
-		this.cursor = cursor;
-		this.view = view;
-	}
-	button(key, cosmetics) {
-		const { target, disabled } = this.navState(key);
-		const defaultLabel = key === "indicator" ? this.indicatorText() : DEFAULT_LABEL[key];
-		const label = cosmetics?.label ?? (key === "indicator" || !cosmetics?.emoji ? defaultLabel : void 0);
-		const button = new ButtonBuilder().setCustomId(this.cursor.encode({
-			page: Math.min(Math.max(0, target), PAGE_MAX),
-			slot: CONTROL_SLOT[key]
-		})).setStyle(cosmetics?.style ?? ButtonStyle.Secondary).setDisabled(disabled);
-		if (label !== void 0) button.setLabel(label);
-		if (cosmetics?.emoji) button.setEmoji(cosmetics.emoji);
-		return button;
-	}
-	navState(key) {
-		const { page, totalPages, hasPrev, hasNext } = this.view;
-		const knownTotal = totalPages !== void 0;
-		return {
-			target: {
-				first: 0,
-				prev: page - 1,
-				indicator: page,
-				next: page + 1,
-				last: knownTotal ? totalPages - 1 : page
-			}[key],
-			disabled: {
-				first: !hasPrev,
-				prev: !hasPrev,
-				indicator: true,
-				next: !hasNext || page + 1 > PAGE_MAX,
-				last: !hasNext || !knownTotal || totalPages - 1 > PAGE_MAX
-			}[key]
-		};
-	}
-	row(...keys) {
-		if (keys.length === 0) throw new SeedcordRangeError(SeedcordErrorCode.PaginationEmptyControls);
-		if (keys.length > MAX_BUTTONS_PER_ROW) throw new SeedcordRangeError(SeedcordErrorCode.PaginationTooManyControls, [keys.length]);
-		const seen = /* @__PURE__ */ new Set();
-		for (const key of keys) {
-			if (seen.has(key)) throw new SeedcordTypeError(SeedcordErrorCode.PaginationDuplicateControls, [key]);
-			seen.add(key);
-		}
-		return new ActionRowBuilder().addComponents(keys.map((key) => this.button(key)));
-	}
-	indicatorText() {
-		const { page, totalPages } = this.view;
-		return totalPages === void 0 ? `Page ${page + 1}` : `Page ${page + 1} of ${totalPages}`;
-	}
-};
-
-//#endregion
-//#region src/pagination/render.ts
-var PageContainer = class extends BuilderComponent {
-	constructor(view, renderItem, controlRow) {
-		super("container");
-		const base = view.page * view.perPage;
-		let lines = [];
-		const flush = () => {
-			if (lines.length === 0) return;
-			this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(lines.join("\n")));
-			lines = [];
-		};
-		view.items.forEach((item, offset) => {
-			const rendered = renderItem(item, base + offset);
-			if (typeof rendered === "string") {
-				lines.push(rendered);
-				return;
-			}
-			flush();
-			this.instance.addSectionComponents(rendered.component);
-		});
-		flush();
-		this.instance.addActionRowComponents(controlRow);
-	}
-};
-function toReplyResponse(renderable) {
-	if (typeof renderable === "string") return { components: [new TextDisplayBuilder().setContent(renderable)] };
-	if (Array.isArray(renderable)) return { components: renderable };
-	return renderable;
-}
-const ARRAY_KEYS = [
-	"first",
-	"prev",
-	"indicator",
-	"next",
-	"last"
-];
-const CURSOR_KEYS = [
-	"prev",
-	"indicator",
-	"next"
-];
-/**
-* Build a page's V2 reply. A `render` override builds the whole tree, otherwise the default container lists
-* the items and appends the controls (all five for a known total, prev/indicator/next for a cursor source).
-*/
-function renderPage(view, cursor, config) {
-	const controls = new Controls(cursor, view);
-	if (config.render) return toReplyResponse(config.render(view, controls));
-	return { components: [new PageContainer(view, config.renderItem ?? String, controls.row(...view.totalPages === void 0 ? CURSOR_KEYS : ARRAY_KEYS)).component] };
-}
-
 //#endregion
 //#region src/pagination/Paginator.ts
 function contextOf(interaction, core) {
@@ -1767,7 +1163,7 @@ function contextOf(interaction, core) {
 		interaction,
 		user: interaction.user,
 		guild: interaction.guild,
-		...core && { core }
+		core
 	};
 }
 /**
@@ -1789,15 +1185,11 @@ function contextOf(interaction, core) {
 * export class BansNav extends Bans.Handler {}
 * ```
 */
-var Paginator = class {
-	/** The page cursor, pass it to your `@ButtonRoute`. */
-	cursor;
+var Paginator = class extends PaginatorBase {
 	/** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
 	Handler;
-	config;
 	constructor(config) {
-		this.cursor = pageCursor(config.prefix);
-		this.config = config;
+		super(config);
 		const loadPage = (ctx, n) => this.page(ctx, n);
 		this.Handler = class Nav extends ButtonHandler {
 			async execute() {
@@ -1807,39 +1199,29 @@ var Paginator = class {
 			}
 		};
 	}
-	/** Render page 0 and send it, picking reply or followUp from the interaction's state. */
-	async start(interaction, core) {
-		const response = await this.page(contextOf(interaction, core), 0);
-		return new ReplySender(interaction, interactionRoute(interaction)).send(response, { ephemeral: this.config.ephemeral ?? false });
-	}
-	/** Render a page as a {@link ReplyResponse}. To post it elsewhere, add `flags: MessageFlags.IsComponentsV2`. */
-	async page(ctx, n) {
-		return renderPage(await this.config.source.page(ctx, n), this.cursor, this.config);
+	/**
+	* Render page 0 and send it through the handler's sender, which picks reply, edit, or followUp from its
+	* ack state.
+	*
+	* @param handler - The handler starting the paginator, normally `this`.
+	*/
+	async start(handler) {
+		const interaction = handler.getEvent();
+		const response = await this.page(contextOf(interaction, handler.core), 0);
+		return handler.getSender().send(response, { ephemeral: this.config.ephemeral ?? false });
 	}
 };
 
 //#endregion
 //#region src/pagination/sources.ts
-const DEFAULT_PER_PAGE = 10;
 /**
 * A source for a bounded list you can load whole. It loads the full list on every click, then slices the
-* page via {@link paginate}, so the real total is known (a real last button, "Page X of Y"). Cache inside
-* your loader if the load is expensive.
+* page, so the real total is known (a real last button, "Page X of Y"). Cache inside your loader if the
+* load is expensive.
 *
 * @typeParam Item - The item type, inferred from the loader's return.
 */
-var ArraySource = class {
-	load;
-	perPage;
-	constructor(load, opts) {
-		this.load = load;
-		this.perPage = opts?.perPage ?? DEFAULT_PER_PAGE;
-		if (!Number.isSafeInteger(this.perPage) || this.perPage <= 0) throw new SeedcordRangeError(SeedcordErrorCode.PaginationInvalidPerPage, [this.perPage]);
-	}
-	async page(ctx, n) {
-		return paginate(await this.load(ctx), n, this.perPage);
-	}
-};
+var ArraySource = class extends ArraySource$1 {};
 /**
 * A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
 * The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
@@ -1848,496 +1230,35 @@ var ArraySource = class {
 *
 * @typeParam Item - The item type, inferred from the fetcher's slice.
 */
-var CursorSource = class {
-	fetch;
-	perPage;
-	constructor(fetch, opts) {
-		this.fetch = fetch;
-		this.perPage = opts?.perPage ?? DEFAULT_PER_PAGE;
-		if (!Number.isSafeInteger(this.perPage) || this.perPage <= 0) throw new SeedcordRangeError(SeedcordErrorCode.PaginationInvalidPerPage, [this.perPage]);
-	}
-	async page(ctx, n) {
-		const page = Math.max(0, Math.trunc(n));
-		const { items, hasNext } = await this.fetch(ctx, page, this.perPage);
-		return {
-			items: [...items],
-			page,
-			perPage: this.perPage,
-			hasPrev: page > 0,
-			hasNext
-		};
-	}
-};
-
-//#endregion
-//#region src/subscribers/Subscriber.ts
-/**
-* Abstract base class for handling application subscribers.
-*
-* Provides type-safe access to subscribers data and the core framework instance.
-* Extend this class to create custom subscriber handlers.
-*
-* @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
-*/
-var Subscriber = class {
-	data;
-	core;
-	logger;
-	/**
-	* Instantiates the subscriber with event data and core.
-	*
-	* @param data - The subscriber event data
-	* @param core - The core framework instance
-	*/
-	constructor(data, core) {
-		this.data = data;
-		this.core = core;
-		this.logger = new Logger(this.constructor.name);
-	}
-};
-
-//#endregion
-//#region src/subscribers/decorators/Subscribe.ts
-/**
-* Registers a subscriber handler class with a specific subscriber event.
-*
-* Associates the decorated class with a subscriber event type for automatic
-* registration and execution when the subscriber is emitted.
-*
-* @typeParam TSubscriber - The subscriber event name to register for
-* @param subscriber - The subscriber event name to register for
-* @param options - Options to configure the subscriber handler registration.
-* @decorator
-* @example
-* ```typescript
-* \@Subscribe('userJoin')
-* class WelcomeHandler extends Subscriber<'userJoin'> {
-*   async execute() {
-*     // Handle user join event
-*   }
-* }
-* ```
-* @example
-* ```ts
-* \@Subscribe('userJoin', { frequency: 'once' })
-* // or
-* \@Subscribe('userJoin')
-* ```
-*/
-function Subscribe(subscriber, options) {
-	return function(constructor) {
-		const meta = {
-			subscriber,
-			frequency: options?.frequency
-		};
-		Reflect.defineMetadata(SubscribeMetadataKey, meta, constructor);
-	};
-}
-
-//#endregion
-//#region src/subscribers/decorators/WebhookUrl.ts
-/**
-* Declares the environment variable a {@link WebhookLog} reporter reads its webhook url from.
-*
-* An unset variable disables the reporter with a boot warning. A set but malformed value throws
-* at boot.
-*
-* @param envKey - The environment variable name holding the webhook url
-* @decorator
-* @example
-* ```ts
-* \@Subscribe('memberBanned')
-* \@WebhookUrl('BAN_LOG_WEBHOOK_URL')
-* class BanLog extends WebhookLog<'memberBanned'> {
-*   report() {
-*     return { components: [new BanCard(this.data).component] };
-*   }
-* }
-* ```
-*/
-function WebhookUrl(envKey) {
-	return function(constructor) {
-		Reflect.defineMetadata(WebhookUrlMetadataKey, envKey, constructor);
-	};
-}
-
-//#endregion
-//#region src/miscellaneous/flagsFor.ts
-/** @internal */
-function flagsFor(ephemeral) {
-	let flags = MessageFlags$1.IsComponentsV2;
-	if (ephemeral) flags |= MessageFlags$1.Ephemeral;
-	return flags;
-}
+var CursorSource = class extends CursorSource$1 {};
 
 //#endregion
-//#region src/subscribers/bases/webhookHelpers.ts
-const DISCORD_WEBHOOK_REGEX = new RegExp(String.raw`^https?:\/\/(?:canary\.|ptb\.)?discord(?:app)?\.com\/api\/webhooks\/\d+\/[\w$-]+$`);
-function isDiscordWebhookUrl(value) {
-	return URL.canParse(value) && DISCORD_WEBHOOK_REGEX.test(value);
-}
-function jsonAttachment(name, description, data) {
-	const content = filterCirculars(data);
-	return {
-		name,
-		description,
-		data: Buffer.from(JSON.stringify(content, void 0, 2), "utf8")
-	};
-}
-function neutralizeFences(text) {
-	return text.replaceAll("```", "`​`​`");
-}
-/** An error's stack with its direct cause appended (one level), ANSI-stripped for the webhook payload. */
-function errorReport(error) {
-	let report = error.stack ?? `${error.name}: ${error.message}`;
-	if (Error.isError(error.cause)) {
-		const cause = error.cause.stack ?? `${error.cause.name}: ${error.cause.message}`;
-		report += `\n\nCaused by:\n${cause}`;
-	}
-	const stripped = neutralizeFences(stripAnsi(report));
-	return stripped.length > 1800 ? `${stripped.slice(0, 1799)}…` : stripped;
-}
-var WebhookSeparator = class extends BuilderComponent {
-	constructor() {
-		super("separator");
-		this.instance.setSpacing(SeparatorSpacingSize.Small).setDivider(true);
-	}
-};
-
-//#endregion
-//#region src/subscribers/bases/WebhookSender.ts
-const HTTP_NOT_FOUND = 404;
-const HTTP_UNAUTHORIZED = 401;
+//#region src/subscribers/index.ts
 /**
-* Sends component messages to a Discord webhook through `@discordjs/rest`.
+* Base class for a gateway subscriber, binding `this.core` to the gateway {@link Core}.
 *
-* @throws A `SeedcordError` when the url does not carry a webhook id and token.
+* @typeParam KeyOfSubscribers - The subscription key this handler receives
 */
-var WebhookSender = class {
-	rest = new REST();
-	route;
-	constructor(url) {
-		const match = /\/webhooks\/(\d+)\/([\w$-]+)$/.exec(url);
-		if (!match?.[1] || !match[2]) throw new SeedcordError(SeedcordErrorCode.ConfigWebhookUrlInvalid, ["The url"]);
-		this.route = Routes.webhook(match[1], match[2]);
-	}
-	/**
-	* Fetches the webhook object, sending no message. Returns `missing` on a 404 or 401 from
-	* Discord and `unreachable` on any other failure.
-	*/
-	async verify() {
-		try {
-			await this.rest.get(this.route, { auth: false });
-			return "ok";
-		} catch (error) {
-			return error instanceof DiscordAPIError$1 && (error.status === HTTP_NOT_FOUND || error.status === HTTP_UNAUTHORIZED) ? "missing" : "unreachable";
-		}
-	}
-	async send(options) {
-		const { flags, username, components, files } = options;
-		await this.rest.post(this.route, {
-			auth: false,
-			query: new URLSearchParams({
-				with_components: "true",
-				wait: "true"
-			}),
-			body: {
-				flags,
-				username,
-				components: components.map((component) => component.toJSON()),
-				...files?.length && { attachments: files.map((file, id) => ({
-					id,
-					filename: file.name,
-					description: file.description
-				})) }
-			},
-			...files?.length && { files: files.map((file) => ({
-				name: file.name,
-				data: file.data
-			})) }
-		});
-	}
-};
-
-//#endregion
-//#region src/subscribers/bases/WebhookLog.ts
+var Subscriber = class extends Subscriber$1 {};
 /**
-* Base class for subscribers that deliver their event to a Discord webhook.
-*
-* Declare the url's environment variable with `@WebhookUrl` and implement {@link report}. Url
-* resolution, validation, sender reuse, and sending run in the base. When the variable is unset
-* the reporter is skipped at registration with a boot warning.
+* 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
 */
-var WebhookLog = class WebhookLog extends Subscriber {
-	static senders = /* @__PURE__ */ new Map();
-	async execute() {
-		const url = WebhookLog.urlOf(WebhookLog.envKeyOf(this.constructor));
-		if (url === null) {
-			this.logger.warn(`${chalk.bold(this.constructor.name)} has no webhook url set, this reporter is disabled`);
-			return;
-		}
-		const { username, components, files } = await this.report();
-		try {
-			await WebhookLog.senderFor(url).send({
-				flags: flagsFor(false),
-				username: username ?? this.constructor.name,
-				components,
-				files
-			});
-		} catch (error) {
-			this.logger.error("Failed to send webhook report", error);
-		}
-	}
-	/** @internal */
-	static senderFor(url) {
-		let sender = WebhookLog.senders.get(url);
-		if (!sender) {
-			sender = new WebhookSender(url);
-			WebhookLog.senders.set(url, sender);
-		}
-		return sender;
-	}
-	/** @internal */
-	static envKeyOf(ctor) {
-		const envKey = Reflect.getMetadata(WebhookUrlMetadataKey, ctor);
-		if (!envKey) throw new SeedcordError(SeedcordErrorCode.DecoratorWebhookUrlMissing, [ctor.name]);
-		return envKey;
-	}
-	/** @internal Returns null when the env var is unset, throws when set but malformed. */
-	static urlOf(envKey) {
-		if (!Envapter.has(envKey)) return null;
-		const raw = Envapter.getRequired(envKey, Converters.String).trim();
-		if (raw === "") return null;
-		if (!isDiscordWebhookUrl(raw)) throw new SeedcordError(SeedcordErrorCode.ConfigWebhookUrlInvalid, [envKey]);
-		return raw;
-	}
-};
-
-//#endregion
-//#region src/bot/utilities/miscellaneous/contextMenuLeaves.ts
-/**
-* Collects the names of every registered context-menu command across a set of command builders, split into a
-* user set and a message set. The same builder may appear more than once (a guild command is pushed once per
-* guild), and slash commands carry no context-menu name, so both collapse here. The split mirrors the
-* controller's two name-keyed maps, so the boot guard checks each name against its own kind.
-*
-* @internal
-*/
-function contextMenuLeaves(commands) {
-	const user = /* @__PURE__ */ new Set();
-	const message = /* @__PURE__ */ new Set();
-	for (const command of commands) {
-		if (!(command instanceof ContextMenuCommandBuilder)) continue;
-		if (command.type === ApplicationCommandType.User) user.add(command.name);
-		else message.add(command.name);
-	}
-	return {
-		user,
-		message
-	};
-}
-
-//#endregion
-//#region src/bot/utilities/miscellaneous/slashRouteLeaves.ts
-/**
-* Collects the route keys of every executable slash leaf across a set of command builders, deduplicated. The
-* same builder may appear more than once (a guild command is pushed once per guild), and context-menu
-* commands carry no slash route, so both collapse here. Route keys come from the same {@link routeLeavesOf}
-* that `seedcord codegen` reads, so the boot-time check compares against the generated registry's keys.
-*
-* @internal
-*/
-function slashRouteLeaves(commands) {
-	const leaves = /* @__PURE__ */ new Set();
-	for (const command of commands) {
-		if (!(command instanceof SlashCommandBuilder)) continue;
-		for (const leaf of routeLeavesOf(command.toJSON())) leaves.add(leaf.route);
-	}
-	return leaves;
-}
-
-//#endregion
-//#region src/bot/controllers/CommandRegistry.ts
-/**
-* Manages Discord application command registration and deployment.
-*
-* Scans command directories, builds command structures, and registers both global and guild-scoped commands
-* to Discord's API. Accessed via `core.bot.commands`. Do not construct it directly.
-*/
-var CommandRegistry = class {
-	core;
-	onDeployed;
-	logger = new Logger("Commands");
-	isInitialised = false;
-	globalCommands = [];
-	guildCommands = new Collection();
-	ctorToCommand = /* @__PURE__ */ new Map();
-	loading = false;
-	loadedCommands = [];
-	hmrHandler;
-	pendingEvents = /* @__PURE__ */ new Map();
-	constructor(core, onDeployed) {
-		this.core = core;
-		this.onDeployed = onDeployed;
-		const commandsDir = this.core.config.bot.commands.path;
-		if (!commandsDir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
-		if (!Envapter.isDevelopment && !Envapter.isTest) return;
-		this.hmrHandler = new HmrModuleHandler({
-			handlersDir: commandsDir,
-			isHandler: this.isCommandClass.bind(this),
-			registerHandler: this.registerCommand.bind(this),
-			unregisterHandler: this.unregisterCommand.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
-			logger: this.logger
-		});
-	}
-	getArtifacts(ctor) {
-		return this.ctorToCommand.get(ctor);
-	}
-	/** @internal */
-	async init() {
-		if (this.isInitialised) return;
-		this.isInitialised = true;
-		const commandsDir = this.core.config.bot.commands.path;
-		if (!commandsDir) return;
-		this.loading = true;
-		this.loadedCommands.length = 0;
-		try {
-			await this.loadCommands(commandsDir);
-		} finally {
-			this.loading = false;
-		}
-		this.reportLoad();
-		getDevChannel()?.on("seedcord:refresh-commands", (data) => {
-			this.refresh(data.shouldRefresh);
-		});
-	}
-	reportLoad() {
-		const { utils } = this.logger;
-		utils.summary("Loaded commands", {
-			global: this.globalCommands.length,
-			"guild groups": this.guildCommands.size
-		});
-		let slash = 0;
-		let menu = 0;
-		for (const command of this.loadedCommands) if (command.kind === "slash command") slash++;
-		else menu++;
-		utils.block("Loaded commands", [...utils.entries(this.loadedCommands), ...utils.counts({
-			"slash commands": slash,
-			"context menus": menu
-		})]);
-	}
-	/** @internal */
-	async refresh(shouldRefresh = true) {
-		if (!shouldRefresh) {
-			this.logger.info(chalk.italic("Command refresh cancelled."));
-			this.pendingEvents.clear();
-			return;
-		}
-		this.logger.info(chalk.italic("Refreshing commands..."));
-		for (const event of this.pendingEvents.values()) await this.hmrHandler?.handle(event);
-		this.pendingEvents.clear();
-		await this.setCommands();
-	}
-	/** @internal */
-	async onHmr(event) {
-		const commandsDir = this.core.config.bot.commands.path;
-		if (commandsDir && event.file.startsWith(resolve(process.cwd(), commandsDir))) {
-			this.pendingEvents.delete(event.file);
-			this.pendingEvents.set(event.file, event);
-			getDevChannel()?.send("seedcord:commands-update-prompt", { files: [...this.pendingEvents.keys()].map((f) => formatFilePath(f)) });
-		} else await this.hmrHandler?.handle(event);
-	}
-	async loadCommands(dir) {
-		await traverseDirectory(dir, (fullPath, rel, mod) => {
-			for (const exported of Object.values(mod)) if (this.isCommandClass(exported)) {
-				this.registerCommand(exported, rel);
-				this.hmrHandler?.trackHandler(fullPath, exported);
-			}
-		}, this.logger);
-	}
-	isCommandClass(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof BuilderComponent && Reflect.hasMetadata(CommandMetadataKey, obj);
-	}
-	registerCommand(ctor, rel) {
-		const meta = Reflect.getMetadata(CommandMetadataKey, ctor);
-		if (!meta) return;
-		const comp = new ctor().component;
-		const kind = comp instanceof SlashCommandBuilder ? "slash command" : "context menu";
-		if (meta.scope === "global") this.globalCommands.push(comp);
-		else for (const g of meta.guilds) {
-			const arr = this.guildCommands.get(g) ?? [];
-			arr.push(comp);
-			this.guildCommands.set(g, arr);
-		}
-		this.ctorToCommand.set(ctor, {
-			name: comp.name,
-			scope: meta.scope,
-			...meta.scope === "guild" && { guilds: meta.guilds }
-		});
-		if (this.loading) {
-			this.loadedCommands.push({
-				name: comp.name,
-				from: formatFilePath(rel),
-				kind
-			});
-			return;
-		}
-		this.logger.utils.registration(comp.name, rel, `${meta.scope} ${kind}`);
-	}
-	unregisterCommand(ctor, artifacts) {
-		const info = artifacts ?? this.ctorToCommand.get(ctor);
-		if (!info) return;
-		if (info.scope === "global") {
-			const idx = this.globalCommands.findIndex((c) => c.name === info.name);
-			if (idx !== -1) this.globalCommands.splice(idx, 1);
-		} else for (const g of info.guilds ?? []) {
-			const arr = this.guildCommands.get(g);
-			if (arr) {
-				const idx = arr.findIndex((c) => c.name === info.name);
-				if (idx !== -1) arr.splice(idx, 1);
-			}
-		}
-		this.ctorToCommand.delete(ctor);
-	}
-	/** @internal */
-	async setCommands() {
-		const result = {
-			global: new Collection(),
-			guilds: new Collection()
-		};
-		if (this.globalCommands.length > 0) {
-			const deployed = await this.core.bot.client.application?.commands.set(this.globalCommands);
-			if (deployed) result.global = deployed;
-			const tag = this.globalCommands.length === 1 ? "command" : "commands";
-			this.logger.utils.block(`Deployed ${this.globalCommands.length} global ${tag}`, this.logger.utils.wrap(this.globalCommands.map((command) => command.name)), "info");
-		}
-		for (const [guildId, commands] of this.guildCommands.entries()) {
-			const guild = this.core.bot.client.guilds.cache.get(guildId);
-			if (!guild) {
-				this.logger.warn(`Guild with ID ${guildId} not found, skipping command registration.`);
-				continue;
-			}
-			const deployed = await guild.commands.set(commands);
-			result.guilds.set(guildId, deployed);
-			const tag = commands.length === 1 ? "command" : "commands";
-			this.logger.utils.block(`Deployed ${commands.length} ${tag} to ${paint.amber.bold(guild.name)}`, this.logger.utils.wrap(commands.map((command) => command.name)), "info");
-		}
-		this.onDeployed?.(result);
-		return result;
-	}
-	/** The deduplicated slash route keys across every global and guild command. @internal */
-	routeLeaves() {
-		return slashRouteLeaves([...this.globalCommands, ...this.guildCommands.values()].flat());
-	}
-	/** The registered context-menu command names, split by kind, across every global and guild command. @internal */
-	contextMenuLeaves() {
-		return contextMenuLeaves([...this.globalCommands, ...this.guildCommands.values()].flat());
-	}
-};
+var WebhookLog = class extends WebhookLog$1 {};
+
+//#endregion
+//#region src/plugin.ts
+/**
+* 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.
+*
+* @typeParam Opts - The transport and runtime the plugin declares.
+*/
+var Plugin = class extends Plugin$1 {};
 
 //#endregion
 //#region src/miscellaneous/deriveEventActor.ts
@@ -2416,9 +1337,157 @@ function eventGateContext(eventName, args, core) {
 	};
 }
 
+//#endregion
+//#region src/miscellaneous/extractErrorResponse.ts
+const logger$2 = new Logger("ErrorsHandling", { channel: "errors" });
+/**
+* Processes an error into a user-facing reply and routes its report.
+*
+* A {@link Notice} always renders its own reply. A reporting denial (`report: true`) additionally
+* publishes `handledException` on the interaction path. A raw, non-denial throw publishes
+* `unknownException` and renders the configured `defaultError` (or a generic {@link Fault}). One uuid is
+* threaded into both the reply and the bus payload.
+*/
+function extractErrorResponse(error, core, origin) {
+	const uuid = crypto.randomUUID();
+	const developerUsername = core.config.notifications?.developerUsername;
+	const ctx = developerUsername === void 0 ? { uuid } : {
+		uuid,
+		developerUsername
+	};
+	if (error instanceof Notice) {
+		if (error.report) reportFault(error, core, origin, uuid);
+		return {
+			uuid,
+			response: error.render(ctx)
+		};
+	}
+	reportRawFault(error, core, origin, uuid);
+	const override = core.config.errors?.defaultError;
+	return {
+		uuid,
+		response: override ? new override(uuid).render(ctx) : new Fault().render(ctx)
+	};
+}
+function withThrottle(core, origin, error, publish) {
+	const throttle = FaultThrottle.for(core);
+	const key = faultKey(origin, error);
+	if (!throttle.shouldReport(key)) {
+		logger$2.debug(`throttled duplicate fault ${key}`);
+		return;
+	}
+	publish();
+	throttle.markReported(key);
+}
+function reportFault(denial, core, origin, uuid) {
+	logger$2.error(`${denial.name}: ${uuid}`, denial);
+	withThrottle(core, origin, denial, () => {
+		if (origin.interaction) core.bus[PublishDefault]("handledException", {
+			denial,
+			uuid,
+			source: buildInteractionSource(origin.interaction)
+		});
+		else if (origin.event) core.bus[PublishDefault]("handledException", {
+			denial,
+			uuid,
+			source: buildEventSource(origin.event, origin)
+		});
+		else core.bus[PublishDefault]("unknownException", {
+			uuid,
+			error: denial,
+			...scalarActors(origin),
+			metadata: metadataFor(origin)
+		});
+	});
+}
+function causeLine(error) {
+	const { cause } = error;
+	if (!Error.isError(cause)) return "";
+	const [first] = cause.message.split("\n");
+	return `\ncaused by ${cause.name}: ${first ?? cause.message}`;
+}
+function reportRawFault(error, core, origin, uuid) {
+	if (core.config.errors?.errorStack ?? false) logger$2.error(uuid, error);
+	else logger$2.error(`${uuid} | ${error.message}${causeLine(error)}`);
+	withThrottle(core, origin, error, () => {
+		core.bus[PublishDefault]("unknownException", {
+			uuid,
+			error,
+			...scalarActors(origin),
+			metadata: metadataFor(origin)
+		});
+	});
+}
+function scalarActors(origin) {
+	return {
+		guild: origin.guild ? {
+			id: origin.guild.id,
+			name: origin.guild.name
+		} : void 0,
+		user: origin.user ? {
+			id: origin.user.id,
+			username: origin.user.username
+		} : void 0
+	};
+}
+function metadataFor(origin) {
+	if (origin.event) return {
+		eventName: origin.event.name,
+		handler: origin.event.handler,
+		args: origin.event.args
+	};
+	return origin.metadata;
+}
+function buildEventSource(event, origin) {
+	return {
+		kind: "event",
+		eventName: event.name,
+		handler: event.handler,
+		userId: origin.user?.id ?? null,
+		guildId: origin.guild?.id ?? null,
+		channelId: event.channelId,
+		raw: event.args
+	};
+}
+function faultKey(origin, error) {
+	const name = error instanceof Notice ? error.name : error instanceof DiscordAPIError ? String(error.code) : error.constructor.name;
+	if (origin.event) return `${origin.event.name}:${origin.event.handler}:${name}`;
+	if (origin.interaction) return `${interactionRoute(origin.interaction)}:${name}`;
+	if (origin.route) return `autocomplete:${origin.route}:${name}`;
+	return `autocomplete:${name}`;
+}
+function interactionRoute(interaction) {
+	if (interaction.isChatInputCommand()) return slashRouteOf(interaction);
+	if (interaction.isContextMenuCommand()) return interaction.commandName;
+	if (interaction.isButton() || interaction.isAnySelectMenu() || interaction.isModalSubmit()) return prefixOf(interaction.customId) || interaction.customId;
+	return "interaction";
+}
+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;
+	return {
+		kind: "interaction",
+		interactionKind: interactionKind(interaction),
+		command,
+		customId,
+		userId: interaction.user.id,
+		guildId: interaction.guildId,
+		channelId: interaction.channelId,
+		interactionId: interaction.id,
+		raw: interaction
+	};
+}
+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("EventBoundary");
+const logger$1 = new Logger("EventBoundary", { channel: "errors" });
 /**
 * The event controller boundary. Reports a throw from an event handler and never replies, since a
 * generic event has no reply target. A {@link Silence} or a non-reporting {@link Notice} stops quietly, a
@@ -2431,15 +1500,15 @@ function handleEventFault(caught, eventName, handlerName, args, core) {
 		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger$1.debug(`Silence: ${caught.reason}`);
 		return;
 	}
-	if (!Error.isError(caught)) throw caught;
+	const error = asError(caught);
 	const ignore = new Set(core.config.errors?.ignoreEventApiCodes ?? []);
-	if (caught instanceof DiscordAPIError && ignore.has(caught.code)) {
-		logger$1.debug(`swallowed api code ${caught.code}`);
+	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
+		logger$1.debug(`swallowed api code ${error.code}`);
 		return;
 	}
-	if (caught instanceof Notice && !caught.report) return;
+	if (error instanceof Notice && !error.report) return;
 	const actor = deriveEventActor(args);
-	extractErrorResponse(caught, core, {
+	extractErrorResponse(error, core, {
 		event: {
 			name: eventName,
 			handler: handlerName,
@@ -2454,15 +1523,15 @@ function handleEventFault(caught, eventName, handlerName, args, core) {
 //#endregion
 //#region src/bot/controllers/EventDispatcher.ts
 /**
-* Scans event handler directories, registers handlers with Discord client events,
-* and coordinates event execution through the handler system. Does not handle interactions.
-* Multiple handlers can point to one event.
+* Scans event handler directories, attaches one client listener per registered event, and runs the
+* handlers for each fire. Interactions route through InteractionDispatcher. Multiple handlers can
+* point to one event.
 *
 * @internal
 */
 var EventDispatcher = class {
 	core;
-	logger = new Logger("Events");
+	logger = new Logger("Events", { channel: "events" });
 	isInitialized = false;
 	eventMap = /* @__PURE__ */ new Map();
 	middlewares = [];
@@ -2533,7 +1602,7 @@ var EventDispatcher = class {
 				this.registerHandler(val, relativePath);
 				this.hmrHandler?.trackHandler(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	async loadMiddlewares(dir) {
 		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
@@ -2542,7 +1611,7 @@ var EventDispatcher = class {
 				this.registerMiddleware(val, relativePath);
 				this.hmrHandler?.trackMiddleware(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	/** @internal For use in dev mode */
 	async onHmr(event) {
@@ -2639,10 +1708,14 @@ var EventDispatcher = class {
 		this.logger.debug(`Attaching ${paint.mint.bold(eventName)} to the client with ${paint.mute(handlerEntries?.length ?? 0)} handler(s)`);
 		this.core.bot.client.on(eventName, (...args) => {
 			if (this.draining) return;
-			this.core.bot.emitSafe("any:event", eventName, ...args);
-			const run = this.processEvent(eventName, args).catch((err) => {
-				this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
-				this.core.bot.emit("error:unhandled:event", err);
+			this.core.bus[PublishDefault]("anyEvent", {
+				name: eventName,
+				args
+			});
+			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.add(run);
 			run.finally(() => this.inFlight.delete(run));
@@ -2718,7 +1791,7 @@ const HARMLESS_API_CODES = new Set([
 
 //#endregion
 //#region src/bot/handleInteractionFault.ts
-const logger = new Logger("InteractionBoundary");
+const logger = new Logger("InteractionBoundary", { channel: "errors" });
 /**
 * The interaction controller boundary. Sorts a throw from any handler-lifecycle phase into the right
 * user reply plus the right bus event. When a handler is built its sender is passed in, so the boundary
@@ -2727,33 +1800,45 @@ const logger = new Logger("InteractionBoundary");
 *
 * @internal
 */
-async function handleInteractionFault(caught, interaction, core, sender) {
+async function handleInteractionFault(caught, interaction, core, routeId, sender) {
 	if (caught instanceof Silence) {
 		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger.debug(`Silence: ${caught.reason}`);
 		return;
 	}
-	if (!Error.isError(caught)) throw caught;
+	const error = asError(caught);
 	const ignore = new Set(core.config.errors?.ignoreApiCodes ?? []);
-	if (caught instanceof DiscordAPIError && ignore.has(caught.code)) {
-		logger.debug(`swallowed api code ${caught.code}`);
+	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
+		logger.debug(`swallowed api code ${error.code}`);
 		return;
 	}
 	if (interaction.isAutocomplete()) {
-		extractErrorResponse(caught, core, {
+		extractErrorResponse(error, core, {
 			guild: interaction.guild,
 			user: interaction.user,
 			metadata: interaction,
 			route: slashRouteOf(interaction)
 		});
+		await sendEmptyChoices(interaction, core, routeId);
 		return;
 	}
-	const { response } = extractErrorResponse(caught, core, {
+	const { response } = extractErrorResponse(error, core, {
 		interaction,
 		guild: interaction.guild,
 		user: interaction.user,
 		metadata: interaction
 	});
-	await sendGuarded(sender ?? new ReplySender(interaction, interactionRoute(interaction)), response, caught instanceof Notice ? caught.ephemeral : true);
+	await sendGuarded(sender ?? new ReplySender(interaction, routeId, core.bus), response, error instanceof Notice ? error.ephemeral : true);
+}
+async function sendEmptyChoices(interaction, core, routeId) {
+	const telemetry = {
+		bus: core.bus,
+		interactionId: interaction.id
+	};
+	try {
+		await reportedWrite(telemetry, routeId, "respond", () => interaction.respond([]));
+	} catch (error) {
+		logger.debug(`autocomplete empty-choices send failed: ${String(error)}`);
+	}
 }
 async function sendGuarded(sender, response, ephemeral) {
 	try {
@@ -2777,7 +1862,7 @@ async function sendGuarded(sender, response, ephemeral) {
 */
 var InteractionDispatcher = class {
 	core;
-	logger = new Logger("Interactions");
+	logger = new Logger("Interactions", { channel: "interactions" });
 	isInitialized = false;
 	slashMap = /* @__PURE__ */ new Map();
 	buttonMap = /* @__PURE__ */ new Map();
@@ -2790,6 +1875,7 @@ var InteractionDispatcher = class {
 	messageContextMenuMap = /* @__PURE__ */ new Map();
 	userContextMenuMap = /* @__PURE__ */ new Map();
 	autocompleteMap = /* @__PURE__ */ new Map();
+	handlerFiles = /* @__PURE__ */ new Map();
 	keysToIgnore = /* @__PURE__ */ new Set();
 	middlewares = [];
 	inFlight = /* @__PURE__ */ new Set();
@@ -2832,21 +1918,9 @@ var InteractionDispatcher = class {
 			logger: this.logger
 		});
 	}
-	/**
-	* Warns for each command route with no registered `@SlashRoute` handler, which would fall through to
-	* UnhandledRepliable at runtime. A bot may route commands outside the registry, so this does not throw.
-	*
-	* @internal
-	*/
 	warnUnhandledRoutes(commandLeaves) {
 		for (const route of commandLeaves) if (!this.slashMap.has(route)) this.logger.warn(`Slash route ${paint.sky.bold(route)} has no registered ${chalk.bold("@SlashRoute")} handler.`);
 	}
-	/**
-	* Warns for each context-menu command with no matching handler, which would fall through to UnhandledRepliable
-	* at runtime. Checked per kind since a user and a message command can share a name.
-	*
-	* @internal
-	*/
 	warnUnhandledContextMenuRoutes(leaves) {
 		for (const name of leaves.user) if (!this.userContextMenuMap.has(name)) this.logger.warn(`User context menu ${paint.sky.bold(name)} has no registered ${chalk.bold("@ContextMenuRoute")} handler.`);
 		for (const name of leaves.message) if (!this.messageContextMenuMap.has(name)) this.logger.warn(`Message context menu ${paint.sky.bold(name)} has no registered ${chalk.bold("@ContextMenuRoute")} handler.`);
@@ -2908,7 +1982,7 @@ var InteractionDispatcher = class {
 				this.registerHandler(val, relativePath);
 				this.hmrHandler?.trackHandler(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	async loadMiddlewares(dir) {
 		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
@@ -2917,7 +1991,7 @@ var InteractionDispatcher = class {
 				this.registerMiddleware(val, relativePath);
 				this.hmrHandler?.trackMiddleware(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	registerMiddleware(middlewareCtor, relativePath) {
 		const metadata = Reflect.getMetadata(MiddlewareMetadataKey, middlewareCtor);
@@ -2947,6 +2021,7 @@ var InteractionDispatcher = class {
 		return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
 	}
 	registerHandler(handlerClass, relativePath) {
+		const from = formatFilePath(relativePath);
 		const writes = [];
 		for (const [routeType, map] of this.routeTypes) {
 			const meta = Reflect.getMetadata(InteractionRouteKeys[routeType], handlerClass);
@@ -2954,16 +2029,16 @@ var InteractionDispatcher = class {
 			for (const route of meta) {
 				const existing = map.get(route);
 				if (existing && existing !== handlerClass) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateRoute, [
-					route,
-					existing.name,
-					handlerClass.name
+					`${routeType}:${route}`,
+					`${existing.name} (${this.handlerFiles.get(existing) ?? "unknown file"})`,
+					`${handlerClass.name} (${from})`
 				]);
 				writes.push([map, route]);
 			}
 		}
 		if (writes.length === 0) return;
 		for (const [map, route] of writes) map.set(route, handlerClass);
-		const from = formatFilePath(relativePath);
+		this.handlerFiles.set(handlerClass, from);
 		if (this.loading) this.loadedHandlers.push({
 			name: handlerClass.name,
 			from
@@ -2975,6 +2050,7 @@ var InteractionDispatcher = class {
 		await this.hmrHandler?.handle(event);
 	}
 	unregisterHandler(handlerClass, artifacts) {
+		this.handlerFiles.delete(handlerClass);
 		if (artifacts) {
 			for (const { routeType, routes } of artifacts) {
 				const map = this.routeTypes.find(([type]) => type === routeType)?.[1];
@@ -2995,10 +2071,11 @@ var InteractionDispatcher = class {
 	attachToClient() {
 		this.core.bot.client.on(Events.InteractionCreate, (interaction) => {
 			if (this.draining) return;
-			this.core.bot.emitSafe("any:interaction", interaction);
-			const run = this.handleInteraction(interaction).catch((err) => {
-				this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
-				this.core.bot.emit("error:unhandled:interaction", err);
+			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.add(run);
 			run.finally(() => this.inFlight.delete(run));
@@ -3010,37 +2087,75 @@ var InteractionDispatcher = class {
 	drain(timeoutMs) {
 		return settleWithin(Promise.allSettled(this.inFlight), timeoutMs);
 	}
-	async handleCustomIdInteraction(interaction, getMap, interactionType) {
+	async handleCustomIdInteraction(interaction, kind, getMap) {
 		if ([...this.keysToIgnore].some((matcher) => matcher.owns(interaction.customId))) return;
 		const prefix = prefixOf(interaction.customId);
-		if (!prefix) return this.logger.warn(`${interactionType} has invalid customId: ${interaction.customId}`);
-		await this.processInteraction(interaction, () => prefix, (key) => getMap().get(key));
+		if (!prefix) this.logger.warn(`${paint.sky.bold(kind)} has invalid customId: ${paint.mute(interaction.customId)}`);
+		await this.processInteraction(interaction, kind, () => prefix, (key) => getMap().get(key));
 	}
-	async processInteraction(interaction, extractKey, getHandler, fallback = UnhandledRepliable) {
+	async processInteraction(interaction, kind, extractKey, getHandler, fallback = UnhandledRepliable) {
 		const key = extractKey(interaction);
+		const startedAt = performance.now();
+		const queuedMs = queuedMsFor(interaction.id);
+		const matched = getHandler(key);
+		let routeId = `${kind}:${key || "unrouted"}`;
+		let reported = false;
+		const report = (outcome) => {
+			if (reported) return;
+			reported = true;
+			this.core.bus[PublishDefault]("interactionDispatched", dispatchedPayload({
+				routeId,
+				interactionId: interaction.id,
+				kind,
+				outcome,
+				startedAt,
+				fallback: !matched,
+				queuedMs
+			}));
+		};
 		let sender;
 		try {
-			if (!interaction.isAutocomplete()) for (const { ctor } of this.middlewares) await new ctor(interaction, this.core).execute();
-			let HandlerCtor = getHandler(key);
-			if (!HandlerCtor) {
-				this.logger.warn(`No handler found for key ${paint.sky.bold(key)}. Falling back to ${fallback.name}.`);
-				HandlerCtor = fallback;
-			}
-			this.logger.debug(`Processing ${paint.mint.bold(key)} with ${paint.mute(HandlerCtor.name)}`);
-			const dispatch = new DispatchContext(routeIdOf(HandlerCtor));
-			const handler = new HandlerCtor(interaction, this.core, dispatch);
+			if (!interaction.isAutocomplete()) await this.runMiddlewares(interaction);
+			const HandlerCtor = matched ?? fallback;
+			const dispatch = new DispatchContext(routeIdOf(HandlerCtor) ?? routeId);
+			routeId = dispatch.routeId ?? routeId;
+			const handler = this.buildHandler(HandlerCtor, interaction, dispatch, key, !matched);
 			if (handler instanceof RepliableHandler) sender = handler.getSender();
-			if (!interaction.isAutocomplete()) {
-				const monitor = slowGateMonitor();
-				try {
-					await runHandlerGates(HandlerCtor, interactionGateContext(interaction, this.core), dispatch.routeId ?? void 0, monitor?.observe);
-				} finally {
-					monitor?.report(dispatch.routeId);
-				}
+			const refusal = interaction.isAutocomplete() ? null : await this.gateRefusal(HandlerCtor, interaction, dispatch.routeId);
+			if (refusal) {
+				await this.answer(refusal.caught, interaction, routeId, sender, report);
+				return;
 			}
 			await handler.execute();
+			report("handled");
+		} catch (caught) {
+			await this.answer(caught, interaction, routeId, sender, report);
+		}
+	}
+	async answer(caught, interaction, routeId, sender, report) {
+		try {
+			await handleInteractionFault(caught, interaction, this.core, routeId, 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.mint.bold(key)} with ${paint.mute(HandlerCtor.name)}`);
+		return new HandlerCtor(interaction, this.core, dispatch);
+	}
+	async runMiddlewares(interaction) {
+		for (const { ctor } of this.middlewares) await new ctor(interaction, this.core).execute();
+	}
+	async gateRefusal(HandlerCtor, interaction, routeId) {
+		const monitor = slowGateMonitor();
+		try {
+			await runHandlerGates(HandlerCtor, interactionGateContext(interaction, this.core), routeId ?? void 0, monitor?.observe);
+			return null;
 		} catch (caught) {
-			await handleInteractionFault(caught, interaction, this.core, sender);
+			return { caught };
+		} finally {
+			monitor?.report(routeId);
 		}
 	}
 	async handleInteraction(interaction) {
@@ -3085,47 +2200,41 @@ var InteractionDispatcher = class {
 	}
 	async handleSlashCommand(interaction) {
 		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, () => route, (key) => this.slashMap.get(key));
+		await this.processInteraction(interaction, InteractionRoutes.Slash, () => route, (key) => this.slashMap.get(key));
 	}
 	async handleButton(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.buttonMap, "Button");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.Button, () => this.buttonMap);
 	}
 	async handleModal(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.modalMap, "Modal");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.Modal, () => this.modalMap);
 	}
 	async handleStringSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.stringSelectMap, "String select menu");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.StringMenu, () => this.stringSelectMap);
 	}
 	async handleUserSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.userSelectMap, "User select menu");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.UserMenu, () => this.userSelectMap);
 	}
 	async handleRoleSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.roleSelectMap, "Role select menu");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.RoleMenu, () => this.roleSelectMap);
 	}
 	async handleChannelSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.channelSelectMap, "Channel select menu");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.ChannelMenu, () => this.channelSelectMap);
 	}
 	async handleMentionableSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.mentionableSelectMap, "Mentionable select menu");
+		await this.handleCustomIdInteraction(interaction, InteractionRoutes.MentionableMenu, () => this.mentionableSelectMap);
 	}
 	async handleMessageContextMenu(interaction) {
-		await this.processInteraction(interaction, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
+		await this.processInteraction(interaction, InteractionRoutes.MessageContextMenu, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
 	}
 	async handleUserContextMenu(interaction) {
-		await this.processInteraction(interaction, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
+		await this.processInteraction(interaction, InteractionRoutes.UserContextMenu, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
 	}
 	async handleAutocomplete(interaction) {
 		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, () => route, (key) => this.autocompleteMap.get(key), UnhandledAutocomplete);
+		await this.processInteraction(interaction, InteractionRoutes.Autocomplete, () => route, (key) => this.autocompleteMap.get(key), UnhandledAutocomplete);
 	}
 };
 
-//#endregion
-//#region \0@oxc-project+runtime@0.135.0/helpers/esm/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-
 //#endregion
 //#region \0@oxc-project+runtime@0.135.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -3144,38 +2253,47 @@ const LOGOUT_TIMEOUT_MS = 2e3;
 /**
 * The Discord client and its controllers. Access it through `core.bot`.
 */
-var Bot = class extends TypedEventEmitter {
+var Bot = class {
 	/** @internal */
-	logger = new Logger("Bot");
+	logger = new Logger("Bot", { channel: "bot" });
 	isInitialized = false;
 	_client;
 	interactions;
 	events;
 	emojiInjector;
-	commands;
-	emojis = Emojis;
-	mentions = CommandMentions;
+	commandRegistry;
 	/** @internal */
 	async onHmr(event) {
 		if (this.interactions) await this.interactions.onHmr(event);
 		if (this.events) await this.events.onHmr(event);
-		if (this.commands) await this.commands.onHmr(event);
+		if (this.commandRegistry) await this.commandRegistry.onHmr(event);
 	}
 	/** @internal */
 	constructor(core) {
-		super();
 		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.commands.path) {
-			const mentionInjector = new CommandMentionInjector(core);
-			this.commands = new CommandRegistry(core, (result) => {
-				mentionInjector.inject(result);
+		const commandsDir = core.config.bot.commands.path;
+		if (commandsDir) {
+			const injector = new CommandInjector();
+			const registry = new CommandRegistry({
+				dir: commandsDir,
+				rest: this._client.rest,
+				applicationId: () => this.applicationId(),
+				onDeployed: (result) => {
+					injector.inject(result, registry.allCommands());
+				}
 			});
+			this.commandRegistry = registry;
 		}
 		this.emojiInjector = new EmojiInjector(core);
 		this.registerShutdownTasks(core);
 	}
+	applicationId() {
+		const { application } = this._client;
+		if (!application) throw new SeedcordError(SeedcordErrorCode.CoreApplicationUnavailable);
+		return application.id;
+	}
 	registerShutdownTasks(core) {
 		core.shutdown.addTask(ShutdownPhase.Unbind, "stop-dispatch", () => {
 			this.stopAccepting();
@@ -3200,11 +2318,11 @@ var Bot = class extends TypedEventEmitter {
 		if (this.events) await this.events.init();
 		await this.login(token);
 		await this.emojiInjector.init();
-		if (this.commands) {
-			await this.commands.init();
-			await this.commands.setCommands();
-			this.interactions?.warnUnhandledRoutes(this.commands.routeLeaves());
-			this.interactions?.warnUnhandledContextMenuRoutes(this.commands.contextMenuLeaves());
+		if (this.commandRegistry) {
+			await this.commandRegistry.init();
+			await this.commandRegistry.setCommands();
+			this.interactions?.warnUnhandledRoutes(this.commandRegistry.routeLeaves());
+			this.interactions?.warnUnhandledContextMenuRoutes(this.commandRegistry.contextMenuLeaves());
 		}
 	}
 	/** @internal */
@@ -3213,9 +2331,10 @@ var Bot = class extends TypedEventEmitter {
 		await this.logout();
 	}
 	async login(token) {
-		this._client.once(Events.ClientReady, () => this.emit("ready"));
+		const ready = Promise.withResolvers();
+		this._client.once(Events.ClientReady, () => ready.resolve());
 		this._client.login(token);
-		await this.waitFor("ready");
+		await ready.promise;
 		this.logger.info(`Logged in as ${chalk.bold.magenta(this._client.user?.username)}!`);
 		return this;
 	}
@@ -3226,244 +2345,13 @@ var Bot = class extends TypedEventEmitter {
 	get client() {
 		return this._client;
 	}
-	/**
-	* The overloads enforce the key/args correlation at compile time only. At runtime this forwards
-	* straight to the underlying TypedEventEmitter.
-	*
-	* @internal
-	*/
-	emit(event, ...args) {
-		return super.emit(event, ...args);
-	}
-	emitSafe(event, ...args) {
-		return super.emitSafe(event, ...args);
-	}
-	onListenerError(error, event) {
-		this.logger.error(`listener for ${String(event)} threw`, error);
-	}
-};
-__decorate([Envapt("DISCORD_BOT_TOKEN", { converter: (raw) => validateDiscordToken(raw) }), __decorateMetadata("design:type", String)], Bot.prototype, "botToken", void 0);
-
-//#endregion
-//#region src/subscribers/default/HandledException.ts
-let HandledException = class HandledException extends WebhookLog {
-	report() {
-		return {
-			username: "Handled Exception",
-			components: [new HandledExceptionContainer(this.data).component],
-			files: [jsonAttachment("source.json", "The raw source the fault came from", this.data.source.raw)]
-		};
-	}
-};
-HandledException = __decorate([Subscribe("handledException"), WebhookUrl("HANDLED_EXCEPTION_WEBHOOK_URL")], HandledException);
-var HandledExceptionContainer = class extends BuilderComponent {
-	constructor(data) {
-		super("container");
-		const { denial, uuid, source } = data;
-		this.instance.addTextDisplayComponents((text) => text.setContent(faultSummary(denial, source))).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`\n\`\`\`${neutralizeFences(causeStack(denial))}\`\`\``)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Source")).addFileComponents((file) => file.setURL("attachment://source.json"));
-	}
-};
-function faultSummary(denial, source) {
-	const head = stripAnsi(`### A handled fault was reported: \`${denial.name}\`\n**Message:** ${denial.message}\n`);
-	if (source.kind === "event") return `${head}**Event:** ${source.eventName}\n**Handler:** ${source.handler}\n**User ID:** \`${source.userId ?? "n/a"}\`\n**Guild ID:** \`${source.guildId ?? "n/a"}\`\n**Channel ID:** \`${source.channelId ?? "n/a"}\``;
-	return `${head}**Kind:** ${source.interactionKind}\n**Command:** ${source.command ?? "n/a"}\n**CustomId:** ${source.customId ?? "n/a"}\n**User ID:** \`${source.userId}\`\n**Guild ID:** \`${source.guildId ?? "n/a"}\`\n**Channel ID:** \`${source.channelId ?? "n/a"}\`\n**Interaction ID:** \`${source.interactionId}\``;
-}
-function causeStack(denial) {
-	const { cause } = denial;
-	if (Error.isError(cause)) return stripAnsi(cause.stack ?? cause.message);
-	if (typeof cause === "string") return stripAnsi(cause);
-	if (typeof cause === "bigint" || typeof cause === "symbol" || typeof cause === "function") return cause.toString();
-	if (cause !== void 0) try {
-		return JSON.stringify(cause);
-	} catch {
-		return "[unserializable cause]";
-	}
-	return stripAnsi(denial.stack ?? "No cause recorded.");
-}
-
-//#endregion
-//#region src/subscribers/default/UnknownException.ts
-let UnknownException = class UnknownException extends WebhookLog {
-	report() {
-		const { metadata } = this.data;
-		return {
-			username: "Unknown Exception",
-			components: [new UnhandledErrorContainer(this.data).component],
-			files: metadata ? [jsonAttachment("metadata.json", "Metadata associated with the error", metadata)] : void 0
-		};
-	}
-};
-UnknownException = __decorate([Subscribe("unknownException"), WebhookUrl("UNKNOWN_EXCEPTION_WEBHOOK_URL")], UnknownException);
-var UnhandledErrorContainer = class extends BuilderComponent {
-	constructor(data) {
-		super("container");
-		const { uuid, error, guild, user, metadata } = data;
-		this.instance.addTextDisplayComponents((text) => text.setContent(`### An unknown exception was thrown\n**Guild ID:** \`${guild?.id ?? "Not used in a guild"}\`\n**Guild Name:** ${guild?.name ?? "Not used in a guild"}\n**User ID:** \`${user?.id ?? "Missing user info"}\`\n**Username:** ${user?.username ?? "Missing user info"}\n`)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`\n\`\`\`${errorReport(error)}\`\`\``));
-		this.addTimestampsIfAvailable(error);
-		this.addMetadataIfAvailable(metadata);
-	}
-	addTimestampsIfAvailable(error) {
-		if (!(error instanceof DiscordAPIError$1)) return;
-		const now = Date.now();
-		const snowflake = error.url.match(/\/interactions\/(\d+)\//)?.[1];
-		if (!snowflake) return void 0;
-		const interactionTs = timestampFromSnowflake(snowflake);
-		const diff = now - interactionTs;
-		const seconds = Math.floor(diff / 1e3);
-		const millis = diff % 1e3;
-		this.instance.addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### Timestamps\n- **\`Interaction sent\` :** ${new Date(interactionTs).toISOString()} (${interactionTs})\n- **\`Error logged    \` :** ${new Date(now).toISOString()} (${now})\n- **\`Offset          \` :** ${seconds}s ${millis}ms`));
-	}
-	addMetadataIfAvailable(metadata) {
-		if (!metadata) return;
-		this.instance.addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Metadata")).addFileComponents((file) => file.setURL("attachment://metadata.json"));
-	}
-};
-
-//#endregion
-//#region src/subscribers/Bus.ts
-/**
-* Registers and dispatches subscribers. Subscribers load from the configured directories and run
-* on a programmatic or framework-event publish. Accessed via `core.bus`. Do not construct it directly.
-*/
-var Bus = class extends TypedEventEmitter {
-	core;
-	logger = new Logger("Subscribers");
-	isInitialized = false;
-	subscribersMap = /* @__PURE__ */ new Map();
-	executedOnceHandlers = /* @__PURE__ */ new Set();
-	webhookProbes = /* @__PURE__ */ new Map();
-	hmrHandler;
-	constructor(core) {
-		super();
-		this.core = core;
-		if (this.core.config.subscribers.path) {
-			if (!Envapter.isDevelopment && !Envapter.isTest) return;
-			this.hmrHandler = new HmrModuleHandler({
-				handlersDir: this.core.config.subscribers.path,
-				isHandler: this.isSubscriber.bind(this),
-				registerHandler: this.registerSubscriber.bind(this),
-				unregisterHandler: this.unregisterSubscriber.bind(this),
-				getArtifacts: this.getArtifacts.bind(this),
-				logger: this.logger
-			});
-		}
-	}
-	getArtifacts(ctor) {
-		return [Reflect.getMetadata(SubscribeMetadataKey, ctor).subscriber];
-	}
-	/** @internal */
-	async init() {
-		if (this.isInitialized) return;
-		this.isInitialized = true;
-		this.registerSubscriber(UnknownException);
-		this.registerSubscriber(HandledException);
-		const subscribersDir = this.core.config.subscribers.path;
-		if (subscribersDir) {
-			this.logger.info(chalk.bold(subscribersDir));
-			await this.loadSubscribers(subscribersDir);
-			const totalSubscribers = [...this.subscribersMap.values()].reduce((acc, handlers) => acc + handlers.length, 0);
-			this.logger.utils.list([`${chalk.bold.magenta(totalSubscribers)} subscribers`], chalk.bold.green("Loaded"));
-		}
-		if (!Envapter.isTest) await this.verifyWebhooks();
-	}
-	/** @internal Exposed for tests. */
-	async verifyWebhooks() {
-		const missing = [];
-		await Promise.all([...this.webhookProbes].map(async ([url, envKeys]) => {
-			const result = await WebhookLog.senderFor(url).verify();
-			if (result === "missing") missing.push(...envKeys);
-			else if (result === "unreachable") this.logger.warn(`could not verify webhook at ${paint.sky.bold(envKeys.join(", "))}`);
-		}));
-		if (missing.length > 0) throw new SeedcordError(SeedcordErrorCode.ConfigWebhookNotFound, [missing.join(", ")]);
-	}
-	/** @internal */
-	async onHmr(event) {
-		if (this.hmrHandler) await this.hmrHandler.handle(event);
-	}
-	async loadSubscribers(dir) {
-		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
-			for (const exportName of Object.keys(imported)) {
-				const val = imported[exportName];
-				if (this.isSubscriber(val)) {
-					this.registerSubscriber(val);
-					this.hmrHandler?.trackHandler(fullPath, val);
-					this.logger.utils.registration(val.name, relativePath);
-				}
-			}
-		}, this.logger);
-	}
-	registerSubscriber(handler) {
-		if (handler.prototype instanceof WebhookLog) {
-			const envKey = WebhookLog.envKeyOf(handler);
-			const url = WebhookLog.urlOf(envKey);
-			if (url === null) {
-				this.logger.warn(`${chalk.bold(handler.name)} disabled, ${paint.sky.bold(envKey)} is not set`);
-				return;
-			}
-			const envKeys = this.webhookProbes.get(url) ?? [];
-			if (!envKeys.includes(envKey)) envKeys.push(envKey);
-			this.webhookProbes.set(url, envKeys);
-		}
-		const options = Reflect.getMetadata(SubscribeMetadataKey, handler);
-		let handlers = this.subscribersMap.get(options.subscriber);
-		if (!handlers) {
-			handlers = [];
-			this.subscribersMap.set(options.subscriber, handlers);
-		}
-		handlers.push({
-			ctor: handler,
-			frequency: options.frequency ?? "on"
-		});
-	}
-	unregisterSubscriber(handler, artifacts) {
-		const subscribers = artifacts ?? [...this.subscribersMap.keys()];
-		for (const subscriber of subscribers) {
-			const handlers = this.subscribersMap.get(subscriber);
-			if (!handlers) continue;
-			const index = handlers.findIndex((entry) => entry.ctor === handler);
-			if (index !== -1) handlers.splice(index, 1);
-		}
-	}
-	isSubscriber(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof Subscriber && Reflect.hasMetadata(SubscribeMetadataKey, obj);
-	}
-	/**
-	* Publishes an event to its subscribers and native listeners.
-	*
-	* Fire-and-forget, so subscriber handlers run asynchronously and this returns before they
-	* complete, and callers must not assume side effects have landed. Errors thrown by a subscriber
-	* are caught and logged, never surfaced here. A `'once'` subscriber is marked as executed when
-	* it starts (even if it throws), so it never runs twice.
-	*
-	* @param event - The subscription key to publish
-	* @param data - Payload passed to each subscriber
-	* @returns Whether the underlying emitter had native listeners for the event
-	*/
-	publish(event, data) {
-		this.processSubscriber(event, data);
-		return super.emit(event, ...[data]);
-	}
-	async processSubscriber(subscriberName, data) {
-		const handlers = this.subscribersMap.get(subscriberName);
-		if (!handlers) return;
-		for (const entry of handlers) {
-			if (entry.frequency === "once" && this.executedOnceHandlers.has(entry.ctor)) continue;
-			try {
-				if (entry.frequency === "once") this.executedOnceHandlers.add(entry.ctor);
-				const Ctor = entry.ctor;
-				await new Ctor(data, this.core).execute();
-			} catch (err) {
-				this.logger.error(`Error in subscriber ${String(subscriberName)} handler ${entry.ctor.name}:`, err);
-			}
-		}
-	}
 };
+__decorate([Envapt("DISCORD_BOT_TOKEN", { converter: (raw) => validateDiscordToken(raw) })], Bot.prototype, "botToken", void 0);
 
 //#endregion
 //#region src/version.ts
 /** Package version */
-const version = "0.1.0-next.4";
+const version = "0.1.0-next.6";
 
 //#endregion
 //#region src/Seedcord.ts
@@ -3481,14 +2369,13 @@ var Seedcord = class Seedcord extends Pluggable {
 	version = version;
 	healthCheck;
 	hmrManager;
-	/** @see {@link CoordinatedShutdown} */
-	shutdown;
-	/** @see {@link CoordinatedStartup} */
-	startup;
 	/** @see {@link Bus} */
 	bus;
+	subscribers;
 	/** @see {@link Bot} */
 	bot;
+	/** The discord.js client's REST client. Its token is set during the Login phase. */
+	rest;
 	/** @see {@link IRateLimiter} */
 	rateLimiter;
 	/**
@@ -3496,18 +2383,16 @@ var Seedcord = class Seedcord extends Pluggable {
 	* @throws A **SeedcordError** When attempting to create multiple instances (singleton)
 	*/
 	constructor(config) {
-		const shutdown = new CoordinatedShutdown();
-		const startup = new CoordinatedStartup();
-		super(shutdown, startup);
+		super(new CoordinatedShutdown(), new CoordinatedStartup());
 		this.config = config;
 		installNodeDefaults(config.logger);
 		setBotColor(config.botColor);
-		this.shutdown = shutdown;
-		this.startup = startup;
 		this.hmrManager = new HmrManager();
 		this.hmrManager.init();
 		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(this.shutdown, config.healthCheck);
 		this.registerStartupTasks();
@@ -3516,31 +2401,24 @@ var Seedcord = class Seedcord extends Pluggable {
 	get username() {
 		return this.bot.client.user?.username;
 	}
-	pluginCapabilities() {
-		return {
-			client: this.bot.client,
-			token: this.bot.botToken,
-			rest: this.bot.client.rest
-		};
-	}
 	static reset() {
 		super.reset();
 		LoggerChannelRegistry.instance.reset();
 	}
 	registerStartupTasks() {
 		if (Envapter.isDevelopment || Envapter.isTest) this.registerHmrAwareModules();
-		this.startup.addTask(StartupPhase.Configuration, "Bus Initialization", async () => {
+		this.startup.addTask(StartupPhase.Configuration, "bus-initialization", async () => {
 			this.bus.logger.utils.initialization("Subscribers", "start");
-			await this.bus.init();
+			await this.subscribers.init();
 			this.bus.logger.utils.initialization("Subscribers", "end");
 		});
-		this.startup.addTask(StartupPhase.Login, "Bot Initialization", async () => {
+		this.startup.addTask(StartupPhase.Login, "bot-initialization", async () => {
 			this.bot.logger.utils.initialization("Bot", "start");
 			await this.bot.init();
 			this.bot.logger.utils.initialization("Bot", "end");
 		});
 		const { healthCheck } = this;
-		if (healthCheck) this.startup.addTask(StartupPhase.Ready, "Health Check", async () => {
+		if (healthCheck) this.startup.addTask(StartupPhase.Ready, "health-check", async () => {
 			healthCheck.logger.utils.initialization("HealthCheck", "start");
 			await healthCheck.init();
 			healthCheck.logger.utils.initialization("HealthCheck", "end");
@@ -3562,9 +2440,9 @@ var Seedcord = class Seedcord extends Pluggable {
 		return this;
 	}
 	registerHmrAwareModules() {
-		this.startup.addTask(StartupPhase.Configuration, "HMR Registration", async () => {
+		this.startup.addTask(StartupPhase.Configuration, "hmr-registration", async () => {
 			this.hmrManager.register(this.bot);
-			this.hmrManager.register(this.bus);
+			this.hmrManager.register(this.subscribers);
 			for (const plugin of this.plugins) this.hmrManager.register(plugin);
 			await Promise.resolve();
 		});
@@ -3572,5 +2450,5 @@ var Seedcord = class Seedcord extends Pluggable {
 };
 
 //#endregion
-export { ArraySource, AutocompleteHandler, ButtonHandler, CommandMentions, ContextMenuHandler, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, IgnoreBots, InteractionHandler, InteractionMiddleware, Middleware, MiddlewareType, ModalHandler, Nsfw, Paginator, RegisterEvent, RepliableHandler, Seedcord, SelectMenuHandler, SlashHandler, Subscribe, Subscriber, WebhookLog, WebhookUrl, checkBotPermissions, checkPermissions, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, getConfirmation, hasPermsToAssign, updateMemberRoles, version };
+export { ArraySource, AutocompleteHandler, ButtonHandler, ContextMenuHandler, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, IgnoreBots, InteractionHandler, InteractionMiddleware, Middleware, MiddlewareType, ModalHandler, Nsfw, Paginator, Plugin, RegisterEvent, RepliableHandler, Seedcord, SelectMenuHandler, SlashHandler, Subscriber, WebhookLog, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
 //# sourceMappingURL=index.mjs.map