@seedcord/core 0.11.0 → 0.12.0-next.2

package/dist/internal.index.mjs

@@ -1,13 +1,13 @@
-import { At as guardedAccessor, B as NotInGuild, Bt as isBuilderComponentClass, C as PermissionNames, Ct as warnLinks, D as pickNotice, Dt as linkCommands, Et as indexById, F as MissingPermissions, Ft as skippedNote, G as serializeReply, H as OnCooldown, Ht as Notice, I as MissingRole, It as contextMenuLeaves, K as translateSerializationError, L as NeedsAny, Lt as NoticeCard, M as runCommits, Mt as commandsRoute, N as GateNotice, Nt as globalFirst, O as discardCommits, Ot as accessorStore, P as HasDangerousPermissions, Pt as scopeIdsOf, Q as sendTarget, R as NotAllowed, St as installLinks, Tt as commandRefOf, V as NotOwner, Vt as bindBotColor, X as AckTrace, Y as reportedWrite, Z as checkAckLegality, _ as pageCursor, _t as SubscribeMetadataKey, a as RegisterSubscriber, at as ComponentDefsKey, c as VerifyWebhooks, dt as EventMiddlewareMetadataKey, et as interactionMiddlewareMetaOf, f as Subscriber, ft as GatedMetadataKey, g as PAGE_MAX, gt as InteractionRouteKeys, h as sendFlags, ht as InteractionMiddlewareMetadataKey, i as RegisterDefaults, it as storeInteractionRoute, j as runCheck, jt as GLOBAL_ID, kt as clearStore, lt as CommandMetadataKey, m as deferFlags, mt as InteractionMetadataKey, n as busLoggerOf, nt as interactionRoutesOf, o as RegisteredCount, ot as decodeComponentRoute, p as ReportThrottle, r as registrationFor, rt as storeComponentRoute, s as UnregisterSubscriber, st as ConfigGuilds, tt as contextMenuRouteOf, ut as EventMetadataKey, v as ResolvedEmoji, vt as WebhookUrlMetadataKey, wt as commandKey, y as Silence, yt as CommandInjector, z as NotInDm } from "./subscribers-Ce3SWy23.mjs";
-import { t as PublishDefault } from "./publishDefault-D3dAyzZ9.mjs";
-import { c as setDevChannel, i as FixedScope, n as attachmentsOf, r as sealAttachments, s as getDevChannel } from "./PluginHost-B8kxLOeb.mjs";
-import { t as HmrModuleHandler } from "./HmrModuleHandler-8ZC-UuZh.mjs";
-import { i as logUnknownFault, t as PluginLifecycle } from "./PluginLifecycle-AhQ46NIr.mjs";
-import { t as CoordinatedStartup } from "./CoordinatedStartup-CGnJrqcl.mjs";
-import { t as bindEnv } from "./bindViteEnv-DWq5rftJ.mjs";
+import { A as InteractionRouteKeys, C as CommandMetadataKey, D as InteractionKind, E as GatedMetadataKey, F as isBuilderComponentClass, I as bindBotColor, M as WebhookUrlMetadataKey, O as InteractionMetadataKey, S as assertUniqueKeys, T as EventMiddlewareMetadataKey, _ as OnceTracker, a as RegisterSubscriber, c as VerifyWebhooks, f as Subscriber, g as sendFlags, h as deferFlags, i as RegisterDefaults, j as SubscribeMetadataKey, k as InteractionMiddlewareMetadataKey, m as ReportThrottle, n as busLoggerOf, o as RegisteredCount, p as runCase, r as registrationsFor, s as UnregisterSubscriber, w as EventMetadataKey, x as PublishDefault } from "./Bus-VJw-QpoY.mjs";
+import { $ as GLOBAL_ID, D as AckTrace, E as lazyLogger, F as storeComponentRoute, G as warnLinks, I as storeInteractionRoute, J as indexById, K as commandKey, L as ComponentDefsKey, M as contextMenuRouteOf, N as interactionRoutesOf, O as checkAckLegality, P as routeDecoratorOf, Q as guardedAccessor, R as decodeComponentRoute, S as translateSerializationError, T as reportedWrite, V as CommandInjector, W as installLinks, X as accessorStore, Y as linkCommands, Z as clearStore, _ as NotInGuild, a as discardCommits, at as Notice, c as runCheck, et as commandsRoute, g as NotInDm, h as NotAllowed, i as Silence, it as contextMenuLeaves, j as interactionMiddlewareMetaOf, k as sendTarget, l as runCommits, m as NeedsAny, n as pageCursor, nt as scopeIdsOf, ot as NoticeCard, p as MissingRole, q as commandRefOf, r as ResolvedEmoji, rt as skippedNote, t as PAGE_MAX, tt as globalFirst, u as Fault, v as NotOwner, x as serializeReply, y as OnCooldown, z as ConfigGuilds } from "./subscribers-CGuVjbrg.mjs";
+import { a as KeyedQueue, i as splitPluginKey, l as getDevChannel, n as attachmentsOf, o as FixedScope, r as sealAttachments, u as setDevChannel } from "./PluginHost-DTtxWRiL.mjs";
+import { t as HmrModuleHandler } from "./HmrModuleHandler-Btgu8r96.mjs";
+import { i as logUnknownFault, t as PluginLifecycle } from "./PluginLifecycle-hx5zUc-P.mjs";
+import { t as CoordinatedStartup } from "./CoordinatedStartup-Zw_Lk7Zk.mjs";
+import { t as bindEnv } from "./bindViteEnv-NFzvdqlT.mjs";
 import "reflect-metadata";
 import { SlashCommandBuilder } from "@discordjs/builders";
-import { Routes } from "discord-api-types/v10";
+import { ComponentType, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
 import { SeedcordError, SeedcordTypeError, throwSingleOrAggregate, validateDiscordToken } from "@seedcord/errors/internal";
 import { LEVEL_COLOR, Logger, LoggerChannelRegistry } from "@seedcord/logger";
@@ -30,11 +30,13 @@ var SubscriberLoader = class {
 		if (!this.directory) return;
 		if (!Envapter.isDevelopment && !Envapter.isTest) return;
 		this.hmrHandler = new HmrModuleHandler({
-			handlersDir: this.directory,
-			isHandler: this.isSubscriber.bind(this),
-			registerHandler: this.registerSubscriber.bind(this),
-			unregisterHandler: this.unregisterSubscriber.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
+			handlers: {
+				dir: this.directory,
+				is: this.isSubscriber.bind(this),
+				register: this.registerSubscriber.bind(this),
+				unregister: this.unregisterSubscriber.bind(this),
+				getArtifacts: this.getArtifacts.bind(this)
+			},
 			logger: busLoggerOf(this.bus)
 		});
 	}
@@ -64,13 +66,13 @@ var SubscriberLoader = class {
 		}
 	}
 	registerSubscriber(ctor) {
-		this.bus[RegisterSubscriber](registrationFor(ctor));
+		this.bus[RegisterSubscriber](ctor);
 	}
 	unregisterSubscriber(ctor, artifacts) {
 		this.bus[UnregisterSubscriber](ctor, artifacts);
 	}
 	getArtifacts(ctor) {
-		return [Reflect.getMetadata(SubscribeMetadataKey, ctor).subscriber];
+		return registrationsFor(ctor).map((registration) => registration.key);
 	}
 	isSubscriber(value) {
 		if (typeof value !== "function") return false;
@@ -151,40 +153,142 @@ var MiddlewareRegistry = class {
 };
 
 //#endregion
-//#region src/gates/runGates.ts
-async function timedCheck(gate, ctx, observe) {
-	const start = performance.now();
-	try {
-		await runCheck(gate, ctx);
-	} finally {
-		observe(gate.name, performance.now() - start);
+//#region src/notices/FaultBoundary.ts
+const logger$2 = lazyLogger("Faults", { channel: "errors" });
+const HARMLESS_API_CODES = /* @__PURE__ */ new Set([
+	RESTJSONErrorCodes.UnknownInteraction,
+	RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
+	RESTJSONErrorCodes.UnknownMessage
+]);
+var FaultBoundary = class {
+	core;
+	apiError;
+	dispatch;
+	detailsOf;
+	ignoredCodes;
+	constructor(core, ignoredCodes, apiError, dispatch, detailsOf) {
+		this.core = core;
+		this.apiError = apiError;
+		this.dispatch = dispatch;
+		this.detailsOf = detailsOf;
+		this.ignoredCodes = new Set(ignoredCodes);
 	}
-}
-async function runGates(gates, ctx, observe) {
-	try {
-		for (const gate of gates) await (observe ? timedCheck(gate, ctx, observe) : runCheck(gate, ctx));
-		await runCommits(ctx);
-	} finally {
-		discardCommits(ctx);
+	report(caught) {
+		const { config } = this.core;
+		if (caught instanceof Silence) {
+			if (caught.reason !== void 0 && (config.errors?.logSilences ?? true)) logger$2().debug(`Silence: ${caught.reason}`);
+			return null;
+		}
+		const error = asError(caught);
+		if (error instanceof this.apiError && this.ignoredCodes.has(error.code)) {
+			logger$2().debug(`swallowed api code ${paint.amber(String(error.code))}`);
+			return null;
+		}
+		const uuid = crypto.randomUUID();
+		this.publish(error, uuid);
+		return {
+			error,
+			uuid
+		};
 	}
-}
-async function runHandlerGates(handlerCtor, ctx, declaredRoute, observe) {
-	const gates = Reflect.getMetadata(GatedMetadataKey, handlerCtor);
-	if (!gates) return;
-	await runGates(gates, {
-		...ctx,
-		declaredRoute: declaredRoute ?? null
-	}, observe);
-}
+	async answerWithReply(caught, sender) {
+		const fault = this.report(caught);
+		const reply = fault && this.rendered(fault);
+		if (reply) await this.sendGuarded(() => sender.send(reply.response, { ephemeral: reply.ephemeral }));
+	}
+	async answerWithEmptyChoices(caught, clearChoices) {
+		this.report(caught);
+		await this.sendGuarded(clearChoices);
+	}
+	publish(error, uuid) {
+		if (error instanceof Notice && !error.report) return;
+		const { bus, config } = this.core;
+		const { origin, source, guild, user, metadata } = this.detailsOf();
+		const from = {
+			uuid,
+			dispatchId: this.dispatch.id,
+			origin
+		};
+		if (error instanceof Notice) {
+			logger$2().error(`${error.name}: ${paint.mute(uuid)}`, error);
+			if (source) {
+				bus[PublishDefault]("handledException", {
+					denial: error,
+					...from,
+					source
+				});
+				return;
+			}
+		} else logUnknownFault(logger$2(), paint.mute(uuid), error, config.errors);
+		bus[PublishDefault]("unknownException", {
+			...from,
+			error,
+			guild,
+			user,
+			metadata
+		});
+	}
+	rendered(fault) {
+		try {
+			return this.render(fault);
+		} catch (renderError) {
+			return this.fallbackReply(renderError);
+		}
+	}
+	fallbackReply(renderError) {
+		const fallback = this.report(renderError);
+		if (!fallback) return null;
+		try {
+			return this.render(fallback);
+		} catch (error) {
+			logger$2().error(`could not render a fault card for route ${paint.sky.bold(this.dispatch.routeId)}`, error);
+			return {
+				response: new Fault().render(this.renderContext(fallback.uuid)),
+				ephemeral: true
+			};
+		}
+	}
+	render({ error, uuid }) {
+		const ctx = this.renderContext(uuid);
+		if (error instanceof Notice) return {
+			response: error.render(ctx),
+			ephemeral: error.ephemeral
+		};
+		const Override = this.core.config.errors?.defaultError;
+		return {
+			response: (Override ? new Override(uuid) : new Fault()).render(ctx),
+			ephemeral: true
+		};
+	}
+	renderContext(uuid) {
+		const { dispatch } = this;
+		const developerUsername = this.core.config.notifications?.developerUsername;
+		return developerUsername === void 0 ? {
+			uuid,
+			dispatch
+		} : {
+			uuid,
+			developerUsername,
+			dispatch
+		};
+	}
+	async sendGuarded(send) {
+		try {
+			await send();
+		} catch (error) {
+			if (error instanceof this.apiError && HARMLESS_API_CODES.has(error.code)) {
+				logger$2().debug(`fault reply hit harmless code ${paint.amber(String(error.code))}`);
+				return;
+			}
+			logger$2().error(`could not send a fault reply for route ${paint.sky.bold(this.dispatch.routeId)}`, error);
+		}
+	}
+};
 
 //#endregion
 //#region src/gates/slowGate.ts
 const SLOW_GATE_MS = 750;
-let gateLogger;
-function logger$1() {
-	gateLogger ??= new Logger("Gates", { channel: "gates" });
-	return gateLogger;
-}
+const logger$1 = lazyLogger("Gates", { channel: "gates" });
 function slowGateMonitor() {
 	if (Envapter.isProduction) return void 0;
 	const readings = [];
@@ -203,6 +307,38 @@ function slowGateMonitor() {
 	};
 }
 
+//#endregion
+//#region src/gates/runGates.ts
+async function timedCheck(gate, ctx, observe) {
+	const start = performance.now();
+	try {
+		await runCheck(gate, ctx);
+	} finally {
+		observe(gate.name, performance.now() - start);
+	}
+}
+async function runGates(gates, ctx, observe) {
+	try {
+		for (const gate of gates) await (observe ? timedCheck(gate, ctx, observe) : runCheck(gate, ctx));
+		await runCommits(ctx);
+	} finally {
+		discardCommits(ctx);
+	}
+}
+async function runHandlerGates(handlerCtor, ctx, observe) {
+	const gates = Reflect.getMetadata(GatedMetadataKey, handlerCtor);
+	if (!gates) return;
+	await runGates(gates, ctx, observe);
+}
+async function runInteractionGates(handlerCtor, ctx) {
+	const monitor = slowGateMonitor();
+	try {
+		await runHandlerGates(handlerCtor, ctx, monitor?.observe);
+	} finally {
+		monitor?.report(ctx.dispatch.declaredRoute);
+	}
+}
+
 //#endregion
 //#region src/miscellaneous/emojiConfig.ts
 function isEmojiTuple(value) {
@@ -536,6 +672,7 @@ var CommandRegistry = class {
 	loadedCommands = [];
 	hmrHandler;
 	pendingEvents = /* @__PURE__ */ new Map();
+	deploys = new KeyedQueue();
 	injector = new CommandInjector();
 	lastDeploy = new LastDeploy();
 	reporter = new DeployReporter(this.logger);
@@ -549,11 +686,13 @@ var CommandRegistry = class {
 		this.configuredGuilds = commands.guilds ?? [];
 		if (!Envapter.isDevelopment && !Envapter.isTest) return;
 		this.hmrHandler = new HmrModuleHandler({
-			handlersDir: this.dir,
-			isHandler: isCommandClass,
-			registerHandler: this.registerCommand.bind(this),
-			unregisterHandler: this.unregisterCommand.bind(this),
-			getArtifacts: this.getArtifacts.bind(this),
+			handlers: {
+				dir: this.dir,
+				is: isCommandClass,
+				register: this.registerCommand.bind(this),
+				unregister: this.unregisterCommand.bind(this),
+				getArtifacts: this.getArtifacts.bind(this)
+			},
 			logger: this.logger
 		});
 	}
@@ -573,7 +712,9 @@ var CommandRegistry = class {
 		}
 		this.reportLoad();
 		getDevChannel()?.on("seedcord:refresh-commands", (data) => {
-			this.refresh(data.shouldRefresh);
+			this.refresh(data.shouldRefresh).catch((error) => {
+				this.logger.error("Failed to refresh commands", error);
+			});
 		});
 	}
 	reportLoad() {
@@ -592,15 +733,21 @@ var CommandRegistry = class {
 		})], "debug");
 	}
 	/** @internal */
-	async refresh(shouldRefresh = true) {
+	refresh(shouldRefresh = true) {
+		const answeredEvents = [...this.pendingEvents.values()];
+		this.pendingEvents.clear();
+		return this.afterRunningDeploy(() => this.applyEvents(answeredEvents, shouldRefresh));
+	}
+	afterRunningDeploy(task) {
+		return this.deploys.run("commands", task);
+	}
+	async applyEvents(events, shouldRefresh) {
 		if (!shouldRefresh) {
 			this.logger.debug(paint.italic("Command refresh cancelled."));
-			this.pendingEvents.clear();
 			return;
 		}
 		this.logger.debug(paint.italic("Refreshing commands..."));
-		for (const event of this.pendingEvents.values()) await this.hmrHandler?.handle(event);
-		this.pendingEvents.clear();
+		for (const event of events) await this.hmrHandler?.handle(event);
 		await this.setCommands();
 	}
 	/** @internal */
@@ -653,7 +800,7 @@ var CommandRegistry = class {
 	async deploy(signal, { routes, check }) {
 		await this.init();
 		check?.(this.allCommands());
-		await this.setCommands(signal);
+		await this.afterRunningDeploy(() => this.setCommands(signal));
 		routes?.warnUnhandledRoutes(this.routeLeaves());
 		routes?.warnUnhandledContextMenuRoutes(this.contextMenuLeaves());
 	}
@@ -879,29 +1026,85 @@ function forwardLogsToCli() {
 }
 
 //#endregion
-//#region src/dispatch/dispatchReport.ts
-let dispatchLogger;
-function logger() {
-	dispatchLogger ??= new Logger("Dispatch", { channel: "interactions" });
-	return dispatchLogger;
+//#region src/reply/AutocompleteResponder.ts
+var AutocompleteResponder = class {
+	telemetry;
+	post;
+	attempt;
+	constructor(telemetry, post) {
+		this.telemetry = telemetry;
+		this.post = post;
+	}
+	respond(choices) {
+		this.attempt = reportedWrite(this.telemetry, "respond", () => this.post(choices)).then(() => void 0);
+		return this.attempt;
+	}
+	async clear() {
+		if (!await this.attempt?.then(() => true, () => false)) await this.respond([]);
+	}
+};
+
+//#endregion
+//#region src/dispatch/routeIdOf.ts
+function routeIdOf(kind, route) {
+	return `${kind}:${route || "unrouted"}`;
 }
+
+//#endregion
+//#region src/dispatch/DispatchContext.ts
 /**
-* Classifies a caught stop for `interactionDispatched` so a gate and a
-* handler label the same stop identically.
+* State shared by middleware, gates, and handlers during one dispatch.
 *
-* @internal
+* @typeParam Kind - What started this dispatch, an interaction kind or `event`.
 */
+var DispatchContext = class {
+	kind;
+	route;
+	fallback;
+	state = Object.create(null);
+	id = crypto.randomUUID();
+	constructor(kind, route, fallback = false) {
+		this.kind = kind;
+		this.route = route;
+		this.fallback = fallback;
+	}
+	/**
+	* The dispatch identifier, such as `slash:search/docs`, `button:approve`, or `event:messageCreate`.
+	* Component identifiers contain the custom-ID prefix without encoded params.
+	*/
+	get routeId() {
+		return routeIdOf(this.kind, this.route);
+	}
+	/** The {@link routeId} of the handler's own route. It's `null` on an event and on the unhandled default. */
+	get declaredRoute() {
+		return this.kind === "event" || this.fallback ? null : this.routeId;
+	}
+	set(key, value) {
+		this.state[key] = value;
+	}
+	get(key) {
+		return this.state[key];
+	}
+	/**
+	* Read a key that must be present, with `undefined` stripped from the result.
+	*
+	* @throws A **SeedcordError** when nothing set the key on this dispatch.
+	*/
+	require(key) {
+		const value = this.state[key];
+		if (value === void 0) throw new SeedcordError(SeedcordErrorCode.DispatchStateMissing, [String(key)]);
+		return value;
+	}
+};
+
+//#endregion
+//#region src/dispatch/dispatchReport.ts
+const logger = lazyLogger("Dispatch", { channel: "interactions" });
 function outcomeFor(caught) {
 	if (caught instanceof Silence) return "refused";
 	if (caught instanceof Notice) return caught.report ? "failed" : "refused";
 	return "failed";
 }
-/**
-* Discord's interaction creation to now, read from the snowflake. Called at dispatch entry, since
-* a later read would count the handler run into the queue time as well.
-*
-* @internal
-*/
 function queuedMsFor(interactionId) {
 	try {
 		return Date.now() - timestampFromSnowflake(interactionId);
@@ -912,18 +1115,18 @@ function queuedMsFor(interactionId) {
 function reportDispatch(bus, report) {
 	const durationMs = performance.now() - report.startedAt;
 	bus[PublishDefault]("interactionDispatched", {
-		dispatchId: report.dispatchId,
-		routeId: report.routeId,
+		dispatchId: report.dispatch.id,
+		routeId: report.dispatch.routeId,
 		interactionId: report.interactionId,
-		kind: report.kind,
+		kind: report.dispatch.kind,
 		outcome: report.outcome,
-		fallback: report.fallback,
+		fallback: report.dispatch.fallback,
 		userId: report.userId,
 		guildId: report.guildId,
 		durationMs,
 		queuedMs: report.queuedMs
 	});
-	logger().trace(`${paint.sky.bold(report.routeId)} ${report.outcome} ${paint.mute("in")} ${Math.round(durationMs)}ms`);
+	logger().trace(`${paint.sky.bold(report.dispatch.routeId)} ${report.outcome} ${paint.mute("in")} ${Math.round(durationMs)}ms`);
 }
 
 //#endregion
@@ -969,5 +1172,301 @@ async function runAfter(ran, result, logger) {
 }
 
 //#endregion
-export { AckTrace, AutocompleteRouteBrand, BAKED_IDS_KEY, COMMAND_DEPLOY_TIMEOUT_MS, CommandMetadataKey, CommandRegistry, ComponentDefsBrand, ComponentDefsKey, ComponentKindBrand, ContextMenuKindBrand, ContextMenuNamesBrand, CoordinatedStartup, EventMetadataKey, EventMiddlewareMetadataKey, FixedScope, GLOBAL_ID, GateNotice, GatedMetadataKey, HasDangerousPermissions, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, InteractionRouteKeys, MiddlewareKindsBrand, MiddlewareRegistry, MissingPermissions, MissingRole, NeedsAny, NotAllowed, NotInDm, NotInGuild, NotOwner, NoticeCard, OnCooldown, PAGE_MAX, PermissionNames, PluginLifecycle, PublishDefault, RegisterDefaults, RegisterSubscriber, RegisteredCount, ReportThrottle, SlashRouteBrand, SubscribeMetadataKey, SubscriberLoader, UnregisterSubscriber, VerifyWebhooks, WebhookUrlMetadataKey, accessorStore, attachmentsOf, bindBotColor, bindEnv, busLoggerOf, checkAckLegality, clearStore, commandKey, commandRefOf, commandsRoute, connectDevChannel, contextMenuLeaves, contextMenuRouteOf, currentApplication, decodeComponentRoute, deferFlags, eventResultFor, forwardLogsToCli, fromDevLogLine, fromWireError, getDevChannel, globalFirst, guardedAccessor, guildSummaries, indexById, installLinks, interactionMiddleware, interactionMiddlewareMetaOf, interactionRoutesOf, isCommandClass, isEmojiTuple, linkCommands, logUnknownFault, outcomeFor, pageCursor, pickNotice, planDeploy, putCommands, queuedMsFor, readBotToken, readCommands, readCommandsAt, registrationFor, reportDispatch, reportedWrite, resolveDeployTarget, resolveEmojis, resultFor, runAfter, runGates, runHandlerGates, scopeIdsOf, sealAttachments, sendFlags, sendTarget, serializeReply, setDevChannel, skippedNote, slashRouteLeaves, slowGateMonitor, storeComponentRoute, storeInteractionRoute, toWireError, translateSerializationError, warnLinks, wrapHot };
+//#region src/dispatch/InteractionRun.ts
+var InteractionRun = class {
+	config;
+	ran = [];
+	startedAt = performance.now();
+	queuedMs;
+	boundary;
+	constructor(config) {
+		this.config = config;
+		const { core, apiError, interactionId, dispatch } = config;
+		this.queuedMs = queuedMsFor(interactionId);
+		this.boundary = new FaultBoundary(core, core.config.errors?.ignoreApiCodes, apiError, dispatch, () => config.faultDetails());
+	}
+	async prepare() {
+		const { target } = this.config;
+		this.warnIfUnhandled();
+		return "responder" in target ? this.prepareAutocomplete(target) : this.prepareRepliable(target);
+	}
+	warnIfUnhandled() {
+		const { dispatch, customId, HandlerCtor, logger } = this.config;
+		if (!dispatch.fallback) return;
+		if (dispatch.route === "") {
+			logger.warn(`${paint.sky.bold(dispatch.kind)} has invalid customId: ${paint.mute(String(customId))}`);
+			return;
+		}
+		logger.warn(`No handler found for ${paint.sky.bold(dispatch.routeId)}. Falling back to ${HandlerCtor.name}.`);
+	}
+	async prepareAutocomplete({ responder }) {
+		const answer = (caught) => this.boundary.answerWithEmptyChoices(caught, () => responder.clear());
+		const handler = await this.builtHandler(responder, answer);
+		return handler && (() => this.start(handler, answer));
+	}
+	async prepareRepliable(target) {
+		const { sender } = target;
+		const answer = (caught) => this.boundary.answerWithReply(caught, sender);
+		const handler = await this.builtHandler(sender, answer);
+		if (!handler) return null;
+		const refusal = await this.refusal(target);
+		if (refusal) {
+			await this.finish(answer, refusal.caught);
+			return null;
+		}
+		return () => this.start(handler, answer);
+	}
+	async builtHandler(replyWith, answer) {
+		const { HandlerCtor, event, core, dispatch, logger } = this.config;
+		logger.trace(`Processing ${paint.sky.bold(dispatch.routeId)} with ${paint.mute(HandlerCtor.name)}`);
+		try {
+			return new HandlerCtor(event, core, dispatch, replyWith);
+		} catch (caught) {
+			await this.finish(answer, caught);
+			return null;
+		}
+	}
+	async refusal(target) {
+		try {
+			await this.runMiddlewares(target.sender);
+			await runInteractionGates(this.config.HandlerCtor, target.gateContext());
+			return null;
+		} catch (caught) {
+			return { caught };
+		}
+	}
+	async runMiddlewares(sender) {
+		const { middlewares, event, core, dispatch } = this.config;
+		for (const Middleware of middlewares.chainFor(dispatch.kind)) {
+			const middleware = new Middleware(event, core, dispatch, sender);
+			this.ran.push(middleware);
+			await middleware.execute();
+		}
+	}
+	async start(handler, answer) {
+		try {
+			await handler.execute();
+		} catch (caught) {
+			await this.finish(answer, caught);
+			return;
+		}
+		this.report("handled");
+		await runAfter(this.ran, { outcome: "handled" }, this.config.logger);
+	}
+	async finish(answer, caught) {
+		try {
+			await answer(caught);
+		} finally {
+			this.report(outcomeFor(caught));
+			await runAfter(this.ran, resultFor(caught), this.config.logger);
+		}
+	}
+	report(outcome) {
+		const { core, dispatch, interactionId, userId, guildId } = this.config;
+		reportDispatch(core.bus, {
+			dispatch,
+			interactionId,
+			outcome,
+			userId,
+			guildId,
+			startedAt: this.startedAt,
+			queuedMs: this.queuedMs
+		});
+	}
+};
+
+//#endregion
+//#region src/dispatch/componentKindOf.ts
+const COMPONENT_KINDS = {
+	[ComponentType.Button]: "button",
+	[ComponentType.StringSelect]: "stringMenu",
+	[ComponentType.UserSelect]: "userMenu",
+	[ComponentType.RoleSelect]: "roleMenu",
+	[ComponentType.ChannelSelect]: "channelMenu",
+	[ComponentType.MentionableSelect]: "mentionableMenu"
+};
+function componentKindOf(type) {
+	return COMPONENT_KINDS[type] ?? null;
+}
+
+//#endregion
+//#region src/dispatch/HandlerLoader.ts
+var HandlerLoader = class {
+	options;
+	loadedHandlers = [];
+	loadedMiddlewares = [];
+	initialLoad = false;
+	hmr;
+	constructor(options) {
+		this.options = options;
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		const { handlersDir, middlewaresDir, middlewares, logger } = options;
+		this.hmr = new HmrModuleHandler({
+			handlers: {
+				dir: handlersDir,
+				is: (value) => options.isHandler(value),
+				register: (handler, file) => this.registerHandler(handler, file),
+				unregister: (handler, artifacts) => options.removeHandler(handler, artifacts),
+				getArtifacts: (handler) => options.artifactsOf(handler)
+			},
+			...middlewaresDir && { middlewares: {
+				dir: middlewaresDir,
+				is: (value) => options.isMiddleware(value),
+				register: (middleware, file) => this.registerMiddleware(middleware, file),
+				unregister: (middleware) => middlewares.unregister(middleware)
+			} },
+			logger
+		});
+	}
+	async load() {
+		const { handlersDir, middlewaresDir } = this.options;
+		this.initialLoad = true;
+		this.loadedHandlers.length = 0;
+		this.loadedMiddlewares.length = 0;
+		try {
+			if (middlewaresDir) await this.loadMiddlewares(middlewaresDir);
+			await this.loadHandlers(handlersDir);
+		} finally {
+			this.initialLoad = false;
+		}
+	}
+	async onHmr(event) {
+		await this.hmr?.handle(event);
+	}
+	async loadHandlers(dir) {
+		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const value of Object.values(imported)) {
+			if (!this.options.isHandler(value)) continue;
+			this.registerHandler(value, relativePath);
+			this.hmr?.trackHandler(fullPath, value);
+		}
+	}
+	async loadMiddlewares(dir) {
+		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const value of Object.values(imported)) {
+			if (!this.options.isMiddleware(value)) continue;
+			this.registerMiddleware(value, relativePath);
+			this.hmr?.trackMiddleware(fullPath, value);
+		}
+	}
+	registerHandler(handler, relativePath) {
+		const from = formatFilePath(relativePath);
+		if (!this.options.storeHandler(handler, from)) return;
+		if (this.initialLoad) this.loadedHandlers.push({
+			name: handler.name,
+			from
+		});
+	}
+	registerMiddleware(middleware, relativePath) {
+		const registration = this.options.middlewares.register(middleware);
+		if (!registration || !this.initialLoad) return;
+		const scope = registration.keys ? `${registration.priority}, ${registration.keys.join(", ")}` : registration.priority;
+		this.loadedMiddlewares.push({
+			name: `${middleware.name} (${String(scope)})`,
+			from: formatFilePath(relativePath)
+		});
+	}
+};
+
+//#endregion
+//#region src/dispatch/RouteRegistry.ts
+function emptyRouteMaps() {
+	return {
+		["slash"]: /* @__PURE__ */ new Map(),
+		["userContextMenu"]: /* @__PURE__ */ new Map(),
+		["messageContextMenu"]: /* @__PURE__ */ new Map(),
+		["autocomplete"]: /* @__PURE__ */ new Map(),
+		["button"]: /* @__PURE__ */ new Map(),
+		["stringMenu"]: /* @__PURE__ */ new Map(),
+		["userMenu"]: /* @__PURE__ */ new Map(),
+		["roleMenu"]: /* @__PURE__ */ new Map(),
+		["channelMenu"]: /* @__PURE__ */ new Map(),
+		["mentionableMenu"]: /* @__PURE__ */ new Map(),
+		["modal"]: /* @__PURE__ */ new Map()
+	};
+}
+function matchRoute(maps, kind, route, unhandled) {
+	return maps[kind].get(route) ?? {
+		kind,
+		route,
+		fallback: true,
+		ctor: kind === "autocomplete" ? unhandled.autocomplete : unhandled.repliable
+	};
+}
+var RouteRegistry = class {
+	maps = emptyRouteMaps();
+	get allRoutes() {
+		return Object.values(this.maps).flatMap((routes) => [...routes.values()]);
+	}
+	get size() {
+		return this.allRoutes.length;
+	}
+	register(ctor, from) {
+		const writes = [];
+		for (const [kind, routes] of interactionRoutesOf(ctor)) for (const route of routes) {
+			const existing = this.maps[kind].get(route);
+			if (existing && existing.ctor !== ctor) throw new SeedcordTypeError(SeedcordErrorCode.CoreDuplicateName, [
+				"route",
+				routeIdOf(kind, route),
+				[`${paint.bold(existing.ctor.name)} (${paint.path(existing.from)})`, `${paint.bold(ctor.name)} (${paint.path(from)})`]
+			]);
+			writes.push({
+				kind,
+				route,
+				fallback: false,
+				ctor,
+				from
+			});
+		}
+		for (const write of writes) this.maps[write.kind].set(write.route, write);
+		return writes.length > 0;
+	}
+	unregister(ctor, routes = this.routesOf(ctor)) {
+		for (const { kind, route } of routes) if (this.maps[kind].get(route)?.ctor === ctor) this.maps[kind].delete(route);
+	}
+	routesOf(ctor) {
+		return this.allRoutes.filter((route) => route.ctor === ctor);
+	}
+	warnUnhandledRoutes(logger, leaves) {
+		this.warnMissing(logger, leaves, "slash", "Slash route");
+	}
+	warnUnhandledContextMenuRoutes(logger, leaves) {
+		this.warnMissing(logger, leaves.user, "userContextMenu", "User context menu");
+		this.warnMissing(logger, leaves.message, "messageContextMenu", "Message context menu");
+	}
+	warnMissing(logger, names, kind, label) {
+		const decorator = paint.bold(routeDecoratorOf(kind));
+		for (const name of names) {
+			if (this.maps[kind].has(name)) continue;
+			logger.warn(`${label} ${paint.sky.bold(name)} doesn't have a registered ${decorator} handler.`);
+		}
+	}
+};
+
+//#endregion
+//#region src/subscribers/interactionFaultSource.ts
+const FAULT_KINDS = {
+	slash: "slash",
+	userContextMenu: "context-menu",
+	messageContextMenu: "context-menu",
+	button: "button",
+	stringMenu: "select",
+	userMenu: "select",
+	roleMenu: "select",
+	channelMenu: "select",
+	mentionableMenu: "select",
+	modal: "modal",
+	autocomplete: null
+};
+function interactionFaultSource(dispatch, fields) {
+	const interactionKind = FAULT_KINDS[dispatch.kind];
+	if (interactionKind === null) return null;
+	return {
+		kind: "interaction",
+		interactionKind,
+		command: interactionKind === "slash" || interactionKind === "context-menu" ? dispatch.route : null,
+		...fields
+	};
+}
+
+//#endregion
+export { AckTrace, AutocompleteResponder, AutocompleteRouteBrand, BAKED_IDS_KEY, COMMAND_DEPLOY_TIMEOUT_MS, CommandMetadataKey, CommandRegistry, ComponentDefsBrand, ComponentDefsKey, ComponentKindBrand, ContextMenuKindBrand, ContextMenuNamesBrand, CoordinatedStartup, DispatchContext, EventMetadataKey, EventMiddlewareMetadataKey, FaultBoundary, FixedScope, GLOBAL_ID, GatedMetadataKey, HandlerLoader, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, InteractionRouteKeys, InteractionRun, MiddlewareKindsBrand, MiddlewareRegistry, MissingRole, NeedsAny, NotAllowed, NotInDm, NotInGuild, NotOwner, NoticeCard, OnCooldown, OnceTracker, PAGE_MAX, PluginLifecycle, PublishDefault, RegisterDefaults, RegisterSubscriber, RegisteredCount, ReportThrottle, RouteRegistry, SlashRouteBrand, SubscribeMetadataKey, SubscriberLoader, UnregisterSubscriber, VerifyWebhooks, WebhookUrlMetadataKey, accessorStore, assertUniqueKeys, attachmentsOf, bindBotColor, bindEnv, busLoggerOf, checkAckLegality, clearStore, commandKey, commandRefOf, commandsRoute, componentKindOf, connectDevChannel, contextMenuLeaves, contextMenuRouteOf, currentApplication, decodeComponentRoute, deferFlags, emptyRouteMaps, eventResultFor, forwardLogsToCli, fromDevLogLine, fromWireError, getDevChannel, globalFirst, guardedAccessor, guildSummaries, indexById, installLinks, interactionFaultSource, interactionMiddleware, interactionMiddlewareMetaOf, interactionRoutesOf, isCommandClass, isEmojiTuple, lazyLogger, linkCommands, matchRoute, pageCursor, planDeploy, putCommands, readBotToken, readCommands, readCommandsAt, reportedWrite, resolveDeployTarget, resolveEmojis, resultFor, runAfter, runCase, runHandlerGates, scopeIdsOf, sealAttachments, sendFlags, sendTarget, serializeReply, setDevChannel, skippedNote, slashRouteLeaves, splitPluginKey, storeComponentRoute, storeInteractionRoute, toWireError, translateSerializationError, warnLinks, wrapHot };
 //# sourceMappingURL=internal.index.mjs.map