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

package/dist/index.cjs

@@ -27,27 +27,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 require("reflect-metadata");
-let _seedcord_core = require("@seedcord/core");
+let _seedcord_logger_node = require("@seedcord/logger/node");
 let _seedcord_core_internal = require("@seedcord/core/internal");
-let discord_js = require("discord.js");
 let _seedcord_errors = require("@seedcord/errors");
 let _seedcord_errors_internal = require("@seedcord/errors/internal");
-let _seedcord_utils = require("@seedcord/utils");
-let _seedcord_services = require("@seedcord/services");
-let chalk = require("chalk");
-chalk = __toESM(chalk, 1);
+let _seedcord_core = require("@seedcord/core");
+let _seedcord_logger = require("@seedcord/logger");
 let _discordjs_builders = require("@discordjs/builders");
 let _seedcord_utils_internal = require("@seedcord/utils/internal");
+let discord_js = require("discord.js");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto, 1);
 let _seedcord_event_emitter = require("@seedcord/event-emitter");
-let node_fs = require("node:fs");
-let node_path = require("node:path");
-let node_url = require("node:url");
+let chalk = require("chalk");
+chalk = __toESM(chalk, 1);
+let envapt = require("envapt");
+let discord_api_types_v10 = require("discord-api-types/v10");
+let _seedcord_utils = require("@seedcord/utils");
+let _discordjs_rest = require("@discordjs/rest");
+let _seedcord_core_node = require("@seedcord/core/node");
 let _seedcord_rate_limiter = require("@seedcord/rate-limiter");
 let _seedcord_types_internal = require("@seedcord/types/internal");
-let envapt = require("envapt");
-let node_crypto = require("node:crypto");
-node_crypto = __toESM(node_crypto, 1);
+let envapt_legacy = require("envapt/legacy");
+let node_path = require("node:path");
+let _seedcord_core_hmr = require("@seedcord/core/hmr");
+let _seedcord_utils_node = require("@seedcord/utils/node");
 
+//#region src/logger-bootstrap.ts
+(0, _seedcord_logger_node.installNodeDefaults)();
+
+//#endregion
 //#region src/bot/decorators/Events.ts
 /**
 * Registers an event handler class with one or more Discord.js events.
@@ -140,190 +149,6 @@ function Gated(...gates) {
 	};
 }
 
-//#endregion
-//#region src/miscellaneous/areRoutes.ts
-/**
-* Checks if the provided value is an array of strings.
-*
-* @internal
-*/
-function areRoutes(routes) {
-	return Array.isArray(routes) && routes.every((r) => typeof r === "string");
-}
-
-//#endregion
-//#region src/bot/decorators/Interactions.ts
-/**
-* Types of select menus supported for routing
-*/
-let SelectMenuKind = /* @__PURE__ */ function(SelectMenuKind) {
-	SelectMenuKind["String"] = "string";
-	SelectMenuKind["User"] = "user";
-	SelectMenuKind["Role"] = "role";
-	SelectMenuKind["Channel"] = "channel";
-	SelectMenuKind["Mentionable"] = "mentionable";
-	return SelectMenuKind;
-}({});
-/**
-* Routes one or more slash commands to a {@link SlashHandler}.
-*
-* Pass the same route string(s) as the handler's generic. A single command reads `this.options`, several
-* commands branch with `this.match`. The decorator routes and the generic must match exactly, so listing
-* fewer or more than the handler declares is a compile error. Subcommands use a slash path.
-*
-* @param routes - The route string(s) this handler serves, e.g. `'ban'`, `'ban', 'kick'`, or `'demo/setup'`.
-* @decorator
-* @example
-* ```ts
-* \@SlashRoute('ban')
-* class BanHandler extends SlashHandler<'ban'> {
-*     async execute() {
-*         const target = this.options.getUser('target');
-*     }
-* }
-* ```
-*
-* @example
-* ```ts
-* \@SlashRoute('ban', 'kick')
-* class ModerationHandler extends SlashHandler<'ban' | 'kick'> {
-*     async execute() {
-*         await this.match({ ban: (o) => o.getUser('target'), kick: (o) => o.getUser('member') });
-*     }
-* }
-* ```
-*/
-function SlashRoute(...routes) {
-	return function(constructor) {
-		storeMetadata(_seedcord_core_internal.InteractionRoutes.Slash, routes, constructor);
-	};
-}
-/**
-* Routes button interactions to handler classes.
-*
-* Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
-* generic. Passing different definitions to the decorator and the generic is a compile error. Routing
-* matches the stable prefix, so a wire minted from an older shape still reaches the handler, where
-* reading this.params throws StaleCustomId and the controller boundary turns it into a reply.
-*
-* @param defs - The customId definition(s) this handler decodes, one per route.
-* @decorator
-*/
-function ButtonRoute(...defs) {
-	return function(constructor) {
-		storeComponentRoute(_seedcord_core_internal.InteractionRoutes.Button, defs, constructor);
-	};
-}
-/**
-* Routes modal submissions to handler classes.
-*
-* Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
-* generic. Passing different definitions to the decorator and the generic is a compile error. Routing
-* matches the stable prefix, so an older-shape wire still reaches the handler and throws StaleCustomId
-* on read, the same as a button route.
-*
-* @param defs - The customId definition(s) this handler decodes, one per route.
-* @decorator
-*/
-function ModalRoute(...defs) {
-	return function(constructor) {
-		storeComponentRoute(_seedcord_core_internal.InteractionRoutes.Modal, defs, constructor);
-	};
-}
-/**
-* Routes one or more context-menu commands to a {@link ContextMenuHandler}.
-*
-* Pass the kind (`ApplicationCommandType.User` or `ApplicationCommandType.Message`) and the command name(s),
-* each checked against that kind's registry, so a typo is a compile error. The same kind must sit on the
-* handler's generic, cross-checked both directions. Context menus carry no options, so a multi-name handler
-* reads `this.target` uniformly with no branch.
-*
-* @param kind - The context-menu kind, `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
-* @param names - The command name(s) this handler serves, keyed off the matching registry.
-* @decorator
-* @example
-* ```ts
-* \@ContextMenuRoute(ApplicationCommandType.User, 'View Profile')
-* class ViewProfile extends ContextMenuHandler<ApplicationCommandType.User> {
-*     async execute() {
-*         const user = this.target;
-*     }
-* }
-* ```
-*/
-function ContextMenuRoute(kind, ...names) {
-	return function(constructor) {
-		storeMetadata(kind === discord_js.ApplicationCommandType.User ? _seedcord_core_internal.InteractionRoutes.UserContextMenu : _seedcord_core_internal.InteractionRoutes.MessageContextMenu, names, constructor);
-	};
-}
-/**
-* Routes one or more commands' autocomplete to an {@link AutocompleteHandler}.
-*
-* Pass the same command route string(s) as the handler's generic. One command branches with `this.match`
-* over its autocompletable fields, several commands share one handler whose arms span every command's
-* fields. The decorator routes and the generic must match exactly, so listing fewer or more than the
-* handler declares is a compile error.
-*
-* @param routes - The command route string(s) this handler serves, e.g. `'search'` or `'search', 'find'`.
-* @decorator
-* @example
-* ```ts
-* \@AutocompleteRoute('search')
-* class SearchAutocomplete extends AutocompleteHandler<'search'> {
-*     async execute() {
-*         await this.match({ query: (value, respond) => respond([{ name: value, value }]) });
-*     }
-* }
-* ```
-*/
-function AutocompleteRoute(...routes) {
-	return function(constructor) {
-		storeMetadata(_seedcord_core_internal.InteractionRoutes.Autocomplete, routes, constructor);
-	};
-}
-/**
-* Routes select menu interactions to handler classes.
-*
-* Pass the select kind and the {@link CustomId} definition(s) this handler decodes. The handler's
-* generic must list the same definitions, and its second generic argument must be the matching select
-* interaction type, or it is a compile error.
-*
-* @param type - Select menu kind from {@link SelectMenuKind}.
-* @param defs - The customId definition(s) this handler decodes, one per route.
-* @decorator
-*
-* @example
-* ```typescript
-* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
-* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
-*   // handles user select menus minted from AssignId
-* }
-* ```
-*/
-function SelectMenuRoute(type, ...defs) {
-	return function(constructor) {
-		storeComponentRoute({
-			["string"]: _seedcord_core_internal.InteractionRoutes.StringMenu,
-			["user"]: _seedcord_core_internal.InteractionRoutes.UserMenu,
-			["role"]: _seedcord_core_internal.InteractionRoutes.RoleMenu,
-			["channel"]: _seedcord_core_internal.InteractionRoutes.ChannelMenu,
-			["mentionable"]: _seedcord_core_internal.InteractionRoutes.MentionableMenu
-		}[type], defs, constructor);
-	};
-}
-function storeComponentRoute(route, defs, constructor) {
-	storeMetadata(route, defs.map((def) => def.prefix), constructor);
-	Reflect.defineMetadata(_seedcord_core_internal.ComponentDefsKey, defs, constructor);
-}
-function storeMetadata(route, routes, constructor) {
-	const key = _seedcord_core_internal.InteractionRouteKeys[route];
-	const savedRoutes = Reflect.getMetadata(key, constructor);
-	const existing = areRoutes(savedRoutes) ? savedRoutes : [];
-	const toStore = Array.isArray(routes) ? routes : [routes];
-	Reflect.defineMetadata(key, [...existing, ...toStore], constructor);
-	Reflect.defineMetadata(_seedcord_core_internal.InteractionMetadataKey, true, constructor);
-}
-
 //#endregion
 //#region src/bot/decorators/Middlewares.ts
 /**
@@ -392,21 +217,6 @@ const IgnoreBots = (0, _seedcord_core.defineGate)("IgnoreBots", (ctx) => {
 	if (ctx.user?.bot) throw new _seedcord_core.Silence("actor is a bot");
 });
 
-//#endregion
-//#region src/bot/notices/utils.ts
-function mentionFor(subject) {
-	if (subject instanceof discord_js.Role) return `<@&${subject.id}>`;
-	if (subject instanceof discord_js.TextChannel) return `<#${subject.id}>`;
-	if (subject instanceof discord_js.GuildMember) return `<@${subject.id}>`;
-	return `\`${subject.name}\``;
-}
-function labelFor(subject) {
-	if (subject instanceof discord_js.Role) return "role";
-	if (subject instanceof discord_js.TextChannel) return "channel";
-	if (subject instanceof discord_js.GuildMember) return "member";
-	return "guild";
-}
-
 //#endregion
 //#region src/bot/notices/index.ts
 var NotNsfw = class extends _seedcord_core_internal.GateNotice {
@@ -414,13 +224,6 @@ var NotNsfw = class extends _seedcord_core_internal.GateNotice {
 		super(message);
 	}
 };
-var MissingRole = class extends _seedcord_core_internal.GateNotice {
-	role;
-	constructor(message, role) {
-		super(message ?? (role ? `You need the ${role.name} role to use this.` : "You do not have the required role."));
-		this.role = role;
-	}
-};
 var RoleHigherThanMe = class extends _seedcord_core.Notice {
 	role;
 	botRole;
@@ -441,30 +244,19 @@ var CannotAssignBotRole = class extends _seedcord_core.Notice {
 		return { components: [new _seedcord_core_internal.NoticeCard("I cannot assign a managed role.").component] };
 	}
 };
-var MissingPermissions = class extends _seedcord_core.Notice {
-	where;
-	missingPerms;
-	constructor(message, where, missingPerms) {
-		super(message);
-		this.where = where;
-		this.missingPerms = missingPerms;
-	}
-	render() {
-		const bullets = this.missingPerms.map((perm) => `• ${perm}`).join("\n");
-		return { components: [new _seedcord_core_internal.NoticeCard(`The ${labelFor(this.where)} ${mentionFor(this.where)} is missing the following permission entries:\n\n${bullets}`).component] };
-	}
-};
 var HasDangerousPermissions = class extends _seedcord_core.Notice {
-	target;
+	subject;
 	dangerousPerms;
-	constructor(message, target, dangerousPerms) {
-		super(message);
-		this.target = target;
+	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 _seedcord_core_internal.NoticeCard(`The ${labelFor(this.target)} ${mentionFor(this.target)} has the following permission entries that must not be enabled:\n\n${bullets}`).component] };
+		return { components: [new _seedcord_core_internal.NoticeCard(`${this.customLead ?? `${this.subject} has the following permission entries that must not be enabled:`}\n\n${bullets}`).component] };
 	}
 };
 var UserNotFound = class extends _seedcord_core.Notice {
@@ -540,129 +332,6 @@ function Nsfw(options) {
 	});
 }
 
-//#endregion
-//#region src/bot/utilities/permissions/checkPermissions.ts
-/**
-* Map of permission bits to their prettified human readable names.
-*/
-const PermissionNames = new Map(Object.entries(discord_js.PermissionFlagsBits).map(([key, bit]) => [bit, (0, _seedcord_utils.prettify)(key)]));
-function checkPermissions(a, b, c, d, e) {
-	const { for: pFor, in: pIn, scope, inverse = false, missing: missingCtor, dangerous: dangerousCtor } = a instanceof discord_js.Role || a instanceof discord_js.GuildMember ? {
-		for: a,
-		in: b,
-		scope: c,
-		inverse: d ?? false,
-		...e
-	} : a;
-	const Missing = missingCtor ?? MissingPermissions;
-	const Dangerous = dangerousCtor ?? HasDangerousPermissions;
-	const perms = pIn instanceof discord_js.Guild ? pFor.permissions : pIn.permissionsFor(pFor, true);
-	const names = (bits) => bits.map((bit) => PermissionNames.get(bit) ?? String(bit));
-	const present = scope.filter((bit) => perms.has(bit, true));
-	const presentNames = names(present);
-	if (inverse) {
-		if (present.length > 0) throw new Dangerous(`${pFor instanceof discord_js.Role ? "Role" : "Member"} has dangerous permissions in this ${pIn instanceof discord_js.Guild ? "guild" : "channel"}`, pFor, presentNames);
-		return;
-	}
-	const missingBits = scope.filter((bit) => !perms.has(bit, true));
-	if (missingBits.length > 0) throw new Missing("Missing Any/All/No Permissions", pFor, names(missingBits));
-}
-
-//#endregion
-//#region src/bot/gates/catalog/permissions.ts
-const UNCACHED_MEMBER = "Your server member data could not be resolved. Try again.";
-/**
-* Requires the caller to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
-*
-* Interaction-only and excludes ModalSubmit, since a modal lacks a reliable cached caller member.
-*
-* @param scope - The permission flag bits the caller must all hold.
-* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
-*
-* @see {@link Gated}
-*
-* @example
-* ```ts
-* import { PermissionFlagsBits } from 'discord.js';
-*
-* \@Gated(RequirePermissions([PermissionFlagsBits.BanMembers]))
-* \@SlashRoute('ban')
-* class BanHandler extends SlashHandler<'ban'> {
-*     async execute() {
-*         const target = this.options.getUser('target');
-*     }
-* }
-* ```
-*/
-function RequirePermissions(scope, options) {
-	return (0, _seedcord_core.defineGate)("RequirePermissions", (ctx) => {
-		if (!ctx.guild) throw (0, _seedcord_core_internal.pickNotice)(options?.notInGuild, (message) => new _seedcord_core_internal.NotInGuild(message));
-		if (!ctx.member) throw (0, _seedcord_core_internal.pickNotice)(options?.notInGuild, (message) => new _seedcord_core_internal.NotInGuild(message ?? UNCACHED_MEMBER));
-		checkPermissions(ctx.member, ctx.guild, scope, false, options?.missing ? { missing: options.missing } : void 0);
-	});
-}
-/**
-* Requires the bot to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
-*
-* It reads the bot's own member, so it attaches to modal handlers as well.
-*
-* @param scope - The permission flag bits the bot must all hold.
-* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
-*
-* @see {@link Gated}
-*
-* @example
-* ```ts
-* import { PermissionFlagsBits } from 'discord.js';
-*
-* \@Gated(RequireBotPermissions([PermissionFlagsBits.BanMembers]))
-* \@ModalRoute(MyModalId)
-* class MyModalHandler extends ModalHandler<[typeof MyModalId]> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-function RequireBotPermissions(scope, options) {
-	return (0, _seedcord_core.defineGate)("RequireBotPermissions", (ctx) => {
-		const botMember = ctx.guild?.members.me;
-		if (!ctx.guild || !botMember) throw (0, _seedcord_core_internal.pickNotice)(options?.notInGuild, (message) => new _seedcord_core_internal.NotInGuild(message));
-		checkPermissions(botMember, ctx.guild, scope, false, options?.missing ? { missing: options.missing } : void 0);
-	});
-}
-/**
-* Requires the caller to have `roleId`, read from the member's role cache. Refuses outside a guild first, then
-* when the role is missing.
-*
-* Interaction-only and excludes ModalSubmit.
-*
-* @param roleId - The role snowflake the caller must hold, read from the member's role cache.
-* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-role one with `missingRole`.
-*
-* @see {@link Gated}
-*
-* @example
-* ```ts
-* \@Gated(RequireRole('123456789012345678'))
-* \@SlashRoute('vip')
-* class VipHandler extends SlashHandler<'vip'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-function RequireRole(roleId, options) {
-	return (0, _seedcord_core.defineGate)("RequireRole", (ctx) => {
-		if (!ctx.guild) throw (0, _seedcord_core_internal.pickNotice)(options?.notInGuild, (message) => new _seedcord_core_internal.NotInGuild(message));
-		if (!ctx.member) throw (0, _seedcord_core_internal.pickNotice)(options?.notInGuild, (message) => new _seedcord_core_internal.NotInGuild(message ?? UNCACHED_MEMBER));
-		if (ctx.member.roles.cache.has(roleId)) return;
-		const role = ctx.guild.roles.cache.get(roleId) ?? null;
-		throw (0, _seedcord_core_internal.pickNotice)(options?.missingRole, (message) => new MissingRole(message, role));
-	});
-}
-
 //#endregion
 //#region src/bot/injectors/EmojiInjector.ts
 const emojiStorage = {};
@@ -684,14 +353,14 @@ const Emojis = emojiStorage;
 */
 var EmojiInjector = class {
 	core;
-	logger = new _seedcord_services.Logger("Emojis");
+	logger = new _seedcord_logger.Logger("Emojis");
 	constructor(core) {
 		this.core = core;
 	}
 	async init() {
 		this.clearEmojis();
 		if (!this.core.config.bot.emojis || Object.keys(this.core.config.bot.emojis).length === 0) {
-			this.logger.debug(chalk.default.bold.yellow("No emojis configured, skipping emoji injection."));
+			this.logger.debug("No emojis configured, skipping emoji injection.");
 			return;
 		}
 		const configEmojis = this.core.config.bot.emojis;
@@ -759,7 +428,7 @@ const MULTI_GUILD = Symbol("seedcord:commandmentions:multi-guild");
 */
 var CommandMentionInjector = class {
 	core;
-	logger = new _seedcord_services.Logger("CommandMentions");
+	logger = new _seedcord_logger.Logger("CommandMentions");
 	constructor(core) {
 		this.core = core;
 	}
@@ -851,6 +520,37 @@ async function fetchText(client, channelId) {
 	throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
 }
 
+//#endregion
+//#region src/bot/notices/utils.ts
+function mentionFor(subject) {
+	if (subject instanceof discord_js.Role) return `<@&${subject.id}>`;
+	return `<@${subject.id}>`;
+}
+
+//#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 discord_js.Role || a instanceof discord_js.GuildMember ? {
+		for: a,
+		in: b,
+		scope: c,
+		inverse: d ?? false,
+		...e
+	} : a;
+	const Missing = missingCtor ?? _seedcord_core_internal.MissingPermissions;
+	const Dangerous = dangerousCtor ?? HasDangerousPermissions;
+	const subject = mentionFor(pFor);
+	const perms = pIn instanceof discord_js.Guild ? pFor.permissions : pIn.permissionsFor(pFor, true);
+	const names = (bits) => bits.map((bit) => _seedcord_core_internal.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));
+}
+
 //#endregion
 //#region src/bot/utilities/permissions/checkBotPermissions.ts
 /**
@@ -878,17 +578,17 @@ function checkBotPermissions(target, scope, inverse = false, errors) {
 	if (target instanceof discord_js.Guild) {
 		const me = target.members.me;
 		if (!me) {
-			const names = scope.map((bit) => PermissionNames.get(bit) ?? String(bit));
-			throw new ((errors?.missing) ?? MissingPermissions)("Missing Permissions", target, names);
+			const names = scope.map((bit) => _seedcord_core_internal.PermissionNames.get(bit) ?? String(bit));
+			throw new ((errors?.missingNotice) ?? _seedcord_core_internal.MissingPermissions)(void 0, "The bot", names);
 		}
 		checkPermissions(me, target, scope, inverse, errors);
 		return;
 	}
 	const me = target.guild.members.me;
 	if (!me) {
-		new _seedcord_services.Logger("checkBotPermissions").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?.missing) ?? MissingPermissions)("Missing Permissions", target, names);
+		new _seedcord_logger.Logger("checkBotPermissions").warn(`Bot member is unavailable in guild ${target.guild.id} while checking permissions in channel ${target.id}`);
+		const names = scope.map((bit) => _seedcord_core_internal.PermissionNames.get(bit) ?? String(bit));
+		throw new ((errors?.missingNotice) ?? _seedcord_core_internal.MissingPermissions)(void 0, "The bot", names);
 	}
 	checkPermissions(me, target, scope, inverse, errors);
 }
@@ -925,26 +625,26 @@ function getBotRole(guild) {
 * // Check with custom error handling
 * hasPermsToAssign({
 *   targetRole: role,
-*   errors: {
-*     higher: CustomHigherError,
-*     managed: CustomManagedError,
-*     missing: CustomMissingPermissionsError
+*   noticeOverrides: {
+*     higherNotice: CustomHigherNotice,
+*     managedNotice: CustomManagedNotice,
+*     missingNotice: CustomMissingPermissionsNotice
 *   }
 * });
 * ```
 */
 function hasPermsToAssign(roleOrOptions) {
-	const { targetRole, errors } = roleOrOptions instanceof discord_js.Role ? {
+	const { targetRole, noticeOverrides: errors } = roleOrOptions instanceof discord_js.Role ? {
 		targetRole: roleOrOptions,
-		errors: void 0
+		noticeOverrides: void 0
 	} : roleOrOptions;
-	const HigherErr = errors?.higher ?? RoleHigherThanMe;
-	const ManagedErr = errors?.managed ?? CannotAssignBotRole;
-	const Missing = errors?.missing ?? MissingPermissions;
+	const HigherNotice = errors?.higherNotice ?? RoleHigherThanMe;
+	const ManagedNotice = errors?.managedNotice ?? CannotAssignBotRole;
+	const MissingNotice = errors?.missingNotice ?? _seedcord_core_internal.MissingPermissions;
 	const botRole = getBotRole(targetRole.guild);
-	if (targetRole.comparePositionTo(botRole) >= 0) throw new HigherErr("Role is higher than me", targetRole, botRole);
-	if (targetRole.managed) throw new ManagedErr(`Cannot assign managed role ${targetRole.name}`);
-	checkBotPermissions(targetRole.guild, [discord_js.PermissionFlagsBits.ManageRoles], false, { missing: Missing });
+	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, [discord_js.PermissionFlagsBits.ManageRoles], false, { missingNotice: MissingNotice });
 }
 
 //#endregion
@@ -1072,114 +772,309 @@ async function updateMemberRoles(rolesToAdd, rolesToRemove, member) {
 }
 
 //#endregion
-//#region src/bot/harmlessApiCodes.ts
-/**
-* Discord API error codes that mean a dead end on an interaction, a dead token, a double ack, or a gone
-* message. There is nothing to show the user and no bug to report. The controller boundary drops them on
-* the original throw, and {@link ReplySender} drops them on its own send.
-*
-* @internal
-*/
-const HARMLESS_API_CODES = new Set([
-	discord_js.RESTJSONErrorCodes.UnknownInteraction,
-	discord_js.RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
-	discord_js.RESTJSONErrorCodes.UnknownMessage
-]);
-
-//#endregion
-//#region src/miscellaneous/flagsFor.ts
+//#region src/bot/ReplySender.ts
+function seedState(interaction) {
+	if (interaction.deferred && interaction.ephemeral === null) return "deferred-update";
+	if (interaction.replied) return "replied";
+	if (interaction.deferred) return "deferred-reply";
+	return "unacked";
+}
 /**
-* Builds the `flags` bitfield for a framework reply. Every framework reply is ComponentsV2, so the
-* IsComponentsV2 flag is always set.
-*
-* @param ephemeral - Whether the reply is ephemeral.
-* @returns The OR'd `MessageFlags` value as a plain number.
-*
-* @internal
+* Writes interaction responses through the discord.js interaction. Construction is internal to the repliable
+* handler bases and the dispatcher.
 */
-function flagsFor(ephemeral) {
-	let flags = discord_js.MessageFlags.IsComponentsV2;
-	if (ephemeral) flags |= discord_js.MessageFlags.Ephemeral;
-	return flags;
-}
-
-//#endregion
-//#region src/bot/ReplySender.ts
-/**
-* Sends a {@link ReplyResponse} to an interaction, picking reply, editReply, or followUp from the live
-* acknowledgement state. Logs and drops its own send failures so a dead token never escapes into the
-* controller.
-*/
-var ReplySender = class {
+var ReplySender = class extends _seedcord_core_internal.BaseReplySender {
 	interaction;
-	logger = new _seedcord_services.Logger("ReplySender");
-	constructor(interaction) {
+	constructor(interaction, routeId) {
+		super(routeId, seedState(interaction));
 		this.interaction = interaction;
 	}
-	/**
-	* Sends the reply and returns the sent message so a caller can attach a collector to it. Never throws,
-	* a failed send is logged and dropped and resolves to `undefined`.
-	*
-	* @param response - The ComponentsV2 reply to show.
-	* @param ephemeral - Whether the reply is ephemeral. {@default `true`}
-	* @returns The sent {@link Message}, or `undefined` when the send was swallowed.
-	*/
-	async send(response, ephemeral = true) {
-		try {
-			return await this.dispatch(response, ephemeral);
-		} catch (error) {
-			this.logSwallowed("send", error);
-			return;
-		}
+	async writeReply(response, opts) {
+		const result = await this.interaction.reply({
+			...this.replyOptions(response, (0, _seedcord_core_internal.sendFlags)(opts)),
+			withResponse: true
+		});
+		return this.createdMessage(result);
 	}
-	/**
-	* Edits an already-sent message to a new {@link ReplyResponse}. Used to swap a confirmation prompt for
-	* its outcome. Never throws, a failed edit is logged and dropped.
-	*
-	* @param message - The message to edit (the handle a prior {@link send} returned).
-	* @param response - The reply to replace it with.
-	*/
-	async edit(message, response) {
-		try {
-			await this.interaction.webhook.editMessage(message, this.editBody(response));
-		} catch (error) {
-			this.logSwallowed("edit", error);
-		}
+	async writeDefer(opts) {
+		await this.interaction.deferReply({ flags: (0, _seedcord_core_internal.deferFlags)(opts) });
 	}
-	async dispatch(response, ephemeral) {
-		if (this.interaction.replied) return await this.interaction.followUp(this.replyOptions(response, ephemeral));
-		if (this.interaction.deferred) {
-			if (this.interaction.ephemeral === null) return await this.interaction.followUp(this.replyOptions(response, ephemeral));
-			return await this.interaction.editReply(this.editBody(response));
-		}
-		await this.interaction.reply(this.replyOptions(response, ephemeral));
-		return await this.interaction.fetchReply();
+	async writeDeferUpdate() {
+		await this.sourceInteraction("deferUpdate").deferUpdate();
+	}
+	async writeUpdate(response) {
+		const result = await this.sourceInteraction("update").update({
+			...this.updateOptions(response),
+			withResponse: true
+		});
+		return this.createdMessage(result);
+	}
+	async writeFollowUp(response, opts) {
+		return await this.interaction.followUp(this.replyOptions(response, (0, _seedcord_core_internal.sendFlags)(opts)));
+	}
+	async writeEditOriginal(response) {
+		return await this.interaction.editReply(this.editOptions(response));
+	}
+	async writeEditTarget(targetId, response) {
+		return await this.interaction.webhook.editMessage(targetId, this.editOptions(response));
+	}
+	async writeDeleteOriginal() {
+		await this.interaction.deleteReply();
 	}
-	replyOptions(response, ephemeral) {
+	async writeDeleteTarget(targetId) {
+		await this.interaction.deleteReply(targetId);
+	}
+	async writeModal(data) {
+		const { interaction } = this;
+		if (interaction.isModalSubmit()) this.rejectModalSubmit();
+		await interaction.showModal(data);
+	}
+	guardModalSource() {
+		if (this.interaction.isModalSubmit()) this.rejectModalSubmit();
+	}
+	rejectModalSubmit() {
+		throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyIllegalAckState, [
+			"showModal",
+			"this interaction is a modal submit",
+			"A modal cannot open another modal.",
+			this.routeId
+		]);
+	}
+	sourceInteraction(method) {
+		const { interaction } = this;
+		if (interaction.isMessageComponent()) return interaction;
+		if (interaction.isModalSubmit() && interaction.isFromMessage()) return interaction;
+		throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
+	}
+	replyOptions(response, flags) {
+		const reply = this.serialize(response);
 		return {
-			components: response.components,
-			flags: flagsFor(ephemeral),
-			...response.allowedMentions && { allowedMentions: response.allowedMentions },
-			...response.files && { files: response.files }
+			components: reply.components,
+			flags,
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: [...reply.files] }
 		};
 	}
-	editBody(response) {
+	editOptions(response) {
+		const reply = this.serialize(response);
 		return {
-			components: response.components,
+			components: reply.components,
 			flags: discord_js.MessageFlags.IsComponentsV2,
-			...response.allowedMentions && { allowedMentions: response.allowedMentions },
-			...response.files && { files: response.files }
+			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
+			...reply.files && { files: [...reply.files] }
 		};
 	}
-	logSwallowed(action, error) {
-		if (error instanceof discord_js.DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
-			this.logger.debug(`reply ${action} hit harmless code ${error.code}`);
-			return;
-		}
-		this.logger.error(`reply ${action} failed`, error);
+	updateOptions(response) {
+		const reply = this.serialize(response);
+		return {
+			components: reply.components,
+			flags: discord_js.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 (0, _seedcord_utils_internal.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 _seedcord_logger.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 = node_crypto.randomUUID();
+	const developerUsername = core.config.notifications?.developerUsername;
+	const ctx = developerUsername === void 0 ? { uuid } : {
+		uuid,
+		developerUsername
+	};
+	if (error instanceof _seedcord_core.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 _seedcord_core.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 _seedcord_core.Notice ? error.name : error instanceof discord_js.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 (0, _seedcord_core_internal.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";
@@ -1224,9 +1119,9 @@ async function collectChoice(message, userId, timeoutMs) {
 		return null;
 	}
 }
-async function settle(sender, interaction, message, outcome) {
+async function settle(sender, message, outcome) {
 	if (outcome === void 0) {
-		await interaction.deleteReply(message).catch(() => void 0);
+		await sender.delete(message).catch(() => void 0);
 		return;
 	}
 	await sender.edit(message, typeof outcome === "function" ? await outcome() : outcome);
@@ -1234,30 +1129,19 @@ async function settle(sender, interaction, message, 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);
-	const message = await sender.send(response, ephemeral);
-	if (!message) return false;
+	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, interaction, message, options?.onTimeout);
+		await settle(sender, message, options?.onTimeout);
 		return false;
 	}
 	await winner.deferUpdate().catch(() => void 0);
 	const confirmed = winner.customId === CONFIRM_IDS.confirm;
-	await settle(sender, interaction, message, confirmed ? options?.onConfirm : options?.onCancel);
+	await settle(sender, message, confirmed ? options?.onConfirm : options?.onCancel);
 	return confirmed;
 }
 
-//#endregion
-//#region src/hmr/devChannel.ts
-let channel;
-function setDevChannel(next) {
-	channel = next;
-}
-function getDevChannel() {
-	return channel;
-}
-
 //#endregion
 //#region src/interfaces/Plugin.ts
 /**
@@ -1285,7 +1169,7 @@ var Plugin = class extends _seedcord_event_emitter.TypedEventEmitter {
 	* @param patterns - Glob patterns relative to the project root
 	*/
 	registerCriticalFiles(patterns) {
-		getDevChannel()?.send("seedcord:register-critical-files", { patterns });
+		(0, _seedcord_core_internal.getDevChannel)()?.send("seedcord:register-critical-files", { patterns });
 	}
 	/** @internal */
 	removeListener(event, listener) {
@@ -1367,19 +1251,10 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 //#endregion
 //#region src/handlers/BaseHandler.ts
 /**
-* Base class for a Discord event or interaction handler. Don't register handlers directly, use the more specific handler subclasses.
+* The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
+* gate hook.
 */
-var BaseHandler = class {
-	core;
-	event;
-	logger;
-	dispatch;
-	constructor(event, core, dispatch) {
-		this.core = core;
-		this.event = event;
-		this.logger = new _seedcord_services.Logger(this.constructor.name);
-		this.dispatch = dispatch;
-	}
+var BaseHandler = class extends _seedcord_core.BaseHandler {
 	/** @internal */
 	getEvent() {
 		return this.event;
@@ -1403,36 +1278,49 @@ var InteractionMiddleware = class extends BaseHandler {
 };
 
 //#endregion
-//#region src/handlers/interaction/InteractionHandler.ts
+//#region src/handlers/RepliableHandler.ts
 /**
-* Shared base the typed interaction handlers extend.
+* Shared base the repliable interaction handlers extend.
 *
-* Not a public entry point. You should be using {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
-* or {@link SelectMenuHandler} instead. This class only carries the repliable-event plumbing those bases share,
-* so DO NOT use it directly.
+* Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+* {@link SelectMenuHandler}, or {@link ContextMenuHandler} instead. This class binds the core reply base
+* to the gateway sender.
 *
-* @typeParam Repliable - The interaction type this handler processes
+* @typeParam Event - The repliable interaction type this handler processes
 */
-var InteractionHandler = class extends BaseHandler {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
+var RepliableHandler = class extends _seedcord_core.RepliableHandler {
+	/** @internal */
+	getEvent() {
+		return this.event;
+	}
+	buildSender(event, _core, routeId) {
+		return new ReplySender(event, routeId);
 	}
 };
 
 //#endregion
-//#region src/bot/utilities/miscellaneous/slashRouteOf.ts
+//#region src/handlers/interaction/InteractionHandler.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.
+* Shared base the typed interaction handlers extend.
 *
-* @internal
+* Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+* or {@link SelectMenuHandler} instead. This class adds `showModal` on top of the reply members those bases
+* share.
+*
+* @typeParam Repliable - The interaction type this handler processes
 */
-function slashRouteOf(interaction) {
-	const group = interaction.options.getSubcommandGroup(false) ?? void 0;
-	const subcommand = interaction.options.getSubcommand(false) ?? void 0;
-	return (0, _seedcord_utils_internal.buildSlashRoute)(interaction.commandName, subcommand, group);
-}
+var InteractionHandler = class extends RepliableHandler {
+	constructor(event, core, dispatch) {
+		super(event, core, dispatch);
+	}
+	/**
+	* Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
+	* compile time (Discord forbids a modal in response to a modal).
+	*/
+	showModal(modal) {
+		return this.sender.showModal(modal);
+	}
+};
 
 //#endregion
 //#region src/handlers/interaction/SlashHandler.ts
@@ -1468,7 +1356,7 @@ var SlashHandler = class extends InteractionHandler {
 	}
 	/**
 	* Run the arm for whichever command fired. Use this only when the handler is registered for several
-	* routes. A single-route handler reads `this.options` directly instead, match buys nothing there.
+	* routes.
 	*
 	* Provide one arm per registered route, keyed by its route string, and each arm receives that route's
 	* own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
@@ -1492,7 +1380,7 @@ var SlashHandler = class extends InteractionHandler {
 	*/
 	async match(arms) {
 		const route = slashRouteOf(this.event);
-		const arm = arms[route];
+		const arm = Object.hasOwn(arms, route) ? arms[route] : void 0;
 		if (!arm) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.SlashMatchArmMissing, [route]);
 		return await arm(this.options);
 	}
@@ -1563,11 +1451,11 @@ var AutocompleteHandler = class extends BaseHandler {
 	constructor(event, core, dispatch) {
 		super(event, core, dispatch);
 	}
+	decodedFocused;
 	/**
 	* The focused option for this interaction. `value` is always the raw partial string the user is typing,
 	* even for an integer or number option, so coerce it yourself when you need a number.
 	*/
-	decodedFocused;
 	get focused() {
 		if (this.decodedFocused) return this.decodedFocused;
 		const raw = this.event.options.getFocused(true);
@@ -1583,7 +1471,7 @@ var AutocompleteHandler = class extends BaseHandler {
 	* match is how you read it. There is no single-field shortcut the way slash/component handlers have one.
 	*
 	* Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
-	* arm receives the focused partial value and a `respond` pinned to that field's choice value type. The
+	* arm receives the focused partial value and a `respond` typed to that field's choice value. The
 	* arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
 	* focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
 	*
@@ -1605,11 +1493,15 @@ var AutocompleteHandler = class extends BaseHandler {
 	*/
 	async match(arms) {
 		const { name, value } = this.focused;
-		const respond = (choices) => this.event.respond(choices);
-		const arm = arms[name];
+		const respond = (choices) => this.respond(choices);
+		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
 		if (!arm) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.AutocompleteMatchArmMissing, [name]);
 		return await arm(value, respond);
 	}
+	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
+	async respond(choices) {
+		await this.event.respond(choices);
+	}
 	/** The firing command route, for a field whose completion differs per registered command. */
 	get route() {
 		return slashRouteOf(this.event);
@@ -1617,7 +1509,7 @@ var AutocompleteHandler = class extends BaseHandler {
 	/**
 	* The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
 	* (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
-	* types the focused field. Read the focused field from `this.focused`, not here.
+	* types the focused field. The focused field is on `this.focused`.
 	*/
 	get options() {
 		return this.event.options;
@@ -1629,25 +1521,25 @@ var AutocompleteHandler = class extends BaseHandler {
 /**
 * Shared base the customId-routed component handlers extend.
 *
-* Not a public entry point. You should be using {@link ButtonHandler}, {@link SelectMenuHandler}, or
-* {@link ModalHandler} instead. This class only carries the customId decode and route-matching plumbing
-* those bases share, so DO NOT use it directly.
+* Not a public entry point. Extend {@link ButtonHandler}, {@link SelectMenuHandler}, or {@link ModalHandler}
+* instead. This class defines the customId decode and the route matching those bases share.
 *
 * @typeParam Event - The component interaction type this handler processes
 * @typeParam Defs - The customId route definitions registered on the concrete handler
 */
 var ComponentHandler = class extends InteractionHandler {
-	get registeredDefs() {
-		const defs = Reflect.getMetadata(_seedcord_core_internal.ComponentDefsKey, this.constructor);
-		if (!defs) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CustomIdHandlerRouteMissing, [this.constructor.name]);
-		return defs;
+	/** Rewrite the source message this component interaction came from. */
+	update(response) {
+		return this.sender.update(response);
+	}
+	/** Acknowledge the component without changing the source message. */
+	deferUpdate() {
+		return this.sender.deferUpdate();
 	}
 	decoded;
 	get route() {
-		if (this.decoded) return this.decoded;
-		const decoded = (0, _seedcord_core_internal.decodeFor)(this.registeredDefs, this.event.customId);
-		this.decoded = decoded;
-		return decoded;
+		this.decoded ??= (0, _seedcord_core_internal.decodeComponentRoute)(this.constructor, this.event.customId);
+		return this.decoded;
 	}
 	/**
 	* The decoded params of the single route this handler is registered for.
@@ -1666,10 +1558,11 @@ var ComponentHandler = class extends InteractionHandler {
 	* handler `this.params` is `never`, so match is the only way to read the decoded params.
 	*
 	* Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
-	* decoded params. The arms must cover every registered def, a missing prefix or an unknown key is a
-	* compile error. Decoding runs before any arm, so a stale or corrupt wire throws before an arm body executes.
+	* decoded params. The arms cover every registered route prefix, checked at compile time, and a prefix
+	* unmatched at runtime throws `CustomIdMatchArmMissing`. Decoding runs before any arm, so a stale or
+	* corrupt wire throws before an arm body executes.
 	*
-	* @param arms - One handler per registered route, keyed by prefix.
+	* @param arms - One callback per registered route, keyed by prefix.
 	* @returns The result of the arm that ran.
 	*
 	* @example
@@ -1678,8 +1571,8 @@ var ComponentHandler = class extends InteractionHandler {
 	* class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
 	*     async execute() {
 	*         await this.match({
-	*             approve: ({ userId }) => this.event.reply(`approved <@${userId}>`),
-	*             reject: ({ userId }) => this.event.reply(`rejected <@${userId}>`)
+	*             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
+	*             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
 	*         });
 	*     }
 	* }
@@ -1687,7 +1580,7 @@ var ComponentHandler = class extends InteractionHandler {
 	*/
 	async match(arms) {
 		const { prefix, params } = this.route;
-		const arm = arms[prefix];
+		const arm = Object.hasOwn(arms, prefix) ? arms[prefix] : void 0;
 		if (!arm) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CustomIdMatchArmMissing, [prefix]);
 		return await arm(params);
 	}
@@ -1699,8 +1592,9 @@ var ComponentHandler = class extends InteractionHandler {
 * Base class for a button interaction handler.
 *
 * Register the customId definitions this handler decodes with `@ButtonRoute`, list the same ones in the
-* generic, then read `this.params` for a single route or `this.match` for several. Passing different
-* definitions to the decorator and the generic is a compile error.
+* generic, then read `this.params` for a single route or `this.match` for several. Reply through the handler
+* members, or rewrite the source message with `this.update`. Passing different definitions to the decorator
+* and the generic is a compile error.
 *
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ApproveId]`.
 * @typeParam Cache - The interaction cache state, `'cached'` by default.
@@ -1711,7 +1605,7 @@ var ComponentHandler = class extends InteractionHandler {
 * class ApproveButton extends ButtonHandler<[typeof ApproveId]> {
 *     async execute() {
 *         const { userId } = this.params;
-*         await this.event.reply(`approved <@${userId}>`);
+*         await this.reply(`approved <@${userId}>`);
 *     }
 * }
 * ```
@@ -1725,7 +1619,8 @@ var ButtonHandler = class extends ComponentHandler {};
 *
 * Register the customId definitions this handler decodes with `@ModalRoute`, list the same ones in the
 * generic, then read `this.params` for a single route or `this.match` for several. Read the submitted
-* inputs from `this.event.fields`.
+* inputs from `this.event.fields`, and reply through the handler members. Discord forbids opening a modal in
+* response to a modal, so `showModal` fails compilation on this kind.
 *
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
 * @typeParam Cache - The interaction cache state, `'cached'` by default.
@@ -1737,7 +1632,7 @@ var ButtonHandler = class extends ComponentHandler {};
 *     async execute() {
 *         const { guildId } = this.params;
 *         const name = this.event.fields.getTextInputValue('name');
-*         await this.event.reply(`saved ${name} for ${guildId}`);
+*         await this.reply(`saved ${name} for ${guildId}`);
 *     }
 * }
 * ```
@@ -1751,7 +1646,8 @@ var ModalHandler = class extends ComponentHandler {};
 *
 * Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
 * so `this.event` and `this.event.values` are narrowed to that kind. Read `this.params` for a single
-* route or `this.match` for several.
+* route or `this.match` for several, and reply through the handler members or rewrite the source message
+* with `this.update`.
 *
 * @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
@@ -1763,7 +1659,7 @@ var ModalHandler = class extends ComponentHandler {};
 * class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
 *     async execute() {
 *         const { roleId } = this.params;
-*         await this.event.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
+*         await this.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
 *     }
 * }
 * ```
@@ -2029,16 +1925,16 @@ var Paginator = class {
 		const loadPage = (ctx, n) => this.page(ctx, n);
 		this.Handler = class Nav extends ButtonHandler {
 			async execute() {
-				await this.event.deferUpdate();
+				await this.deferUpdate();
 				const response = await loadPage(contextOf(this.event, this.core), this.params.page);
-				await new ReplySender(this.event).edit(this.event.message, response);
+				await this.update(response);
 			}
 		};
 	}
 	/** 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).send(response, this.config.ephemeral ?? false);
+		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) {
@@ -2120,7 +2016,7 @@ var Subscriber = class {
 	constructor(data, core) {
 		this.data = data;
 		this.core = core;
-		this.logger = new _seedcord_services.Logger(this.constructor.name);
+		this.logger = new _seedcord_logger.Logger(this.constructor.name);
 	}
 };
 
@@ -2163,183 +2059,183 @@ function Subscribe(subscriber, options) {
 }
 
 //#endregion
-//#region src/subscribers/bases/WebhookLog.ts
+//#region src/subscribers/decorators/WebhookUrl.ts
 /**
-* Abstract webhook logging handler for subscriber events.
+* Declares the environment variable a {@link WebhookLog} reporter reads its webhook url from.
 *
-* Extends Subscriber to provide webhook-based logging capabilities.
-* Implementations must define the webhook client to send messages to by implementing the webhook property.
+* An unset variable disables the reporter with a boot warning. A set but malformed value throws
+* at boot.
 *
-* @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+* @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] };
+*   }
+* }
+* ```
 */
-var WebhookLog = class extends Subscriber {
-	constructor(data, core) {
-		super(data, core);
+function WebhookUrl(envKey) {
+	return function(constructor) {
+		Reflect.defineMetadata(_seedcord_core_internal.WebhookUrlMetadataKey, envKey, constructor);
+	};
+}
+
+//#endregion
+//#region src/miscellaneous/flagsFor.ts
+/** @internal */
+function flagsFor(ephemeral) {
+	let flags = discord_api_types_v10.MessageFlags.IsComponentsV2;
+	if (ephemeral) flags |= discord_api_types_v10.MessageFlags.Ephemeral;
+	return flags;
+}
+
+//#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 = (0, _seedcord_utils.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((0, _seedcord_utils.stripAnsi)(report));
+	return stripped.length > 1800 ? `${stripped.slice(0, 1799)}…` : stripped;
+}
+var WebhookSeparator = class extends _seedcord_core.BuilderComponent {
+	constructor() {
+		super("separator");
+		this.instance.setSpacing(discord_api_types_v10.SeparatorSpacingSize.Small).setDivider(true);
 	}
 };
 
 //#endregion
-//#region src/hmr/HmrModuleHandler.ts
+//#region src/subscribers/bases/WebhookSender.ts
+const HTTP_NOT_FOUND = 404;
+const HTTP_UNAUTHORIZED = 401;
 /**
-* Reloads THandler and optional TMiddleware modules on HMR updates.
-*
-* You can either implement a custom `onHmr()` method in your class by extending `HmrAware`, or if it's a plugin, override the existing `onHmr()` with fully custom logic. Or, use this class's `handle()` method inside your `onHmr()` to get standard HMR handling for your modules based on the provided options you give to the constructor.
+* Sends component messages to a Discord webhook through `@discordjs/rest`.
 *
-* This is only useful during development.
+* @throws A `SeedcordError` when the url does not carry a webhook id and token.
 */
-var HmrModuleHandler = class {
-	store;
-	options;
-	constructor(options) {
-		this.options = {
-			...options,
-			logger: options.logger.inChannel("hmr")
-		};
-		this.store = {
-			fileToHandlers: /* @__PURE__ */ new Map(),
-			fileToMiddlewares: /* @__PURE__ */ new Map(),
-			handlerArtifacts: /* @__PURE__ */ new Map()
-		};
+var WebhookSender = class {
+	rest = new _discordjs_rest.REST();
+	route;
+	constructor(url) {
+		const match = /\/webhooks\/(\d+)\/([\w$-]+)$/.exec(url);
+		if (!match?.[1] || !match[2]) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigWebhookUrlInvalid, ["The url"]);
+		this.route = discord_api_types_v10.Routes.webhook(match[1], match[2]);
 	}
 	/**
-	* Handles an HMR update event by reloading affected modules based on the event details and config. It receives an {@link HmrUpdateEvent}, then checks the type of update.
-	*
-	* - If it's a deletion, it unloads the module.
-	* - If it's an update/creation, it checks if the file is tracked, unloads it if so, then reloads the file if it is in the handlers or middlewares directory and is a valid handler/middleware.
+	* Fetches the webhook object, sending no message. Returns `missing` on a 404 or 401 from
+	* Discord and `unreachable` on any other failure.
 	*/
-	async handle(event) {
-		const { file, affectedModules, type } = event;
-		const { logger, handlersDir, middlewaresDir } = this.options;
-		if (type === "delete" || type === "deleteDir") {
-			this.unload(file);
-			return;
-		}
-		if (type === "update" && !(0, node_fs.existsSync)(file)) {
-			if (this.isTracked(file)) {
-				logger.info(`Received update for non-existent file: ${(0, _seedcord_utils.formatFilePath)(file)}, treating as delete`);
-				this.unload(file);
-			}
-			return;
-		}
-		const rollbackEnabled = event.rollback ?? true;
-		const filesToReload = affectedModules && affectedModules.length > 0 ? affectedModules : [file];
-		const absHandlersDir = (0, node_path.resolve)(process.cwd(), handlersDir);
-		const absMiddlewaresDir = middlewaresDir ? (0, node_path.resolve)(process.cwd(), middlewaresDir) : null;
-		for (const fileToReload of filesToReload) {
-			const isHandler = fileToReload.startsWith(absHandlersDir);
-			const isMiddleware = absMiddlewaresDir ? fileToReload.startsWith(absMiddlewaresDir) : false;
-			if (!isHandler && !isMiddleware) continue;
-			await this.reloadWithRollback(fileToReload, rollbackEnabled);
-		}
-	}
-	async reloadWithRollback(file, rollbackEnabled) {
-		const { logger } = this.options;
-		const snapshot = this.snapshotUnits(file);
-		this.unload(file);
-		if (await this.reloadFile(file)) return;
-		this.unload(file);
-		if (!rollbackEnabled) return;
-		this.restoreUnits(file, snapshot);
-		logger.warn(`${chalk.default.yellow.bold("Rolled back")} ${chalk.default.gray((0, _seedcord_utils.formatFilePath)(file))} to the last-good version`);
-	}
-	/**
-	* Tracks a handler module as being loaded from a specific file.
-	* @param file - The file path the handler was loaded from.
-	* @param handler - The handler module instance.
-	*/
-	trackHandler(file, handler) {
-		let set = this.store.fileToHandlers.get(file);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			this.store.fileToHandlers.set(file, set);
-		}
-		set.add(handler);
-		if (this.options.getArtifacts) {
-			const artifacts = this.options.getArtifacts(handler);
-			this.store.handlerArtifacts.set(handler, artifacts);
+	async verify() {
+		try {
+			await this.rest.get(this.route, { auth: false });
+			return "ok";
+		} catch (error) {
+			return error instanceof _discordjs_rest.DiscordAPIError && (error.status === HTTP_NOT_FOUND || error.status === HTTP_UNAUTHORIZED) ? "missing" : "unreachable";
 		}
 	}
-	/**
-	* Tracks a middleware module as being loaded from a specific file.
-	* @param file - The file path the middleware was loaded from.
-	* @param middleware - The middleware module instance.
-	*/
-	trackMiddleware(file, middleware) {
-		let set = this.store.fileToMiddlewares.get(file);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			this.store.fileToMiddlewares.set(file, set);
-		}
-		set.add(middleware);
-	}
-	isTracked(file) {
-		return this.store.fileToHandlers.has(file) || this.store.fileToMiddlewares.has(file);
-	}
-	unload(file) {
-		const { logger } = this.options;
-		const handlers = this.store.fileToHandlers.get(file);
-		if (handlers) {
-			for (const handler of handlers) {
-				const artifacts = this.store.handlerArtifacts.get(handler);
-				this.options.unregisterHandler(handler, artifacts);
-				this.store.handlerArtifacts.delete(handler);
-				const name = handler.name ?? "Handler";
-				logger.info(`${chalk.default.red.bold("Unloaded")} ${chalk.default.cyan.bold(name)} from ${chalk.default.gray((0, _seedcord_utils.formatFilePath)(file))}`);
-			}
-			this.store.fileToHandlers.delete(file);
-		}
-		const middlewares = this.store.fileToMiddlewares.get(file);
-		if (middlewares) {
-			for (const middleware of middlewares) {
-				this.options.unregisterMiddleware?.(middleware);
-				const name = middleware.name ?? "Middleware";
-				logger.info(`${chalk.default.red.bold("Unloaded")} ${chalk.default.cyan.bold(name)} from ${chalk.default.gray((0, _seedcord_utils.formatFilePath)(file))}`);
-			}
-			this.store.fileToMiddlewares.delete(file);
-		}
+	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
+			})) }
+		});
 	}
-	async reloadFile(file) {
-		const { logger, isHandler, isMiddleware, registerHandler, registerMiddleware } = this.options;
-		if (!(0, node_fs.existsSync)(file)) {
-			logger.info(`File does not exist, skipping reload: ${(0, _seedcord_utils.formatFilePath)(file)}`);
-			return false;
+};
+
+//#endregion
+//#region src/subscribers/bases/WebhookLog.ts
+/**
+* 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.
+*
+* @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.default.bold(this.constructor.name)} has no webhook url set, this reporter is disabled`);
+			return;
 		}
+		const { username, components, files } = await this.report();
 		try {
-			let fileUrl = (0, node_url.pathToFileURL)(file).href;
-			if (process.env.VITEST === "true") fileUrl += `?update=${Date.now()}`;
-			const imported = await import(fileUrl);
-			for (const val of Object.values(imported)) if (isHandler(val)) {
-				registerHandler(val, file);
-				this.trackHandler(file, val);
-				const name = val.name ?? "Handler";
-				logger.info(`${chalk.default.blue.bold("Reloaded")} ${chalk.default.cyan.bold(name)} from ${chalk.default.gray((0, _seedcord_utils.formatFilePath)(file))}`);
-			} else if (isMiddleware && registerMiddleware && isMiddleware(val)) {
-				registerMiddleware(val, file);
-				this.trackMiddleware(file, val);
-				const name = val.name ?? "Middleware";
-				logger.info(`${chalk.default.blue.bold("Reloaded")} ${chalk.default.cyan.bold(name)} from ${chalk.default.gray((0, _seedcord_utils.formatFilePath)(file))}`);
-			}
-			return true;
+			await WebhookLog.senderFor(url).send({
+				flags: flagsFor(false),
+				username: username ?? this.constructor.name,
+				components,
+				files
+			});
 		} catch (error) {
-			logger.error(`Failed to reload file: ${file}`, error);
-			return false;
+			this.logger.error("Failed to send webhook report", error);
 		}
 	}
-	snapshotUnits(file) {
-		return {
-			handlers: [...this.store.fileToHandlers.get(file) ?? []],
-			middlewares: [...this.store.fileToMiddlewares.get(file) ?? []]
-		};
-	}
-	restoreUnits(file, snapshot) {
-		for (const handler of snapshot.handlers) {
-			this.options.registerHandler(handler, file);
-			this.trackHandler(file, handler);
-		}
-		if (this.options.registerMiddleware) for (const middleware of snapshot.middlewares) {
-			this.options.registerMiddleware(middleware, file);
-			this.trackMiddleware(file, middleware);
+	/** @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(_seedcord_core_internal.WebhookUrlMetadataKey, ctor);
+		if (!envKey) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.DecoratorWebhookUrlMissing, [ctor.name]);
+		return envKey;
+	}
+	/** @internal Returns null when the env var is unset, throws when set but malformed. */
+	static urlOf(envKey) {
+		if (!envapt.Envapter.has(envKey)) return null;
+		const raw = envapt.Envapter.getRequired(envKey, envapt.Converters.String).trim();
+		if (raw === "") return null;
+		if (!isDiscordWebhookUrl(raw)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigWebhookUrlInvalid, [envKey]);
+		return raw;
 	}
 };
 
@@ -2398,11 +2294,13 @@ var CommandRegistry = class {
 	core;
 	onDeployed;
 	name = "Commands";
-	logger = new _seedcord_services.Logger("Commands");
+	logger = new _seedcord_logger.Logger("Commands");
 	isInitialised = false;
 	globalCommands = [];
 	guildCommands = new discord_js.Collection();
 	ctorToCommand = /* @__PURE__ */ new Map();
+	loading = false;
+	loadedCommands = [];
 	hmrHandler;
 	pendingEvents = /* @__PURE__ */ new Map();
 	constructor(core, onDeployed) {
@@ -2411,7 +2309,7 @@ var CommandRegistry = class {
 		const commandsDir = this.core.config.bot.commands.path;
 		if (!commandsDir) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
 		if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
-		this.hmrHandler = new HmrModuleHandler({
+		this.hmrHandler = new _seedcord_core_hmr.HmrModuleHandler({
 			handlersDir: commandsDir,
 			isHandler: this.isCommandClass.bind(this),
 			registerHandler: this.registerCommand.bind(this),
@@ -2429,15 +2327,32 @@ var CommandRegistry = class {
 		this.isInitialised = true;
 		const commandsDir = this.core.config.bot.commands.path;
 		if (!commandsDir) return;
-		this.logger.info(chalk.default.bold(commandsDir));
-		await this.loadCommands(commandsDir);
-		this.logger.utils.summary("Loaded commands", {
+		this.loading = true;
+		this.loadedCommands.length = 0;
+		try {
+			await this.loadCommands(commandsDir);
+		} finally {
+			this.loading = false;
+		}
+		this.reportLoad();
+		(0, _seedcord_core_internal.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
 		});
-		getDevChannel()?.on("seedcord:refresh-commands", (data) => {
-			this.refresh(data.shouldRefresh);
-		});
+		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) {
@@ -2457,11 +2372,11 @@ var CommandRegistry = class {
 		if (commandsDir && event.file.startsWith((0, node_path.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) => (0, _seedcord_utils.formatFilePath)(f)) });
+			(0, _seedcord_core_internal.getDevChannel)()?.send("seedcord:commands-update-prompt", { files: [...this.pendingEvents.keys()].map((f) => (0, _seedcord_utils.formatFilePath)(f)) });
 		} else await this.hmrHandler?.handle(event);
 	}
 	async loadCommands(dir) {
-		await (0, _seedcord_utils.traverseDirectory)(dir, (fullPath, rel, mod) => {
+		await (0, _seedcord_utils_node.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);
@@ -2476,25 +2391,27 @@ var CommandRegistry = class {
 		const meta = Reflect.getMetadata(_seedcord_core_internal.CommandMetadataKey, ctor);
 		if (!meta) return;
 		const comp = new ctor().component;
-		const commandType = comp instanceof _discordjs_builders.SlashCommandBuilder ? "slash command" : "context menu command";
-		if (meta.scope === "global") {
-			this.globalCommands.push(comp);
-			this.logger.utils.registration(ctor.name, rel);
-			this.logger.utils.item(`Global ${commandType}: ${chalk.default.bold.cyan(comp.name)}`);
-		} else {
-			for (const g of meta.guilds) {
-				const arr = this.guildCommands.get(g) ?? [];
-				arr.push(comp);
-				this.guildCommands.set(g, arr);
-			}
-			this.logger.utils.registration(ctor.name, rel);
-			this.logger.utils.item(`Guild ${commandType}: ${chalk.default.bold.cyan(comp.name)} for ${chalk.default.magenta.bold(meta.guilds.length)} guild(s)`);
+		const kind = comp instanceof _discordjs_builders.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: (0, _seedcord_utils.formatFilePath)(rel),
+				kind
+			});
+			return;
+		}
+		this.logger.utils.registration(comp.name, rel, `${meta.scope} ${kind}`);
 	}
 	unregisterCommand(ctor, artifacts) {
 		const info = artifacts ?? this.ctorToCommand.get(ctor);
@@ -2521,8 +2438,7 @@ var CommandRegistry = class {
 			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.summary("Configured global", { [tag]: this.globalCommands.length });
-			this.logger.utils.item(`${this.globalCommands.map((command) => chalk.default.bold.cyan(command.name)).join(", ")}`);
+			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);
@@ -2533,269 +2449,101 @@ var CommandRegistry = class {
 			const deployed = await guild.commands.set(commands);
 			result.guilds.set(guildId, deployed);
 			const tag = commands.length === 1 ? "command" : "commands";
-			this.logger.utils.summary(`Configured commands for ${chalk.default.bold.yellow(guild.name)}`, { [tag]: commands.length });
-			this.logger.utils.item(`${commands.map((command) => chalk.default.bold.cyan(command.name)).join(", ")}`);
-		}
-		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());
-	}
-};
-
-//#endregion
-//#region src/miscellaneous/deriveEventActor.ts
-function deriveEventActor(args) {
-	const tuple = Array.isArray(args) ? args : [args];
-	for (const arg of tuple) {
-		if (arg instanceof discord_js.Message) return {
-			guild: arg.guild,
-			member: arg.member,
-			user: arg.author,
-			channelId: arg.channelId
-		};
-		if (arg instanceof discord_js.GuildMember) return {
-			guild: arg.guild,
-			member: arg,
-			user: arg.user,
-			channelId: null
-		};
-		if (arg instanceof discord_js.User) return {
-			guild: null,
-			member: null,
-			user: arg,
-			channelId: null
-		};
-	}
-	return {
-		guild: null,
-		member: null,
-		user: null,
-		channelId: null
-	};
-}
-
-//#endregion
-//#region src/bot/gates/runGates.ts
-function interactionGateContext(interaction, core) {
-	const rawMember = interaction.member;
-	const memberRoleIds = rawMember instanceof discord_js.GuildMember ? [...rawMember.roles.cache.keys()].filter((id) => id !== interaction.guildId) : rawMember?.roles ?? [];
-	return {
-		kind: "interaction",
-		interaction,
-		core,
-		user: interaction.user,
-		guild: interaction.guild,
-		member: rawMember instanceof discord_js.GuildMember ? rawMember : null,
-		userId: interaction.user.id,
-		guildId: interaction.guildId,
-		channelId: interaction.channelId,
-		memberRoleIds,
-		memberPermissions: interaction.memberPermissions?.bitfield ?? null,
-		routeId: null
-	};
-}
-function eventGateContext(eventName, args, core) {
-	const actor = deriveEventActor(args);
-	return {
-		kind: "event",
-		core,
-		eventName,
-		payload: args,
-		user: actor.user,
-		guild: actor.guild,
-		member: actor.member,
-		userId: actor.user?.id ?? null,
-		guildId: actor.guild?.id ?? null,
-		channelId: actor.channelId,
-		memberRoleIds: actor.member ? [...actor.member.roles.cache.keys()].filter((id) => id !== actor.guild?.id) : [],
-		memberPermissions: actor.member?.permissions.bitfield ?? null,
-		routeId: null
-	};
-}
-
-//#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 _seedcord_services.Logger("ErrorsHandling");
-/**
-* The single throttle for every fault publish, so a recurring fault reports once per window across both
-* the interaction and event paths. Exported so tests reset it between cases.
-*
-* @internal
-*/
-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.
-*
-* @internal
-*/
-function extractErrorResponse(error, core, origin) {
-	const uuid = node_crypto.randomUUID();
-	const developerUsername = core.config.notifications?.developerUsername;
-	const ctx = developerUsername === void 0 ? { uuid } : {
-		uuid,
-		developerUsername
-	};
-	if (error instanceof _seedcord_core.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 _seedcord_core.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,
-			guild: origin.guild,
-			user: origin.user,
-			metadata: metadataFor(origin)
-		});
-	});
-}
-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}`);
-		core.bus.publish("unknownException", {
-			uuid,
-			error,
-			guild: origin.guild,
-			user: origin.user,
-			metadata: metadataFor(origin)
-		});
-	});
-}
-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) {
+			this.logger.utils.block(`Deployed ${commands.length} ${tag} to ${_seedcord_logger.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());
+	}
+};
+
+//#endregion
+//#region src/miscellaneous/deriveEventActor.ts
+function deriveEventActor(args) {
+	const tuple = Array.isArray(args) ? args : [args];
+	for (const arg of tuple) {
+		if (arg instanceof discord_js.Message) return {
+			guild: arg.guild,
+			member: arg.member,
+			user: arg.author,
+			channelId: arg.channelId
+		};
+		if (arg instanceof discord_js.GuildMember) return {
+			guild: arg.guild,
+			member: arg,
+			user: arg.user,
+			channelId: null
+		};
+		if (arg instanceof discord_js.User) return {
+			guild: null,
+			member: null,
+			user: arg,
+			channelId: null
+		};
+	}
 	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
+		guild: null,
+		member: null,
+		user: null,
+		channelId: null
 	};
 }
-function faultKey(origin, error) {
-	const name = error instanceof _seedcord_core.Notice ? error.name : error instanceof discord_js.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 (0, _seedcord_core_internal.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;
+
+//#endregion
+//#region src/bot/gates/runGates.ts
+function interactionGateContext(interaction, core) {
+	const rawMember = interaction.member;
+	const memberRoleIds = rawMember instanceof discord_js.GuildMember ? [...rawMember.roles.cache.keys()].filter((id) => id !== interaction.guildId) : rawMember?.roles ?? [];
 	return {
 		kind: "interaction",
-		interactionKind: interactionKind(interaction),
-		command,
-		customId,
+		interaction,
+		core,
+		user: interaction.user,
+		guild: interaction.guild,
+		member: rawMember instanceof discord_js.GuildMember ? rawMember : null,
 		userId: interaction.user.id,
 		guildId: interaction.guildId,
 		channelId: interaction.channelId,
-		interactionId: interaction.id,
-		raw: interaction
+		memberRoleIds,
+		memberPermissions: interaction.memberPermissions?.bitfield ?? null,
+		appPermissions: interaction.appPermissions.bitfield,
+		memberGuildPermissions: rawMember instanceof discord_js.GuildMember ? rawMember.permissions.bitfield : null,
+		appGuildPermissions: interaction.guild?.members.me?.permissions.bitfield ?? null,
+		routeId: null
 	};
 }
-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";
+function eventGateContext(eventName, args, core) {
+	const actor = deriveEventActor(args);
+	return {
+		kind: "event",
+		core,
+		eventName,
+		payload: args,
+		user: actor.user,
+		guild: actor.guild,
+		member: actor.member,
+		userId: actor.user?.id ?? null,
+		guildId: actor.guild?.id ?? null,
+		channelId: actor.channelId,
+		memberRoleIds: actor.member ? [...actor.member.roles.cache.keys()].filter((id) => id !== actor.guild?.id) : [],
+		memberPermissions: actor.member?.permissions.bitfield ?? null,
+		appPermissions: null,
+		memberGuildPermissions: actor.member?.permissions.bitfield ?? null,
+		appGuildPermissions: actor.guild?.members.me?.permissions.bitfield ?? null,
+		routeId: null
+	};
 }
 
 //#endregion
 //#region src/bot/handleEventFault.ts
-const logger$1 = new _seedcord_services.Logger("EventBoundary");
+const logger$1 = new _seedcord_logger.Logger("EventBoundary");
 /**
 * 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
@@ -2805,7 +2553,7 @@ const logger$1 = new _seedcord_services.Logger("EventBoundary");
 */
 function handleEventFault(caught, eventName, handlerName, args, core) {
 	if (caught instanceof _seedcord_core.Silence) {
-		if (caught.reason !== void 0) logger$1.debug(`Silence: ${caught.reason}`);
+		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger$1.debug(`Silence: ${caught.reason}`);
 		return;
 	}
 	if (!Error.isError(caught)) throw caught;
@@ -2839,20 +2587,23 @@ function handleEventFault(caught, eventName, handlerName, args, core) {
 */
 var EventDispatcher = class {
 	core;
-	logger = new _seedcord_services.Logger("Events");
+	logger = new _seedcord_logger.Logger("Events");
 	isInitialized = false;
 	name = "Events";
 	eventMap = /* @__PURE__ */ new Map();
 	middlewares = [];
 	executedOnceHandlers = /* @__PURE__ */ new Set();
 	attachedEvents = /* @__PURE__ */ new Set();
+	loading = false;
+	loadedHandlers = [];
+	loadedMiddlewares = [];
 	hmrHandler;
 	constructor(core) {
 		this.core = core;
 		const eventsDir = this.core.config.bot.events.path;
 		if (!eventsDir) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreControllerPathMissing, ["EventDispatcher", "events"]);
 		if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
-		this.hmrHandler = new HmrModuleHandler({
+		this.hmrHandler = new _seedcord_core_hmr.HmrModuleHandler({
 			handlersDir: eventsDir,
 			...(0, _seedcord_utils.hasKeys)(this.core.config.bot.events, ["middlewares"]) && { middlewaresDir: this.core.config.bot.events.middlewares },
 			isHandler: this.isEventHandlerClass.bind(this),
@@ -2875,23 +2626,32 @@ var EventDispatcher = class {
 		this.isInitialized = true;
 		const handlersDir = this.core.config.bot.events.path;
 		if (!handlersDir) return;
-		this.logger.info(chalk.default.bold(handlersDir));
 		const middlewareDir = (0, _seedcord_utils.hasKeys)(this.core.config.bot.events, ["middlewares"]) ? this.core.config.bot.events.middlewares : void 0;
-		if (middlewareDir) {
-			this.logger.info(`${chalk.default.bold(middlewareDir)} ${chalk.default.gray("(middlewares)")}`);
-			await this.loadMiddlewares(middlewareDir);
+		this.loading = true;
+		this.loadedHandlers.length = 0;
+		this.loadedMiddlewares.length = 0;
+		try {
+			if (middlewareDir) await this.loadMiddlewares(middlewareDir);
+			await this.loadHandlers(handlersDir);
+		} finally {
+			this.loading = false;
 		}
-		await this.loadHandlers(handlersDir);
 		this.attachToClient();
-		this.logger.info(`${chalk.default.bold.green("Loaded event handlers:")}`);
-		const eventList = [`${chalk.default.magenta.bold(this.middlewares.length)} middlewares`];
-		this.eventMap.forEach((handlers, eventName) => {
-			eventList.push(`${chalk.default.magenta.bold(handlers.length)} ${eventName}`);
+		this.reportLoad();
+	}
+	reportLoad() {
+		const { utils } = this.logger;
+		utils.summary("Loaded", {
+			"event handlers": this.loadedHandlers.length,
+			middlewares: this.loadedMiddlewares.length
 		});
-		this.logger.utils.list(eventList);
+		if (this.loadedMiddlewares.length > 0) utils.block("Loaded event middlewares", utils.entries(this.loadedMiddlewares));
+		const perEvent = {};
+		for (const [event, handlers] of this.eventMap) perEvent[event] = handlers.length;
+		utils.block("Loaded event handlers", [...utils.entries(this.loadedHandlers), ...utils.counts(perEvent)]);
 	}
 	async loadHandlers(dir) {
-		await (0, _seedcord_utils.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
 			for (const val of Object.values(imported)) {
 				if (!this.isEventHandlerClass(val)) continue;
 				this.registerHandler(val, relativePath);
@@ -2900,7 +2660,7 @@ var EventDispatcher = class {
 		}, this.logger);
 	}
 	async loadMiddlewares(dir) {
-		await (0, _seedcord_utils.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
 			for (const val of Object.values(imported)) {
 				if (!this.isMiddlewareClass(val)) continue;
 				this.registerMiddleware(val, relativePath);
@@ -2938,7 +2698,14 @@ var EventDispatcher = class {
 			...metadata.events && { events: metadata.events }
 		});
 		this.middlewares.sort((a, b) => a.priority - b.priority);
-		this.logger.utils.registration(`${middlewareCtor.name} ${chalk.default.gray(`(${metadata.priority})`)}`, relativePath, "event middleware");
+		if (this.loading) {
+			this.loadedMiddlewares.push({
+				name: `${middlewareCtor.name} (${metadata.priority})`,
+				from: (0, _seedcord_utils.formatFilePath)(relativePath)
+			});
+			return;
+		}
+		this.logger.utils.registration(`${middlewareCtor.name} ${_seedcord_logger.paint.mute(`(${metadata.priority})`)}`, relativePath, "event middleware");
 	}
 	async runMiddlewares(eventName, args) {
 		for (const { ctor, events } of this.middlewares) {
@@ -2976,10 +2743,15 @@ var EventDispatcher = class {
 		};
 		if (Array.isArray(raw)) for (const entry of raw) register(entry.event, entry.frequency);
 		else {
-			const names = areRoutes(raw) ? raw : typeof raw === "string" ? [raw] : [];
+			const names = (0, _seedcord_core_internal.areRoutes)(raw) ? raw : typeof raw === "string" ? [raw] : [];
 			for (const name of names) register(name, "on");
 		}
-		this.logger.utils.registration(handlerClass.name, relativePath);
+		const from = (0, _seedcord_utils.formatFilePath)(relativePath);
+		if (this.loading) this.loadedHandlers.push({
+			name: handlerClass.name,
+			from
+		});
+		else this.logger.utils.registration(handlerClass.name, from);
 	}
 	attachToClient() {
 		for (const [eventName] of this.eventMap) this.attachListener(eventName);
@@ -2988,12 +2760,12 @@ var EventDispatcher = class {
 		if (this.attachedEvents.has(eventName)) return;
 		this.attachedEvents.add(eventName);
 		const handlerEntries = this.eventMap.get(eventName);
-		this.logger.debug(`Attaching ${chalk.default.bold.green(eventName)} to the client with ${chalk.default.gray(handlerEntries?.length ?? 0)} handler(s)`);
+		this.logger.debug(`Attaching ${_seedcord_logger.paint.mint.bold(eventName)} to the client with ${_seedcord_logger.paint.mute(handlerEntries?.length ?? 0)} handler(s)`);
 		this.core.bot.client.on(eventName, (...args) => {
 			this.core.bot.emitSafe("any:event", eventName, ...args);
 			(async () => {
 				await this.processEvent(eventName, args).catch((err) => {
-					this.logger.error(`[${chalk.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+					this.logger.error(`[${_seedcord_logger.paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
 					this.core.bot.emit("error:unhandled:event", err);
 				});
 			})();
@@ -3015,7 +2787,7 @@ var EventDispatcher = class {
 	}
 	async processHandler(eventName, ctor, args) {
 		try {
-			this.logger.debug(`Processing ${chalk.default.bold.green(eventName)} with ${chalk.default.gray(ctor.name)}`);
+			this.logger.debug(`Processing ${_seedcord_logger.paint.mint.bold(eventName)} with ${_seedcord_logger.paint.mute(ctor.name)}`);
 			const handler = new ctor(args, this.core, eventName);
 			await (0, _seedcord_core_internal.runHandlerGates)(ctor, eventGateContext(eventName, args, this.core));
 			await handler.execute();
@@ -3026,35 +2798,55 @@ var EventDispatcher = class {
 };
 
 //#endregion
-//#region src/bot/defaults/UnhandledEvent.ts
+//#region src/bot/defaults/UnhandledRepliable.ts
 /**
-* Default handler for unhandled interactions. A reply failure here rides the controller boundary as a
-* raw fault, so it needs no decorator of its own.
-*
-* @internal
+* @internal Default handler for unhandled repliable interactions.
 */
-var UnhandledEvent = class extends InteractionHandler {
+var UnhandledRepliable = class extends InteractionHandler {
 	async execute() {
-		await this.event.reply({
-			content: `Feature not implemented yet.`,
-			flags: discord_js.MessageFlags.Ephemeral
-		});
+		await this.reply("Feature not implemented yet.");
+	}
+};
+
+//#endregion
+//#region src/bot/defaults/UnhandledAutocomplete.ts
+/**
+* @internal Default handler for an autocomplete with no registered handler.
+*/
+var UnhandledAutocomplete = class extends AutocompleteHandler {
+	async execute() {
+		await this.respond([]);
 	}
 };
 
+//#endregion
+//#region src/bot/harmlessApiCodes.ts
+/**
+* Discord API error codes that mean a dead end on an interaction, a dead token, a double ack, or a gone
+* message. Nothing to show the user and no bug to report, so the boundary's fault-card send drops them.
+*
+* @internal
+*/
+const HARMLESS_API_CODES = new Set([
+	discord_js.RESTJSONErrorCodes.UnknownInteraction,
+	discord_js.RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
+	discord_js.RESTJSONErrorCodes.UnknownMessage
+]);
+
 //#endregion
 //#region src/bot/handleInteractionFault.ts
-const logger = new _seedcord_services.Logger("InteractionBoundary");
+const logger = new _seedcord_logger.Logger("InteractionBoundary");
 /**
 * The interaction controller boundary. Sorts a throw from any handler-lifecycle phase into the right
-* user reply plus the right bus event, building a {@link ReplySender} lazily so it reads the live
-* acknowledgement state at catch time.
+* user reply plus the right bus event. When a handler is built its sender is passed in, so the boundary
+* sends from the current ack state. A middleware or pre-construction throw arrives with no sender, so the
+* boundary builds one from the interaction flags.
 *
 * @internal
 */
-async function handleInteractionFault(caught, interaction, core) {
+async function handleInteractionFault(caught, interaction, core, sender) {
 	if (caught instanceof _seedcord_core.Silence) {
-		if (caught.reason !== void 0) logger.debug(`Silence: ${caught.reason}`);
+		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger.debug(`Silence: ${caught.reason}`);
 		return;
 	}
 	if (!Error.isError(caught)) throw caught;
@@ -3078,7 +2870,18 @@ async function handleInteractionFault(caught, interaction, core) {
 		user: interaction.user,
 		metadata: interaction
 	});
-	await new ReplySender(interaction).send(response, caught instanceof _seedcord_core.Notice ? caught.ephemeral : true);
+	await sendGuarded(sender ?? new ReplySender(interaction, interactionRoute(interaction)), response, caught instanceof _seedcord_core.Notice ? caught.ephemeral : true);
+}
+async function sendGuarded(sender, response, ephemeral) {
+	try {
+		await sender.send(response, { ephemeral });
+	} catch (error) {
+		if (error instanceof discord_js.DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
+			logger.debug(`reply send hit harmless code ${error.code}`);
+			return;
+		}
+		logger.error("reply send failed", error);
+	}
 }
 
 //#endregion
@@ -3091,7 +2894,7 @@ async function handleInteractionFault(caught, interaction, core) {
 */
 var InteractionDispatcher = class {
 	core;
-	logger = new _seedcord_services.Logger("Interactions");
+	logger = new _seedcord_logger.Logger("Interactions");
 	isInitialized = false;
 	name = "Interactions";
 	slashMap = /* @__PURE__ */ new Map();
@@ -3107,6 +2910,9 @@ var InteractionDispatcher = class {
 	autocompleteMap = /* @__PURE__ */ new Map();
 	keysToIgnore = /* @__PURE__ */ new Set();
 	middlewares = [];
+	loading = false;
+	loadedHandlers = [];
+	loadedMiddlewares = [];
 	hmrHandler;
 	routeTypes = [
 		[_seedcord_core_internal.InteractionRoutes.Slash, this.slashMap],
@@ -3129,7 +2935,7 @@ var InteractionDispatcher = class {
 		const interactionsDir = this.core.config.bot.interactions.path;
 		if (!interactionsDir) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreControllerPathMissing, ["InteractionDispatcher", "interactions"]);
 		if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
-		this.hmrHandler = new HmrModuleHandler({
+		this.hmrHandler = new _seedcord_core_hmr.HmrModuleHandler({
 			handlersDir: interactionsDir,
 			...(0, _seedcord_utils.hasKeys)(this.core.config.bot.interactions, ["middlewares"]) && this.core.config.bot.interactions.middlewares && { middlewaresDir: this.core.config.bot.interactions.middlewares },
 			isHandler: this.isHandlerClass.bind(this),
@@ -3144,28 +2950,28 @@ var InteractionDispatcher = class {
 	}
 	/**
 	* Warns for each command route with no registered `@SlashRoute` handler, which would fall through to
-	* UnhandledEvent at runtime. A bot may route commands outside the registry, so this does not throw.
+	* 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 ${chalk.default.bold.cyan(route)} has no registered ${chalk.default.bold("@SlashRoute")} handler.`);
+		for (const route of commandLeaves) if (!this.slashMap.has(route)) this.logger.warn(`Slash route ${_seedcord_logger.paint.sky.bold(route)} has no registered ${chalk.default.bold("@SlashRoute")} handler.`);
 	}
 	/**
-	* Warns for each context-menu command with no matching handler, which would fall through to UnhandledEvent
+	* 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 ${chalk.default.bold.cyan(name)} has no registered ${chalk.default.bold("@ContextMenuRoute")} handler.`);
-		for (const name of leaves.message) if (!this.messageContextMenuMap.has(name)) this.logger.warn(`Message context menu ${chalk.default.bold.cyan(name)} has no registered ${chalk.default.bold("@ContextMenuRoute")} handler.`);
+		for (const name of leaves.user) if (!this.userContextMenuMap.has(name)) this.logger.warn(`User context menu ${_seedcord_logger.paint.sky.bold(name)} has no registered ${chalk.default.bold("@ContextMenuRoute")} handler.`);
+		for (const name of leaves.message) if (!this.messageContextMenuMap.has(name)) this.logger.warn(`Message context menu ${_seedcord_logger.paint.sky.bold(name)} has no registered ${chalk.default.bold("@ContextMenuRoute")} handler.`);
 	}
 	getArtifacts(handlerClass) {
 		const artifacts = [];
 		for (const [routeType] of this.routeTypes) {
 			const meta = Reflect.getMetadata(_seedcord_core_internal.InteractionRouteKeys[routeType], handlerClass);
-			if (areRoutes(meta)) artifacts.push({
+			if ((0, _seedcord_core_internal.areRoutes)(meta)) artifacts.push({
 				routeType,
 				routes: meta
 			});
@@ -3177,32 +2983,42 @@ var InteractionDispatcher = class {
 		this.isInitialized = true;
 		const handlersDir = this.core.config.bot.interactions.path;
 		if (!handlersDir) return;
-		this.logger.info(chalk.default.bold(handlersDir));
 		const middlewareDir = (0, _seedcord_utils.hasKeys)(this.core.config.bot.interactions, ["middlewares"]) ? this.core.config.bot.interactions.middlewares : void 0;
-		if (middlewareDir) {
-			this.logger.info(`${chalk.default.bold(middlewareDir)} ${chalk.default.gray("(middlewares)")}`);
-			await this.loadMiddlewares(middlewareDir);
+		this.loading = true;
+		this.loadedHandlers.length = 0;
+		this.loadedMiddlewares.length = 0;
+		try {
+			if (middlewareDir) await this.loadMiddlewares(middlewareDir);
+			await this.loadHandlers(handlersDir);
+		} finally {
+			this.loading = false;
 		}
-		await this.loadHandlers(handlersDir);
 		this.attachToClient();
-		this.logger.info(`${chalk.default.bold.green("Loaded interaction handlers:")}`);
-		this.logger.utils.list([
-			`${chalk.default.magenta.bold(this.middlewares.length)} middlewares`,
-			`${chalk.default.magenta.bold(this.slashMap.size)} slash commands`,
-			`${chalk.default.magenta.bold(this.buttonMap.size)} buttons`,
-			`${chalk.default.magenta.bold(this.modalMap.size)} modals`,
-			`${chalk.default.magenta.bold(this.stringSelectMap.size)} string selects`,
-			`${chalk.default.magenta.bold(this.userSelectMap.size)} user selects`,
-			`${chalk.default.magenta.bold(this.roleSelectMap.size)} role selects`,
-			`${chalk.default.magenta.bold(this.channelSelectMap.size)} channel selects`,
-			`${chalk.default.magenta.bold(this.mentionableSelectMap.size)} mentionable selects`,
-			`${chalk.default.magenta.bold(this.messageContextMenuMap.size)} message context menus`,
-			`${chalk.default.magenta.bold(this.userContextMenuMap.size)} user context menus`,
-			`${chalk.default.magenta.bold(this.autocompleteMap.size)} autocomplete`
-		]);
+		this.reportLoad();
+	}
+	reportLoad() {
+		const { utils } = this.logger;
+		utils.summary("Loaded", {
+			"interaction handlers": this.loadedHandlers.length,
+			middlewares: this.loadedMiddlewares.length
+		});
+		if (this.loadedMiddlewares.length > 0) utils.block("Loaded middlewares", utils.entries(this.loadedMiddlewares));
+		utils.block("Loaded interaction handlers", [...utils.entries(this.loadedHandlers), ...utils.counts({
+			slash: this.slashMap.size,
+			buttons: this.buttonMap.size,
+			modals: this.modalMap.size,
+			"string selects": this.stringSelectMap.size,
+			"user selects": this.userSelectMap.size,
+			"role selects": this.roleSelectMap.size,
+			"channel selects": this.channelSelectMap.size,
+			"mentionable selects": this.mentionableSelectMap.size,
+			"message menus": this.messageContextMenuMap.size,
+			"user menus": this.userContextMenuMap.size,
+			autocomplete: this.autocompleteMap.size
+		})]);
 	}
 	async loadHandlers(dir) {
-		await (0, _seedcord_utils.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
 			for (const val of Object.values(imported)) {
 				if (!this.isHandlerClass(val)) continue;
 				this.registerHandler(val, relativePath);
@@ -3211,7 +3027,7 @@ var InteractionDispatcher = class {
 		}, this.logger);
 	}
 	async loadMiddlewares(dir) {
-		await (0, _seedcord_utils.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
 			for (const val of Object.values(imported)) {
 				if (!this.isMiddlewareClass(val)) continue;
 				this.registerMiddleware(val, relativePath);
@@ -3229,7 +3045,14 @@ var InteractionDispatcher = class {
 			priority: metadata.priority
 		});
 		this.middlewares.sort((a, b) => a.priority - b.priority);
-		this.logger.utils.registration(`${middlewareCtor.name} ${chalk.default.gray(`(${metadata.priority})`)}`, relativePath, "middleware");
+		if (this.loading) {
+			this.loadedMiddlewares.push({
+				name: `${middlewareCtor.name} (${metadata.priority})`,
+				from: (0, _seedcord_utils.formatFilePath)(relativePath)
+			});
+			return;
+		}
+		this.logger.utils.registration(`${middlewareCtor.name} ${_seedcord_logger.paint.mute(`(${metadata.priority})`)}`, relativePath, "middleware");
 	}
 	isHandlerClass(obj) {
 		if (typeof obj !== "function") return false;
@@ -3243,7 +3066,7 @@ var InteractionDispatcher = class {
 		const writes = [];
 		for (const [routeType, map] of this.routeTypes) {
 			const meta = Reflect.getMetadata(_seedcord_core_internal.InteractionRouteKeys[routeType], handlerClass);
-			if (!areRoutes(meta)) continue;
+			if (!(0, _seedcord_core_internal.areRoutes)(meta)) continue;
 			for (const route of meta) {
 				const existing = map.get(route);
 				if (existing && existing !== handlerClass) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.InteractionDuplicateRoute, [
@@ -3253,9 +3076,15 @@ var InteractionDispatcher = class {
 				]);
 				writes.push([map, route]);
 			}
-			this.logger.utils.registration(handlerClass.name, (0, _seedcord_utils.formatFilePath)(relativePath));
 		}
+		if (writes.length === 0) return;
 		for (const [map, route] of writes) map.set(route, handlerClass);
+		const from = (0, _seedcord_utils.formatFilePath)(relativePath);
+		if (this.loading) this.loadedHandlers.push({
+			name: handlerClass.name,
+			from
+		});
+		else this.logger.utils.registration(handlerClass.name, from);
 	}
 	/** @internal For use in dev mode */
 	async onHmr(event) {
@@ -3271,7 +3100,7 @@ var InteractionDispatcher = class {
 		}
 		for (const [routeType, map] of this.routeTypes) {
 			const meta = Reflect.getMetadata(_seedcord_core_internal.InteractionRouteKeys[routeType], handlerClass);
-			if (!areRoutes(meta)) continue;
+			if (!(0, _seedcord_core_internal.areRoutes)(meta)) continue;
 			meta.forEach((route) => map.delete(route));
 		}
 	}
@@ -3283,7 +3112,7 @@ var InteractionDispatcher = class {
 		this.core.bot.client.on(discord_js.Events.InteractionCreate, (interaction) => {
 			this.core.bot.emitSafe("any:interaction", interaction);
 			this.handleInteraction(interaction).catch((err) => {
-				this.logger.error(`[${chalk.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+				this.logger.error(`[${_seedcord_logger.paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
 				this.core.bot.emit("error:unhandled:interaction", err);
 			});
 		});
@@ -3294,22 +3123,31 @@ var InteractionDispatcher = class {
 		if (!prefix) return this.logger.warn(`${interactionType} has invalid customId: ${interaction.customId}`);
 		await this.processInteraction(interaction, () => prefix, (key) => getMap().get(key));
 	}
-	async processInteraction(interaction, extractKey, getHandler) {
+	async processInteraction(interaction, extractKey, getHandler, fallback = UnhandledRepliable) {
 		const key = extractKey(interaction);
+		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 ${chalk.default.bold.cyan(key)}. Falling back to UnhandledEvent.`);
-				HandlerCtor = UnhandledEvent;
+				this.logger.warn(`No handler found for key ${_seedcord_logger.paint.sky.bold(key)}. Falling back to ${fallback.name}.`);
+				HandlerCtor = fallback;
 			}
-			this.logger.debug(`Processing ${chalk.default.bold.green(key)} with ${chalk.default.gray(HandlerCtor.name)}`);
+			this.logger.debug(`Processing ${_seedcord_logger.paint.mint.bold(key)} with ${_seedcord_logger.paint.mute(HandlerCtor.name)}`);
 			const dispatch = new _seedcord_core.DispatchContext((0, _seedcord_core_internal.routeIdOf)(HandlerCtor));
 			const handler = new HandlerCtor(interaction, this.core, dispatch);
-			if (!interaction.isAutocomplete()) await (0, _seedcord_core_internal.runHandlerGates)(HandlerCtor, interactionGateContext(interaction, this.core));
+			if (handler instanceof RepliableHandler) sender = handler.getSender();
+			if (!interaction.isAutocomplete()) {
+				const monitor = (0, _seedcord_core_internal.slowGateMonitor)();
+				try {
+					await (0, _seedcord_core_internal.runHandlerGates)(HandlerCtor, interactionGateContext(interaction, this.core), dispatch.routeId ?? void 0, monitor?.observe);
+				} finally {
+					monitor?.report(dispatch.routeId);
+				}
+			}
 			await handler.execute();
 		} catch (caught) {
-			await handleInteractionFault(caught, interaction, this.core);
+			await handleInteractionFault(caught, interaction, this.core, sender);
 		}
 	}
 	async handleInteraction(interaction) {
@@ -3385,12 +3223,7 @@ var InteractionDispatcher = class {
 	}
 	async handleAutocomplete(interaction) {
 		const route = slashRouteOf(interaction);
-		if (!this.autocompleteMap.has(route)) {
-			this.logger.warn(`No autocomplete handler for ${chalk.default.bold.cyan(route)}.`);
-			await interaction.respond([]);
-			return;
-		}
-		await this.processInteraction(interaction, () => route, (key) => this.autocompleteMap.get(key));
+		await this.processInteraction(interaction, () => route, (key) => this.autocompleteMap.get(key), UnhandledAutocomplete);
 	}
 };
 
@@ -3418,7 +3251,7 @@ function __decorate(decorators, target, key, desc) {
 */
 var Bot = class extends Plugin {
 	/** @internal */
-	logger = new _seedcord_services.Logger("Bot");
+	logger = new _seedcord_logger.Logger("Bot");
 	isInitialized = false;
 	_client;
 	interactions;
@@ -3446,7 +3279,7 @@ var Bot = class extends Plugin {
 			});
 		}
 		this.emojiInjector = new EmojiInjector(core);
-		core.shutdown.addTask(_seedcord_services.ShutdownPhase.DiscordCleanup, "stop-bot", async () => await this.stop(), 2e3);
+		core.shutdown.addTask(_seedcord_core_node.ShutdownPhase.DiscordCleanup, "stop-bot", async () => await this.stop(), 2e3);
 	}
 	/**
 	* Initializes Discord client and all controllers
@@ -3479,7 +3312,9 @@ var Bot = class extends Plugin {
 	* Logs the bot into Discord using the configured token
 	*/
 	async login(token) {
-		await this._client.login(token);
+		this._client.once(discord_js.Events.ClientReady, () => this.emit("ready"));
+		this._client.login(token);
+		await this.waitFor("ready");
 		this.logger.info(`Logged in as ${chalk.default.bold.magenta(this._client.user?.username)}!`);
 		return this;
 	}
@@ -3503,199 +3338,72 @@ var Bot = class extends Plugin {
 		this.logger.error(`listener for ${String(event)} threw`, error);
 	}
 };
-__decorate([(0, envapt.Envapt)("DISCORD_BOT_TOKEN", { converter: (raw) => (0, _seedcord_errors_internal.validateDiscordToken)(raw) }), __decorateMetadata("design:type", String)], Bot.prototype, "botToken", void 0);
-
-//#endregion
-//#region src/hmr/HmrManager.ts
-var HmrManager = class {
-	logger = new _seedcord_services.Logger("HMR", { channel: "hmr" });
-	listeners = /* @__PURE__ */ new Set();
-	constructor() {}
-	/** @internal */
-	init() {
-		if (!{}.hot) return;
-		setDevChannel((0, _seedcord_types_internal.wrapHot)({}.hot));
-		if (envapt.Envapter.isDevelopment || envapt.Envapter.isTest) {
-			this.logger.info("Enabled");
-			getDevChannel()?.on("seedcord:hmr", (payload) => {
-				const affected = payload.affectedModules?.length ?? 0;
-				this.logger.info(`${chalk.default.bold("1")} module changed, ${chalk.default.bold(affected)} affected modules`);
-				if (payload.affectedModules) this.logger.utils.list(payload.affectedModules.map((mod) => (0, _seedcord_utils.formatFilePath)(mod)), "Affected modules: ");
-				this.handleUpdate(payload);
-			});
-		}
-	}
-	/** @internal */
-	register(listener) {
-		this.listeners.add(listener);
-	}
-	/** @internal */
-	unregister(listener) {
-		this.listeners.delete(listener);
-	}
-	async handleUpdate(event) {
-		const promises = [...this.listeners].map(async (listener) => {
-			try {
-				await listener.onHmr(event);
-			} catch (error) {
-				this.logger.error(`Error handling HMR update in ${chalk.default.bold(listener.name)}: `, error);
-			}
-		});
-		await Promise.all(promises);
-	}
-};
-
-//#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$-]+$`);
-/**
-* Whether a string is a well-formed Discord webhook URL.
-*
-* @internal
-*/
-function isDiscordWebhookUrl(value) {
-	return URL.canParse(value) && DISCORD_WEBHOOK_REGEX.test(value);
-}
-/**
-* Serializes a value to a JSON attachment, made circular-safe first.
-*
-* @internal
-*/
-function jsonAttachment(name, description, data) {
-	const content = (0, _seedcord_utils.filterCirculars)(data);
-	return new discord_js.AttachmentBuilder(Buffer.from(JSON.stringify(content, void 0, 2), "utf8"), {
-		name,
-		description
-	});
-}
-/**
-* The small divider the default webhook reporters place between sections.
-*
-* @internal
-*/
-var WebhookSeparator = class extends _seedcord_core.BuilderComponent {
-	constructor() {
-		super("separator");
-		this.instance.setSpacing(discord_js.SeparatorSpacingSize.Small).setDivider(true);
-	}
-};
+__decorate([(0, envapt_legacy.Envapt)("DISCORD_BOT_TOKEN", { converter: (raw) => (0, _seedcord_errors_internal.validateDiscordToken)(raw) }), __decorateMetadata("design:type", String)], Bot.prototype, "botToken", void 0);
 
 //#endregion
 //#region src/subscribers/default/HandledException.ts
-var _HandledException;
-function webhookUrlValidator$1(raw) {
-	if (raw !== null && typeof raw !== "string") throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigHandledExceptionWebhookInvalid);
-	const value = raw?.trim() ?? "";
-	if (value === "") throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigHandledExceptionWebhookMissing);
-	if (!isDiscordWebhookUrl(value)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigHandledExceptionWebhookInvalid);
-	return value;
-}
 let HandledException = class HandledException extends WebhookLog {
-	static {
-		_HandledException = this;
-	}
-	webhook = new discord_js.WebhookClient({ url: _HandledException.handledExceptionWebhookUrl });
-	async execute() {
-		const { source } = this.data;
-		try {
-			await this.webhook.send({
-				flags: flagsFor(false),
-				withComponents: true,
-				username: "Handled Exception",
-				components: [new HandledExceptionContainer(this.data).component],
-				files: [jsonAttachment("source.json", "The raw source the fault came from", source.raw)]
-			});
-		} catch (error) {
-			this.logger.error("Failed to send handled exception webhook", error);
-		}
+	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)]
+		};
 	}
 };
-__decorate([(0, envapt.Envapt)("HANDLED_EXCEPTION_WEBHOOK_URL", { converter: (raw) => webhookUrlValidator$1(raw) }), __decorateMetadata("design:type", String)], HandledException, "handledExceptionWebhookUrl", void 0);
-HandledException = _HandledException = __decorate([Subscribe("handledException")], HandledException);
+HandledException = __decorate([Subscribe("handledException"), WebhookUrl("HANDLED_EXCEPTION_WEBHOOK_URL")], HandledException);
 var HandledExceptionContainer = class extends _seedcord_core.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\`\`\`${causeStack(denial)}\`\`\``)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Source")).addFileComponents((file) => file.setURL("attachment://source.json"));
+		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"));
 	}
 };
-/**
-* The summary block of a fault report, narrowed per source kind so an interaction fault shows its
-* command and customId while an event fault shows its event name and handler.
-*
-* @internal
-*/
 function faultSummary(denial, source) {
-	const head = `### A handled fault was reported: \`${denial.name}\`\n**Message:** ${denial.message}\n`;
+	const head = (0, _seedcord_utils.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}\``;
 }
-/**
-* The text shown for a denial's cause in the report. Tolerates a non-serializable cause (a bigint or a
-* circular object) so building the report never throws.
-*
-* @internal
-*/
 function causeStack(denial) {
 	const { cause } = denial;
-	if (Error.isError(cause)) return cause.stack ?? cause.message;
-	if (typeof cause === "string") return cause;
+	if (Error.isError(cause)) return (0, _seedcord_utils.stripAnsi)(cause.stack ?? cause.message);
+	if (typeof cause === "string") return (0, _seedcord_utils.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 denial.stack ?? "No cause recorded.";
+	return (0, _seedcord_utils.stripAnsi)(denial.stack ?? "No cause recorded.");
 }
 
 //#endregion
 //#region src/subscribers/default/UnknownException.ts
-var _UnknownException;
-function webhookUrlValidator(raw) {
-	if (raw !== null && typeof raw !== "string") throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid);
-	const value = raw?.trim() ?? "";
-	if (value === "") throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigUnknownExceptionWebhookMissing);
-	if (!isDiscordWebhookUrl(value)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid);
-	return value;
-}
 let UnknownException = class UnknownException extends WebhookLog {
-	static {
-		_UnknownException = this;
-	}
-	webhook = new discord_js.WebhookClient({ url: _UnknownException.unknownExceptionWebhookUrl });
-	async execute() {
+	report() {
 		const { metadata } = this.data;
-		const metadataFile = metadata ? jsonAttachment("metadata.json", "Metadata associated with the error", metadata) : null;
-		try {
-			await this.webhook.send({
-				flags: flagsFor(false),
-				withComponents: true,
-				username: "Unknown Exception",
-				components: [new UnhandledErrorContainer(this.data).component],
-				files: metadataFile ? [metadataFile] : []
-			});
-		} catch (error) {
-			this.logger.error("Failed to send unknown exception webhook", error);
-		}
+		return {
+			username: "Unknown Exception",
+			components: [new UnhandledErrorContainer(this.data).component],
+			files: metadata ? [jsonAttachment("metadata.json", "Metadata associated with the error", metadata)] : void 0
+		};
 	}
 };
-__decorate([(0, envapt.Envapt)("UNKNOWN_EXCEPTION_WEBHOOK_URL", { converter: (raw) => webhookUrlValidator(raw) }), __decorateMetadata("design:type", String)], UnknownException, "unknownExceptionWebhookUrl", void 0);
-UnknownException = _UnknownException = __decorate([Subscribe("unknownException")], UnknownException);
+UnknownException = __decorate([Subscribe("unknownException"), WebhookUrl("UNKNOWN_EXCEPTION_WEBHOOK_URL")], UnknownException);
 var UnhandledErrorContainer = class extends _seedcord_core.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\`\`\`${error.stack}\`\`\``));
+		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 discord_js.DiscordAPIError)) return;
+		if (!(error instanceof _discordjs_rest.DiscordAPIError)) return;
 		const now = Date.now();
 		const snowflake = error.url.match(/\/interactions\/(\d+)\//)?.[1];
 		if (!snowflake) return void 0;
-		const interactionTs = Number(discord_js.SnowflakeUtil.deconstruct(snowflake).timestamp);
+		const interactionTs = (0, _seedcord_utils.timestampFromSnowflake)(snowflake);
 		const diff = now - interactionTs;
 		const seconds = Math.floor(diff / 1e3);
 		const millis = diff % 1e3;
@@ -3710,28 +3418,25 @@ var UnhandledErrorContainer = class extends _seedcord_core.BuilderComponent {
 //#endregion
 //#region src/subscribers/Bus.ts
 /**
-* Manages application subscribers and event handling
-*
-* Provides a centralized system for registering and executing custom subscribers
-* throughout the application lifecycle. Bus subscribers are loaded from configured directories
-* and can be triggered programmatically or by framework events. Accessed via `core.bus`. Do not
-* construct it directly.
+* Registers and dispatches subscribers. Subscribers load from the configured directories and run
+* on a programmatic or framework-event publish. Accessed via `core.bus`. Do not construct it directly.
 */
 var Bus = class extends Plugin {
 	core;
-	logger = new _seedcord_services.Logger("Subscribers");
+	logger = new _seedcord_logger.Logger("Subscribers");
 	/** @internal */
 	name = "Subscribers";
 	isInitialized = false;
 	subscribersMap = /* @__PURE__ */ new Map();
 	executedOnceHandlers = /* @__PURE__ */ new Set();
+	webhookProbes = /* @__PURE__ */ new Map();
 	hmrHandler;
 	constructor(core) {
 		super(core);
 		this.core = core;
 		if (this.core.config.subscribers.path) {
 			if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
-			this.hmrHandler = new HmrModuleHandler({
+			this.hmrHandler = new _seedcord_core_hmr.HmrModuleHandler({
 				handlersDir: this.core.config.subscribers.path,
 				isHandler: this.isSubscriber.bind(this),
 				registerHandler: this.registerSubscriber.bind(this),
@@ -3750,7 +3455,6 @@ var Bus = class extends Plugin {
 		this.isInitialized = true;
 		this.registerSubscriber(UnknownException);
 		this.registerSubscriber(HandledException);
-		envapt.Envapter.require("UNKNOWN_EXCEPTION_WEBHOOK_URL", "HANDLED_EXCEPTION_WEBHOOK_URL");
 		const subscribersDir = this.core.config.subscribers.path;
 		if (subscribersDir) {
 			this.logger.info(chalk.default.bold(subscribersDir));
@@ -3758,13 +3462,24 @@ var Bus = class extends Plugin {
 			const totalSubscribers = [...this.subscribersMap.values()].reduce((acc, handlers) => acc + handlers.length, 0);
 			this.logger.utils.list([`${chalk.default.bold.magenta(totalSubscribers)} subscribers`], chalk.default.bold.green("Loaded"));
 		}
+		if (!envapt.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 ${_seedcord_logger.paint.sky.bold(envKeys.join(", "))}`);
+		}));
+		if (missing.length > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigWebhookNotFound, [missing.join(", ")]);
 	}
-	/** @internal For use in dev mode */
+	/** @internal */
 	async onHmr(event) {
 		if (this.hmrHandler) await this.hmrHandler.handle(event);
 	}
 	async loadSubscribers(dir) {
-		await (0, _seedcord_utils.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
 			for (const exportName of Object.keys(imported)) {
 				const val = imported[exportName];
 				if (this.isSubscriber(val)) {
@@ -3776,6 +3491,17 @@ var Bus = class extends Plugin {
 		}, 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.default.bold(handler.name)} disabled, ${_seedcord_logger.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(_seedcord_core_internal.SubscribeMetadataKey, handler);
 		let handlers = this.subscribersMap.get(options.subscriber);
 		if (!handlers) {
@@ -3835,7 +3561,7 @@ var Bus = class extends Plugin {
 //#endregion
 //#region src/version.ts
 /** Package version */
-const version = "0.1.0-next.1";
+const version = "0.1.0-next.3";
 
 //#endregion
 //#region src/Seedcord.ts
@@ -3854,6 +3580,8 @@ var Seedcord = class Seedcord extends Pluggable {
 	/** @internal */
 	version = version;
 	static isInstantiated = false;
+	healthCheck;
+	hmrManager;
 	/** @see {@link CoordinatedShutdown} */
 	shutdown;
 	/** @see {@link CoordinatedStartup} */
@@ -3864,10 +3592,6 @@ var Seedcord = class Seedcord extends Pluggable {
 	bot;
 	/** @see {@link IRateLimiter} */
 	rateLimiter;
-	/** @see {@link HealthCheck} */
-	healthCheck;
-	/** @see {@link HmrManager} */
-	hmrManager;
 	/**
 	* Creates a new Seedcord instance
 	*
@@ -3877,42 +3601,43 @@ var Seedcord = class Seedcord extends Pluggable {
 	constructor(config) {
 		if (Seedcord.isInstantiated) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreSingletonViolation);
 		Seedcord.isInstantiated = true;
-		const shutdown = new _seedcord_services.CoordinatedShutdown(config.shutdownEnabled);
-		const startup = new _seedcord_services.CoordinatedStartup();
+		const shutdown = new _seedcord_core_node.CoordinatedShutdown(config.shutdownEnabled);
+		const startup = new _seedcord_core_node.CoordinatedStartup();
 		super(shutdown, startup);
 		this.config = config;
+		(0, _seedcord_logger_node.installNodeDefaults)(config.logger);
 		(0, _seedcord_core_internal.setBotColor)(config.botColor);
 		this.shutdown = shutdown;
 		this.startup = startup;
-		this.hmrManager = new HmrManager();
+		this.hmrManager = new _seedcord_core_internal.HmrManager();
 		this.hmrManager.init();
 		this.bus = new Bus(this);
 		this.bot = new Bot(this);
 		this.rateLimiter = config.store ?? new _seedcord_rate_limiter.MemoryRateLimiter();
-		this.healthCheck = new _seedcord_services.HealthCheck(this.shutdown, config.healthCheck);
+		this.healthCheck = new _seedcord_core_node.HealthCheck(this.shutdown, config.healthCheck);
 		this.registerStartupTasks();
 	}
-	/** @internal */
+	/** The bot's discord username, populated after login. */
+	get username() {
+		return this.bot.client.user?.username;
+	}
 	static reset() {
 		Seedcord.isInstantiated = false;
+		_seedcord_logger.LoggerChannelRegistry.instance.reset();
 	}
-	/**
-	* Registers default startup tasks
-	* @internal
-	*/
 	registerStartupTasks() {
 		if (envapt.Envapter.isDevelopment || envapt.Envapter.isTest) this.registerHmrAwareModules();
-		this.startup.addTask(_seedcord_services.StartupPhase.Configuration, "Bus Initialization", async () => {
+		this.startup.addTask(_seedcord_core_node.StartupPhase.Configuration, "Bus Initialization", async () => {
 			this.bus.logger.utils.initialization("Subscribers", "start");
 			await this.bus.init();
 			this.bus.logger.utils.initialization("Subscribers", "end");
 		});
-		this.startup.addTask(_seedcord_services.StartupPhase.Instantiation, "Bot Initialization", async () => {
+		this.startup.addTask(_seedcord_core_node.StartupPhase.Instantiation, "Bot Initialization", async () => {
 			this.bot.logger.utils.initialization("Bot", "start");
 			await this.bot.init();
 			this.bot.logger.utils.initialization("Bot", "end");
 		});
-		this.startup.addTask(_seedcord_services.StartupPhase.Ready, "Health Check", async () => {
+		this.startup.addTask(_seedcord_core_node.StartupPhase.Ready, "Health Check", async () => {
 			this.healthCheck.logger.utils.initialization("HealthCheck", "start");
 			await this.healthCheck.init();
 			this.healthCheck.logger.utils.initialization("HealthCheck", "end");
@@ -3928,7 +3653,7 @@ var Seedcord = class Seedcord extends Pluggable {
 		return this;
 	}
 	registerHmrAwareModules() {
-		this.startup.addTask(_seedcord_services.StartupPhase.Configuration, "HMR Registration", async () => {
+		this.startup.addTask(_seedcord_core_node.StartupPhase.Configuration, "HMR Registration", async () => {
 			this.hmrManager.register(this.bot);
 			this.hmrManager.register(this.bus);
 			for (const plugin of this.plugins) this.hmrManager.register(plugin);
@@ -3940,49 +3665,45 @@ var Seedcord = class Seedcord extends Pluggable {
 //#endregion
 exports.ArraySource = ArraySource;
 exports.AutocompleteHandler = AutocompleteHandler;
-exports.AutocompleteRoute = AutocompleteRoute;
 exports.ButtonHandler = ButtonHandler;
-exports.ButtonRoute = ButtonRoute;
 exports.CommandMentions = CommandMentions;
 exports.ContextMenuHandler = ContextMenuHandler;
-exports.ContextMenuRoute = ContextMenuRoute;
 exports.CursorSource = CursorSource;
 exports.Emojis = Emojis;
 exports.EventHandler = EventHandler;
 exports.EventMiddleware = EventMiddleware;
 exports.Gated = Gated;
-exports.HmrModuleHandler = HmrModuleHandler;
 exports.IgnoreBots = IgnoreBots;
 exports.InteractionHandler = InteractionHandler;
 exports.InteractionMiddleware = InteractionMiddleware;
 exports.Middleware = Middleware;
 exports.MiddlewareType = MiddlewareType;
 exports.ModalHandler = ModalHandler;
-exports.ModalRoute = ModalRoute;
 exports.Nsfw = Nsfw;
 exports.Paginator = Paginator;
 exports.Pluggable = Pluggable;
 exports.Plugin = Plugin;
-Object.defineProperty(exports, 'RegisterCommand', {
+exports.RegisterEvent = RegisterEvent;
+exports.RepliableHandler = RepliableHandler;
+exports.Seedcord = Seedcord;
+exports.SelectMenuHandler = SelectMenuHandler;
+Object.defineProperty(exports, 'ShutdownPhase', {
   enumerable: true,
   get: function () {
-    return _seedcord_core.RegisterCommand;
+    return _seedcord_core_node.ShutdownPhase;
   }
 });
-exports.RegisterEvent = RegisterEvent;
-exports.ReplySender = ReplySender;
-exports.RequireBotPermissions = RequireBotPermissions;
-exports.RequirePermissions = RequirePermissions;
-exports.RequireRole = RequireRole;
-exports.Seedcord = Seedcord;
-exports.SelectMenuHandler = SelectMenuHandler;
-exports.SelectMenuKind = SelectMenuKind;
-exports.SelectMenuRoute = SelectMenuRoute;
 exports.SlashHandler = SlashHandler;
-exports.SlashRoute = SlashRoute;
+Object.defineProperty(exports, 'StartupPhase', {
+  enumerable: true,
+  get: function () {
+    return _seedcord_core_node.StartupPhase;
+  }
+});
 exports.Subscribe = Subscribe;
 exports.Subscriber = Subscriber;
 exports.WebhookLog = WebhookLog;
+exports.WebhookUrl = WebhookUrl;
 exports.checkBotPermissions = checkBotPermissions;
 exports.checkPermissions = checkPermissions;
 exports.fetchGuildMember = fetchGuildMember;
@@ -4017,17 +3738,17 @@ Object.keys(_seedcord_event_emitter).forEach(function (k) {
   });
 });
 
-Object.keys(_seedcord_rate_limiter).forEach(function (k) {
+Object.keys(_seedcord_logger).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return _seedcord_rate_limiter[k]; }
+    get: function () { return _seedcord_logger[k]; }
   });
 });
 
-Object.keys(_seedcord_services).forEach(function (k) {
+Object.keys(_seedcord_rate_limiter).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return _seedcord_services[k]; }
+    get: function () { return _seedcord_rate_limiter[k]; }
   });
 });