@seedcord/gateway 0.1.4 → 0.2.0

package/dist/index.cjs

@@ -1,2486 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-require("reflect-metadata");
-let _seedcord_logger_node = require("@seedcord/logger/node");
-let _seedcord_core_internal = require("@seedcord/core/internal");
-let _seedcord_errors = require("@seedcord/errors");
-let _seedcord_errors_internal = require("@seedcord/errors/internal");
-let _seedcord_core = require("@seedcord/core");
-let _seedcord_logger = require("@seedcord/logger");
-let discord_js = require("discord.js");
-let _discordjs_builders = require("@discordjs/builders");
-let _seedcord_utils_internal = require("@seedcord/utils/internal");
-let _seedcord_core_plugin = require("@seedcord/core/plugin");
-let _seedcord_core_node_internal = require("@seedcord/core/node/internal");
-let _seedcord_rate_limiter = require("@seedcord/rate-limiter");
-let _seedcord_types_internal = require("@seedcord/types/internal");
-let envapt = require("envapt");
-let chalk = require("chalk");
-chalk = __toESM(chalk, 1);
-let envapt_legacy = require("envapt/legacy");
-let _seedcord_core_hmr = require("@seedcord/core/hmr");
-let _seedcord_utils = require("@seedcord/utils");
-let _seedcord_utils_node = require("@seedcord/utils/node");
-let node_crypto = require("node:crypto");
-node_crypto = __toESM(node_crypto, 1);
-
-//#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.
-*
-* Associates the decorated class with the provided Discord client events for automatic registration and execution when those events are emitted.
-*
-* Supply any number of event tuples. Each tuple can include per event options.
-*
-* @typeParam EventKey - Union of Discord.js ClientEvents keys to register for
-* @param defs - One or more tuples of [event, options]
-* @decorator
-* @example
-* ```ts
-* \@RegisterEvent([Events.MessageCreate])
-* class MessageHandler extends EventHandler<Events.MessageCreate> {
-*   async execute() {
-*     // Handle message creation
-*   }
-* }
-* ```
-*
-* @example
-* ```ts
-* \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
-* class MessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
-*   async execute() {
-*     // Handle message creation or update
-*   }
-* }
-* ```
-*
-* @example
-* ```ts
-* \@RegisterEvent([Events.MessageCreate, { frequency: 'once' }], [Events.MessageUpdate])
-* class OneTimeMessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
-*   async execute() {
-*     // Handle only the first message creation, and message update normally
-*   }
-* }
-* ```
-*/
-function RegisterEvent(...defs) {
-	return function(constructor) {
-		const existing = Reflect.getMetadata(_seedcord_core_internal.EventMetadataKey, constructor) ?? [];
-		const entries = defs.map(([event, options]) => ({
-			event,
-			frequency: options?.frequency ?? "on"
-		}));
-		Reflect.defineMetadata(_seedcord_core_internal.EventMetadataKey, [...existing, ...entries], constructor);
-	};
-}
-
-//#endregion
-//#region src/bot/decorators/Gated.ts
-/**
-* Attaches gates to a handler. The gates run before `execute`, and a gate refusing stops the handler with
-* the reply or drop the gate threw. Multiple gates are ANDed, so each must pass. A gate that requires a
-* context the handler does not provide (a button gate on a slash handler, an interaction gate on an event
-* handler) is a compile error at this line, and the error names the gate and the handler kind. Place it
-* above the route decorator.
-*
-* Combine gates with {@link and} or {@link or} to build a single gate from multiple arms.
-*
-* @example
-* ```ts
-* import { PermissionFlagsBits } from 'discord.js';
-*
-* \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.Administrator]))
-* \@SlashRoute('maintenance')
-* class Maintenance extends SlashHandler<'maintenance'> {
-*     async execute() {
-*         // both gates passed, so this runs in a guild with an admin caller
-*     }
-* }
-* ```
-*
-* @typeParam Gates - The non-empty tuple of gates to run, in order, against the handler's context.
-* @typeParam TCtor - The decorated handler's constructor, checked against every gate's required context.
-* @param gates - One or more gates to attach, each ANDed so the handler runs only when all pass.
-* @param ctor - The handler class being decorated, rejected at compile time when a gate needs a context it lacks.
-*
-* @see {@link defineGate}
-* @see {@link defineEffectGate}
-* @decorator
-*/
-function Gated(...gates) {
-	return function(ctor) {
-		const existing = Reflect.getMetadata(_seedcord_core_internal.GatedMetadataKey, ctor) ?? [];
-		Reflect.defineMetadata(_seedcord_core_internal.GatedMetadataKey, [...existing, ...gates], ctor);
-	};
-}
-
-//#endregion
-//#region src/bot/decorators/Middlewares.ts
-/**
-* Middleware types supported by Seedcord
-*/
-let MiddlewareType = /* @__PURE__ */ function(MiddlewareType) {
-	MiddlewareType["Interaction"] = "interaction";
-	MiddlewareType["Event"] = "event";
-	return MiddlewareType;
-}({});
-/**
-* Decorator used to register middleware with priority ordering. The lower the priority number, the earlier it runs.
-*
-* Interaction middleware cannot specify event filters.
-*
-* @param type - Middleware kind from {@link MiddlewareType}
-* @param priority - Ordering value where lower runs earlier. {@default `0` }
-* @param options - Additional registration options
-*
-* @decorator
-*
-* @example
-* ```ts
-* \@Middleware(MiddlewareType.Event, 10, { events: [Events.MessageCreate, Events.MessageUpdate] })
-* class MyEventMiddleware extends EventMiddleware {}
-* ```
-* @throws A **SeedcordTypeError** If priority is not a finite number
-* @throws A **SeedcordError** If interaction middleware specifies event filters
-*/
-function Middleware(type, priority = 0, options = {}) {
-	return (ctor) => {
-		const normalizedPriority = Number(priority);
-		if (!Number.isFinite(normalizedPriority)) throw new _seedcord_errors_internal.SeedcordTypeError(_seedcord_errors.SeedcordErrorCode.DecoratorInvalidMiddlewarePriority);
-		if (type === "interaction" && Array.isArray(options.events) && options.events.length > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.DecoratorInteractionEventFilter);
-		const metadata = {
-			priority: normalizedPriority,
-			type,
-			...options.events && options.events.length > 0 && { events: options.events }
-		};
-		Reflect.defineMetadata(_seedcord_core_internal.MiddlewareMetadataKey, metadata, ctor);
-	};
-}
-
-//#endregion
-//#region src/bot/gates/catalog/IgnoreBots.ts
-/**
-* Drops a client event whose actor is a bot, with a {@link Silence} so nothing is replied. Event-only, because a
-* Silence on an interaction would leave Discord's failed-interaction state. It rejects an interaction handler at
-* the decorator line. Takes no options, so attach it directly without calling it.
-*
-* @see {@link Gated}
-*
-* @example
-* ```ts
-* import { Events } from 'discord.js';
-*
-* \@Gated(IgnoreBots)
-* class OnMessage extends EventHandler<Events.MessageCreate> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-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/index.ts
-var NotNsfw = class extends _seedcord_core_internal.GateNotice {
-	constructor(message = "This can only be used in an age-restricted channel.") {
-		super(message);
-	}
-};
-var RoleHigherThanMe = class extends _seedcord_core.Notice {
-	role;
-	botRole;
-	constructor(message, role, botRole) {
-		super(message);
-		this.role = role;
-		this.botRole = botRole;
-	}
-	render() {
-		return { components: [new _seedcord_core_internal.NoticeCard(`I cannot assign a role that is higher than me.\n\nThe role <@&${this.role.id}> is higher than my role <@&${this.botRole.id}> in the hierarchy.`).component] };
-	}
-};
-var CannotAssignBotRole = class extends _seedcord_core.Notice {
-	constructor(message = "I cannot assign a managed role.") {
-		super(message);
-	}
-	render() {
-		return { components: [new _seedcord_core_internal.NoticeCard("I cannot assign a managed role.").component] };
-	}
-};
-
-//#endregion
-//#region src/bot/gates/catalog/Nsfw.ts
-function channelIsNsfw(channel) {
-	if (!channel) return false;
-	if (channel.isThread()) return channel.parent?.nsfw ?? false;
-	return "nsfw" in channel ? channel.nsfw : false;
-}
-/**
-* Requires an age-restricted channel, else refuses. Pass {@link GateNoticeOptions} to reword or replace the refusal.
-*
-* A thread inherits its parent channel's nsfw flag. ModalSubmit has no reliable channel, so it is excluded.
-*
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
-*
-* @see {@link Gated}
-*
-* @example
-* ```ts
-* \@Gated(Nsfw())
-* \@SlashRoute('nsfwcmd')
-* class NsfwHandler extends SlashHandler<'nsfwcmd'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-function Nsfw(options) {
-	return (0, _seedcord_core.defineGate)("Nsfw", (ctx) => {
-		if (channelIsNsfw(ctx.interaction.channel)) return;
-		throw (0, _seedcord_core_internal.pickNotice)(options, (message) => new NotNsfw(message));
-	});
-}
-
-//#endregion
-//#region src/bot/injectors/EmojiInjector.ts
-const emojiStorage = (0, _seedcord_core_internal.accessorStore)();
-/**
-* The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
-* A read before that throws.
-*/
-const Emojis = (0, _seedcord_core_internal.guardedAccessor)("Emojis", emojiStorage);
-var EmojiInjector = class {
-	core;
-	logger = new _seedcord_logger.Logger("Emojis", { channel: "bot" });
-	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("No emojis configured, skipping emoji injection.");
-			return;
-		}
-		const configEmojis = this.core.config.bot.emojis;
-		await this.core.bot.client.application?.emojis.fetch();
-		const failures = [];
-		const fetchedGuilds = /* @__PURE__ */ new Set();
-		for (const [key, value] of Object.entries(configEmojis)) if ((0, _seedcord_core_internal.isEmojiTuple)(value)) await this.resolveTuple(key, value, failures, fetchedGuilds);
-		else if (typeof value === "string") this.resolveString(key, value, failures);
-		else failures.push(`  - "${key}" has an invalid value (expected a name or [name, guildId])`);
-		if (failures.length > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigEmojiUnresolved, [failures.length, failures.join("\n")]);
-		this.logger.utils.summary("Loaded emojis", { emojis: Object.keys(emojiStorage).length });
-	}
-	async resolveTuple(key, value, failures, fetchedGuilds) {
-		const [emojiName, guildId] = value;
-		const guild = this.core.bot.client.guilds.cache.get(guildId);
-		if (!guild) {
-			failures.push(`  - "${emojiName}" for "${key}" targets guild ${guildId}, which is not available (check the Guilds intent)`);
-			return;
-		}
-		if (!fetchedGuilds.has(guildId)) {
-			await guild.emojis.fetch();
-			fetchedGuilds.add(guildId);
-		}
-		const guildEmoji = guild.emojis.cache.find((e) => e.name === emojiName);
-		if (!guildEmoji) {
-			failures.push(`  - "${emojiName}" for "${key}" was not found in guild ${guildId}`);
-			return;
-		}
-		emojiStorage[key] = guildEmoji;
-	}
-	resolveString(key, emojiName, failures) {
-		const appEmoji = this.core.bot.client.application?.emojis.cache.find((e) => e.name === emojiName);
-		if (!appEmoji) {
-			failures.push(`  - "${emojiName}" for "${key}" was not found among the application emojis`);
-			return;
-		}
-		emojiStorage[key] = appEmoji;
-	}
-	clearEmojis() {
-		(0, _seedcord_core_internal.clearStore)(emojiStorage);
-	}
-};
-
-//#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, dangerousNotice } = a instanceof discord_js.Role || a instanceof discord_js.GuildMember ? {
-		for: a,
-		in: b,
-		scope: c,
-		inverse: d ?? false,
-		...e
-	} : a;
-	const perms = pIn instanceof discord_js.Guild ? pFor.permissions : pIn.permissionsFor(pFor, true);
-	(0, _seedcord_core.assertPermissions)({
-		subject: mentionFor(pFor),
-		permissions: perms.bitfield,
-		scope,
-		inverse,
-		...missingNotice && { missingNotice },
-		...dangerousNotice && { dangerousNotice }
-	});
-}
-
-//#endregion
-//#region src/bot/utilities/permissions/checkBotPermissions.ts
-/**
-* Checks the bot's own permissions in a {@link Guild} or {@link TextChannel}. Refuses when a permission in
-* `scope` is missing, or with `inverse` when one is present. When the bot member is uncached, the refusal
-* reports every permission in `scope` as missing.
-*
-* @example
-* ```ts
-* import { PermissionFlagsBits } from 'discord.js';
-* import { checkBotPermissions } from '@seedcord/gateway';
-*
-* checkBotPermissions(textChannel, [PermissionFlagsBits.SendMessages, PermissionFlagsBits.ViewChannel]);
-* ```
-*/
-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) => _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_logger.Logger("checkBotPermissions", { channel: "errors" }).warn(`Bot member is unavailable in guild ${target.guild.id} while checking permissions in channel ${target.id}`);
-		const names = scope.map((bit) => _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);
-}
-
-//#endregion
-//#region src/bot/utilities/permissions/hasPermsToAssign.ts
-function botRoleOf(guild) {
-	const botRole = guild.roles.botRoleFor(guild.client.user);
-	if (!botRole) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreBotRoleMissing, [guild.id]);
-	return botRole;
-}
-/**
-* Validates that the bot can assign a target role. Refuses when the target role is above the bot's, is managed, or the bot lacks Manage Roles.
-*
-* @param roleOrOptions - Target role or complete options for the check
-* @throws A `Notice` on refusal, or a `SeedcordError` when the bot has no role in the guild's role cache.
-*
-* @example
-* ```ts
-* import { hasPermsToAssign } from '@seedcord/gateway';
-*
-* // Check if the bot can assign a specific role
-* hasPermsToAssign(role);
-*
-* // Check with custom error handling
-* hasPermsToAssign({
-*   targetRole: role,
-*   noticeOverrides: {
-*     higherNotice: CustomHigherNotice,
-*     managedNotice: CustomManagedNotice,
-*     missingNotice: CustomMissingPermissionsNotice
-*   }
-* });
-* ```
-*/
-function hasPermsToAssign(roleOrOptions) {
-	const { targetRole, noticeOverrides: errors } = roleOrOptions instanceof discord_js.Role ? {
-		targetRole: roleOrOptions,
-		noticeOverrides: void 0
-	} : roleOrOptions;
-	const HigherNotice = errors?.higherNotice ?? RoleHigherThanMe;
-	const ManagedNotice = errors?.managedNotice ?? CannotAssignBotRole;
-	const MissingNotice = errors?.missingNotice ?? _seedcord_core_internal.MissingPermissions;
-	const botRole = botRoleOf(targetRole.guild);
-	if (targetRole.comparePositionTo(botRole) >= 0) throw new HigherNotice("Role is higher than me", targetRole, botRole);
-	if (targetRole.managed) throw new ManagedNotice(`Cannot assign managed role ${targetRole.name}`);
-	checkBotPermissions(targetRole.guild, [discord_js.PermissionFlagsBits.ManageRoles], false, { missingNotice: MissingNotice });
-}
-
-//#endregion
-//#region src/bot/confirm/reserved.ts
-const RESERVED_CONFIRM_PREFIX = "__seedcord_confirm";
-const CONFIRM_DEF = new _seedcord_core.CustomId(RESERVED_CONFIRM_PREFIX).oneOf("choice", ["confirm", "cancel"]);
-
-//#endregion
-//#region src/bot/confirm/getConfirmation.ts
-const DEFAULT_TIMEOUT_MS = 3e4;
-const CONFIRM_IDS = {
-	confirm: CONFIRM_DEF.encode({ choice: "confirm" }),
-	cancel: CONFIRM_DEF.encode({ choice: "cancel" })
-};
-var ConfirmButtons = class extends _seedcord_core.RowComponent {
-	constructor(options) {
-		super("button");
-		this.instance.addComponents(new _discordjs_builders.ButtonBuilder().setCustomId(CONFIRM_IDS.confirm).setLabel(options?.confirmLabel ?? "Confirm").setStyle(options?.confirmStyle ?? discord_js.ButtonStyle.Danger), new _discordjs_builders.ButtonBuilder().setCustomId(CONFIRM_IDS.cancel).setLabel(options?.cancelLabel ?? "Cancel").setStyle(discord_js.ButtonStyle.Secondary));
-	}
-};
-var ConfirmPromptCard = class extends _seedcord_core.BuilderComponent {
-	constructor(text, options) {
-		super("container");
-		this.instance.addTextDisplayComponents(new _discordjs_builders.TextDisplayBuilder().setContent(text)).addActionRowComponents(new ConfirmButtons(options).component);
-	}
-};
-function defaultPrompt(text, options) {
-	return { components: [new ConfirmPromptCard(text, options).component] };
-}
-async function collectChoice(message, userId, timeoutMs) {
-	try {
-		return await message.awaitMessageComponent({
-			componentType: discord_js.ComponentType.Button,
-			time: timeoutMs,
-			filter: (click) => click.user.id === userId && CONFIRM_DEF.owns(click.customId)
-		});
-	} catch {
-		return null;
-	}
-}
-async function settle(sender, message, outcome) {
-	if (outcome === void 0) {
-		await sender.delete(message).catch(() => void 0);
-		return;
-	}
-	await sender.edit(message, typeof outcome === "function" ? await outcome() : outcome);
-}
-async function getConfirmation(handler, prompt, options) {
-	const { ephemeral = true, timeoutMs = DEFAULT_TIMEOUT_MS } = options ?? {};
-	const response = typeof prompt === "string" ? defaultPrompt(prompt, options) : await prompt(CONFIRM_IDS);
-	const interaction = handler.getEvent();
-	const sender = handler.getSender();
-	const message = await sender.send(response, { ephemeral });
-	const winner = await collectChoice(message, interaction.user.id, timeoutMs);
-	if (!winner) {
-		await settle(sender, message, options?.onTimeout);
-		return false;
-	}
-	await winner.deferUpdate().catch(() => void 0);
-	const confirmed = winner.customId === CONFIRM_IDS.confirm;
-	await settle(sender, message, confirmed ? options?.onConfirm : options?.onCancel);
-	return confirmed;
-}
-
-//#endregion
-//#region src/handlers/BaseHandler.ts
-/**
-* The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
-* gate hook.
-*/
-var BaseHandler = class extends _seedcord_core.BaseHandler {
-	getEvent() {
-		return this.event;
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/InteractionMiddleware.ts
-/**
-* Base class for interaction middleware
-*
-* Middleware runs before interaction handlers and can modify behavior or block execution.
-* Unlike handlers, middleware should not send responses directly.
-*
-* @typeParam Repliable - The interaction type this middleware processes
-*/
-var InteractionMiddleware = class extends BaseHandler {
-	constructor(event, core) {
-		super(event, core, void 0, "interactions");
-	}
-};
-
-//#endregion
-//#region src/bot/ReplySender.ts
-function isReplyFile(file) {
-	return typeof file === "object" && "data" in file && ArrayBuffer.isView(file.data);
-}
-function toDjsFile(file) {
-	if (!isReplyFile(file)) return file;
-	return {
-		attachment: Buffer.from(file.data),
-		name: file.name,
-		...file.description !== void 0 && { description: file.description },
-		...file.title !== void 0 && { title: file.title }
-	};
-}
-function seedState(interaction) {
-	if (interaction.deferred && interaction.ephemeral === null) return "deferred-update";
-	if (interaction.replied) return "replied";
-	if (interaction.deferred) return "deferred-reply";
-	return "unacked";
-}
-/** Writes interaction responses through discord.js. The repliable handler bases and the dispatcher construct it. */
-var ReplySender = class extends _seedcord_core_internal.BaseReplySender {
-	interaction;
-	constructor(interaction, routeId, bus) {
-		super(routeId, {
-			bus,
-			interactionId: interaction.id
-		}, seedState(interaction));
-		this.interaction = interaction;
-	}
-	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);
-	}
-	async writeDefer(opts) {
-		await this.interaction.deferReply({ flags: (0, _seedcord_core_internal.deferFlags)(opts) });
-	}
-	async writeDeferUpdate() {
-		await this.sourceInteraction("deferUpdate").deferUpdate();
-	}
-	async writeUpdate(response) {
-		const result = await this.sourceInteraction("update").update({
-			...this.updateOptions(response),
-			withResponse: true
-		});
-		return this.createdMessage(result);
-	}
-	async writeFollowUp(response, opts) {
-		return await this.interaction.followUp(this.replyOptions(response, (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();
-	}
-	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: reply.components,
-			flags,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: reply.files.map(toDjsFile) }
-		};
-	}
-	editOptions(response) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags: discord_js.MessageFlags.IsComponentsV2,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: reply.files.map(toDjsFile) }
-		};
-	}
-	updateOptions(response) {
-		const reply = this.serialize(response);
-		return {
-			components: reply.components,
-			flags: discord_js.MessageFlags.IsComponentsV2,
-			...reply.allowedMentions && { allowedMentions: reply.allowedMentions },
-			...reply.files && { files: reply.files.map(toDjsFile) }
-		};
-	}
-	createdMessage(result) {
-		return result.resource?.message ?? void 0;
-	}
-};
-
-//#endregion
-//#region src/handlers/RepliableHandler.ts
-/**
-* Shared base the repliable interaction handlers extend.
-*
-* Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
-* {@link SelectMenuHandler}, or {@link ContextMenuHandler} instead. This class binds the core reply base
-* to the gateway sender.
-*
-* @typeParam Event - The repliable interaction type this handler processes
-*/
-var RepliableHandler = class extends _seedcord_core.RepliableHandler {
-	/** @internal */
-	getEvent() {
-		return this.event;
-	}
-	buildSender(event, core, routeId) {
-		return new ReplySender(event, routeId, core.bus);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/InteractionHandler.ts
-/**
-* Shared base the typed interaction handlers extend.
-*
-* 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
-*/
-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/bot/utilities/miscellaneous/slashRouteOf.ts
-function slashRouteOf(interaction) {
-	const group = interaction.options.getSubcommandGroup(false) ?? void 0;
-	const subcommand = interaction.options.getSubcommand(false) ?? void 0;
-	return (0, _seedcord_utils_internal.buildSlashRoute)(interaction.commandName, subcommand, group);
-}
-
-//#endregion
-//#region src/handlers/interaction/SlashHandler.ts
-/**
-* Base class for a chat-input (slash) command handler.
-*
-* Pass the route from the generated registry as the generic, the same string as `@SlashRoute`, then read
-* `this.options` for a single command or `this.match` for several. Command authoring stays plain
-* discord.js, `seedcord codegen` reads its `toJSON()` to type these options.
-*
-* @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
-* @typeParam Cache - The interaction cache state, `'cached'` by default.
-*
-* @example
-* ```ts
-* \@SlashRoute('ban')
-* class BanHandler extends SlashHandler<'ban'> {
-*     async execute() {
-*         const target = this.options.getUser('target'); // User
-*         const reason = this.options.getString('reason'); // string | null
-*     }
-* }
-* ```
-*/
-var SlashHandler = class extends InteractionHandler {
-	/**
-	* The typed options for this command's route. Required options drop the null, choices narrow to their
-	* literal union, and only the getters for kinds this command actually uses appear. Use `this.event.options`
-	* directly for anything outside this view, such as narrowing a channel option by type.
-	*/
-	get options() {
-		return this.event.options;
-	}
-	/**
-	* Run the arm for whichever command fired. Use this only when the handler is registered for several
-	* routes.
-	*
-	* Provide one arm per registered route, keyed by its route string, and each arm receives that route's
-	* own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
-	* key is a compile error.
-	*
-	* @param arms - One handler per registered route, keyed by route string.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@SlashRoute('ban', 'kick')
-	* class ModHandler extends SlashHandler<'ban' | 'kick'> {
-	*     async execute() {
-	*         await this.match({
-	*             ban: (options) => this.event.guild?.members.ban(options.getUser('target', true).id),
-	*             kick: (options) => this.event.guild?.members.kick(options.getUser('member', true).id)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		const route = slashRouteOf(this.event);
-		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);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/ContextMenuHandler.ts
-/**
-* Base class for a context-menu command handler (right-click a user or a message).
-*
-* Pass the kind from `discord.js`'s {@link ApplicationCommandType} as the generic, the same value as
-* `@ContextMenuRoute`. Read the right-clicked entity from `this.target`, a `User` for a user menu and a
-* `Message` for a message menu. Context menus carry no options, so a handler registered for several names
-* reads `this.target` uniformly with no per-name branch.
-*
-* @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
-* @typeParam Cache - The interaction cache state, `'cached'` by default.
-*
-* @example
-* ```ts
-* \@ContextMenuRoute(ApplicationCommandType.Message, 'Report Message')
-* class ReportMessage extends ContextMenuHandler<ApplicationCommandType.Message> {
-*     async execute() {
-*         const message = this.target;
-*     }
-* }
-* ```
-*/
-var ContextMenuHandler = class extends InteractionHandler {
-	get target() {
-		const event = this.event;
-		return "targetUser" in event ? event.targetUser : event.targetMessage;
-	}
-	/**
-	* The invoking guild member, resolved only on user menus. Reading it on a message menu is a compile
-	* error since the type is `never` there.
-	*/
-	get targetMember() {
-		return this.event.targetMember;
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/AutocompleteHandler.ts
-/**
-* Base class for a Discord autocomplete handler.
-*
-* Pass the command route(s) from the generated registry as the generic, the same string(s) as
-* `@AutocompleteRoute`. Branch on the focused field with `this.match`, read already-entered sibling options
-* with `this.options`, and find which command fired with `this.route`.
-*
-* @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'search'` or `'search' | 'find'`.
-* @typeParam Cache - The interaction cache state, `'cached'` by default.
-*
-* @example
-* ```ts
-* \@AutocompleteRoute('search')
-* class SearchAutocomplete extends AutocompleteHandler<'search'> {
-*     async execute() {
-*         await this.match({
-*             query: (value, respond) => respond([{ name: value, value }])
-*         });
-*     }
-* }
-* ```
-*/
-var AutocompleteHandler = class extends BaseHandler {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch, "interactions");
-	}
-	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.
-	*/
-	get focused() {
-		if (this.decodedFocused) return this.decodedFocused;
-		const raw = this.event.options.getFocused(true);
-		const focused = {
-			name: raw.name,
-			value: raw.value
-		};
-		this.decodedFocused = focused;
-		return focused;
-	}
-	/**
-	* Run the arm for the focused field. Because an autocomplete always dispatches by which field is
-	* focused, match is how you read it. There is no single-field shortcut the way slash/component handlers have one.
-	*
-	* Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
-	* arm receives the focused partial value and a `respond` typed to that field's choice value. The
-	* arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
-	* focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
-	*
-	* @param arms - One handler per autocompletable field, keyed by field name.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@AutocompleteRoute('search')
-	* class SearchAutocomplete extends AutocompleteHandler<'search'> {
-	*     async execute() {
-	*         await this.match({
-	*             query: (value, respond) => respond(titles(value).map((s) => ({ name: s, value: s }))),
-	*             tag: (value, respond) => respond(tags(value).map((s) => ({ name: s, value: s })))
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		const { name, value } = this.focused;
-		const respond = (choices) => this.respond(choices);
-		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-		if (!arm) throw new _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) {
-		const routeId = this.dispatch?.routeId ?? "autocomplete";
-		await (0, _seedcord_core_internal.reportedWrite)({
-			bus: this.core.bus,
-			interactionId: this.event.id
-		}, routeId, "respond", () => this.event.respond(choices));
-	}
-	/** The firing command route, for a field whose completion differs per registered command. */
-	get route() {
-		return slashRouteOf(this.event);
-	}
-	/**
-	* The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
-	* (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
-	* types the focused field. The focused field is on `this.focused`.
-	*/
-	get options() {
-		return this.event.options;
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/ComponentHandler.ts
-/**
-* Shared base the customId-routed component handlers extend.
-*
-* 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 {
-	/** 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() {
-		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.
-	*
-	* Reading this decodes `this.event.customId` once (cached after the first read) and throws
-	* `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
-	* controller boundary turns into a reply. On a handler registered for several routes this is
-	* `never`. Use {@link match} instead.
-	*/
-	get params() {
-		return this.route.params;
-	}
-	/**
-	* Run the arm for whichever route the component was minted from. Use this only when the handler is
-	* registered for several routes. A single-route handler reads `this.params` directly. On a multi-route
-	* handler `this.params` is `never`, leaving match as the only way to read the decoded params.
-	*
-	* Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
-	* decoded params. The 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 callback per registered route, keyed by prefix.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@ButtonRoute(Approve, Reject)
-	* class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
-	*     async execute() {
-	*         await this.match({
-	*             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
-	*             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		const { prefix, params } = this.route;
-		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);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/ButtonHandler.ts
-/**
-* 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. 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.
-*
-* @example
-* ```ts
-* \@ButtonRoute(ApproveId)
-* class ApproveButton extends ButtonHandler<[typeof ApproveId]> {
-*     async execute() {
-*         const { userId } = this.params;
-*         await this.reply(`approved <@${userId}>`);
-*     }
-* }
-* ```
-*/
-var ButtonHandler = class extends ComponentHandler {};
-
-//#endregion
-//#region src/handlers/interaction/components/ModalHandler.ts
-/**
-* Base class for a modal submit handler.
-*
-* 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`, 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.
-*
-* @example
-* ```ts
-* \@ModalRoute(ConfigId)
-* class ConfigModal extends ModalHandler<[typeof ConfigId]> {
-*     async execute() {
-*         const { guildId } = this.params;
-*         const name = this.event.fields.getTextInputValue('name');
-*         await this.reply(`saved ${name} for ${guildId}`);
-*     }
-* }
-* ```
-*/
-var ModalHandler = class extends ComponentHandler {
-	/** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
-	update(response) {
-		this.ensureSourceMessage("update");
-		return super.update(response);
-	}
-	/** Acknowledge the submit without changing the source message. Throws when a command opened the modal. */
-	deferUpdate() {
-		this.ensureSourceMessage("deferUpdate");
-		return super.deferUpdate();
-	}
-	ensureSourceMessage(method) {
-		if (this.event.isFromMessage()) return;
-		throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/SelectMenuHandler.ts
-/**
-* Base class for a select menu handler.
-*
-* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
-* so `this.event` and `this.event.values` are narrowed to that kind. Read `this.params` for a single
-* route or `this.match` for several, 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]`.
-* @typeParam Cache - The interaction cache state, `'cached'` by default.
-*
-* @example
-* ```ts
-* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
-* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
-*     async execute() {
-*         const { roleId } = this.params;
-*         await this.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
-*     }
-* }
-* ```
-*/
-var SelectMenuHandler = class extends ComponentHandler {};
-
-//#endregion
-//#region src/handlers/event/EventHandler.ts
-/**
-* Base class for a Discord client event handler.
-*
-* Pass the event name(s) as the generic, the same one(s) as `@RegisterEvent`. A single-event handler reads
-* `this.event` (the payload tuple) directly. A handler registered for several events branches with `this.match`,
-* keyed by event name, since the union of payload tuples is not directly readable.
-*
-* @typeParam Names - One or more `ClientEvents` keys, e.g. `Events.MessageCreate` or `Events.MessageCreate | Events.MessageUpdate`.
-*
-* @example
-* ```ts
-* \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
-* class PingPong extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
-*     async execute() {
-*         await this.match({
-*             [Events.MessageCreate]: (message) => message.reply('pong'),
-*             [Events.MessageUpdate]: (_oldMessage, edited) => edited.reply('pong')
-*         });
-*     }
-* }
-* ```
-*/
-var EventHandler = class extends BaseHandler {
-	firedEvent;
-	constructor(event, core, eventName) {
-		super(event, core, void 0, "events");
-		this.firedEvent = eventName;
-	}
-	/**
-	* Run the arm for whichever event fired. Use this only when the handler is registered for several
-	* events. A single-event handler reads `this.event` directly. On a multi-event handler `this.event` is
-	* `never`, so match is the only way to read the payload.
-	*
-	* Provide one arm per registered event, keyed by its name, and each arm receives that event's own
-	* payload tuple. The arms must cover every event in the generic, a missing event or an unknown key is a
-	* compile error.
-	*
-	* @param arms - One handler per registered event, keyed by event name.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
-	* class MessageWatcher extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
-	*     async execute() {
-	*         await this.match({
-	*             [Events.MessageCreate]: (message) => this.scan(message),
-	*             [Events.MessageUpdate]: (_old, updated) => this.scan(updated)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		const name = this.firedEvent;
-		if (name === void 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.EventMatchArmMissing, ["<no event>"]);
-		const arm = arms[name];
-		if (typeof arm !== "function") throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.EventMatchArmMissing, [name]);
-		return await arm(...this.getEvent());
-	}
-};
-
-//#endregion
-//#region src/handlers/event/EventMiddleware.ts
-/**
-* Base class for Discord event middleware.
-*
-* Middleware runs before event handlers and can stop the event by throwing a `Silence`. Unlike `EventHandler`, it
-* runs the SAME for every event it is registered for, so it has no `match`. Specify a single event in the
-* generic and `{ events }` to read `this.event` fully typed. Span several events (or omit `{ events }` for a
-* catchall) and `this.event` narrows to `never`, read `this.eventName` and do work that does not depend on the
-* payload shape. A middleware that needs each event's payload is written one event per class.
-*
-* @typeParam EventName - One or more `ClientEvents` keys. Defaults to every event (catchall).
-*/
-var EventMiddleware = class extends BaseHandler {
-	firedEvent;
-	constructor(event, core, eventName) {
-		super(event, core, void 0, "events");
-		this.firedEvent = eventName;
-	}
-	/**
-	* The event that fired this middleware. Read it on a catchall or multi-event middleware, where `this.event`
-	* is `never`, to do work that does not depend on the payload shape. A single-event middleware reads
-	* `this.event` directly and does not need this.
-	*/
-	get eventName() {
-		if (this.firedEvent === void 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.EventMiddlewareNameUnavailable);
-		return this.firedEvent;
-	}
-};
-
-//#endregion
-//#region src/pagination/Paginator.ts
-function contextOf(interaction, core) {
-	return {
-		interaction,
-		user: interaction.user,
-		guild: interaction.guild,
-		core
-	};
-}
-/**
-* A restart-proof paginator. Each nav button's customId encodes its full target page, so clicks are
-* idempotent and survive a restart. A persistent `@ButtonRoute` on `Handler` dispatches the clicks.
-*
-* @typeParam Item - The item type, inferred from the source.
-* @typeParam Prefix - The route prefix, inferred from `config.prefix`.
-*
-* @example
-* ```ts
-* export const Bans = new Paginator({
-*     prefix: 'bans',
-*     source: new ArraySource((ctx) => ctx.guild.bans.fetch().then((b) => [...b.values()]), { perPage: 10 }),
-*     renderItem: (ban) => ban.user.tag
-* });
-*
-* \@ButtonRoute(Bans.cursor)
-* export class BansNav extends Bans.Handler {}
-* ```
-*/
-var Paginator = class extends _seedcord_core.PaginatorBase {
-	/** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
-	Handler;
-	constructor(config) {
-		super(config);
-		const loadPage = (ctx, n) => this.page(ctx, n);
-		this.Handler = class Nav extends ButtonHandler {
-			async execute() {
-				await this.deferUpdate();
-				const response = await loadPage(contextOf(this.event, this.core), this.params.page);
-				await this.update(response);
-			}
-		};
-	}
-	/**
-	* Render page 0 and send it through the handler's sender, which picks reply, edit, or followUp from its
-	* ack state.
-	*
-	* @param handler - The handler starting the paginator, normally `this`.
-	*/
-	async start(handler) {
-		const interaction = handler.getEvent();
-		const response = await this.page(contextOf(interaction, handler.core), 0);
-		return handler.getSender().send(response, { ephemeral: this.config.ephemeral ?? false });
-	}
-};
-
-//#endregion
-//#region src/pagination/sources.ts
-/**
-* A source for a bounded list you can load whole. It loads the full list on every click, then slices the
-* page, so the real total is known (a real last button, "Page X of Y"). Cache inside your loader if the
-* load is expensive.
-*
-* @typeParam Item - The item type, inferred from the loader's return.
-*/
-var ArraySource = class extends _seedcord_core.ArraySource {};
-/**
-* A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
-* The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
-* source has no cheap total, so `totalPages` is undefined, the last button is omitted, and the indicator
-* reads "Page X".
-*
-* @typeParam Item - The item type, inferred from the fetcher's slice.
-*/
-var CursorSource = class extends _seedcord_core.CursorSource {};
-
-//#endregion
-//#region src/subscribers/index.ts
-/**
-* Base class for a gateway subscriber, binding `this.core` to the gateway {@link Core}.
-*
-* @typeParam KeyOfSubscribers - The subscription key this handler receives
-*/
-var Subscriber = class extends _seedcord_core.Subscriber {};
-/**
-* Base class for a gateway subscriber that delivers its event to a Discord webhook, binding
-* `this.core` to the gateway {@link Core}.
-*
-* @typeParam KeyOfSubscribers - The subscription key this reporter receives
-*/
-var WebhookLog = class extends _seedcord_core.WebhookLog {};
-
-//#endregion
-//#region src/plugin.ts
-/**
-* Base class for a gateway plugin, binding `this.core` to the gateway {@link Core}.
-*
-* A plugin that runs on either transport extends the base from `@seedcord/core/plugin`, whose
-* `this.core` is typed to the shared members only.
-*
-* @typeParam Opts - The transport and runtime the plugin declares.
-*/
-var Plugin = class extends _seedcord_core_plugin.Plugin {};
-
-//#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,
-		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 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/miscellaneous/extractErrorResponse.ts
-const logger$2 = new _seedcord_logger.Logger("ErrorsHandling", { channel: "errors" });
-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(core, origin, error, publish) {
-	const throttle = _seedcord_core_internal.FaultThrottle.for(core);
-	const key = faultKey(origin, error);
-	if (!throttle.shouldReport(key)) {
-		logger$2.debug(`throttled duplicate fault ${key}`);
-		return;
-	}
-	publish();
-	throttle.markReported(key);
-}
-function reportFault(denial, core, origin, uuid) {
-	logger$2.error(`${denial.name}: ${uuid}`, denial);
-	withThrottle(core, origin, denial, () => {
-		if (origin.interaction) core.bus[_seedcord_core_internal.PublishDefault]("handledException", {
-			denial,
-			uuid,
-			source: buildInteractionSource(origin.interaction)
-		});
-		else if (origin.event) core.bus[_seedcord_core_internal.PublishDefault]("handledException", {
-			denial,
-			uuid,
-			source: buildEventSource(origin.event, origin)
-		});
-		else core.bus[_seedcord_core_internal.PublishDefault]("unknownException", {
-			uuid,
-			error: denial,
-			...scalarActors(origin),
-			metadata: metadataFor(origin)
-		});
-	});
-}
-function causeLine(error) {
-	const { cause } = error;
-	if (!Error.isError(cause)) return "";
-	const [first] = cause.message.split("\n");
-	return `\ncaused by ${cause.name}: ${first ?? cause.message}`;
-}
-function reportRawFault(error, core, origin, uuid) {
-	if (core.config.errors?.errorStack ?? false) logger$2.error(uuid, error);
-	else logger$2.error(`${uuid} | ${error.message}${causeLine(error)}`);
-	withThrottle(core, origin, error, () => {
-		core.bus[_seedcord_core_internal.PublishDefault]("unknownException", {
-			uuid,
-			error,
-			...scalarActors(origin),
-			metadata: metadataFor(origin)
-		});
-	});
-}
-function scalarActors(origin) {
-	return {
-		guild: origin.guild ? {
-			id: origin.guild.id,
-			name: origin.guild.name
-		} : void 0,
-		user: origin.user ? {
-			id: origin.user.id,
-			username: origin.user.username
-		} : void 0
-	};
-}
-function metadataFor(origin) {
-	if (origin.event) return {
-		eventName: origin.event.name,
-		handler: origin.event.handler,
-		args: origin.event.args
-	};
-	return origin.metadata;
-}
-function buildEventSource(event, origin) {
-	return {
-		kind: "event",
-		eventName: event.name,
-		handler: event.handler,
-		userId: origin.user?.id ?? null,
-		guildId: origin.guild?.id ?? null,
-		channelId: event.channelId,
-		raw: event.args
-	};
-}
-function faultKey(origin, error) {
-	const name = error instanceof _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;
-	return {
-		kind: "interaction",
-		interactionKind: interactionKind(interaction),
-		command,
-		customId,
-		userId: interaction.user.id,
-		guildId: interaction.guildId,
-		channelId: interaction.channelId,
-		interactionId: interaction.id,
-		raw: interaction
-	};
-}
-function interactionKind(interaction) {
-	if (interaction.isChatInputCommand()) return "slash";
-	if (interaction.isContextMenuCommand()) return "context-menu";
-	if (interaction.isButton()) return "button";
-	if (interaction.isAnySelectMenu()) return "select";
-	return "modal";
-}
-
-//#endregion
-//#region src/bot/handleEventFault.ts
-const logger$1 = new _seedcord_logger.Logger("Faults", { channel: "errors" });
-function handleEventFault(caught, eventName, handlerName, args, core) {
-	if (caught instanceof _seedcord_core.Silence) {
-		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger$1.debug(`Silence: ${caught.reason}`);
-		return;
-	}
-	const error = (0, _seedcord_core_internal.asError)(caught);
-	const ignore = new Set(core.config.errors?.ignoreEventApiCodes ?? []);
-	if (error instanceof discord_js.DiscordAPIError && ignore.has(error.code)) {
-		logger$1.debug(`swallowed api code ${error.code}`);
-		return;
-	}
-	if (error instanceof _seedcord_core.Notice && !error.report) return;
-	const actor = deriveEventActor(args);
-	extractErrorResponse(error, core, {
-		event: {
-			name: eventName,
-			handler: handlerName,
-			args,
-			channelId: actor.channelId
-		},
-		guild: actor.guild,
-		user: actor.user
-	});
-}
-
-//#endregion
-//#region src/bot/controllers/EventDispatcher.ts
-/**
-* Interactions route through InteractionDispatcher.
-*
-* @internal
-*/
-var EventDispatcher = class {
-	core;
-	logger = new _seedcord_logger.Logger("Events", { channel: "events" });
-	isInitialized = false;
-	eventMap = /* @__PURE__ */ new Map();
-	middlewares = [];
-	executedOnceHandlers = /* @__PURE__ */ new Set();
-	attachedEvents = /* @__PURE__ */ new Set();
-	inFlight = /* @__PURE__ */ new Set();
-	draining = false;
-	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 _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),
-			isMiddleware: this.isMiddlewareClass.bind(this),
-			registerHandler: this.registerHandler.bind(this),
-			registerMiddleware: this.registerMiddleware.bind(this),
-			unregisterHandler: this.unregisterHandler.bind(this),
-			unregisterMiddleware: this.unregisterMiddleware.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
-			logger: this.logger
-		});
-	}
-	getArtifacts(ctor) {
-		const events = [];
-		for (const [event, handlers] of this.eventMap.entries()) if (handlers.some((h) => h.ctor === ctor)) events.push(event);
-		return events;
-	}
-	async init() {
-		if (this.isInitialized) return;
-		this.isInitialized = true;
-		const handlersDir = this.core.config.bot.events.path;
-		if (!handlersDir) return;
-		const middlewareDir = (0, _seedcord_utils.hasKeys)(this.core.config.bot.events, ["middlewares"]) ? this.core.config.bot.events.middlewares : void 0;
-		this.loading = true;
-		this.loadedHandlers.length = 0;
-		this.loadedMiddlewares.length = 0;
-		try {
-			if (middlewareDir) await this.loadMiddlewares(middlewareDir);
-			await this.loadHandlers(handlersDir);
-		} finally {
-			this.loading = false;
-		}
-		this.attachToClient();
-		this.reportLoad();
-	}
-	reportLoad() {
-		const { utils } = this.logger;
-		utils.summary("Loaded", {
-			"event handlers": this.loadedHandlers.length,
-			middlewares: this.loadedMiddlewares.length
-		}, "debug");
-		if (this.loadedMiddlewares.length > 0) utils.block("Loaded event middlewares", utils.entries(this.loadedMiddlewares), "debug");
-		const perEvent = {};
-		for (const [event, handlers] of this.eventMap) perEvent[event] = handlers.length;
-		utils.block("Loaded event handlers", [...utils.entries(this.loadedHandlers), ...utils.counts(perEvent)], "debug");
-	}
-	async loadHandlers(dir) {
-		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);
-				this.hmrHandler?.trackHandler(fullPath, val);
-			}
-		});
-	}
-	async loadMiddlewares(dir) {
-		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);
-				this.hmrHandler?.trackMiddleware(fullPath, val);
-			}
-		});
-	}
-	/** @internal */
-	async onHmr(event) {
-		await this.hmrHandler?.handle(event);
-	}
-	unregisterHandler(handlerClass, artifacts) {
-		const events = artifacts ?? [...this.eventMap.keys()];
-		for (const event of events) {
-			const handlers = this.eventMap.get(event);
-			if (!handlers) continue;
-			const index = handlers.findIndex((h) => h.ctor === handlerClass);
-			if (index !== -1) {
-				handlers.splice(index, 1);
-				if (handlers.length === 0) this.eventMap.delete(event);
-			}
-		}
-	}
-	unregisterMiddleware(middlewareCtor) {
-		const index = this.middlewares.findIndex((entry) => entry.ctor === middlewareCtor);
-		if (index !== -1) this.middlewares.splice(index, 1);
-	}
-	registerMiddleware(middlewareCtor, relativePath) {
-		const metadata = Reflect.getMetadata(_seedcord_core_internal.MiddlewareMetadataKey, middlewareCtor);
-		if (metadata?.type !== "event") return;
-		if (this.middlewares.some((entry) => entry.ctor === middlewareCtor)) return;
-		this.middlewares.push({
-			ctor: middlewareCtor,
-			priority: metadata.priority,
-			...metadata.events && { events: metadata.events }
-		});
-		this.middlewares.sort((a, b) => a.priority - b.priority);
-		if (this.loading) this.loadedMiddlewares.push({
-			name: `${middlewareCtor.name} (${metadata.priority})`,
-			from: (0, _seedcord_utils.formatFilePath)(relativePath)
-		});
-	}
-	async runMiddlewares(eventName, args) {
-		for (const { ctor, events } of this.middlewares) {
-			if (events && !events.includes(eventName)) continue;
-			try {
-				await new ctor(args, this.core, eventName).execute();
-			} catch (caught) {
-				handleEventFault(caught, String(eventName), ctor.name, args, this.core);
-				return false;
-			}
-		}
-		return true;
-	}
-	isEventHandlerClass(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof EventHandler && Reflect.hasMetadata(_seedcord_core_internal.EventMetadataKey, obj);
-	}
-	isMiddlewareClass(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof EventMiddleware && Reflect.hasMetadata(_seedcord_core_internal.MiddlewareMetadataKey, obj);
-	}
-	registerHandler(handlerClass, relativePath) {
-		const raw = Reflect.getMetadata(_seedcord_core_internal.EventMetadataKey, handlerClass);
-		const register = (key, frequency) => {
-			let handlers = this.eventMap.get(key);
-			if (!handlers) {
-				handlers = [];
-				this.eventMap.set(key, handlers);
-			}
-			handlers.push({
-				ctor: handlerClass,
-				frequency
-			});
-			if (this.isInitialized && !this.attachedEvents.has(key)) this.attachListener(key);
-		};
-		if (Array.isArray(raw)) for (const entry of raw) register(entry.event, entry.frequency);
-		else {
-			const names = (0, _seedcord_core_internal.areRoutes)(raw) ? raw : typeof raw === "string" ? [raw] : [];
-			for (const name of names) register(name, "on");
-		}
-		const from = (0, _seedcord_utils.formatFilePath)(relativePath);
-		if (this.loading) this.loadedHandlers.push({
-			name: handlerClass.name,
-			from
-		});
-	}
-	attachToClient() {
-		for (const [eventName] of this.eventMap) this.attachListener(eventName);
-	}
-	attachListener(eventName) {
-		if (this.attachedEvents.has(eventName)) return;
-		this.attachedEvents.add(eventName);
-		const handlerEntries = this.eventMap.get(eventName);
-		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) => {
-			if (this.draining) return;
-			this.core.bus[_seedcord_core_internal.PublishDefault]("anyEvent", {
-				name: eventName,
-				args
-			});
-			const run = this.processEvent(eventName, args).catch((caught) => {
-				const error = (0, _seedcord_core_internal.asError)(caught);
-				this.logger.error(`[${_seedcord_logger.paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
-				this.core.bus[_seedcord_core_internal.PublishDefault]("unhandledEventError", { error });
-			});
-			this.inFlight.add(run);
-			run.finally(() => this.inFlight.delete(run));
-		});
-	}
-	stopAccepting() {
-		this.draining = true;
-	}
-	drain(timeoutMs) {
-		return (0, _seedcord_core_node_internal.settleWithin)(Promise.allSettled(this.inFlight), timeoutMs);
-	}
-	async processEvent(eventName, args) {
-		const handlerEntries = this.eventMap.get(eventName);
-		if (!handlerEntries || handlerEntries.length === 0) return;
-		const handlersToExecute = handlerEntries.filter((entry) => entry.frequency !== "once" || !this.executedOnceHandlers.has(entry.ctor));
-		if (handlersToExecute.length === 0) return;
-		if (!await this.runMiddlewares(eventName, args)) return;
-		for (const entry of handlersToExecute) {
-			if (entry.frequency === "once") {
-				if (this.executedOnceHandlers.has(entry.ctor)) continue;
-				this.executedOnceHandlers.add(entry.ctor);
-			}
-			await this.processHandler(eventName, entry.ctor, args);
-		}
-	}
-	async processHandler(eventName, ctor, args) {
-		try {
-			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);
-			const eventCtx = eventGateContext(eventName, args, this.core);
-			await (0, _seedcord_core_internal.runHandlerGates)(ctor, eventCtx);
-			await handler.execute();
-		} catch (caught) {
-			handleEventFault(caught, String(eventName), ctor.name, args, this.core);
-		}
-	}
-};
-
-//#endregion
-//#region src/bot/defaults/UnhandledRepliable.ts
-var UnhandledRepliable = class extends InteractionHandler {
-	async execute() {
-		await this.reply("Feature not implemented yet.");
-	}
-};
-
-//#endregion
-//#region src/bot/defaults/UnhandledAutocomplete.ts
-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 = /* @__PURE__ */ new Set([
-	discord_js.RESTJSONErrorCodes.UnknownInteraction,
-	discord_js.RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
-	discord_js.RESTJSONErrorCodes.UnknownMessage
-]);
-
-//#endregion
-//#region src/bot/handleInteractionFault.ts
-const logger = new _seedcord_logger.Logger("Faults", { channel: "errors" });
-async function handleInteractionFault(caught, interaction, core, routeId, sender) {
-	if (caught instanceof _seedcord_core.Silence) {
-		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger.debug(`Silence: ${caught.reason}`);
-		return;
-	}
-	const error = (0, _seedcord_core_internal.asError)(caught);
-	const ignore = new Set(core.config.errors?.ignoreApiCodes ?? []);
-	if (error instanceof discord_js.DiscordAPIError && ignore.has(error.code)) {
-		logger.debug(`swallowed api code ${error.code}`);
-		return;
-	}
-	if (interaction.isAutocomplete()) {
-		extractErrorResponse(error, core, {
-			guild: interaction.guild,
-			user: interaction.user,
-			metadata: interaction,
-			route: slashRouteOf(interaction)
-		});
-		await sendEmptyChoices(interaction, core, routeId);
-		return;
-	}
-	const { response } = extractErrorResponse(error, core, {
-		interaction,
-		guild: interaction.guild,
-		user: interaction.user,
-		metadata: interaction
-	});
-	await sendGuarded(sender ?? new ReplySender(interaction, routeId, core.bus), response, error instanceof _seedcord_core.Notice ? error.ephemeral : true);
-}
-async function sendEmptyChoices(interaction, core, routeId) {
-	const telemetry = {
-		bus: core.bus,
-		interactionId: interaction.id
-	};
-	try {
-		await (0, _seedcord_core_internal.reportedWrite)(telemetry, routeId, "respond", () => interaction.respond([]));
-	} catch (error) {
-		logger.debug(`autocomplete empty-choices send failed: ${String(error)}`);
-	}
-}
-async function sendGuarded(sender, response, ephemeral) {
-	try {
-		await sender.send(response, { ephemeral });
-	} catch (error) {
-		if (error instanceof 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
-//#region src/bot/controllers/InteractionDispatcher.ts
-var InteractionDispatcher = class {
-	core;
-	logger = new _seedcord_logger.Logger("Interactions", { channel: "interactions" });
-	isInitialized = false;
-	slashMap = /* @__PURE__ */ new Map();
-	buttonMap = /* @__PURE__ */ new Map();
-	modalMap = /* @__PURE__ */ new Map();
-	stringSelectMap = /* @__PURE__ */ new Map();
-	userSelectMap = /* @__PURE__ */ new Map();
-	roleSelectMap = /* @__PURE__ */ new Map();
-	channelSelectMap = /* @__PURE__ */ new Map();
-	mentionableSelectMap = /* @__PURE__ */ new Map();
-	messageContextMenuMap = /* @__PURE__ */ new Map();
-	userContextMenuMap = /* @__PURE__ */ new Map();
-	autocompleteMap = /* @__PURE__ */ new Map();
-	handlerFiles = /* @__PURE__ */ new Map();
-	keysToIgnore = /* @__PURE__ */ new Set();
-	middlewares = [];
-	inFlight = /* @__PURE__ */ new Set();
-	draining = false;
-	loading = false;
-	loadedHandlers = [];
-	loadedMiddlewares = [];
-	hmrHandler;
-	routeTypes = [
-		[_seedcord_core_internal.InteractionRoutes.Slash, this.slashMap],
-		[_seedcord_core_internal.InteractionRoutes.Button, this.buttonMap],
-		[_seedcord_core_internal.InteractionRoutes.Modal, this.modalMap],
-		[_seedcord_core_internal.InteractionRoutes.StringMenu, this.stringSelectMap],
-		[_seedcord_core_internal.InteractionRoutes.UserMenu, this.userSelectMap],
-		[_seedcord_core_internal.InteractionRoutes.RoleMenu, this.roleSelectMap],
-		[_seedcord_core_internal.InteractionRoutes.ChannelMenu, this.channelSelectMap],
-		[_seedcord_core_internal.InteractionRoutes.MentionableMenu, this.mentionableSelectMap],
-		[_seedcord_core_internal.InteractionRoutes.MessageContextMenu, this.messageContextMenuMap],
-		[_seedcord_core_internal.InteractionRoutes.UserContextMenu, this.userContextMenuMap],
-		[_seedcord_core_internal.InteractionRoutes.Autocomplete, this.autocompleteMap]
-	];
-	constructor(core) {
-		this.core = core;
-		const ignoredKeysFromConfig = (0, _seedcord_utils.hasKeys)(this.core.config.bot.interactions, ["ignoreCustomIds"]) ? this.core.config.bot.interactions.ignoreCustomIds : void 0;
-		if (ignoredKeysFromConfig) for (const ignoredKey of ignoredKeysFromConfig) this.keysToIgnore.add(ignoredKey);
-		this.keysToIgnore.add(CONFIRM_DEF);
-		const interactionsDir = this.core.config.bot.interactions.path;
-		if (!interactionsDir) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreControllerPathMissing, ["InteractionDispatcher", "interactions"]);
-		if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
-		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),
-			isMiddleware: this.isMiddlewareClass.bind(this),
-			registerHandler: this.registerHandler.bind(this),
-			registerMiddleware: this.registerMiddleware.bind(this),
-			unregisterHandler: this.unregisterHandler.bind(this),
-			unregisterMiddleware: this.unregisterMiddleware.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
-			logger: this.logger
-		});
-	}
-	warnUnhandledRoutes(commandLeaves) {
-		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.`);
-	}
-	warnUnhandledContextMenuRoutes(leaves) {
-		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 ((0, _seedcord_core_internal.areRoutes)(meta)) artifacts.push({
-				routeType,
-				routes: meta
-			});
-		}
-		return artifacts;
-	}
-	async init() {
-		if (this.isInitialized) return;
-		this.isInitialized = true;
-		const handlersDir = this.core.config.bot.interactions.path;
-		if (!handlersDir) return;
-		const middlewareDir = (0, _seedcord_utils.hasKeys)(this.core.config.bot.interactions, ["middlewares"]) ? this.core.config.bot.interactions.middlewares : void 0;
-		this.loading = true;
-		this.loadedHandlers.length = 0;
-		this.loadedMiddlewares.length = 0;
-		try {
-			if (middlewareDir) await this.loadMiddlewares(middlewareDir);
-			await this.loadHandlers(handlersDir);
-		} finally {
-			this.loading = false;
-		}
-		this.attachToClient();
-		this.reportLoad();
-	}
-	reportLoad() {
-		const { utils } = this.logger;
-		utils.summary("Loaded", {
-			"interaction handlers": this.loadedHandlers.length,
-			middlewares: this.loadedMiddlewares.length
-		}, "debug");
-		if (this.loadedMiddlewares.length > 0) utils.block("Loaded middlewares", utils.entries(this.loadedMiddlewares), "debug");
-		utils.block("Loaded interaction handlers", [...utils.entries(this.loadedHandlers), ...utils.counts({
-			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
-		})], "debug");
-	}
-	async loadHandlers(dir) {
-		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);
-				this.hmrHandler?.trackHandler(fullPath, val);
-			}
-		});
-	}
-	async loadMiddlewares(dir) {
-		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);
-				this.hmrHandler?.trackMiddleware(fullPath, val);
-			}
-		});
-	}
-	registerMiddleware(middlewareCtor, relativePath) {
-		const metadata = Reflect.getMetadata(_seedcord_core_internal.MiddlewareMetadataKey, middlewareCtor);
-		if (metadata?.type !== "interaction") return;
-		if (this.middlewares.some((entry) => entry.ctor === middlewareCtor)) return;
-		if (this.middlewares.some((entry) => entry.ctor.name === middlewareCtor.name)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.InteractionDuplicateMiddleware, [middlewareCtor.name]);
-		this.middlewares.push({
-			ctor: middlewareCtor,
-			priority: metadata.priority
-		});
-		this.middlewares.sort((a, b) => a.priority - b.priority);
-		if (this.loading) this.loadedMiddlewares.push({
-			name: `${middlewareCtor.name} (${metadata.priority})`,
-			from: (0, _seedcord_utils.formatFilePath)(relativePath)
-		});
-	}
-	isHandlerClass(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof InteractionHandler && Reflect.hasMetadata(_seedcord_core_internal.InteractionMetadataKey, obj) || obj.prototype instanceof AutocompleteHandler && Reflect.hasMetadata(_seedcord_core_internal.InteractionMetadataKey, obj);
-	}
-	isMiddlewareClass(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(_seedcord_core_internal.MiddlewareMetadataKey, obj);
-	}
-	registerHandler(handlerClass, relativePath) {
-		const from = (0, _seedcord_utils.formatFilePath)(relativePath);
-		const writes = [];
-		for (const [routeType, map] of this.routeTypes) {
-			const meta = Reflect.getMetadata(_seedcord_core_internal.InteractionRouteKeys[routeType], handlerClass);
-			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, [
-					`${routeType}:${route}`,
-					`${existing.name} (${this.handlerFiles.get(existing) ?? "unknown file"})`,
-					`${handlerClass.name} (${from})`
-				]);
-				writes.push([map, route]);
-			}
-		}
-		if (writes.length === 0) return;
-		for (const [map, route] of writes) map.set(route, handlerClass);
-		this.handlerFiles.set(handlerClass, from);
-		if (this.loading) this.loadedHandlers.push({
-			name: handlerClass.name,
-			from
-		});
-	}
-	async onHmr(event) {
-		await this.hmrHandler?.handle(event);
-	}
-	unregisterHandler(handlerClass, artifacts) {
-		this.handlerFiles.delete(handlerClass);
-		if (artifacts) {
-			for (const { routeType, routes } of artifacts) {
-				const map = this.routeTypes.find(([type]) => type === routeType)?.[1];
-				if (map) routes.forEach((route) => map.delete(route));
-			}
-			return;
-		}
-		for (const [routeType, map] of this.routeTypes) {
-			const meta = Reflect.getMetadata(_seedcord_core_internal.InteractionRouteKeys[routeType], handlerClass);
-			if (!(0, _seedcord_core_internal.areRoutes)(meta)) continue;
-			meta.forEach((route) => map.delete(route));
-		}
-	}
-	unregisterMiddleware(middlewareCtor) {
-		const index = this.middlewares.findIndex((entry) => entry.ctor === middlewareCtor);
-		if (index !== -1) this.middlewares.splice(index, 1);
-	}
-	attachToClient() {
-		this.core.bot.client.on(discord_js.Events.InteractionCreate, (interaction) => {
-			if (this.draining) return;
-			this.core.bus[_seedcord_core_internal.PublishDefault]("anyInteraction", { interaction });
-			const run = this.handleInteraction(interaction).catch((caught) => {
-				const error = (0, _seedcord_core_internal.asError)(caught);
-				this.logger.error(`[${_seedcord_logger.paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
-				this.core.bus[_seedcord_core_internal.PublishDefault]("unhandledInteractionError", { error });
-			});
-			this.inFlight.add(run);
-			run.finally(() => this.inFlight.delete(run));
-		});
-	}
-	stopAccepting() {
-		this.draining = true;
-	}
-	drain(timeoutMs) {
-		return (0, _seedcord_core_node_internal.settleWithin)(Promise.allSettled(this.inFlight), timeoutMs);
-	}
-	async handleCustomIdInteraction(interaction, kind, getMap) {
-		if ([...this.keysToIgnore].some((matcher) => matcher.owns(interaction.customId))) return;
-		const prefix = (0, _seedcord_core_internal.prefixOf)(interaction.customId);
-		if (!prefix) this.logger.warn(`${_seedcord_logger.paint.sky.bold(kind)} has invalid customId: ${_seedcord_logger.paint.mute(interaction.customId)}`);
-		await this.processInteraction(interaction, kind, () => prefix, (key) => getMap().get(key));
-	}
-	async processInteraction(interaction, kind, extractKey, getHandler, fallback = UnhandledRepliable) {
-		const key = extractKey(interaction);
-		const startedAt = performance.now();
-		const queuedMs = (0, _seedcord_core_internal.queuedMsFor)(interaction.id);
-		const matched = getHandler(key);
-		let routeId = `${kind}:${key || "unrouted"}`;
-		let reported = false;
-		const report = (outcome) => {
-			if (reported) return;
-			reported = true;
-			(0, _seedcord_core_internal.reportDispatch)(this.core.bus, {
-				routeId,
-				interactionId: interaction.id,
-				kind,
-				outcome,
-				startedAt,
-				fallback: !matched,
-				queuedMs
-			});
-		};
-		let sender;
-		try {
-			if (!interaction.isAutocomplete()) await this.runMiddlewares(interaction);
-			const HandlerCtor = matched ?? fallback;
-			const dispatch = new _seedcord_core.DispatchContext((0, _seedcord_core_internal.routeIdOf)(HandlerCtor) ?? routeId);
-			routeId = dispatch.routeId ?? routeId;
-			const handler = this.buildHandler(HandlerCtor, interaction, dispatch, key, !matched);
-			if (handler instanceof RepliableHandler) sender = handler.getSender();
-			const refusal = interaction.isAutocomplete() ? null : await this.gateRefusal(HandlerCtor, interaction, dispatch.routeId);
-			if (refusal) {
-				await this.answer(refusal.caught, interaction, routeId, sender, report);
-				return;
-			}
-			await handler.execute();
-			report("handled");
-		} catch (caught) {
-			await this.answer(caught, interaction, routeId, sender, report);
-		}
-	}
-	async answer(caught, interaction, routeId, sender, report) {
-		try {
-			await handleInteractionFault(caught, interaction, this.core, routeId, sender);
-		} finally {
-			report((0, _seedcord_core_internal.outcomeFor)(caught));
-		}
-	}
-	buildHandler(HandlerCtor, interaction, dispatch, key, isFallback) {
-		if (isFallback) this.logger.warn(`No handler found for key ${_seedcord_logger.paint.sky.bold(key)}. Falling back to ${HandlerCtor.name}.`);
-		this.logger.debug(`Processing ${_seedcord_logger.paint.mint.bold(key)} with ${_seedcord_logger.paint.mute(HandlerCtor.name)}`);
-		return new HandlerCtor(interaction, this.core, dispatch);
-	}
-	async runMiddlewares(interaction) {
-		for (const { ctor } of this.middlewares) await new ctor(interaction, this.core).execute();
-	}
-	async gateRefusal(HandlerCtor, interaction, routeId) {
-		const monitor = (0, _seedcord_core_internal.slowGateMonitor)();
-		try {
-			await (0, _seedcord_core_internal.runHandlerGates)(HandlerCtor, interactionGateContext(interaction, this.core), routeId ?? void 0, monitor?.observe);
-			return null;
-		} catch (caught) {
-			return { caught };
-		} finally {
-			monitor?.report(routeId);
-		}
-	}
-	async handleInteraction(interaction) {
-		switch (true) {
-			case interaction.isChatInputCommand():
-				await this.handleSlashCommand(interaction);
-				break;
-			case interaction.isButton():
-				await this.handleButton(interaction);
-				break;
-			case interaction.isModalSubmit():
-				await this.handleModal(interaction);
-				break;
-			case interaction.isStringSelectMenu():
-				await this.handleStringSelectMenu(interaction);
-				break;
-			case interaction.isUserSelectMenu():
-				await this.handleUserSelectMenu(interaction);
-				break;
-			case interaction.isRoleSelectMenu():
-				await this.handleRoleSelectMenu(interaction);
-				break;
-			case interaction.isChannelSelectMenu():
-				await this.handleChannelSelectMenu(interaction);
-				break;
-			case interaction.isMentionableSelectMenu():
-				await this.handleMentionableSelectMenu(interaction);
-				break;
-			case interaction.isMessageContextMenuCommand():
-				await this.handleMessageContextMenu(interaction);
-				break;
-			case interaction.isUserContextMenuCommand():
-				await this.handleUserContextMenu(interaction);
-				break;
-			case interaction.isAutocomplete():
-				await this.handleAutocomplete(interaction);
-				break;
-			default: this.logger.warn(`Unhandled interaction type: ${interaction.type}`);
-		}
-	}
-	async handleSlashCommand(interaction) {
-		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Slash, () => route, (key) => this.slashMap.get(key));
-	}
-	async handleButton(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Button, () => this.buttonMap);
-	}
-	async handleModal(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Modal, () => this.modalMap);
-	}
-	async handleStringSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.StringMenu, () => this.stringSelectMap);
-	}
-	async handleUserSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.UserMenu, () => this.userSelectMap);
-	}
-	async handleRoleSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.RoleMenu, () => this.roleSelectMap);
-	}
-	async handleChannelSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.ChannelMenu, () => this.channelSelectMap);
-	}
-	async handleMentionableSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.MentionableMenu, () => this.mentionableSelectMap);
-	}
-	async handleMessageContextMenu(interaction) {
-		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.MessageContextMenu, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
-	}
-	async handleUserContextMenu(interaction) {
-		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.UserContextMenu, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
-	}
-	async handleAutocomplete(interaction) {
-		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Autocomplete, () => route, (key) => this.autocompleteMap.get(key), UnhandledAutocomplete);
-	}
-};
-
-//#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-//#endregion
-//#region src/bot/Bot.ts
-const DISPATCH_DRAIN_TIMEOUT_MS = 5e3;
-const DRAIN_TASK_TIMEOUT_MS = 6e3;
-const UNBIND_TIMEOUT_MS = 2e3;
-const LOGOUT_TIMEOUT_MS = 2e3;
-/**
-* The Discord client and its controllers. Access it through `core.bot`.
-*/
-var Bot = class {
-	/** @internal */
-	logger = new _seedcord_logger.Logger("Bot", { channel: "bot" });
-	isInitialized = false;
-	_client;
-	interactions;
-	events;
-	emojiInjector;
-	commandRegistry;
-	/** @internal */
-	async onHmr(event) {
-		if (this.interactions) await this.interactions.onHmr(event);
-		if (this.events) await this.events.onHmr(event);
-		if (this.commandRegistry) await this.commandRegistry.onHmr(event);
-	}
-	/** @internal */
-	constructor(core) {
-		this._client = new discord_js.Client(core.config.bot.clientOptions);
-		if (core.config.bot.interactions.path) this.interactions = new InteractionDispatcher(core);
-		if (core.config.bot.events.path) this.events = new EventDispatcher(core);
-		const commandsDir = core.config.bot.commands.path;
-		if (commandsDir) {
-			const injector = new _seedcord_core_internal.CommandInjector();
-			const registry = new _seedcord_core_node_internal.CommandRegistry({
-				dir: commandsDir,
-				rest: this._client.rest,
-				applicationId: () => this.applicationId(),
-				onDeployed: (result) => {
-					injector.inject(result, registry.allCommands());
-				}
-			});
-			this.commandRegistry = registry;
-		}
-		this.emojiInjector = new EmojiInjector(core);
-		this.registerShutdownTasks(core);
-	}
-	applicationId() {
-		const { application } = this._client;
-		if (!application) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreApplicationUnavailable);
-		return application.id;
-	}
-	registerShutdownTasks(core) {
-		core.shutdown.addTask(_seedcord_core_node_internal.ShutdownPhase.Unbind, "stop-dispatch", () => {
-			this.stopAccepting();
-			return Promise.resolve();
-		}, UNBIND_TIMEOUT_MS);
-		core.shutdown.addTask(_seedcord_core_node_internal.ShutdownPhase.Drain, "drain-dispatch", () => this.drain(), DRAIN_TASK_TIMEOUT_MS);
-		core.shutdown.addTask(_seedcord_core_node_internal.ShutdownPhase.Logout, "stop-bot", async () => await this.stop(), LOGOUT_TIMEOUT_MS);
-	}
-	stopAccepting() {
-		this.interactions?.stopAccepting();
-		this.events?.stopAccepting();
-	}
-	async drain() {
-		await Promise.allSettled([this.interactions?.drain(DISPATCH_DRAIN_TIMEOUT_MS), this.events?.drain(DISPATCH_DRAIN_TIMEOUT_MS)]);
-	}
-	/** @internal */
-	async init() {
-		if (this.isInitialized) return;
-		this.isInitialized = true;
-		const token = this.botToken;
-		if (this.interactions) await this.interactions.init();
-		if (this.events) await this.events.init();
-		await this.login(token);
-		await this.emojiInjector.init();
-		if (this.commandRegistry) {
-			await this.commandRegistry.init();
-			await this.commandRegistry.setCommands();
-			this.interactions?.warnUnhandledRoutes(this.commandRegistry.routeLeaves());
-			this.interactions?.warnUnhandledContextMenuRoutes(this.commandRegistry.contextMenuLeaves());
-		}
-	}
-	/** @internal */
-	async stop() {
-		this._client.removeAllListeners();
-		await this.logout();
-	}
-	async login(token) {
-		const ready = Promise.withResolvers();
-		this._client.once(discord_js.Events.ClientReady, () => ready.resolve());
-		this._client.login(token);
-		await ready.promise;
-		this.logger.info(`Logged in as ${chalk.default.bold.magenta(this._client.user?.username)}!`);
-		return this;
-	}
-	async logout() {
-		await this._client.destroy();
-		this.logger.info(chalk.default.bold.red("Logged out of Discord!"));
-	}
-	get client() {
-		return this._client;
-	}
-};
-__decorate([(0, envapt_legacy.Envapt)("DISCORD_BOT_TOKEN", { converter: (raw) => (0, _seedcord_errors_internal.validateDiscordToken)(raw) })], Bot.prototype, "botToken", void 0);
-
-//#endregion
-//#region src/version.ts
-/** Package version */
-const version = "0.1.4";
-
-//#endregion
-//#region src/Seedcord.ts
-/**
-* The gateway bot host. Opens a discord.js gateway session, discovers handlers, and runs
-* coordinated startup and shutdown. Attach plugins with `attach()`.
-*/
-var Seedcord = class Seedcord extends _seedcord_core_node_internal.Pluggable {
-	config;
-	/** @internal */
-	[_seedcord_types_internal.SeedcordBrand] = true;
-	/** @internal */
-	augmentTarget = "@seedcord/gateway";
-	/** @internal */
-	version = version;
-	healthCheck;
-	hmrManager;
-	/** @see {@link Bus} */
-	bus;
-	subscribers;
-	/** @see {@link Bot} */
-	bot;
-	/** The discord.js client's REST client. Its token is set during the Login phase. */
-	rest;
-	/** @see {@link IRateLimiter} */
-	rateLimiter;
-	/**
-	* @param config - Bot configuration including paths and Discord client options
-	* @throws A **SeedcordError** When attempting to create multiple instances (singleton)
-	*/
-	constructor(config) {
-		super(new _seedcord_core_node_internal.CoordinatedShutdown(), new _seedcord_core_node_internal.CoordinatedStartup());
-		this.config = config;
-		(0, _seedcord_logger_node.installNodeDefaults)(config.logger);
-		(0, _seedcord_core_internal.setBotColor)(config.botColor);
-		this.hmrManager = new _seedcord_core_internal.HmrManager();
-		this.hmrManager.init();
-		this.bus = new _seedcord_core.Bus(this);
-		this.subscribers = new _seedcord_core_node_internal.SubscriberLoader(this.bus, config.subscribers.path);
-		this.bot = new Bot(this);
-		this.rest = this.bot.client.rest;
-		this.rateLimiter = config.store ?? new _seedcord_rate_limiter.MemoryRateLimiter();
-		this.healthCheck = _seedcord_core_node_internal.HealthCheck.fromOption(this.shutdown, config.healthCheck);
-		this.registerStartupTasks();
-	}
-	/** The bot's discord username, populated after login. */
-	get username() {
-		return this.bot.client.user?.username;
-	}
-	static reset() {
-		super.reset();
-		_seedcord_logger.LoggerChannelRegistry.instance.configure({});
-	}
-	registerStartupTasks() {
-		if (envapt.Envapter.isDevelopment || envapt.Envapter.isTest) this.registerHmrAwareModules();
-		this.startup.addTask(_seedcord_core_node_internal.StartupPhase.Configuration, "bus-initialization", async () => {
-			this.bus.logger.utils.initialization("Subscribers", "start");
-			await this.subscribers.init();
-			this.bus.logger.utils.initialization("Subscribers", "end");
-		});
-		this.startup.addTask(_seedcord_core_node_internal.StartupPhase.Login, "bot-initialization", async () => {
-			this.bot.logger.utils.initialization("Bot", "start");
-			await this.bot.init();
-			this.bot.logger.utils.initialization("Bot", "end");
-		});
-		const { healthCheck } = this;
-		if (healthCheck) this.startup.addTask(_seedcord_core_node_internal.StartupPhase.Ready, "health-check", async () => {
-			healthCheck.logger.utils.initialization("HealthCheck", "start");
-			await healthCheck.init();
-			healthCheck.logger.utils.initialization("HealthCheck", "end");
-		});
-	}
-	/**
-	* Starts the bot and runs all initialization tasks
-	*
-	* @returns This Seedcord instance when initialized
-	*/
-	async start() {
-		try {
-			await super.init();
-		} catch (caught) {
-			await this.shutdown.run(1, false);
-			Seedcord.reset();
-			throw caught;
-		}
-		return this;
-	}
-	registerHmrAwareModules() {
-		this.startup.addTask(_seedcord_core_node_internal.StartupPhase.Configuration, "hmr-registration", async () => {
-			this.hmrManager.register(this.bot);
-			this.hmrManager.register(this.subscribers);
-			for (const plugin of this.plugins) this.hmrManager.register(plugin);
-			await Promise.resolve();
-		});
-	}
-};
-
-//#endregion
-exports.ArraySource = ArraySource;
-exports.AutocompleteHandler = AutocompleteHandler;
-exports.BaseHandler = BaseHandler;
-exports.ButtonHandler = ButtonHandler;
-exports.ComponentHandler = ComponentHandler;
-exports.ContextMenuHandler = ContextMenuHandler;
-exports.CursorSource = CursorSource;
-exports.Emojis = Emojis;
-exports.EventHandler = EventHandler;
-exports.EventMiddleware = EventMiddleware;
-exports.Gated = Gated;
-exports.IgnoreBots = IgnoreBots;
-exports.InteractionHandler = InteractionHandler;
-exports.InteractionMiddleware = InteractionMiddleware;
-exports.Middleware = Middleware;
-exports.MiddlewareType = MiddlewareType;
-exports.ModalHandler = ModalHandler;
-exports.Nsfw = Nsfw;
-exports.Paginator = Paginator;
-exports.Plugin = Plugin;
-exports.RegisterEvent = RegisterEvent;
-exports.RepliableHandler = RepliableHandler;
-exports.Seedcord = Seedcord;
-exports.SelectMenuHandler = SelectMenuHandler;
-exports.SlashHandler = SlashHandler;
-exports.Subscriber = Subscriber;
-exports.WebhookLog = WebhookLog;
-exports.checkBotPermissions = checkBotPermissions;
-exports.checkPermissions = checkPermissions;
-exports.getConfirmation = getConfirmation;
-exports.hasPermsToAssign = hasPermsToAssign;
-exports.version = version;
-Object.keys(_seedcord_core).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _seedcord_core[k]; }
-  });
-});
-
-Object.keys(_seedcord_errors).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _seedcord_errors[k]; }
-  });
-});
-
-var _seedcord_event_emitter = require("@seedcord/event-emitter");
-Object.keys(_seedcord_event_emitter).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _seedcord_event_emitter[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_logger[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_rate_limiter[k]; }
-  });
-});
-
-Object.keys(_seedcord_utils).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _seedcord_utils[k]; }
-  });
-});
-
-//# sourceMappingURL=index.cjs.map