@seedcord/gateway 0.5.0 → 0.6.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 import { WinstonConsoleSink, WinstonFileSink, installNodeDefaults } from "@seedcord/logger/node";
-import { EventMetadataKey, GateNotice, GatedMetadataKey, HmrManager, InteractionMetadataKey, MiddlewareMetadataKey, MissingPermissions, NoticeCard, PermissionNames, PublishDefault, accessorStore, areRoutes, asError, busLoggerOf, clearStore, decodeComponentRoute, deferFlags, guardedAccessor, interactionRoutesOf, isEmojiTuple, outcomeFor, pickNotice, queuedMsFor, reportDispatch, reportedWrite, routeIdOf, runHandlerGates, sendFlags, setBotColor, slowGateMonitor } from "@seedcord/core/internal";
+import { EventMetadataKey, EventMiddlewareMetadataKey, GateNotice, GatedMetadataKey, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, MiddlewareRegistry, MissingPermissions, NoticeCard, PermissionNames, PublishDefault, accessorStore, areRoutes, asError, busLoggerOf, clearStore, decodeComponentRoute, deferFlags, eventResultFor, guardedAccessor, interactionMiddleware, interactionRoutesOf, isEmojiTuple, outcomeFor, pickNotice, queuedMsFor, reportDispatch, reportedWrite, resultFor, runAfter, runHandlerGates, sendFlags, setBotColor, slowGateMonitor } from "@seedcord/core/internal";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
 import { SeedcordError, SeedcordTypeError, validateDiscordToken } from "@seedcord/errors/internal";
 import { ArraySourceBase, BaseHandler as BaseHandler$1, BaseReplySender, BuilderComponent, Bus, CursorSourceBase, CustomId, DispatchContext, Fault, InteractionKind, Notice, PaginatorBase, RepliableHandler as RepliableHandler$1, ResolvedEmoji, RowComponent, Silence, Subscriber as Subscriber$1, WebhookLog as WebhookLog$1, assertPermissions, defineGate } from "@seedcord/core";
@@ -10,7 +10,7 @@ import { ButtonBuilder, TextDisplayBuilder } from "@discordjs/builders";
 import { buildSlashRoute } from "@seedcord/utils/internal";
 import { Plugin as Plugin$1 } from "@seedcord/core/plugin";
 import { CoordinatedShutdown, CoordinatedStartup, Pluggable } from "@seedcord/core/node";
-import { CommandRegistry, HealthCheck, ShutdownPhase, StartupPhase, SubscriberLoader, settleWithin, shutdownOf } from "@seedcord/core/node/internal";
+import { CommandRegistry, DRAIN_TASK_TIMEOUT_MS, DRAIN_WINDOW_MS, HealthCheck, ShutdownPhase, StartupPhase, SubscriberLoader, drainInFlight, shutdownOf } from "@seedcord/core/node/internal";
 import { MemoryRateLimiter } from "@seedcord/rate-limiter";
 import { HostAugmentTarget, HostVersion, SeedcordBrand } from "@seedcord/types/internal";
 import { Envapter } from "envapt";
@@ -132,45 +132,39 @@ function Gated(...gates) {
 //#endregion
 //#region src/bot/decorators/Middlewares.ts
 /**
-* Middleware types supported by Seedcord
-*/
-let MiddlewareType = /* @__PURE__ */ function(MiddlewareType) {
-	MiddlewareType["Interaction"] = "interaction";
-	MiddlewareType["Event"] = "event";
-	return MiddlewareType;
-}({});
-/**
-* Decorator used to register middleware with priority ordering. The lower the priority number, the earlier it runs.
-*
-* Interaction middleware cannot specify event filters.
-*
-* @param type - Middleware kind from {@link MiddlewareType}
-* @param priority - Ordering value where lower runs earlier. {@default `0` }
-* @param options - Additional registration options
+* Registers an event middleware. It runs before the handlers for every event it lists.
 *
+* @param options - The events this middleware runs on and its ordering.
 * @decorator
 *
 * @example
 * ```ts
-* \@Middleware(MiddlewareType.Event, 10, { events: [Events.MessageCreate, Events.MessageUpdate] })
-* class MyEventMiddleware extends EventMiddleware {}
+* \@RegisterEventMiddleware({ events: [Events.MessageCreate], priority: 10 })
+* class Audit extends EventMiddleware<Events.MessageCreate> {
+*     async execute() {
+*         this.logger.info(this.event[0].id);
+*     }
+* }
 * ```
-* @throws A **SeedcordTypeError** If priority is not a finite number
-* @throws A **SeedcordError** If interaction middleware specifies event filters
+*
+* @throws A **SeedcordTypeError** If `priority` is not a finite number.
 */
-function Middleware(type, priority = 0, options = {}) {
-	return (ctor) => {
-		const normalizedPriority = Number(priority);
-		if (!Number.isFinite(normalizedPriority)) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorInvalidMiddlewarePriority);
-		if (type === "interaction" && Array.isArray(options.events) && options.events.length > 0) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorInteractionEventFilter);
+function RegisterEventMiddleware(options = {}) {
+	return function(ctor) {
+		const priority = Number(options.priority ?? 0);
+		if (!Number.isFinite(priority)) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorInvalidMiddlewarePriority);
+		if (options.events?.length === 0) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorEmptyMiddlewareFilter, ["events"]);
 		const metadata = {
-			priority: normalizedPriority,
-			type,
-			...options.events && options.events.length > 0 && { events: options.events }
+			priority,
+			...options.events && { events: options.events }
 		};
-		Reflect.defineMetadata(MiddlewareMetadataKey, metadata, ctor);
+		Reflect.defineMetadata(EventMiddlewareMetadataKey, metadata, ctor);
 	};
 }
+/** @internal */
+function eventMiddlewareMetaOf(constructor) {
+	return Reflect.getMetadata(EventMiddlewareMetadataKey, constructor);
+}
 
 //#endregion
 //#region src/bot/gates/catalog/IgnoreBots.ts
@@ -502,34 +496,6 @@ async function getConfirmation(handler, prompt, options) {
 	return confirmed;
 }
 
-//#endregion
-//#region src/handlers/BaseHandler.ts
-/**
-* The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
-* gate hook.
-*/
-var BaseHandler = class extends BaseHandler$1 {
-	getEvent() {
-		return this.event;
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/InteractionMiddleware.ts
-/**
-* Base class for interaction middleware
-*
-* Middleware runs before interaction handlers and can modify behavior or block execution.
-* Unlike handlers, middleware should not send responses directly.
-*
-* @typeParam Repliable - The interaction type this middleware processes
-*/
-var InteractionMiddleware = class extends BaseHandler {
-	constructor(event, core) {
-		super(event, core, void 0, "interactions");
-	}
-};
-
 //#endregion
 //#region src/bot/ReplySender.ts
 function isReplyFile(file) {
@@ -553,9 +519,10 @@ function seedState(interaction) {
 /** Writes interaction responses through discord.js. The repliable handler bases and the dispatcher construct it. */
 var ReplySender = class extends BaseReplySender {
 	interaction;
-	constructor(interaction, routeId, bus) {
-		super(routeId, {
+	constructor(interaction, dispatch, bus) {
+		super({
 			bus,
+			dispatch,
 			interactionId: interaction.id
 		}, seedState(interaction));
 		this.interaction = interaction;
@@ -665,8 +632,35 @@ var RepliableHandler = class extends RepliableHandler$1 {
 	getEvent() {
 		return this.event;
 	}
-	buildSender(event, core, routeId) {
-		return new ReplySender(event, routeId, core.bus);
+	buildSender(event, core, dispatch) {
+		return new ReplySender(event, dispatch, core.bus);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/InteractionMiddleware.ts
+/**
+* Base class for interaction middleware.
+*
+* Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
+* reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
+* `this.event` a union. The discord.js guards narrow it. A catchall reads every repliable kind.
+*
+* @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+*
+* @example
+* ```ts
+* \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
+* class Audit extends InteractionMiddleware<InteractionKind.Button> {
+*     async execute() {
+*         this.logger.info(this.event.customId);
+*     }
+* }
+* ```
+*/
+var InteractionMiddleware = class extends RepliableHandler {
+	constructor(event, core, dispatch, sender) {
+		super(event, core, dispatch, sender);
 	}
 };
 
@@ -895,6 +889,18 @@ var MessageContextMenuHandler = class extends InteractionHandler {
 	}
 };
 
+//#endregion
+//#region src/handlers/BaseHandler.ts
+/**
+* The gateway base, fixes the core base's `TCore` to the gateway {@link Core} and adds the `getEvent`
+* gate hook.
+*/
+var BaseHandler = class extends BaseHandler$1 {
+	getEvent() {
+		return this.event;
+	}
+};
+
 //#endregion
 //#region src/handlers/interaction/AutocompleteHandler.ts
 /**
@@ -972,11 +978,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) {
-		const routeId = this.dispatch?.routeId ?? "autocomplete";
 		await reportedWrite({
 			bus: this.core.bus,
+			dispatch: this.dispatch,
 			interactionId: this.event.id
-		}, routeId, "respond", () => this.event.respond(choices));
+		}, "respond", () => this.event.respond(choices));
 	}
 	/** The firing command route, for a field whose completion differs per registered command. */
 	get route() {
@@ -1314,8 +1320,8 @@ var MentionableMenuHandler = class extends SelectMenuHandler {
 */
 var EventHandler = class extends BaseHandler {
 	firedEvent;
-	constructor(event, core, eventName) {
-		super(event, core, void 0, "events");
+	constructor(event, core, dispatch, eventName) {
+		super(event, core, dispatch, "events");
 		this.firedEvent = eventName;
 	}
 	/**
@@ -1367,8 +1373,8 @@ var EventHandler = class extends BaseHandler {
 */
 var EventMiddleware = class extends BaseHandler {
 	firedEvent;
-	constructor(event, core, eventName) {
-		super(event, core, void 0, "events");
+	constructor(event, core, dispatch, eventName) {
+		super(event, core, dispatch, "events");
 		this.firedEvent = eventName;
 	}
 	/**
@@ -1528,13 +1534,14 @@ function deriveEventActor(args) {
 
 //#endregion
 //#region src/bot/gates/runGates.ts
-function interactionGateContext(interaction, core) {
+function interactionGateContext(interaction, core, dispatch) {
 	const rawMember = interaction.member;
 	const memberRoleIds = rawMember instanceof GuildMember ? [...rawMember.roles.cache.keys()].filter((id) => id !== interaction.guildId) : rawMember?.roles ?? [];
 	return {
 		kind: "interaction",
 		interaction,
 		core,
+		dispatch,
 		user: interaction.user,
 		guild: interaction.guild,
 		member: rawMember instanceof GuildMember ? rawMember : null,
@@ -1546,14 +1553,15 @@ function interactionGateContext(interaction, core) {
 		appPermissions: interaction.appPermissions.bitfield,
 		memberGuildPermissions: rawMember instanceof GuildMember ? rawMember.permissions.bitfield : null,
 		appGuildPermissions: interaction.guild?.members.me?.permissions.bitfield ?? null,
-		routeId: null
+		declaredRoute: null
 	};
 }
-function eventGateContext(eventName, args, core) {
+function eventGateContext(eventName, args, core, dispatch) {
 	const actor = deriveEventActor(args);
 	return {
 		kind: "event",
 		core,
+		dispatch,
 		eventName,
 		payload: args,
 		user: actor.user,
@@ -1567,54 +1575,62 @@ function eventGateContext(eventName, args, core) {
 		appPermissions: null,
 		memberGuildPermissions: actor.member?.permissions.bitfield ?? null,
 		appGuildPermissions: actor.guild?.members.me?.permissions.bitfield ?? null,
-		routeId: null
+		declaredRoute: null
 	};
 }
 
 //#endregion
 //#region src/miscellaneous/extractErrorResponse.ts
 const logger$2 = new Logger("ErrorsHandling", { channel: "errors" });
-function extractErrorResponse(error, core, origin) {
+function extractErrorResponse(error, core, fault) {
 	const uuid = crypto.randomUUID();
+	const { dispatch } = fault;
 	const developerUsername = core.config.notifications?.developerUsername;
-	const ctx = developerUsername === void 0 ? { uuid } : {
+	const ctx = developerUsername === void 0 ? {
+		uuid,
+		dispatch
+	} : {
 		uuid,
-		developerUsername
+		developerUsername,
+		dispatch
 	};
 	if (error instanceof Notice) {
-		if (error.report) reportFault(error, core, origin, uuid);
+		if (error.report) reportFault(error, core, fault, uuid);
 		return {
 			uuid,
 			response: error.render(ctx)
 		};
 	}
-	reportRawFault(error, core, origin, uuid);
-	const override = core.config.errors?.defaultError;
+	reportRawFault(error, core, fault, uuid);
+	const Override = core.config.errors?.defaultError;
 	return {
 		uuid,
-		response: override ? new override(uuid).render(ctx) : new Fault().render(ctx)
+		response: Override ? new Override(uuid).render(ctx) : new Fault().render(ctx)
 	};
 }
-function reportFault(denial, core, origin, uuid) {
+function reportFault(denial, core, fault, uuid) {
 	logger$2.error(`${denial.name}: ${uuid}`, denial);
-	if (origin.interaction) core.bus[PublishDefault]("handledException", {
+	if (fault.interaction) core.bus[PublishDefault]("handledException", {
 		denial,
 		uuid,
-		routeId: origin.routeId,
-		source: buildInteractionSource(origin.interaction)
+		dispatchId: fault.dispatch.id,
+		origin: fault.origin,
+		source: buildInteractionSource(fault.interaction)
 	});
-	else if (origin.event) core.bus[PublishDefault]("handledException", {
+	else if (fault.event) core.bus[PublishDefault]("handledException", {
 		denial,
 		uuid,
-		routeId: origin.routeId,
-		source: buildEventSource(origin.event, origin)
+		dispatchId: fault.dispatch.id,
+		origin: fault.origin,
+		source: buildEventSource(fault.event, fault)
 	});
 	else core.bus[PublishDefault]("unknownException", {
 		uuid,
+		dispatchId: fault.dispatch.id,
 		error: denial,
-		routeId: origin.routeId,
-		...scalarActors(origin),
-		metadata: metadataFor(origin)
+		origin: fault.origin,
+		...scalarActors(fault),
+		metadata: metadataFor(fault)
 	});
 }
 function causeLine(error) {
@@ -1623,44 +1639,45 @@ function causeLine(error) {
 	const [first] = cause.message.split("\n");
 	return `\ncaused by ${cause.name}: ${first ?? cause.message}`;
 }
-function reportRawFault(error, core, origin, uuid) {
+function reportRawFault(error, core, fault, uuid) {
 	if (core.config.errors?.errorStack ?? false) logger$2.error(uuid, error);
 	else logger$2.error(`${uuid} | ${error.message}${causeLine(error)}`);
 	core.bus[PublishDefault]("unknownException", {
 		uuid,
+		dispatchId: fault.dispatch.id,
 		error,
-		routeId: origin.routeId,
-		...scalarActors(origin),
-		metadata: metadataFor(origin)
+		origin: fault.origin,
+		...scalarActors(fault),
+		metadata: metadataFor(fault)
 	});
 }
-function scalarActors(origin) {
+function scalarActors(fault) {
 	return {
-		guild: origin.guild ? {
-			id: origin.guild.id,
-			name: origin.guild.name
+		guild: fault.guild ? {
+			id: fault.guild.id,
+			name: fault.guild.name
 		} : void 0,
-		user: origin.user ? {
-			id: origin.user.id,
-			username: origin.user.username
+		user: fault.user ? {
+			id: fault.user.id,
+			username: fault.user.username
 		} : void 0
 	};
 }
-function metadataFor(origin) {
-	if (origin.event) return {
-		eventName: origin.event.name,
-		handler: origin.event.handler,
-		args: origin.event.args
+function metadataFor(fault) {
+	if (fault.event) return {
+		eventName: fault.event.name,
+		handler: fault.event.handler,
+		args: fault.event.args
 	};
-	return origin.metadata;
+	return fault.metadata;
 }
-function buildEventSource(event, origin) {
+function buildEventSource(event, fault) {
 	return {
 		kind: "event",
 		eventName: event.name,
 		handler: event.handler,
-		userId: origin.user?.id ?? null,
-		guildId: origin.guild?.id ?? null,
+		userId: fault.user?.id ?? null,
+		guildId: fault.guild?.id ?? null,
 		channelId: event.channelId,
 		raw: event.args
 	};
@@ -1691,7 +1708,8 @@ function interactionKind(interaction) {
 //#endregion
 //#region src/bot/handleEventFault.ts
 const logger$1 = new Logger("Faults", { channel: "errors" });
-function handleEventFault(caught, eventName, handlerName, args, core) {
+function handleEventFault(caught, fault, core) {
+	const { eventName, handlerName, args, dispatch } = fault;
 	if (caught instanceof Silence) {
 		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger$1.debug(`Silence: ${caught.reason}`);
 		return;
@@ -1711,14 +1729,45 @@ function handleEventFault(caught, eventName, handlerName, args, core) {
 			args,
 			channelId: actor.channelId
 		},
-		routeId: `event:${eventName}:${handlerName}`,
+		origin: `event:${eventName}:${handlerName}`,
+		dispatch,
 		guild: actor.guild,
 		user: actor.user
 	});
 }
 
+//#endregion
+//#region src/bot/reportEventDispatch.ts
+function reportEventDispatching(core, dispatchId, name, args) {
+	core.bus[PublishDefault]("eventDispatching", {
+		dispatchId,
+		name,
+		args
+	});
+}
+function reportEventDispatched(core, dispatchId, name, result, startedAt) {
+	core.bus[PublishDefault]("eventDispatched", {
+		dispatchId,
+		name,
+		outcome: result.outcome,
+		handlers: result.handlers.map(({ handler, outcome }) => ({
+			handler,
+			outcome
+		})),
+		durationMs: performance.now() - startedAt
+	});
+}
+
 //#endregion
 //#region src/bot/controllers/EventDispatcher.ts
+const eventMiddleware = (ctor) => {
+	const metadata = eventMiddlewareMetaOf(ctor);
+	if (!metadata) return void 0;
+	return {
+		priority: metadata.priority,
+		...metadata.events && { keys: metadata.events }
+	};
+};
 /**
 * Interactions route through InteractionDispatcher.
 *
@@ -1729,7 +1778,7 @@ var EventDispatcher = class {
 	logger = new Logger("Events", { channel: "events" });
 	isInitialized = false;
 	eventMap = /* @__PURE__ */ new Map();
-	middlewares = [];
+	middlewares = new MiddlewareRegistry(eventMiddleware);
 	executedOnceHandlers = /* @__PURE__ */ new Set();
 	attachedEvents = /* @__PURE__ */ new Set();
 	inFlight = /* @__PURE__ */ new Set();
@@ -1825,35 +1874,32 @@ var EventDispatcher = class {
 		}
 	}
 	unregisterMiddleware(middlewareCtor) {
-		const index = this.middlewares.findIndex((entry) => entry.ctor === middlewareCtor);
-		if (index !== -1) this.middlewares.splice(index, 1);
+		this.middlewares.unregister(middlewareCtor);
 	}
 	registerMiddleware(middlewareCtor, relativePath) {
-		const metadata = Reflect.getMetadata(MiddlewareMetadataKey, middlewareCtor);
-		if (metadata?.type !== "event") return;
-		if (this.middlewares.some((entry) => entry.ctor === middlewareCtor)) return;
-		this.middlewares.push({
-			ctor: middlewareCtor,
-			priority: metadata.priority,
-			...metadata.events && { events: metadata.events }
-		});
-		this.middlewares.sort((a, b) => a.priority - b.priority);
-		if (this.loading) this.loadedMiddlewares.push({
-			name: `${middlewareCtor.name} (${metadata.priority})`,
+		const registration = this.middlewares.register(middlewareCtor);
+		if (!registration || !this.loading) return;
+		const scope = registration.keys ? `${registration.priority}, ${registration.keys.join(", ")}` : registration.priority;
+		this.loadedMiddlewares.push({
+			name: `${middlewareCtor.name} (${String(scope)})`,
 			from: formatFilePath(relativePath)
 		});
 	}
-	async runMiddlewares(eventName, args) {
-		for (const { ctor, events } of this.middlewares) {
-			if (events && !events.includes(eventName)) continue;
-			try {
-				await new ctor(args, this.core, eventName).execute();
-			} catch (caught) {
-				handleEventFault(caught, String(eventName), ctor.name, args, this.core);
-				return false;
-			}
+	async runMiddlewares(eventName, args, dispatch, ran) {
+		for (const Middleware of this.middlewares.chainFor(eventName)) try {
+			const middleware = new Middleware(args, this.core, dispatch, eventName);
+			ran.push(middleware);
+			await middleware.execute();
+		} catch (caught) {
+			handleEventFault(caught, {
+				eventName: String(eventName),
+				handlerName: Middleware.name,
+				args,
+				dispatch
+			}, this.core);
+			return { caught };
 		}
-		return true;
+		return null;
 	}
 	isEventHandlerClass(obj) {
 		if (typeof obj !== "function") return false;
@@ -1861,7 +1907,7 @@ var EventDispatcher = class {
 	}
 	isMiddlewareClass(obj) {
 		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof EventMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
+		return obj.prototype instanceof EventMiddleware && Reflect.hasMetadata(EventMiddlewareMetadataKey, obj);
 	}
 	registerHandler(handlerClass, relativePath) {
 		const raw = Reflect.getMetadata(EventMetadataKey, handlerClass);
@@ -1898,10 +1944,6 @@ var EventDispatcher = class {
 		this.logger.debug(`Attaching ${paint.sky.bold(eventName)} to the client with ${paint.mute(handlerEntries?.length ?? 0)} handler(s)`);
 		this.core.bot.client.on(eventName, (...args) => {
 			if (this.draining) return;
-			this.core.bus[PublishDefault]("eventDispatching", {
-				name: eventName,
-				args
-			});
 			const run = this.processEvent(eventName, args).catch((caught) => {
 				const error = asError(caught);
 				this.logger.error(`[${paint.coral.bold("UNHANDLED ERROR AT ROOT")}] ${error.name}`, error.stack);
@@ -1915,31 +1957,57 @@ var EventDispatcher = class {
 		this.draining = true;
 	}
 	drain(timeoutMs) {
-		return settleWithin(Promise.allSettled(this.inFlight), timeoutMs);
+		return drainInFlight(this.inFlight, timeoutMs, this.logger, "Events");
 	}
 	async processEvent(eventName, args) {
+		const startedAt = performance.now();
 		const handlerEntries = this.eventMap.get(eventName);
 		if (!handlerEntries || handlerEntries.length === 0) return;
 		const handlersToExecute = handlerEntries.filter((entry) => entry.frequency !== "once" || !this.executedOnceHandlers.has(entry.ctor));
 		if (handlersToExecute.length === 0) return;
-		if (!await this.runMiddlewares(eventName, args)) return;
-		for (const entry of handlersToExecute) {
-			if (entry.frequency === "once") {
-				if (this.executedOnceHandlers.has(entry.ctor)) continue;
-				this.executedOnceHandlers.add(entry.ctor);
+		const dispatch = new DispatchContext(`event:${String(eventName)}`);
+		reportEventDispatching(this.core, dispatch.id, eventName, args);
+		const ran = [];
+		const handlers = [];
+		let stopped = null;
+		try {
+			stopped = await this.runMiddlewares(eventName, args, dispatch, ran);
+			if (stopped) return;
+			for (const entry of handlersToExecute) {
+				if (entry.frequency === "once") {
+					if (this.executedOnceHandlers.has(entry.ctor)) continue;
+					this.executedOnceHandlers.add(entry.ctor);
+				}
+				handlers.push(await this.processHandler(eventName, entry.ctor, args, dispatch));
 			}
-			await this.processHandler(eventName, entry.ctor, args);
+		} finally {
+			const result = eventResultFor(stopped, handlers);
+			reportEventDispatched(this.core, dispatch.id, eventName, result, startedAt);
+			await runAfter(ran, result, this.logger);
 		}
 	}
-	async processHandler(eventName, ctor, args) {
+	async processHandler(eventName, Ctor, args, dispatch) {
 		try {
-			this.logger.debug(`Processing ${paint.sky.bold(eventName)} with ${paint.mute(ctor.name)}`);
-			const handler = new ctor(args, this.core, eventName);
-			const eventCtx = eventGateContext(eventName, args, this.core);
-			await runHandlerGates(ctor, eventCtx);
+			this.logger.debug(`Processing ${paint.sky.bold(eventName)} with ${paint.mute(Ctor.name)}`);
+			const handler = new Ctor(args, this.core, dispatch, eventName);
+			const eventCtx = eventGateContext(eventName, args, this.core, dispatch);
+			await runHandlerGates(Ctor, eventCtx);
 			await handler.execute();
+			return {
+				handler: Ctor.name,
+				outcome: "handled"
+			};
 		} catch (caught) {
-			handleEventFault(caught, String(eventName), ctor.name, args, this.core);
+			handleEventFault(caught, {
+				eventName: String(eventName),
+				handlerName: Ctor.name,
+				args,
+				dispatch
+			}, this.core);
+			return {
+				handler: Ctor.name,
+				...resultFor(caught)
+			};
 		}
 	}
 };
@@ -1977,7 +2045,8 @@ const HARMLESS_API_CODES = /* @__PURE__ */ new Set([
 //#endregion
 //#region src/bot/handleInteractionFault.ts
 const logger = new Logger("Faults", { channel: "errors" });
-async function handleInteractionFault(caught, interaction, core, routeId, sender) {
+async function handleInteractionFault(caught, interaction, core, dispatch, sender) {
+	const { routeId } = dispatch;
 	if (caught instanceof Silence) {
 		if (caught.reason !== void 0 && (core.config.errors?.logSilences ?? true)) logger.debug(`Silence: ${caught.reason}`);
 		return;
@@ -1990,30 +2059,33 @@ async function handleInteractionFault(caught, interaction, core, routeId, sender
 	}
 	if (interaction.isAutocomplete()) {
 		extractErrorResponse(error, core, {
-			routeId,
+			origin: routeId,
+			dispatch,
 			guild: interaction.guild,
 			user: interaction.user,
 			metadata: interaction
 		});
-		await sendEmptyChoices(interaction, core, routeId);
+		await sendEmptyChoices(interaction, core, dispatch);
 		return;
 	}
 	const { response } = extractErrorResponse(error, core, {
 		interaction,
-		routeId,
+		origin: routeId,
+		dispatch,
 		guild: interaction.guild,
 		user: interaction.user,
 		metadata: interaction
 	});
-	await sendGuarded(sender ?? new ReplySender(interaction, routeId, core.bus), response, error instanceof Notice ? error.ephemeral : true);
+	await sendGuarded(sender ?? new ReplySender(interaction, dispatch, core.bus), response, error instanceof Notice ? error.ephemeral : true);
 }
-async function sendEmptyChoices(interaction, core, routeId) {
+async function sendEmptyChoices(interaction, core, dispatch) {
 	const telemetry = {
 		bus: core.bus,
+		dispatch,
 		interactionId: interaction.id
 	};
 	try {
-		await reportedWrite(telemetry, routeId, "respond", () => interaction.respond([]));
+		await reportedWrite(telemetry, "respond", () => interaction.respond([]));
 	} catch (error) {
 		logger.debug(`autocomplete empty-choices send failed: ${String(error)}`);
 	}
@@ -2051,7 +2123,7 @@ var InteractionDispatcher = class {
 	};
 	handlerFiles = /* @__PURE__ */ new Map();
 	keysToIgnore = /* @__PURE__ */ new Set();
-	middlewares = [];
+	middlewares = new MiddlewareRegistry(interactionMiddleware);
 	inFlight = /* @__PURE__ */ new Set();
 	draining = false;
 	loading = false;
@@ -2150,19 +2222,15 @@ var InteractionDispatcher = class {
 		});
 	}
 	registerMiddleware(middlewareCtor, relativePath) {
-		const metadata = Reflect.getMetadata(MiddlewareMetadataKey, middlewareCtor);
-		if (metadata?.type !== "interaction") return;
-		if (this.middlewares.some((entry) => entry.ctor === middlewareCtor)) return;
-		if (this.middlewares.some((entry) => entry.ctor.name === middlewareCtor.name)) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateMiddleware, [middlewareCtor.name]);
-		this.middlewares.push({
-			ctor: middlewareCtor,
-			priority: metadata.priority
-		});
-		this.middlewares.sort((a, b) => a.priority - b.priority);
-		if (this.loading) this.loadedMiddlewares.push({
-			name: `${middlewareCtor.name} (${metadata.priority})`,
-			from: formatFilePath(relativePath)
-		});
+		const metadata = this.middlewares.register(middlewareCtor);
+		if (!metadata) return;
+		if (this.loading) {
+			const scope = metadata.keys ? `${metadata.priority}, ${metadata.keys.join(", ")}` : metadata.priority;
+			this.loadedMiddlewares.push({
+				name: `${middlewareCtor.name} (${String(scope)})`,
+				from: formatFilePath(relativePath)
+			});
+		}
 	}
 	isHandlerClass(obj) {
 		if (typeof obj !== "function") return false;
@@ -2170,7 +2238,7 @@ var InteractionDispatcher = class {
 	}
 	isMiddlewareClass(obj) {
 		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
+		return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(InteractionMiddlewareMetadataKey, obj);
 	}
 	registerHandler(handlerClass, relativePath) {
 		const from = formatFilePath(relativePath);
@@ -2203,8 +2271,7 @@ var InteractionDispatcher = class {
 		for (const { routeType, routes } of artifacts ?? this.getArtifacts(handlerClass)) for (const route of routes) this.maps[routeType].delete(route);
 	}
 	unregisterMiddleware(middlewareCtor) {
-		const index = this.middlewares.findIndex((entry) => entry.ctor === middlewareCtor);
-		if (index !== -1) this.middlewares.splice(index, 1);
+		this.middlewares.unregister(middlewareCtor);
 	}
 	attachToClient() {
 		this.core.bot.client.on(Events.InteractionCreate, (interaction) => {
@@ -2223,7 +2290,7 @@ var InteractionDispatcher = class {
 		this.draining = true;
 	}
 	drain(timeoutMs) {
-		return settleWithin(Promise.allSettled(this.inFlight), timeoutMs);
+		return drainInFlight(this.inFlight, timeoutMs, this.logger, "Interactions");
 	}
 	async handleCustomIdInteraction(interaction, kind) {
 		if ([...this.keysToIgnore].some((matcher) => matcher.owns(interaction.customId))) return;
@@ -2236,43 +2303,49 @@ var InteractionDispatcher = class {
 		const startedAt = performance.now();
 		const queuedMs = queuedMsFor(interaction.id);
 		const matched = this.maps[kind].get(key);
-		let routeId = `${kind}:${key || "unrouted"}`;
-		let reported = false;
-		const report = (outcome) => {
-			if (reported) return;
-			reported = true;
-			reportDispatch(this.core.bus, {
-				routeId,
-				interactionId: interaction.id,
-				kind,
-				outcome,
-				startedAt,
-				fallback: !matched,
-				queuedMs
-			});
-		};
+		const HandlerCtor = matched ?? fallback;
+		const dispatch = new DispatchContext(`${kind}:${key || "unrouted"}`);
+		const report = this.reporterFor({
+			interaction,
+			kind,
+			fallback: !matched,
+			startedAt,
+			queuedMs,
+			dispatchId: dispatch.id,
+			routeId: dispatch.routeId
+		});
 		let sender;
+		const ran = [];
+		let result = { outcome: "handled" };
 		try {
-			if (!interaction.isAutocomplete()) await this.runMiddlewares(interaction);
-			const HandlerCtor = matched ?? fallback;
-			const dispatch = new DispatchContext(routeIdOf(HandlerCtor) ?? routeId);
-			routeId = dispatch.routeId ?? routeId;
 			const handler = this.buildHandler(HandlerCtor, interaction, dispatch, key, !matched);
 			if (handler instanceof RepliableHandler) sender = handler.sender;
-			const refusal = interaction.isAutocomplete() ? null : await this.gateRefusal(HandlerCtor, interaction, dispatch.routeId);
+			const refusal = await this.refusalBeforeHandler({
+				HandlerCtor,
+				kind,
+				interaction,
+				dispatch,
+				sender,
+				ran,
+				declaredRoute: matched ? dispatch.routeId : void 0
+			});
 			if (refusal) {
-				await this.answer(refusal.caught, interaction, routeId, sender, report);
+				result = resultFor(refusal.caught);
+				await this.answer(refusal.caught, interaction, dispatch, sender, report);
 				return;
 			}
 			await handler.execute();
 			report("handled");
 		} catch (caught) {
-			await this.answer(caught, interaction, routeId, sender, report);
+			if (result.outcome === "handled") result = resultFor(caught);
+			await this.answer(caught, interaction, dispatch, sender, report);
+		} finally {
+			await runAfter(ran, result, this.logger);
 		}
 	}
-	async answer(caught, interaction, routeId, sender, report) {
+	async answer(caught, interaction, dispatch, sender, report) {
 		try {
-			await handleInteractionFault(caught, interaction, this.core, routeId, sender);
+			await handleInteractionFault(caught, interaction, this.core, dispatch, sender);
 		} finally {
 			report(outcomeFor(caught));
 		}
@@ -2282,18 +2355,51 @@ var InteractionDispatcher = class {
 		this.logger.debug(`Processing ${paint.sky.bold(key)} with ${paint.mute(HandlerCtor.name)}`);
 		return new HandlerCtor(interaction, this.core, dispatch);
 	}
-	async runMiddlewares(interaction) {
-		for (const { ctor } of this.middlewares) await new ctor(interaction, this.core).execute();
+	reporterFor(row) {
+		let reported = false;
+		return (outcome) => {
+			if (reported) return;
+			reported = true;
+			reportDispatch(this.core.bus, {
+				dispatchId: row.dispatchId,
+				routeId: row.routeId,
+				interactionId: row.interaction.id,
+				kind: row.kind,
+				outcome,
+				startedAt: row.startedAt,
+				fallback: row.fallback,
+				userId: row.interaction.user.id,
+				guildId: row.interaction.guildId,
+				queuedMs: row.queuedMs
+			});
+		};
+	}
+	async refusalBeforeHandler(step) {
+		const { HandlerCtor, kind, interaction, dispatch, sender, ran, declaredRoute } = step;
+		if (kind !== InteractionKind.Autocomplete && sender) try {
+			await this.runMiddlewares(kind, interaction, dispatch, sender, ran);
+		} catch (caught) {
+			return { caught };
+		}
+		if (interaction.isAutocomplete()) return null;
+		return this.gateRefusal(HandlerCtor, interaction, dispatch, declaredRoute);
+	}
+	async runMiddlewares(kind, interaction, dispatch, sender, ran) {
+		for (const Middleware of this.middlewares.chainFor(kind)) {
+			const middleware = new Middleware(interaction, this.core, dispatch, sender);
+			ran.push(middleware);
+			await middleware.execute();
+		}
 	}
-	async gateRefusal(HandlerCtor, interaction, routeId) {
+	async gateRefusal(HandlerCtor, interaction, dispatch, declaredRoute) {
 		const monitor = slowGateMonitor();
 		try {
-			await runHandlerGates(HandlerCtor, interactionGateContext(interaction, this.core), routeId ?? void 0, monitor?.observe);
+			await runHandlerGates(HandlerCtor, interactionGateContext(interaction, this.core, dispatch), declaredRoute, monitor?.observe);
 			return null;
 		} catch (caught) {
 			return { caught };
 		} finally {
-			monitor?.report(routeId);
+			monitor?.report(declaredRoute ?? null);
 		}
 	}
 	async handleInteraction(interaction) {
@@ -2396,8 +2502,6 @@ 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;
 const loggerSlot = Symbol("seedcord:bot:logger");
@@ -2460,7 +2564,7 @@ var Bot = class {
 		this.#events?.stopAccepting();
 	}
 	async #drain() {
-		await Promise.allSettled([this.#interactions?.drain(DISPATCH_DRAIN_TIMEOUT_MS), this.#events?.drain(DISPATCH_DRAIN_TIMEOUT_MS)]);
+		await Promise.allSettled([this.#interactions?.drain(DRAIN_WINDOW_MS), this.#events?.drain(DRAIN_WINDOW_MS)]);
 	}
 	/** @internal */
 	async [initSlot]() {
@@ -2510,7 +2614,7 @@ function initBot(bot) {
 //#endregion
 //#region src/version.ts
 /** Package version */
-const version = "0.5.0";
+const version = "0.6.0";
 
 //#endregion
 //#region src/Seedcord.ts
@@ -2546,7 +2650,7 @@ var Seedcord = class Seedcord extends Pluggable {
 	* @throws A **SeedcordError** When attempting to create multiple instances (singleton)
 	*/
 	constructor(config) {
-		super(new CoordinatedShutdown(), new CoordinatedStartup());
+		super(new CoordinatedShutdown(config.lifecycle?.shutdownDeadline), new CoordinatedStartup());
 		this.config = config;
 		installNodeDefaults(config.logger);
 		setBotColor(config.botColor);
@@ -2614,5 +2718,5 @@ var Seedcord = class Seedcord extends Pluggable {
 };
 
 //#endregion
-export { ArraySource, AutocompleteHandler, BaseHandler, ButtonHandler, ChannelMenuHandler, ComponentHandler, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, GatewayEmoji, IgnoreBots, InteractionHandler, InteractionMiddleware, MentionableMenuHandler, MessageContextMenuHandler, Middleware, MiddlewareType, ModalHandler, Nsfw, Paginator, Plugin, RegisterEvent, RepliableHandler, ReplySender, RoleMenuHandler, Seedcord, SelectMenuHandler, SlashHandler, StringMenuHandler, Subscriber, UserContextMenuHandler, UserMenuHandler, WebhookLog, WinstonConsoleSink, WinstonFileSink, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
+export { ArraySource, AutocompleteHandler, BaseHandler, ButtonHandler, ChannelMenuHandler, ComponentHandler, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, GatewayEmoji, IgnoreBots, InteractionHandler, InteractionMiddleware, MentionableMenuHandler, MessageContextMenuHandler, ModalHandler, Nsfw, Paginator, Plugin, RegisterEvent, RegisterEventMiddleware, RepliableHandler, ReplySender, RoleMenuHandler, Seedcord, SelectMenuHandler, SlashHandler, StringMenuHandler, Subscriber, UserContextMenuHandler, UserMenuHandler, WebhookLog, WinstonConsoleSink, WinstonFileSink, checkBotPermissions, checkPermissions, getConfirmation, hasPermsToAssign, version };
 //# sourceMappingURL=index.mjs.map