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

package/dist/index.cjs

@@ -38,19 +38,17 @@ let _seedcord_utils_internal = require("@seedcord/utils/internal");
 let discord_js = require("discord.js");
 let node_crypto = require("node:crypto");
 node_crypto = __toESM(node_crypto, 1);
-let _seedcord_event_emitter = require("@seedcord/event-emitter");
-let chalk = require("chalk");
-chalk = __toESM(chalk, 1);
-let envapt = require("envapt");
-let discord_api_types_v10 = require("discord-api-types/v10");
-let _seedcord_utils = require("@seedcord/utils");
-let _discordjs_rest = require("@discordjs/rest");
-let _seedcord_core_node = require("@seedcord/core/node");
+let _seedcord_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 node_path = require("node:path");
 let _seedcord_core_hmr = require("@seedcord/core/hmr");
+let _seedcord_utils = require("@seedcord/utils");
 let _seedcord_utils_node = require("@seedcord/utils/node");
 
 //#region src/logger-bootstrap.ts
@@ -165,7 +163,7 @@ let MiddlewareType = /* @__PURE__ */ function(MiddlewareType) {
 * Interaction middleware cannot specify event filters.
 *
 * @param type - Middleware kind from {@link MiddlewareType}
-* @param priority - Ordering value where lower runs earlier. {@default `0`}
+* @param priority - Ordering value where lower runs earlier. {@default `0` }
 * @param options - Additional registration options
 *
 * @decorator
@@ -353,7 +351,7 @@ const Emojis = emojiStorage;
 */
 var EmojiInjector = class {
 	core;
-	logger = new _seedcord_logger.Logger("Emojis");
+	logger = new _seedcord_logger.Logger("Emojis", { channel: "bot" });
 	constructor(core) {
 		this.core = core;
 	}
@@ -428,7 +426,7 @@ const MULTI_GUILD = Symbol("seedcord:commandmentions:multi-guild");
 */
 var CommandMentionInjector = class {
 	core;
-	logger = new _seedcord_logger.Logger("CommandMentions");
+	logger = new _seedcord_logger.Logger("CommandMentions", { channel: "bot" });
 	constructor(core) {
 		this.core = core;
 	}
@@ -586,7 +584,7 @@ function checkBotPermissions(target, scope, inverse = false, errors) {
 	}
 	const me = target.guild.members.me;
 	if (!me) {
-		new _seedcord_logger.Logger("checkBotPermissions").warn(`Bot member is unavailable in guild ${target.guild.id} while checking permissions in channel ${target.id}`);
+		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);
 	}
@@ -785,8 +783,11 @@ function seedState(interaction) {
 */
 var ReplySender = class extends _seedcord_core_internal.BaseReplySender {
 	interaction;
-	constructor(interaction, routeId) {
-		super(routeId, seedState(interaction));
+	constructor(interaction, routeId, bus) {
+		super(routeId, seedState(interaction), bus && {
+			bus,
+			interactionId: interaction.id
+		});
 		this.interaction = interaction;
 	}
 	async writeReply(response, opts) {
@@ -893,43 +894,9 @@ function slashRouteOf(interaction) {
 	return (0, _seedcord_utils_internal.buildSlashRoute)(interaction.commandName, subcommand, group);
 }
 
-//#endregion
-//#region src/miscellaneous/FaultThrottle.ts
-/**
-* Drops duplicate fault reports inside a fixed window so a recurring fault (a database outage on a
-* hot path) reports once per window instead of flooding the webhook. Keyed on a structural string, so
-* the map stays small, and a stale entry is evicted on the next read of its key.
-*
-* @internal
-*/
-var FaultThrottle = class {
-	windowMs;
-	now;
-	lastReportedAt = /* @__PURE__ */ new Map();
-	constructor(windowMs = 6e4, now = () => Date.now()) {
-		this.windowMs = windowMs;
-		this.now = now;
-	}
-	/** Evicts the entry for this key if it has aged out, so the map never holds stale keys forever. */
-	shouldReport(key) {
-		const last = this.lastReportedAt.get(key);
-		if (last === void 0) return true;
-		if (this.now() - last < this.windowMs) return false;
-		this.lastReportedAt.delete(key);
-		return true;
-	}
-	markReported(key) {
-		this.lastReportedAt.set(key, this.now());
-	}
-	clear() {
-		this.lastReportedAt.clear();
-	}
-};
-
 //#endregion
 //#region src/miscellaneous/extractErrorResponse.ts
-const logger$2 = new _seedcord_logger.Logger("ErrorsHandling");
-const faultThrottle = new FaultThrottle();
+const logger$2 = new _seedcord_logger.Logger("ErrorsHandling", { channel: "errors" });
 /**
 * Processes an error into a user-facing reply and routes its report.
 *
@@ -959,29 +926,30 @@ function extractErrorResponse(error, core, origin) {
 		response: override ? new override(uuid).render(ctx) : new _seedcord_core.Fault().render(ctx)
 	};
 }
-function withThrottle(origin, error, publish) {
+function withThrottle(core, origin, error, publish) {
+	const throttle = _seedcord_core_internal.FaultThrottle.for(core);
 	const key = faultKey(origin, error);
-	if (!faultThrottle.shouldReport(key)) {
-		logger$2.info(`throttled duplicate fault ${key}`);
+	if (!throttle.shouldReport(key)) {
+		logger$2.debug(`throttled duplicate fault ${key}`);
 		return;
 	}
 	publish();
-	faultThrottle.markReported(key);
+	throttle.markReported(key);
 }
 function reportFault(denial, core, origin, uuid) {
-	withThrottle(origin, denial, () => {
-		logger$2.error(`${denial.name}: ${uuid}`, denial);
-		if (origin.interaction) core.bus.publish("handledException", {
+	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.publish("handledException", {
+		else if (origin.event) core.bus[_seedcord_core_internal.PublishDefault]("handledException", {
 			denial,
 			uuid,
 			source: buildEventSource(origin.event, origin)
 		});
-		else core.bus.publish("unknownException", {
+		else core.bus[_seedcord_core_internal.PublishDefault]("unknownException", {
 			uuid,
 			error: denial,
 			...scalarActors(origin),
@@ -996,10 +964,10 @@ function causeLine(error) {
 	return `\ncaused by ${cause.name}: ${first ?? cause.message}`;
 }
 function reportRawFault(error, core, origin, uuid) {
-	withThrottle(origin, error, () => {
-		if (core.config.errors?.errorStack ?? false) logger$2.error(uuid, error);
-		else logger$2.error(`${uuid} | ${error.message}${causeLine(error)}`);
-		core.bus.publish("unknownException", {
+	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),
@@ -1142,112 +1110,6 @@ async function getConfirmation(interaction, prompt, options) {
 	return confirmed;
 }
 
-//#endregion
-//#region src/interfaces/Plugin.ts
-/**
-* Base class for Seedcord plugins
-*
-* Extend this class to create plugins that integrate with the Seedcord lifecycle.
-* Plugins have access to the core instance and must implement initialization logic.
-*/
-var Plugin = class extends _seedcord_event_emitter.TypedEventEmitter {
-	pluggable;
-	name = this.constructor.name;
-	constructor(pluggable) {
-		super();
-		this.pluggable = pluggable;
-	}
-	/**
-	* Reloads plugin state on an HMR update. The base implementation is a no-op, override it in your plugin.
-	* @virtual
-	*/
-	onHmr(_event) {
-		return Promise.resolve();
-	}
-	/**
-	* Registers critical file patterns that should trigger a full restart when changed in Dev HMR.
-	* @param patterns - Glob patterns relative to the project root
-	*/
-	registerCriticalFiles(patterns) {
-		(0, _seedcord_core_internal.getDevChannel)()?.send("seedcord:register-critical-files", { patterns });
-	}
-	/** @internal */
-	removeListener(event, listener) {
-		return super.removeListener(event, listener);
-	}
-	/** @internal */
-	removeAllListeners(event) {
-		return super.removeAllListeners(event);
-	}
-};
-/**
-* Base class for objects that can have plugins attached.
-*
-* Provides plugin attachment capabilities and lifecycle management. Plugins are attached during
-* configuration and initialized during startup. Not constructed directly, the host is a {@link Seedcord}.
-*/
-var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitter {
-	isInitialized = false;
-	shutdown;
-	startup;
-	plugins = [];
-	static PLUGIN_INIT_TIMEOUT_MS = 15e3;
-	constructor(shutdown, startup) {
-		super();
-		this.shutdown = shutdown;
-		this.startup = startup;
-	}
-	/** @internal */
-	async init() {
-		if (this.isInitialized) return this;
-		await this.startup.run();
-		this.isInitialized = true;
-		return this;
-	}
-	/**
-	* Attaches a plugin to this instance
-	*
-	* Plugins provide external functionality and are initialized during the specified startup phase.
-	* The plugin instance becomes available as a property in `core` wherever it's available.
-	*
-	* Make sure to augment the {@link Core} interface with the plugin type to ensure TypeScript recognizes it and provides intellisense.
-	*
-	* @typeParam Key - The property name for accessing the plugin
-	* @typeParam Ctor - The plugin constructor type
-	* @param key - Property name to access the plugin instance
-	* @param Plugin - Plugin constructor class
-	* @param startupPhase - When during startup to initialize this plugin ({@link StartupPhase})
-	* @param args - Additional arguments to pass to the plugin constructor
-	* @returns This instance with the plugin attached as a typed property
-	* @throws A **SeedcordError** When called after initialization or if key already exists
-	* @example
-	* ```typescript
-	* seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
-	* ```
-	*/
-	attach(key, Plugin, startupPhase, ...args) {
-		if (this.isInitialized) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CorePluginAfterInit);
-		if (key in this) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CorePluginKeyExists, [key]);
-		const instance = new Plugin(this, ...args);
-		this.plugins.push(instance);
-		const entry = { [key]: instance };
-		this.startup.addTask(startupPhase, `Plugin:${key}`, async () => {
-			instance.logger.utils.initialization(key, "start");
-			await instance.init();
-			instance.logger.utils.initialization(key, "end");
-		}, Pluggable.PLUGIN_INIT_TIMEOUT_MS);
-		return Object.assign(this, entry);
-	}
-	/** @internal */
-	removeListener(event, listener) {
-		return super.removeListener(event, listener);
-	}
-	/** @internal */
-	removeAllListeners(event) {
-		return super.removeAllListeners(event);
-	}
-};
-
 //#endregion
 //#region src/handlers/BaseHandler.ts
 /**
@@ -1273,7 +1135,7 @@ var BaseHandler = class extends _seedcord_core.BaseHandler {
 */
 var InteractionMiddleware = class extends BaseHandler {
 	constructor(event, core) {
-		super(event, core);
+		super(event, core, void 0, "interactions");
 	}
 };
 
@@ -1293,8 +1155,8 @@ var RepliableHandler = class extends _seedcord_core.RepliableHandler {
 	getEvent() {
 		return this.event;
 	}
-	buildSender(event, _core, routeId) {
-		return new ReplySender(event, routeId);
+	buildSender(event, core, routeId) {
+		return new ReplySender(event, routeId, core.bus);
 	}
 };
 
@@ -1449,7 +1311,7 @@ var ContextMenuHandler = class extends InteractionHandler {
 */
 var AutocompleteHandler = class extends BaseHandler {
 	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
+		super(event, core, dispatch, "interactions");
 	}
 	decodedFocused;
 	/**
@@ -1500,7 +1362,11 @@ var AutocompleteHandler = class extends BaseHandler {
 	}
 	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
 	async respond(choices) {
-		await this.event.respond(choices);
+		const routeId = this.dispatch?.routeId ?? "autocomplete";
+		await (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() {
@@ -1693,7 +1559,7 @@ var SelectMenuHandler = class extends ComponentHandler {};
 var EventHandler = class extends BaseHandler {
 	firedEvent;
 	constructor(event, core, eventName) {
-		super(event, core);
+		super(event, core, void 0, "events");
 		this.firedEvent = eventName;
 	}
 	/**
@@ -1746,7 +1612,7 @@ var EventHandler = class extends BaseHandler {
 var EventMiddleware = class extends BaseHandler {
 	firedEvent;
 	constructor(event, core, eventName) {
-		super(event, core);
+		super(event, core, void 0, "events");
 		this.firedEvent = eventName;
 	}
 	/**
@@ -1931,10 +1797,15 @@ var Paginator = class {
 			}
 		};
 	}
-	/** Render page 0 and send it, picking reply or followUp from the interaction's state. */
-	async start(interaction, core) {
-		const response = await this.page(contextOf(interaction, core), 0);
-		return new ReplySender(interaction, interactionRoute(interaction)).send(response, { ephemeral: this.config.ephemeral ?? false });
+	/**
+	* Render page 0 and send it through the handler's sender, picking reply 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 });
 	}
 	/** Render a page as a {@link ReplyResponse}. To post it elsewhere, add `flags: MessageFlags.IsComponentsV2`. */
 	async page(ctx, n) {
@@ -1994,250 +1865,32 @@ var CursorSource = class {
 };
 
 //#endregion
-//#region src/subscribers/Subscriber.ts
+//#region src/subscribers/index.ts
 /**
-* Abstract base class for handling application subscribers.
-*
-* Provides type-safe access to subscribers data and the core framework instance.
-* Extend this class to create custom subscriber handlers.
+* Base class for a gateway subscriber, binding `this.core` to the gateway {@link Core}.
 *
-* @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+* @typeParam KeyOfSubscribers - The subscription key this handler receives
 */
-var Subscriber = class {
-	data;
-	core;
-	logger;
-	/**
-	* Instantiates the subscriber with event data and core.
-	*
-	* @param data - The subscriber event data
-	* @param core - The core framework instance
-	*/
-	constructor(data, core) {
-		this.data = data;
-		this.core = core;
-		this.logger = new _seedcord_logger.Logger(this.constructor.name);
-	}
-};
-
-//#endregion
-//#region src/subscribers/decorators/Subscribe.ts
+var Subscriber = class extends _seedcord_core.Subscriber {};
 /**
-* Registers a subscriber handler class with a specific subscriber event.
+* Base class for a gateway subscriber that delivers its event to a Discord webhook, binding
+* `this.core` to the gateway {@link Core}.
 *
-* Associates the decorated class with a subscriber event type for automatic
-* registration and execution when the subscriber is emitted.
-*
-* @typeParam TSubscriber - The subscriber event name to register for
-* @param subscriber - The subscriber event name to register for
-* @param options - Options to configure the subscriber handler registration.
-* @decorator
-* @example
-* ```typescript
-* \@Subscribe('userJoin')
-* class WelcomeHandler extends Subscriber<'userJoin'> {
-*   async execute() {
-*     // Handle user join event
-*   }
-* }
-* ```
-* @example
-* ```ts
-* \@Subscribe('userJoin', { frequency: 'once' })
-* // or
-* \@Subscribe('userJoin')
-* ```
+* @typeParam KeyOfSubscribers - The subscription key this reporter receives
 */
-function Subscribe(subscriber, options) {
-	return function(constructor) {
-		const meta = {
-			subscriber,
-			frequency: options?.frequency
-		};
-		Reflect.defineMetadata(_seedcord_core_internal.SubscribeMetadataKey, meta, constructor);
-	};
-}
+var WebhookLog = class extends _seedcord_core.WebhookLog {};
 
 //#endregion
-//#region src/subscribers/decorators/WebhookUrl.ts
+//#region src/plugin.ts
 /**
-* Declares the environment variable a {@link WebhookLog} reporter reads its webhook url from.
+* Base class for a gateway plugin, binding `this.core` to the gateway {@link Core}.
 *
-* An unset variable disables the reporter with a boot warning. A set but malformed value throws
-* at boot.
+* A plugin that runs on either transport extends the base from `@seedcord/core/plugin`, whose
+* `this.core` carries the shared members only.
 *
-* @param envKey - The environment variable name holding the webhook url
-* @decorator
-* @example
-* ```ts
-* \@Subscribe('memberBanned')
-* \@WebhookUrl('BAN_LOG_WEBHOOK_URL')
-* class BanLog extends WebhookLog<'memberBanned'> {
-*   report() {
-*     return { components: [new BanCard(this.data).component] };
-*   }
-* }
-* ```
+* @typeParam Opts - The transport, runtime, and capabilities the plugin declares.
 */
-function WebhookUrl(envKey) {
-	return function(constructor) {
-		Reflect.defineMetadata(_seedcord_core_internal.WebhookUrlMetadataKey, envKey, constructor);
-	};
-}
-
-//#endregion
-//#region src/miscellaneous/flagsFor.ts
-/** @internal */
-function flagsFor(ephemeral) {
-	let flags = discord_api_types_v10.MessageFlags.IsComponentsV2;
-	if (ephemeral) flags |= discord_api_types_v10.MessageFlags.Ephemeral;
-	return flags;
-}
-
-//#endregion
-//#region src/subscribers/bases/webhookHelpers.ts
-const DISCORD_WEBHOOK_REGEX = new RegExp(String.raw`^https?:\/\/(?:canary\.|ptb\.)?discord(?:app)?\.com\/api\/webhooks\/\d+\/[\w$-]+$`);
-function isDiscordWebhookUrl(value) {
-	return URL.canParse(value) && DISCORD_WEBHOOK_REGEX.test(value);
-}
-function jsonAttachment(name, description, data) {
-	const content = (0, _seedcord_utils.filterCirculars)(data);
-	return {
-		name,
-		description,
-		data: Buffer.from(JSON.stringify(content, void 0, 2), "utf8")
-	};
-}
-function neutralizeFences(text) {
-	return text.replaceAll("```", "`​`​`");
-}
-/** An error's stack with its direct cause appended (one level), ANSI-stripped for the webhook payload. */
-function errorReport(error) {
-	let report = error.stack ?? `${error.name}: ${error.message}`;
-	if (Error.isError(error.cause)) {
-		const cause = error.cause.stack ?? `${error.cause.name}: ${error.cause.message}`;
-		report += `\n\nCaused by:\n${cause}`;
-	}
-	const stripped = neutralizeFences((0, _seedcord_utils.stripAnsi)(report));
-	return stripped.length > 1800 ? `${stripped.slice(0, 1799)}…` : stripped;
-}
-var WebhookSeparator = class extends _seedcord_core.BuilderComponent {
-	constructor() {
-		super("separator");
-		this.instance.setSpacing(discord_api_types_v10.SeparatorSpacingSize.Small).setDivider(true);
-	}
-};
-
-//#endregion
-//#region src/subscribers/bases/WebhookSender.ts
-const HTTP_NOT_FOUND = 404;
-const HTTP_UNAUTHORIZED = 401;
-/**
-* Sends component messages to a Discord webhook through `@discordjs/rest`.
-*
-* @throws A `SeedcordError` when the url does not carry a webhook id and token.
-*/
-var WebhookSender = class {
-	rest = new _discordjs_rest.REST();
-	route;
-	constructor(url) {
-		const match = /\/webhooks\/(\d+)\/([\w$-]+)$/.exec(url);
-		if (!match?.[1] || !match[2]) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigWebhookUrlInvalid, ["The url"]);
-		this.route = discord_api_types_v10.Routes.webhook(match[1], match[2]);
-	}
-	/**
-	* Fetches the webhook object, sending no message. Returns `missing` on a 404 or 401 from
-	* Discord and `unreachable` on any other failure.
-	*/
-	async verify() {
-		try {
-			await this.rest.get(this.route, { auth: false });
-			return "ok";
-		} catch (error) {
-			return error instanceof _discordjs_rest.DiscordAPIError && (error.status === HTTP_NOT_FOUND || error.status === HTTP_UNAUTHORIZED) ? "missing" : "unreachable";
-		}
-	}
-	async send(options) {
-		const { flags, username, components, files } = options;
-		await this.rest.post(this.route, {
-			auth: false,
-			query: new URLSearchParams({
-				with_components: "true",
-				wait: "true"
-			}),
-			body: {
-				flags,
-				username,
-				components: components.map((component) => component.toJSON()),
-				...files?.length && { attachments: files.map((file, id) => ({
-					id,
-					filename: file.name,
-					description: file.description
-				})) }
-			},
-			...files?.length && { files: files.map((file) => ({
-				name: file.name,
-				data: file.data
-			})) }
-		});
-	}
-};
-
-//#endregion
-//#region src/subscribers/bases/WebhookLog.ts
-/**
-* Base class for subscribers that deliver their event to a Discord webhook.
-*
-* Declare the url's environment variable with `@WebhookUrl` and implement {@link report}. Url
-* resolution, validation, sender reuse, and sending run in the base. When the variable is unset
-* the reporter is skipped at registration with a boot warning.
-*
-* @typeParam KeyOfSubscribers - The subscription key this reporter receives
-*/
-var WebhookLog = class WebhookLog extends Subscriber {
-	static senders = /* @__PURE__ */ new Map();
-	async execute() {
-		const url = WebhookLog.urlOf(WebhookLog.envKeyOf(this.constructor));
-		if (url === null) {
-			this.logger.warn(`${chalk.default.bold(this.constructor.name)} has no webhook url set, this reporter is disabled`);
-			return;
-		}
-		const { username, components, files } = await this.report();
-		try {
-			await WebhookLog.senderFor(url).send({
-				flags: flagsFor(false),
-				username: username ?? this.constructor.name,
-				components,
-				files
-			});
-		} catch (error) {
-			this.logger.error("Failed to send webhook report", error);
-		}
-	}
-	/** @internal */
-	static senderFor(url) {
-		let sender = WebhookLog.senders.get(url);
-		if (!sender) {
-			sender = new WebhookSender(url);
-			WebhookLog.senders.set(url, sender);
-		}
-		return sender;
-	}
-	/** @internal */
-	static envKeyOf(ctor) {
-		const envKey = Reflect.getMetadata(_seedcord_core_internal.WebhookUrlMetadataKey, ctor);
-		if (!envKey) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.DecoratorWebhookUrlMissing, [ctor.name]);
-		return envKey;
-	}
-	/** @internal Returns null when the env var is unset, throws when set but malformed. */
-	static urlOf(envKey) {
-		if (!envapt.Envapter.has(envKey)) return null;
-		const raw = envapt.Envapter.getRequired(envKey, envapt.Converters.String).trim();
-		if (raw === "") return null;
-		if (!isDiscordWebhookUrl(raw)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigWebhookUrlInvalid, [envKey]);
-		return raw;
-	}
-};
+var Plugin = class extends _seedcord_core_plugin.Plugin {};
 
 //#endregion
 //#region src/bot/utilities/miscellaneous/contextMenuLeaves.ts
@@ -2293,8 +1946,7 @@ function slashRouteLeaves(commands) {
 var CommandRegistry = class {
 	core;
 	onDeployed;
-	name = "Commands";
-	logger = new _seedcord_logger.Logger("Commands");
+	logger = new _seedcord_logger.Logger("Commands", { channel: "commands" });
 	isInitialised = false;
 	globalCommands = [];
 	guildCommands = new discord_js.Collection();
@@ -2381,7 +2033,7 @@ var CommandRegistry = class {
 				this.registerCommand(exported, rel);
 				this.hmrHandler?.trackHandler(fullPath, exported);
 			}
-		}, this.logger);
+		});
 	}
 	isCommandClass(obj) {
 		if (typeof obj !== "function") return false;
@@ -2543,7 +2195,7 @@ function eventGateContext(eventName, args, core) {
 
 //#endregion
 //#region src/bot/handleEventFault.ts
-const logger$1 = new _seedcord_logger.Logger("EventBoundary");
+const logger$1 = new _seedcord_logger.Logger("EventBoundary", { channel: "errors" });
 /**
 * The event controller boundary. Reports a throw from an event handler and never replies, since a
 * generic event has no reply target. A {@link Silence} or a non-reporting {@link Notice} stops quietly, a
@@ -2556,15 +2208,15 @@ function handleEventFault(caught, eventName, handlerName, args, core) {
 		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger$1.debug(`Silence: ${caught.reason}`);
 		return;
 	}
-	if (!Error.isError(caught)) throw caught;
+	const error = (0, _seedcord_core_internal.asError)(caught);
 	const ignore = new Set(core.config.errors?.ignoreEventApiCodes ?? []);
-	if (caught instanceof discord_js.DiscordAPIError && ignore.has(caught.code)) {
-		logger$1.debug(`swallowed api code ${caught.code}`);
+	if (error instanceof discord_js.DiscordAPIError && ignore.has(error.code)) {
+		logger$1.debug(`swallowed api code ${error.code}`);
 		return;
 	}
-	if (caught instanceof _seedcord_core.Notice && !caught.report) return;
+	if (error instanceof _seedcord_core.Notice && !error.report) return;
 	const actor = deriveEventActor(args);
-	extractErrorResponse(caught, core, {
+	extractErrorResponse(error, core, {
 		event: {
 			name: eventName,
 			handler: handlerName,
@@ -2579,21 +2231,22 @@ function handleEventFault(caught, eventName, handlerName, args, core) {
 //#endregion
 //#region src/bot/controllers/EventDispatcher.ts
 /**
-* Scans event handler directories, registers handlers with Discord client events,
-* and coordinates event execution through the handler system. Does not handle interactions.
-* Multiple handlers can point to one event.
+* Scans event handler directories, attaches one client listener per registered event, and runs the
+* handlers for each fire. Interactions route through InteractionDispatcher. Multiple handlers can
+* point to one event.
 *
 * @internal
 */
 var EventDispatcher = class {
 	core;
-	logger = new _seedcord_logger.Logger("Events");
+	logger = new _seedcord_logger.Logger("Events", { channel: "events" });
 	isInitialized = false;
-	name = "Events";
 	eventMap = /* @__PURE__ */ new Map();
 	middlewares = [];
 	executedOnceHandlers = /* @__PURE__ */ new Set();
 	attachedEvents = /* @__PURE__ */ new Set();
+	inFlight = /* @__PURE__ */ new Set();
+	draining = false;
 	loading = false;
 	loadedHandlers = [];
 	loadedMiddlewares = [];
@@ -2657,7 +2310,7 @@ var EventDispatcher = class {
 				this.registerHandler(val, relativePath);
 				this.hmrHandler?.trackHandler(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	async loadMiddlewares(dir) {
 		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
@@ -2666,7 +2319,7 @@ var EventDispatcher = class {
 				this.registerMiddleware(val, relativePath);
 				this.hmrHandler?.trackMiddleware(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	/** @internal For use in dev mode */
 	async onHmr(event) {
@@ -2762,15 +2415,26 @@ var EventDispatcher = class {
 		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) => {
-			this.core.bot.emitSafe("any:event", eventName, ...args);
-			(async () => {
-				await this.processEvent(eventName, args).catch((err) => {
-					this.logger.error(`[${_seedcord_logger.paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
-					this.core.bot.emit("error:unhandled:event", err);
-				});
-			})();
+			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;
@@ -2835,7 +2499,7 @@ const HARMLESS_API_CODES = new Set([
 
 //#endregion
 //#region src/bot/handleInteractionFault.ts
-const logger = new _seedcord_logger.Logger("InteractionBoundary");
+const logger = new _seedcord_logger.Logger("InteractionBoundary", { channel: "errors" });
 /**
 * The interaction controller boundary. Sorts a throw from any handler-lifecycle phase into the right
 * user reply plus the right bus event. When a handler is built its sender is passed in, so the boundary
@@ -2844,33 +2508,45 @@ const logger = new _seedcord_logger.Logger("InteractionBoundary");
 *
 * @internal
 */
-async function handleInteractionFault(caught, interaction, core, sender) {
+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;
 	}
-	if (!Error.isError(caught)) throw caught;
+	const error = (0, _seedcord_core_internal.asError)(caught);
 	const ignore = new Set(core.config.errors?.ignoreApiCodes ?? []);
-	if (caught instanceof discord_js.DiscordAPIError && ignore.has(caught.code)) {
-		logger.debug(`swallowed api code ${caught.code}`);
+	if (error instanceof discord_js.DiscordAPIError && ignore.has(error.code)) {
+		logger.debug(`swallowed api code ${error.code}`);
 		return;
 	}
 	if (interaction.isAutocomplete()) {
-		extractErrorResponse(caught, core, {
+		extractErrorResponse(error, core, {
 			guild: interaction.guild,
 			user: interaction.user,
 			metadata: interaction,
 			route: slashRouteOf(interaction)
 		});
+		await sendEmptyChoices(interaction, core, routeId);
 		return;
 	}
-	const { response } = extractErrorResponse(caught, core, {
+	const { response } = extractErrorResponse(error, core, {
 		interaction,
 		guild: interaction.guild,
 		user: interaction.user,
 		metadata: interaction
 	});
-	await sendGuarded(sender ?? new ReplySender(interaction, interactionRoute(interaction)), response, caught instanceof _seedcord_core.Notice ? caught.ephemeral : true);
+	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 {
@@ -2894,9 +2570,8 @@ async function sendGuarded(sender, response, ephemeral) {
 */
 var InteractionDispatcher = class {
 	core;
-	logger = new _seedcord_logger.Logger("Interactions");
+	logger = new _seedcord_logger.Logger("Interactions", { channel: "interactions" });
 	isInitialized = false;
-	name = "Interactions";
 	slashMap = /* @__PURE__ */ new Map();
 	buttonMap = /* @__PURE__ */ new Map();
 	modalMap = /* @__PURE__ */ new Map();
@@ -2908,8 +2583,11 @@ var InteractionDispatcher = class {
 	messageContextMenuMap = /* @__PURE__ */ new Map();
 	userContextMenuMap = /* @__PURE__ */ new Map();
 	autocompleteMap = /* @__PURE__ */ new Map();
+	handlerFiles = /* @__PURE__ */ new Map();
 	keysToIgnore = /* @__PURE__ */ new Set();
 	middlewares = [];
+	inFlight = /* @__PURE__ */ new Set();
+	draining = false;
 	loading = false;
 	loadedHandlers = [];
 	loadedMiddlewares = [];
@@ -3024,7 +2702,7 @@ var InteractionDispatcher = class {
 				this.registerHandler(val, relativePath);
 				this.hmrHandler?.trackHandler(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	async loadMiddlewares(dir) {
 		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
@@ -3033,7 +2711,7 @@ var InteractionDispatcher = class {
 				this.registerMiddleware(val, relativePath);
 				this.hmrHandler?.trackMiddleware(fullPath, val);
 			}
-		}, this.logger);
+		});
 	}
 	registerMiddleware(middlewareCtor, relativePath) {
 		const metadata = Reflect.getMetadata(_seedcord_core_internal.MiddlewareMetadataKey, middlewareCtor);
@@ -3063,6 +2741,7 @@ var InteractionDispatcher = class {
 		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);
@@ -3070,16 +2749,16 @@ var InteractionDispatcher = class {
 			for (const route of meta) {
 				const existing = map.get(route);
 				if (existing && existing !== handlerClass) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.InteractionDuplicateRoute, [
-					route,
-					existing.name,
-					handlerClass.name
+					`${routeType}:${route}`,
+					`${existing.name} (${this.handlerFiles.get(existing) ?? "unknown file"})`,
+					`${handlerClass.name} (${from})`
 				]);
 				writes.push([map, route]);
 			}
 		}
 		if (writes.length === 0) return;
 		for (const [map, route] of writes) map.set(route, handlerClass);
-		const from = (0, _seedcord_utils.formatFilePath)(relativePath);
+		this.handlerFiles.set(handlerClass, from);
 		if (this.loading) this.loadedHandlers.push({
 			name: handlerClass.name,
 			from
@@ -3091,6 +2770,7 @@ var InteractionDispatcher = class {
 		await this.hmrHandler?.handle(event);
 	}
 	unregisterHandler(handlerClass, artifacts) {
+		this.handlerFiles.delete(handlerClass);
 		if (artifacts) {
 			for (const { routeType, routes } of artifacts) {
 				const map = this.routeTypes.find(([type]) => type === routeType)?.[1];
@@ -3110,44 +2790,92 @@ var InteractionDispatcher = class {
 	}
 	attachToClient() {
 		this.core.bot.client.on(discord_js.Events.InteractionCreate, (interaction) => {
-			this.core.bot.emitSafe("any:interaction", interaction);
-			this.handleInteraction(interaction).catch((err) => {
-				this.logger.error(`[${_seedcord_logger.paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
-				this.core.bot.emit("error:unhandled:interaction", err);
+			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));
 		});
 	}
-	async handleCustomIdInteraction(interaction, getMap, interactionType) {
+	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) return this.logger.warn(`${interactionType} has invalid customId: ${interaction.customId}`);
-		await this.processInteraction(interaction, () => prefix, (key) => getMap().get(key));
+		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, extractKey, getHandler, fallback = UnhandledRepliable) {
+	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;
+			this.core.bus[_seedcord_core_internal.PublishDefault]("interactionDispatched", (0, _seedcord_core_internal.dispatchedPayload)({
+				routeId,
+				interactionId: interaction.id,
+				kind,
+				outcome,
+				startedAt,
+				fallback: !matched,
+				queuedMs
+			}));
+		};
 		let sender;
 		try {
-			if (!interaction.isAutocomplete()) for (const { ctor } of this.middlewares) await new ctor(interaction, this.core).execute();
-			let HandlerCtor = getHandler(key);
-			if (!HandlerCtor) {
-				this.logger.warn(`No handler found for key ${_seedcord_logger.paint.sky.bold(key)}. Falling back to ${fallback.name}.`);
-				HandlerCtor = fallback;
-			}
-			this.logger.debug(`Processing ${_seedcord_logger.paint.mint.bold(key)} with ${_seedcord_logger.paint.mute(HandlerCtor.name)}`);
-			const dispatch = new _seedcord_core.DispatchContext((0, _seedcord_core_internal.routeIdOf)(HandlerCtor));
-			const handler = new HandlerCtor(interaction, this.core, dispatch);
+			if (!interaction.isAutocomplete()) await 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();
-			if (!interaction.isAutocomplete()) {
-				const monitor = (0, _seedcord_core_internal.slowGateMonitor)();
-				try {
-					await (0, _seedcord_core_internal.runHandlerGates)(HandlerCtor, interactionGateContext(interaction, this.core), dispatch.routeId ?? void 0, monitor?.observe);
-				} finally {
-					monitor?.report(dispatch.routeId);
-				}
+			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) {
-			await handleInteractionFault(caught, interaction, this.core, sender);
+			return { caught };
+		} finally {
+			monitor?.report(routeId);
 		}
 	}
 	async handleInteraction(interaction) {
@@ -3192,47 +2920,41 @@ var InteractionDispatcher = class {
 	}
 	async handleSlashCommand(interaction) {
 		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, () => route, (key) => this.slashMap.get(key));
+		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Slash, () => route, (key) => this.slashMap.get(key));
 	}
 	async handleButton(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.buttonMap, "Button");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Button, () => this.buttonMap);
 	}
 	async handleModal(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.modalMap, "Modal");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Modal, () => this.modalMap);
 	}
 	async handleStringSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.stringSelectMap, "String select menu");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.StringMenu, () => this.stringSelectMap);
 	}
 	async handleUserSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.userSelectMap, "User select menu");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.UserMenu, () => this.userSelectMap);
 	}
 	async handleRoleSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.roleSelectMap, "Role select menu");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.RoleMenu, () => this.roleSelectMap);
 	}
 	async handleChannelSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.channelSelectMap, "Channel select menu");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.ChannelMenu, () => this.channelSelectMap);
 	}
 	async handleMentionableSelectMenu(interaction) {
-		await this.handleCustomIdInteraction(interaction, () => this.mentionableSelectMap, "Mentionable select menu");
+		await this.handleCustomIdInteraction(interaction, _seedcord_core_internal.InteractionRoutes.MentionableMenu, () => this.mentionableSelectMap);
 	}
 	async handleMessageContextMenu(interaction) {
-		await this.processInteraction(interaction, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
+		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.MessageContextMenu, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
 	}
 	async handleUserContextMenu(interaction) {
-		await this.processInteraction(interaction, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
+		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.UserContextMenu, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
 	}
 	async handleAutocomplete(interaction) {
 		const route = slashRouteOf(interaction);
-		await this.processInteraction(interaction, () => route, (key) => this.autocompleteMap.get(key), UnhandledAutocomplete);
+		await this.processInteraction(interaction, _seedcord_core_internal.InteractionRoutes.Autocomplete, () => route, (key) => this.autocompleteMap.get(key), UnhandledAutocomplete);
 	}
 };
 
-//#endregion
-//#region \0@oxc-project+runtime@0.135.0/helpers/esm/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-
 //#endregion
 //#region \0@oxc-project+runtime@0.135.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -3244,23 +2966,25 @@ function __decorate(decorators, target, key, desc) {
 
 //#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;
 /**
-* Discord bot implementation that manages client and controllers
-*
-* Don't instantiate this class directly. Use `core.bot` instead.
+* The Discord client and its controllers. Access it through `core.bot`.
 */
-var Bot = class extends Plugin {
+var Bot = class {
 	/** @internal */
-	logger = new _seedcord_logger.Logger("Bot");
+	logger = new _seedcord_logger.Logger("Bot", { channel: "bot" });
 	isInitialized = false;
 	_client;
 	interactions;
 	events;
-	commands;
 	emojiInjector;
+	commands;
 	emojis = Emojis;
 	mentions = CommandMentions;
-	/** @internal For use in dev mode */
+	/** @internal */
 	async onHmr(event) {
 		if (this.interactions) await this.interactions.onHmr(event);
 		if (this.events) await this.events.onHmr(event);
@@ -3268,7 +2992,6 @@ var Bot = class extends Plugin {
 	}
 	/** @internal */
 	constructor(core) {
-		super(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);
@@ -3279,12 +3002,24 @@ var Bot = class extends Plugin {
 			});
 		}
 		this.emojiInjector = new EmojiInjector(core);
-		core.shutdown.addTask(_seedcord_core_node.ShutdownPhase.DiscordCleanup, "stop-bot", async () => await this.stop(), 2e3);
+		this.registerShutdownTasks(core);
 	}
-	/**
-	* Initializes Discord client and all controllers
-	* @internal
-	*/
+	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;
@@ -3300,27 +3035,19 @@ var Bot = class extends Plugin {
 			this.interactions?.warnUnhandledContextMenuRoutes(this.commands.contextMenuLeaves());
 		}
 	}
-	/**
-	* Stops the bot and cleans up connections
-	* @internal
-	*/
+	/** @internal */
 	async stop() {
 		this._client.removeAllListeners();
 		await this.logout();
 	}
-	/**
-	* Logs the bot into Discord using the configured token
-	*/
 	async login(token) {
-		this._client.once(discord_js.Events.ClientReady, () => this.emit("ready"));
+		const ready = Promise.withResolvers();
+		this._client.once(discord_js.Events.ClientReady, () => ready.resolve());
 		this._client.login(token);
-		await this.waitFor("ready");
+		await ready.promise;
 		this.logger.info(`Logged in as ${chalk.default.bold.magenta(this._client.user?.username)}!`);
 		return this;
 	}
-	/**
-	* Logs out and destroys the Discord client connection
-	*/
 	async logout() {
 		await this._client.destroy();
 		this.logger.info(chalk.default.bold.red("Logged out of Discord!"));
@@ -3328,250 +3055,21 @@ var Bot = class extends Plugin {
 	get client() {
 		return this._client;
 	}
-	emit(event, ...args) {
-		return super.emit(event, ...args);
-	}
-	emitSafe(event, ...args) {
-		return super.emitSafe(event, ...args);
-	}
-	onListenerError(error, event) {
-		this.logger.error(`listener for ${String(event)} threw`, error);
-	}
-};
-__decorate([(0, envapt_legacy.Envapt)("DISCORD_BOT_TOKEN", { converter: (raw) => (0, _seedcord_errors_internal.validateDiscordToken)(raw) }), __decorateMetadata("design:type", String)], Bot.prototype, "botToken", void 0);
-
-//#endregion
-//#region src/subscribers/default/HandledException.ts
-let HandledException = class HandledException extends WebhookLog {
-	report() {
-		return {
-			username: "Handled Exception",
-			components: [new HandledExceptionContainer(this.data).component],
-			files: [jsonAttachment("source.json", "The raw source the fault came from", this.data.source.raw)]
-		};
-	}
-};
-HandledException = __decorate([Subscribe("handledException"), WebhookUrl("HANDLED_EXCEPTION_WEBHOOK_URL")], HandledException);
-var HandledExceptionContainer = class extends _seedcord_core.BuilderComponent {
-	constructor(data) {
-		super("container");
-		const { denial, uuid, source } = data;
-		this.instance.addTextDisplayComponents((text) => text.setContent(faultSummary(denial, source))).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`\n\`\`\`${neutralizeFences(causeStack(denial))}\`\`\``)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Source")).addFileComponents((file) => file.setURL("attachment://source.json"));
-	}
-};
-function faultSummary(denial, source) {
-	const head = (0, _seedcord_utils.stripAnsi)(`### A handled fault was reported: \`${denial.name}\`\n**Message:** ${denial.message}\n`);
-	if (source.kind === "event") return `${head}**Event:** ${source.eventName}\n**Handler:** ${source.handler}\n**User ID:** \`${source.userId ?? "n/a"}\`\n**Guild ID:** \`${source.guildId ?? "n/a"}\`\n**Channel ID:** \`${source.channelId ?? "n/a"}\``;
-	return `${head}**Kind:** ${source.interactionKind}\n**Command:** ${source.command ?? "n/a"}\n**CustomId:** ${source.customId ?? "n/a"}\n**User ID:** \`${source.userId}\`\n**Guild ID:** \`${source.guildId ?? "n/a"}\`\n**Channel ID:** \`${source.channelId ?? "n/a"}\`\n**Interaction ID:** \`${source.interactionId}\``;
-}
-function causeStack(denial) {
-	const { cause } = denial;
-	if (Error.isError(cause)) return (0, _seedcord_utils.stripAnsi)(cause.stack ?? cause.message);
-	if (typeof cause === "string") return (0, _seedcord_utils.stripAnsi)(cause);
-	if (typeof cause === "bigint" || typeof cause === "symbol" || typeof cause === "function") return cause.toString();
-	if (cause !== void 0) try {
-		return JSON.stringify(cause);
-	} catch {
-		return "[unserializable cause]";
-	}
-	return (0, _seedcord_utils.stripAnsi)(denial.stack ?? "No cause recorded.");
-}
-
-//#endregion
-//#region src/subscribers/default/UnknownException.ts
-let UnknownException = class UnknownException extends WebhookLog {
-	report() {
-		const { metadata } = this.data;
-		return {
-			username: "Unknown Exception",
-			components: [new UnhandledErrorContainer(this.data).component],
-			files: metadata ? [jsonAttachment("metadata.json", "Metadata associated with the error", metadata)] : void 0
-		};
-	}
-};
-UnknownException = __decorate([Subscribe("unknownException"), WebhookUrl("UNKNOWN_EXCEPTION_WEBHOOK_URL")], UnknownException);
-var UnhandledErrorContainer = class extends _seedcord_core.BuilderComponent {
-	constructor(data) {
-		super("container");
-		const { uuid, error, guild, user, metadata } = data;
-		this.instance.addTextDisplayComponents((text) => text.setContent(`### An unknown exception was thrown\n**Guild ID:** \`${guild?.id ?? "Not used in a guild"}\`\n**Guild Name:** ${guild?.name ?? "Not used in a guild"}\n**User ID:** \`${user?.id ?? "Missing user info"}\`\n**Username:** ${user?.username ?? "Missing user info"}\n`)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`\n\`\`\`${errorReport(error)}\`\`\``));
-		this.addTimestampsIfAvailable(error);
-		this.addMetadataIfAvailable(metadata);
-	}
-	addTimestampsIfAvailable(error) {
-		if (!(error instanceof _discordjs_rest.DiscordAPIError)) return;
-		const now = Date.now();
-		const snowflake = error.url.match(/\/interactions\/(\d+)\//)?.[1];
-		if (!snowflake) return void 0;
-		const interactionTs = (0, _seedcord_utils.timestampFromSnowflake)(snowflake);
-		const diff = now - interactionTs;
-		const seconds = Math.floor(diff / 1e3);
-		const millis = diff % 1e3;
-		this.instance.addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### Timestamps\n- **\`Interaction sent\` :** ${new Date(interactionTs).toISOString()} (${interactionTs})\n- **\`Error logged    \` :** ${new Date(now).toISOString()} (${now})\n- **\`Offset          \` :** ${seconds}s ${millis}ms`));
-	}
-	addMetadataIfAvailable(metadata) {
-		if (!metadata) return;
-		this.instance.addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Metadata")).addFileComponents((file) => file.setURL("attachment://metadata.json"));
-	}
-};
-
-//#endregion
-//#region src/subscribers/Bus.ts
-/**
-* Registers and dispatches subscribers. Subscribers load from the configured directories and run
-* on a programmatic or framework-event publish. Accessed via `core.bus`. Do not construct it directly.
-*/
-var Bus = class extends Plugin {
-	core;
-	logger = new _seedcord_logger.Logger("Subscribers");
-	/** @internal */
-	name = "Subscribers";
-	isInitialized = false;
-	subscribersMap = /* @__PURE__ */ new Map();
-	executedOnceHandlers = /* @__PURE__ */ new Set();
-	webhookProbes = /* @__PURE__ */ new Map();
-	hmrHandler;
-	constructor(core) {
-		super(core);
-		this.core = core;
-		if (this.core.config.subscribers.path) {
-			if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
-			this.hmrHandler = new _seedcord_core_hmr.HmrModuleHandler({
-				handlersDir: this.core.config.subscribers.path,
-				isHandler: this.isSubscriber.bind(this),
-				registerHandler: this.registerSubscriber.bind(this),
-				unregisterHandler: this.unregisterSubscriber.bind(this),
-				getArtifacts: this.getArtifacts.bind(this),
-				logger: this.logger
-			});
-		}
-	}
-	getArtifacts(ctor) {
-		return [Reflect.getMetadata(_seedcord_core_internal.SubscribeMetadataKey, ctor).subscriber];
-	}
-	/** @internal */
-	async init() {
-		if (this.isInitialized) return;
-		this.isInitialized = true;
-		this.registerSubscriber(UnknownException);
-		this.registerSubscriber(HandledException);
-		const subscribersDir = this.core.config.subscribers.path;
-		if (subscribersDir) {
-			this.logger.info(chalk.default.bold(subscribersDir));
-			await this.loadSubscribers(subscribersDir);
-			const totalSubscribers = [...this.subscribersMap.values()].reduce((acc, handlers) => acc + handlers.length, 0);
-			this.logger.utils.list([`${chalk.default.bold.magenta(totalSubscribers)} subscribers`], chalk.default.bold.green("Loaded"));
-		}
-		if (!envapt.Envapter.isTest) await this.verifyWebhooks();
-	}
-	/** @internal Exposed for tests. */
-	async verifyWebhooks() {
-		const missing = [];
-		await Promise.all([...this.webhookProbes].map(async ([url, envKeys]) => {
-			const result = await WebhookLog.senderFor(url).verify();
-			if (result === "missing") missing.push(...envKeys);
-			else if (result === "unreachable") this.logger.warn(`could not verify webhook at ${_seedcord_logger.paint.sky.bold(envKeys.join(", "))}`);
-		}));
-		if (missing.length > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigWebhookNotFound, [missing.join(", ")]);
-	}
-	/** @internal */
-	async onHmr(event) {
-		if (this.hmrHandler) await this.hmrHandler.handle(event);
-	}
-	async loadSubscribers(dir) {
-		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
-			for (const exportName of Object.keys(imported)) {
-				const val = imported[exportName];
-				if (this.isSubscriber(val)) {
-					this.registerSubscriber(val);
-					this.hmrHandler?.trackHandler(fullPath, val);
-					this.logger.utils.registration(val.name, relativePath);
-				}
-			}
-		}, this.logger);
-	}
-	registerSubscriber(handler) {
-		if (handler.prototype instanceof WebhookLog) {
-			const envKey = WebhookLog.envKeyOf(handler);
-			const url = WebhookLog.urlOf(envKey);
-			if (url === null) {
-				this.logger.warn(`${chalk.default.bold(handler.name)} disabled, ${_seedcord_logger.paint.sky.bold(envKey)} is not set`);
-				return;
-			}
-			const envKeys = this.webhookProbes.get(url) ?? [];
-			if (!envKeys.includes(envKey)) envKeys.push(envKey);
-			this.webhookProbes.set(url, envKeys);
-		}
-		const options = Reflect.getMetadata(_seedcord_core_internal.SubscribeMetadataKey, handler);
-		let handlers = this.subscribersMap.get(options.subscriber);
-		if (!handlers) {
-			handlers = [];
-			this.subscribersMap.set(options.subscriber, handlers);
-		}
-		handlers.push({
-			ctor: handler,
-			frequency: options.frequency ?? "on"
-		});
-	}
-	unregisterSubscriber(handler, artifacts) {
-		const subscribers = artifacts ?? [...this.subscribersMap.keys()];
-		for (const subscriber of subscribers) {
-			const handlers = this.subscribersMap.get(subscriber);
-			if (!handlers) continue;
-			const index = handlers.findIndex((entry) => entry.ctor === handler);
-			if (index !== -1) handlers.splice(index, 1);
-		}
-	}
-	isSubscriber(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof Subscriber && Reflect.hasMetadata(_seedcord_core_internal.SubscribeMetadataKey, obj);
-	}
-	/**
-	* Publishes an event to its subscribers and native listeners.
-	*
-	* Fire-and-forget, so subscriber handlers run asynchronously and this returns before they
-	* complete, and callers must not assume side effects have landed. Errors thrown by a subscriber
-	* are caught and logged, never surfaced here. A `'once'` subscriber is marked as executed when
-	* it starts (even if it throws), so it never runs twice.
-	*
-	* @param event - The subscription key to publish
-	* @param data - Payload passed to each subscriber
-	* @returns Whether the underlying emitter had native listeners for the event
-	*/
-	publish(event, data) {
-		this.processSubscriber(event, data);
-		return super.emit(event, ...[data]);
-	}
-	async processSubscriber(subscriberName, data) {
-		const handlers = this.subscribersMap.get(subscriberName);
-		if (!handlers) return;
-		for (const entry of handlers) {
-			if (entry.frequency === "once" && this.executedOnceHandlers.has(entry.ctor)) continue;
-			try {
-				if (entry.frequency === "once") this.executedOnceHandlers.add(entry.ctor);
-				const Ctor = entry.ctor;
-				await new Ctor(data, this.core).execute();
-			} catch (err) {
-				this.logger.error(`Error in subscriber ${String(subscriberName)} handler ${entry.ctor.name}:`, err);
-			}
-		}
-	}
 };
+__decorate([(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.0-next.3";
+const version = "0.1.0-next.5";
 
 //#endregion
 //#region src/Seedcord.ts
 /**
-* Main Seedcord bot framework class
-*
-* Primary entry point for creating Discord bots with Seedcord.
-* Manages component lifecycle and provides plugin support.
+* 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 Pluggable {
+var Seedcord = class Seedcord extends _seedcord_core_node_internal.Pluggable {
 	config;
 	/** @internal */
 	[_seedcord_types_internal.SeedcordBrand] = true;
@@ -3579,83 +3077,86 @@ var Seedcord = class Seedcord extends Pluggable {
 	augmentTarget = "@seedcord/gateway";
 	/** @internal */
 	version = version;
-	static isInstantiated = false;
 	healthCheck;
 	hmrManager;
-	/** @see {@link CoordinatedShutdown} */
-	shutdown;
-	/** @see {@link CoordinatedStartup} */
-	startup;
 	/** @see {@link Bus} */
 	bus;
+	subscribers;
 	/** @see {@link Bot} */
 	bot;
 	/** @see {@link IRateLimiter} */
 	rateLimiter;
 	/**
-	* Creates a new Seedcord instance
-	*
 	* @param config - Bot configuration including paths and Discord client options
 	* @throws A **SeedcordError** When attempting to create multiple instances (singleton)
 	*/
 	constructor(config) {
-		if (Seedcord.isInstantiated) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreSingletonViolation);
-		Seedcord.isInstantiated = true;
-		const shutdown = new _seedcord_core_node.CoordinatedShutdown(config.shutdownEnabled);
-		const startup = new _seedcord_core_node.CoordinatedStartup();
-		super(shutdown, startup);
+		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.shutdown = shutdown;
-		this.startup = startup;
 		this.hmrManager = new _seedcord_core_internal.HmrManager();
 		this.hmrManager.init();
-		this.bus = new Bus(this);
+		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.rateLimiter = config.store ?? new _seedcord_rate_limiter.MemoryRateLimiter();
-		this.healthCheck = new _seedcord_core_node.HealthCheck(this.shutdown, config.healthCheck);
+		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;
 	}
+	pluginCapabilities() {
+		return {
+			client: this.bot.client,
+			token: this.bot.botToken,
+			rest: this.bot.client.rest
+		};
+	}
 	static reset() {
-		Seedcord.isInstantiated = false;
+		super.reset();
 		_seedcord_logger.LoggerChannelRegistry.instance.reset();
 	}
 	registerStartupTasks() {
 		if (envapt.Envapter.isDevelopment || envapt.Envapter.isTest) this.registerHmrAwareModules();
-		this.startup.addTask(_seedcord_core_node.StartupPhase.Configuration, "Bus Initialization", async () => {
+		this.startup.addTask(_seedcord_core_node_internal.StartupPhase.Configuration, "bus-initialization", async () => {
 			this.bus.logger.utils.initialization("Subscribers", "start");
-			await this.bus.init();
+			await this.subscribers.init();
 			this.bus.logger.utils.initialization("Subscribers", "end");
 		});
-		this.startup.addTask(_seedcord_core_node.StartupPhase.Instantiation, "Bot Initialization", async () => {
+		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");
 		});
-		this.startup.addTask(_seedcord_core_node.StartupPhase.Ready, "Health Check", async () => {
-			this.healthCheck.logger.utils.initialization("HealthCheck", "start");
-			await this.healthCheck.init();
-			this.healthCheck.logger.utils.initialization("HealthCheck", "end");
+		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 fully initialized
+	* @returns This Seedcord instance when initialized
 	*/
 	async start() {
-		await super.init();
+		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.StartupPhase.Configuration, "HMR Registration", async () => {
+		this.startup.addTask(_seedcord_core_node_internal.StartupPhase.Configuration, "hmr-registration", async () => {
 			this.hmrManager.register(this.bot);
-			this.hmrManager.register(this.bus);
+			this.hmrManager.register(this.subscribers);
 			for (const plugin of this.plugins) this.hmrManager.register(plugin);
 			await Promise.resolve();
 		});
@@ -3681,29 +3182,14 @@ exports.MiddlewareType = MiddlewareType;
 exports.ModalHandler = ModalHandler;
 exports.Nsfw = Nsfw;
 exports.Paginator = Paginator;
-exports.Pluggable = Pluggable;
 exports.Plugin = Plugin;
 exports.RegisterEvent = RegisterEvent;
 exports.RepliableHandler = RepliableHandler;
 exports.Seedcord = Seedcord;
 exports.SelectMenuHandler = SelectMenuHandler;
-Object.defineProperty(exports, 'ShutdownPhase', {
-  enumerable: true,
-  get: function () {
-    return _seedcord_core_node.ShutdownPhase;
-  }
-});
 exports.SlashHandler = SlashHandler;
-Object.defineProperty(exports, 'StartupPhase', {
-  enumerable: true,
-  get: function () {
-    return _seedcord_core_node.StartupPhase;
-  }
-});
-exports.Subscribe = Subscribe;
 exports.Subscriber = Subscriber;
 exports.WebhookLog = WebhookLog;
-exports.WebhookUrl = WebhookUrl;
 exports.checkBotPermissions = checkBotPermissions;
 exports.checkPermissions = checkPermissions;
 exports.fetchGuildMember = fetchGuildMember;
@@ -3731,6 +3217,7 @@ Object.keys(_seedcord_errors).forEach(function (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,