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

package/dist/{edge.index-D-60VfMn.cjs → edge.index-Bd6sbr37.cjs}

@@ -1,7 +1,9 @@
 //#region \0rolldown/runtime.js
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -31,6 +33,10 @@ var __copyProps = (to, from, except, desc) => {
 	return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
 //#endregion
 let _seedcord_errors_internal = require("@seedcord/errors/internal");
@@ -42,8 +48,8 @@ let _seedcord_logger = require("@seedcord/logger");
 let _seedcord_rate_limiter = require("@seedcord/rate-limiter");
 let discord_api_types_v10 = require("discord-api-types/v10");
 let _discordjs_core_http_only = require("@discordjs/core/http-only");
-let _seedcord_errors = require("@seedcord/errors");
 let _seedcord_utils_internal = require("@seedcord/utils/internal");
+let _seedcord_errors = require("@seedcord/errors");
 
 //#region src/reply/ReplySender.ts
 function wireAllowedMentions(mentions) {
@@ -77,8 +83,11 @@ function callbackData(reply, flags) {
 var ReplySender = class extends _seedcord_core_internal.BaseReplySender {
 	ref;
 	rest;
-	constructor(ref, rest, routeId) {
-		super(routeId);
+	constructor(ref, rest, routeId, bus) {
+		super(routeId, "unacked", bus && {
+			bus,
+			interactionId: ref.id
+		});
 		this.ref = ref;
 		this.rest = rest;
 	}
@@ -174,12 +183,16 @@ function apiFor(rest) {
 * @typeParam Event - The repliable interaction type this handler processes
 */
 var RepliableHandler = class extends _seedcord_core.RepliableHandler {
+	/** @internal */
+	getEvent() {
+		return this.event;
+	}
 	buildSender(event, core, routeId) {
 		return new ReplySender({
 			application_id: event.application_id,
 			id: event.id,
 			token: event.token
-		}, core.rest, routeId);
+		}, core.rest, routeId, core.bus);
 	}
 	/**
 	* Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
@@ -212,31 +225,132 @@ function interactionGateContext(payload, core, routeId) {
 	};
 }
 
+//#endregion
+//#region src/dispatch/slashRouteOf.ts
+/**
+* Computes the dispatch route for a chat-input or autocomplete payload, the raw-payload port of the
+* gateway's `slashRouteOf`. Both assemble keys through `buildSlashRoute`, so a dispatched interaction
+* and a generated registry key always match.
+*/
+function slashRouteOf(data) {
+	const first = data.options?.[0];
+	if (first?.type === discord_api_types_v10.ApplicationCommandOptionType.SubcommandGroup) return (0, _seedcord_utils_internal.buildSlashRoute)(data.name, first.options[0]?.name, first.name);
+	if (first?.type === discord_api_types_v10.ApplicationCommandOptionType.Subcommand) return (0, _seedcord_utils_internal.buildSlashRoute)(data.name, first.name);
+	return data.name;
+}
+
+//#endregion
+//#region src/dispatch/reportFault.ts
+let faultLogger;
+function logger$1() {
+	faultLogger ??= new _seedcord_logger.Logger("Faults", { channel: "errors" });
+	return faultLogger;
+}
+/**
+* Publishes a fault on the bus, the raw-payload equivalent of the reporting half of gateway's
+* `extractErrorResponse`. A reported {@link Notice} publishes `handledException`, everything else
+* publishes `unknownException`.
+*
+* @internal
+*/
+function reportFault(error, uuid, payload, core) {
+	const throttle = _seedcord_core_internal.FaultThrottle.for(core);
+	const key = `${routeKeyOf(payload)}:${nameOf(error)}`;
+	if (!throttle.shouldReport(key)) {
+		logger$1().debug(`throttled duplicate fault ${_seedcord_logger.paint.mute(key)}`);
+		return;
+	}
+	const source = interactionSource(payload);
+	if (error instanceof _seedcord_core.Notice && source) core.bus[_seedcord_core_internal.PublishDefault]("handledException", {
+		denial: error,
+		uuid,
+		source
+	});
+	else core.bus[_seedcord_core_internal.PublishDefault]("unknownException", {
+		uuid,
+		error,
+		...actors(payload),
+		metadata: payload
+	});
+	throttle.markReported(key);
+}
+function routeKeyOf(payload) {
+	if (payload.type === discord_api_types_v10.InteractionType.ApplicationCommandAutocomplete) return `autocomplete:${slashRouteOf(payload.data)}`;
+	if (payload.type === discord_api_types_v10.InteractionType.ApplicationCommand) return payload.data.type === discord_api_types_v10.ApplicationCommandType.ChatInput ? slashRouteOf(payload.data) : payload.data.name;
+	return (0, _seedcord_core_internal.prefixOf)(payload.data.custom_id) || payload.data.custom_id;
+}
+function nameOf(error) {
+	if (error instanceof _seedcord_core.Notice) return error.name;
+	if (error instanceof _discordjs_rest.DiscordAPIError) return String(error.code);
+	return error.constructor.name;
+}
+function actors(payload) {
+	const user = payload.member?.user ?? payload.user;
+	return {
+		guild: void 0,
+		user: user ? {
+			id: user.id,
+			username: user.username
+		} : void 0
+	};
+}
+function interactionSource(payload) {
+	const user = payload.member?.user ?? payload.user;
+	if (!user) return null;
+	const common = {
+		kind: "interaction",
+		userId: user.id,
+		guildId: payload.guild_id ?? null,
+		channelId: payload.channel?.id ?? null,
+		interactionId: payload.id,
+		raw: payload
+	};
+	if (payload.type === discord_api_types_v10.InteractionType.ApplicationCommand) {
+		const isSlash = payload.data.type === discord_api_types_v10.ApplicationCommandType.ChatInput;
+		return {
+			...common,
+			interactionKind: isSlash ? "slash" : "context-menu",
+			command: routeKeyOf(payload),
+			customId: null
+		};
+	}
+	if (payload.type === discord_api_types_v10.InteractionType.ModalSubmit) return {
+		...common,
+		interactionKind: "modal",
+		command: null,
+		customId: payload.data.custom_id
+	};
+	if (payload.type === discord_api_types_v10.InteractionType.MessageComponent) {
+		const isButton = payload.data.component_type === discord_api_types_v10.ComponentType.Button;
+		return {
+			...common,
+			interactionKind: isButton ? "button" : "select",
+			command: null,
+			customId: payload.data.custom_id
+		};
+	}
+	return null;
+}
+
 //#endregion
 //#region src/dispatch/dispatchInteraction.ts
 let dispatchLogger;
 function logger() {
-	dispatchLogger ??= new _seedcord_logger.Logger("Dispatcher");
+	dispatchLogger ??= new _seedcord_logger.Logger("Dispatcher", { channel: "interactions" });
 	return dispatchLogger;
 }
 function createCore(config, token) {
-	return {
+	const draft = {
 		config,
 		rateLimiter: config.store ?? new _seedcord_rate_limiter.MemoryRateLimiter(),
-		rest: new _discordjs_rest.REST().setToken(token),
-		version: "0.1.0-next.1",
-		username: void 0,
-		augmentTarget: "@seedcord/http"
+		rest: new _discordjs_rest.REST().setToken(token)
 	};
+	draft.bus = new _seedcord_core.Bus(draft);
+	return draft;
 }
 function isHandlerCtor(value) {
 	return typeof value === "function" && value.prototype instanceof _seedcord_core.BaseHandler;
 }
-function handlerCtorOf(moduleExports) {
-	if (typeof moduleExports !== "object" || moduleExports === null) return null;
-	for (const value of Object.values(moduleExports)) if (isHandlerCtor(value)) return value;
-	return null;
-}
 const HARMLESS_API_CODES = new Set([
 	discord_api_types_v10.RESTJSONErrorCodes.UnknownInteraction,
 	discord_api_types_v10.RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
@@ -254,10 +368,13 @@ async function sendGuarded(routeId, send) {
 	}
 }
 async function respondEmptyChoices(scope) {
-	await scope.core.rest.post(discord_api_types_v10.Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
+	await (0, _seedcord_core_internal.reportedWrite)({
+		bus: scope.core.bus,
+		interactionId: scope.payload.id
+	}, scope.routeId, "respond", () => scope.core.rest.post(discord_api_types_v10.Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
 		type: discord_api_types_v10.InteractionResponseType.ApplicationCommandAutocompleteResult,
 		data: { choices: [] }
-	} });
+	} }));
 }
 function renderContext(core, uuid) {
 	const developerUsername = core.config.notifications?.developerUsername;
@@ -267,7 +384,10 @@ function renderContext(core, uuid) {
 	};
 }
 async function handleNotice(notice, uuid, scope) {
-	if (notice.report) logger().error(`${notice.name}: ${_seedcord_logger.paint.mute(uuid)}`, notice);
+	if (notice.report) {
+		logger().error(`${notice.name}: ${_seedcord_logger.paint.mute(uuid)}`, notice);
+		reportFault(notice, uuid, scope.payload, scope.core);
+	}
 	const { sender } = scope;
 	if (!sender) {
 		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
@@ -280,6 +400,7 @@ async function handleRawFault(error, uuid, scope) {
 	const { core, sender } = scope;
 	if (core.config.errors?.errorStack ?? false) logger().error(_seedcord_logger.paint.mute(uuid), error);
 	else logger().error(`${_seedcord_logger.paint.mute(uuid)} | ${error.message}`);
+	reportFault(error, uuid, scope.payload, core);
 	if (!sender) {
 		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
 		return;
@@ -290,7 +411,7 @@ async function handleRawFault(error, uuid, scope) {
 }
 async function handleFault(caught, scope) {
 	if (caught instanceof _seedcord_core.Silence) {
-		if (caught.reason !== void 0) logger().debug(`Silence: ${caught.reason}`);
+		if (caught.reason !== void 0 && (scope.core.config.errors?.logSilences ?? true)) logger().debug(`Silence: ${caught.reason}`);
 		return;
 	}
 	const uuid = crypto.randomUUID();
@@ -298,7 +419,7 @@ async function handleFault(caught, scope) {
 		await handleNotice(caught, uuid, scope);
 		return;
 	}
-	const error = Error.isError(caught) ? caught : new Error(String(caught));
+	const error = (0, _seedcord_core_internal.asError)(caught);
 	const ignore = new Set(scope.core.config.errors?.ignoreApiCodes ?? []);
 	if (error instanceof _discordjs_rest.DiscordAPIError && ignore.has(error.code)) {
 		logger().debug(`swallowed api code ${_seedcord_logger.paint.amber(String(error.code))}`);
@@ -306,79 +427,149 @@ async function handleFault(caught, scope) {
 	}
 	await handleRawFault(error, uuid, scope);
 }
+function unhandledRouteId(match) {
+	if (match.routeId) return match.routeId;
+	const key = match.attemptedKey ?? "";
+	return `${match.kind}:${key.length > 0 ? key : "unrouted"}`;
+}
 function freshScope(match, payload, core) {
 	const ref = {
 		application_id: payload.application_id,
 		id: payload.id,
 		token: payload.token
 	};
-	const routeId = match.routeId ?? "unhandled";
+	const routeId = unhandledRouteId(match);
 	return {
 		core,
 		payload,
 		routeId,
-		sender: match.kind === "autocomplete" ? null : new ReplySender(ref, core.rest, routeId)
+		sender: match.kind === "autocomplete" ? null : new ReplySender(ref, core.rest, routeId, core.bus)
 	};
 }
-/**
-* Runs the pre-ack phase for a matched interaction. Loads the route module, constructs the handler, and
-* runs its gates, and the sender posts any refusal. Returns the post-ack execute continuation, or null
-* when a gate refuses or nothing can run.
-*/
-async function dispatchInteraction(args) {
-	const { match, payload, core } = args;
-	let moduleExports;
+function dispatchReporter(match, payload, core) {
+	const startedAt = performance.now();
+	const queuedMs = (0, _seedcord_core_internal.queuedMsFor)(payload.id);
+	return (outcome) => {
+		core.bus[_seedcord_core_internal.PublishDefault]("interactionDispatched", (0, _seedcord_core_internal.dispatchedPayload)({
+			routeId: unhandledRouteId(match),
+			interactionId: payload.id,
+			kind: match.kind,
+			outcome,
+			fallback: match.routeId === null,
+			startedAt,
+			queuedMs
+		}));
+	};
+}
+async function answer(caught, scope, report, outcome = (0, _seedcord_core_internal.outcomeFor)(caught)) {
 	try {
-		moduleExports = await match.load();
-	} catch (caught) {
-		logger().error(`Route ${_seedcord_logger.paint.sky.bold(match.routeId ?? "unhandled")} failed to load its module.`, caught);
-		await handleFault(caught, freshScope(match, payload, core));
-		return null;
+		await handleFault(caught, scope);
+	} finally {
+		report(outcome);
 	}
-	const ctor = handlerCtorOf(moduleExports);
-	if (!ctor) {
-		const routeId = match.routeId ?? "unhandled";
-		logger().error(`Route ${_seedcord_logger.paint.sky.bold(routeId)} loaded a module with no handler class.`);
-		await handleFault(/* @__PURE__ */ new Error(`route ${routeId} loaded a module with no handler class`), freshScope(match, payload, core));
+}
+async function loadHandlerCtor(match, payload, core, report) {
+	const routeId = unhandledRouteId(match);
+	let exported;
+	try {
+		exported = await match.load();
+	} catch (caught) {
+		logger().error(`Route ${_seedcord_logger.paint.sky.bold(routeId)} failed to load its handler.`, caught);
+		await answer(caught, freshScope(match, payload, core), report, "failed");
 		return null;
 	}
-	const dispatch = new _seedcord_core.DispatchContext(match.routeId);
+	if (isHandlerCtor(exported)) return exported;
+	logger().error(`Route ${_seedcord_logger.paint.sky.bold(routeId)} loaded an export that is not a handler class.`);
+	await answer(/* @__PURE__ */ new Error(`route ${routeId} loaded an export that is not a handler class`), freshScope(match, payload, core), report, "failed");
+	return null;
+}
+/**
+* Runs the pre-ack phase for a matched interaction. Loads the route's handler class, constructs it, and
+* runs its gates. The sender posts any refusal. Returns the post-ack execute continuation, or null when a
+* gate refuses or nothing can run.
+*/
+async function dispatchInteraction(args) {
+	const { match, payload, core } = args;
+	const report = dispatchReporter(match, payload, core);
+	const ctor = await loadHandlerCtor(match, payload, core, report);
+	if (!ctor) return null;
+	const dispatch = new _seedcord_core.DispatchContext(unhandledRouteId(match));
 	let handler;
 	try {
 		handler = new ctor(payload, core, dispatch);
 	} catch (caught) {
-		await handleFault(caught, freshScope(match, payload, core));
+		await answer(caught, freshScope(match, payload, core), report);
 		return null;
 	}
 	const scope = {
 		core,
 		payload,
-		routeId: match.routeId ?? handler.constructor.name,
+		routeId: unhandledRouteId(match),
 		sender: handler instanceof RepliableHandler ? handler.getSender() : null
 	};
-	if (!await passedGates(ctor, match, payload, core, scope)) return null;
+	const refusal = await gateRefusal(ctor, match, payload, core);
+	if (refusal) {
+		await answer(refusal.caught, scope, report);
+		return null;
+	}
 	return async () => {
 		try {
 			await handler.execute();
+			report("handled");
 		} catch (caught) {
-			await handleFault(caught, scope);
+			await answer(caught, scope, report);
 		}
 	};
 }
-async function passedGates(ctor, match, payload, core, scope) {
-	if (match.kind === "autocomplete" || payload.type === discord_api_types_v10.InteractionType.ApplicationCommandAutocomplete) return true;
+async function gateRefusal(ctor, match, payload, core) {
+	if (match.kind === "autocomplete" || payload.type === discord_api_types_v10.InteractionType.ApplicationCommandAutocomplete) return null;
 	const monitor = (0, _seedcord_core_internal.slowGateMonitor)();
 	try {
 		await (0, _seedcord_core_internal.runHandlerGates)(ctor, interactionGateContext(payload, core, match.routeId), match.routeId ?? void 0, monitor?.observe);
-		return true;
+		return null;
 	} catch (caught) {
-		await handleFault(caught, scope);
-		return false;
+		return { caught };
 	} finally {
 		monitor?.report(match.routeId);
 	}
 }
 
+//#endregion
+//#region src/dispatch/registerSubscribers.ts
+/**
+* Registers a manifest's subscribers on the bus without importing them. Each row's module loads on
+* the first publish of one of its keys, which keeps an isolate that never publishes free of the cost.
+*
+* @internal
+*/
+function registerSubscribers(bus, manifest) {
+	for (const row of manifest.subscriberRoutes) bus.register({
+		keys: row.keys,
+		frequency: row.frequency,
+		resolve: async () => {
+			const keys = row.keys.join(", ");
+			let module;
+			try {
+				module = await row.load();
+			} catch (caught) {
+				throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.RouteModuleLoadFailed, [keys, row.from], { cause: caught });
+			}
+			if (!Object.hasOwn(module, row.exportName)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.InteractionRouteExportMissing, [
+				keys,
+				row.exportName,
+				row.from
+			]);
+			const exported = module[row.exportName];
+			if (typeof exported !== "function" || !(exported.prototype instanceof _seedcord_core.Subscriber)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.SubscriberRouteNotASubscriber, [
+				keys,
+				row.exportName,
+				row.from
+			]);
+			return exported;
+		}
+	});
+}
+
 //#endregion
 //#region src/inputs/HttpSlashOptions.ts
 var HttpSlashOptions = class {
@@ -455,20 +646,6 @@ function numeric(value) {
 	return Number.isNaN(parsed) ? null : parsed;
 }
 
-//#endregion
-//#region src/dispatch/slashRouteOf.ts
-/**
-* Computes the dispatch route for a chat-input or autocomplete payload, the raw-payload port of the
-* gateway's `slashRouteOf`. Both assemble keys through `buildSlashRoute`, so a dispatched interaction
-* and a generated registry key always match.
-*/
-function slashRouteOf(data) {
-	const first = data.options?.[0];
-	if (first?.type === discord_api_types_v10.ApplicationCommandOptionType.SubcommandGroup) return (0, _seedcord_utils_internal.buildSlashRoute)(data.name, first.options[0]?.name, first.name);
-	if (first?.type === discord_api_types_v10.ApplicationCommandOptionType.Subcommand) return (0, _seedcord_utils_internal.buildSlashRoute)(data.name, first.name);
-	return data.name;
-}
-
 //#endregion
 //#region src/handlers/interaction/AutocompleteHandler.ts
 /**
@@ -482,7 +659,7 @@ function slashRouteOf(data) {
 */
 var AutocompleteHandler = class extends _seedcord_core.BaseHandler {
 	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
+		super(event, core, dispatch, "interactions");
 	}
 	/**
 	* Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
@@ -525,10 +702,14 @@ var AutocompleteHandler = class extends _seedcord_core.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.core.rest.post(discord_api_types_v10.Routes.interactionCallback(this.event.id, this.event.token), { body: {
+		const routeId = this.dispatch?.routeId ?? "autocomplete";
+		await (0, _seedcord_core_internal.reportedWrite)({
+			bus: this.core.bus,
+			interactionId: this.event.id
+		}, routeId, "respond", () => this.core.rest.post(discord_api_types_v10.Routes.interactionCallback(this.event.id, this.event.token), { body: {
 			type: discord_api_types_v10.InteractionResponseType.ApplicationCommandAutocompleteResult,
 			data: { choices }
-		} });
+		} }));
 	}
 	/** The firing command route, for a field whose completion differs per registered command. */
 	get route() {
@@ -626,14 +807,30 @@ function componentMapKey(type) {
 		default: return null;
 	}
 }
-function set(map, kind, key, load) {
-	map.set(key, {
-		kind,
-		routeId: `${kind}:${key}`,
-		load
-	});
+function namedExport(routeId, row) {
+	return async () => {
+		let moduleExports;
+		try {
+			moduleExports = await row.load();
+		} catch (caught) {
+			throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.RouteModuleLoadFailed, [routeId, row.from], { cause: caught });
+		}
+		if (!Object.hasOwn(moduleExports, row.exportName)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.InteractionRouteExportMissing, [
+			routeId,
+			row.exportName,
+			row.from
+		]);
+		return moduleExports[row.exportName];
+	};
+}
+function describeRow(row) {
+	return `${row.exportName} (${row.from})`;
 }
-/** Builds the per-kind lookup maps. */
+/**
+* Builds the per-kind lookup maps.
+*
+* @throws A **SeedcordError** when two rows resolve to the same route.
+*/
 function buildRouteMaps(manifest) {
 	const maps = {
 		slash: /* @__PURE__ */ new Map(),
@@ -650,19 +847,36 @@ function buildRouteMaps(manifest) {
 			modal: /* @__PURE__ */ new Map()
 		}
 	};
-	for (const row of manifest.commands) {
+	const owners = /* @__PURE__ */ new Map();
+	function set(map, kind, key, row) {
+		const routeId = `${kind}:${key}`;
+		const owner = owners.get(routeId);
+		if (owner) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.InteractionDuplicateRoute, [
+			routeId,
+			describeRow(owner),
+			describeRow(row)
+		]);
+		owners.set(routeId, row);
+		map.set(key, {
+			kind,
+			routeId,
+			load: namedExport(routeId, row)
+		});
+	}
+	for (const row of manifest.commandRoutes) {
 		const kind = commandKind(row.type);
-		if (kind) set(maps[kind], kind, row.name, row.load);
+		if (kind) set(maps[kind], kind, row.name, row);
 	}
-	for (const row of manifest.autocomplete) set(maps.autocomplete, "autocomplete", row.name, row.load);
-	for (const row of manifest.components) set(maps.components[row.kind], COMPONENT_KIND[row.kind], row.prefix, row.load);
+	for (const row of manifest.autocompleteRoutes) set(maps.autocomplete, "autocomplete", row.name, row);
+	for (const row of manifest.componentRoutes) set(maps.components[row.kind], COMPONENT_KIND[row.kind], row.prefix, row);
 	return maps;
 }
-function unhandled(kind) {
+function unhandled(kind, attemptedKey) {
 	return {
 		kind,
 		routeId: null,
-		load: () => Promise.resolve(kind === "autocomplete" ? { UnhandledAutocomplete } : { UnhandledRepliable })
+		attemptedKey,
+		load: () => Promise.resolve(kind === "autocomplete" ? UnhandledAutocomplete : UnhandledRepliable)
 	};
 }
 /**
@@ -675,17 +889,27 @@ function unhandled(kind) {
 function resolve(maps, interaction) {
 	switch (interaction.type) {
 		case discord_api_types_v10.InteractionType.ApplicationCommand: {
-			if (interaction.data.type === discord_api_types_v10.ApplicationCommandType.ChatInput) return maps.slash.get(slashRouteOf(interaction.data)) ?? unhandled("slash");
+			if (interaction.data.type === discord_api_types_v10.ApplicationCommandType.ChatInput) {
+				const route = slashRouteOf(interaction.data);
+				return maps.slash.get(route) ?? unhandled("slash", route);
+			}
 			const kind = commandKind(interaction.data.type);
-			return kind ? maps[kind].get(interaction.data.name) ?? unhandled(kind) : null;
+			return kind ? maps[kind].get(interaction.data.name) ?? unhandled(kind, interaction.data.name) : null;
+		}
+		case discord_api_types_v10.InteractionType.ApplicationCommandAutocomplete: {
+			const route = slashRouteOf(interaction.data);
+			return maps.autocomplete.get(route) ?? unhandled("autocomplete", route);
 		}
-		case discord_api_types_v10.InteractionType.ApplicationCommandAutocomplete: return maps.autocomplete.get(slashRouteOf(interaction.data)) ?? unhandled("autocomplete");
 		case discord_api_types_v10.InteractionType.MessageComponent: {
 			const key = componentMapKey(interaction.data.component_type);
 			if (!key) return null;
-			return maps.components[key].get((0, _seedcord_core_internal.prefixOf)(interaction.data.custom_id)) ?? unhandled(COMPONENT_KIND[key]);
+			const prefix = (0, _seedcord_core_internal.prefixOf)(interaction.data.custom_id);
+			return maps.components[key].get(prefix) ?? unhandled(COMPONENT_KIND[key], prefix);
+		}
+		case discord_api_types_v10.InteractionType.ModalSubmit: {
+			const prefix = (0, _seedcord_core_internal.prefixOf)(interaction.data.custom_id);
+			return maps.components.modal.get(prefix) ?? unhandled("modal", prefix);
 		}
-		case discord_api_types_v10.InteractionType.ModalSubmit: return maps.components.modal.get((0, _seedcord_core_internal.prefixOf)(interaction.data.custom_id)) ?? unhandled("modal");
 		default: return null;
 	}
 }
@@ -766,7 +990,7 @@ function buildEngine(core, maps) {
 	const verifier = new Ed25519Verifier(envapt.Envapter.getRequired("DISCORD_PUBLIC_KEY", envapt.Converters.String));
 	const replays = new ReplayGuard();
 	const inFlight = /* @__PURE__ */ new Set();
-	const logger = new _seedcord_logger.Logger("Engine");
+	const logger = new _seedcord_logger.Logger("Engine", { channel: "bot" });
 	async function dispatchMatched(match, payload, ctx) {
 		const start = await dispatchInteraction({
 			match,
@@ -774,13 +998,18 @@ function buildEngine(core, maps) {
 			core
 		});
 		if (!start) return;
-		const work = start();
+		const work = start().catch(rootFault);
 		if (ctx) ctx.waitUntil(work);
 		else {
 			inFlight.add(work);
 			work.finally(() => inFlight.delete(work));
 		}
 	}
+	function rootFault(caught) {
+		const error = (0, _seedcord_core_internal.asError)(caught);
+		logger.error("dispatch failed past the boundary", error);
+		core.bus[_seedcord_core_internal.PublishDefault]("unhandledInteractionError", { error });
+	}
 	const handle = async (request, ctx) => {
 		if (request.method !== "POST") return new Response(null, {
 			status: METHOD_NOT_ALLOWED,
@@ -801,10 +1030,11 @@ function buildEngine(core, maps) {
 		if (!hasInteractionType(payload)) return new Response(null, { status: BAD_REQUEST });
 		if (payload.type === PING) return Response.json({ type: discord_api_types_v10.InteractionResponseType.Pong });
 		try {
+			core.bus[_seedcord_core_internal.PublishDefault]("anyInteraction", { interaction: payload });
 			const match = resolve(maps, payload);
 			if (match) await dispatchMatched(match, payload, ctx);
 		} catch (caught) {
-			logger.error("dispatch failed, acking anyway", caught);
+			rootFault(caught);
 		}
 		return new Response(null, { status: ACCEPTED });
 	};
@@ -830,9 +1060,120 @@ function buildEngine(core, maps) {
 * `SeedcordError` when either is missing or malformed.
 */
 function createSeedcord(config, manifest) {
-	return buildEngine(createCore(config, (0, _seedcord_errors_internal.validateDiscordToken)(envapt.Envapter.get("DISCORD_BOT_TOKEN"))), buildRouteMaps(manifest)).handle;
+	const core = createCore(config, (0, _seedcord_errors_internal.validateDiscordToken)(envapt.Envapter.get("DISCORD_BOT_TOKEN")));
+	core.bus.registerDefaults();
+	registerSubscribers(core.bus, manifest);
+	return buildEngine(core, buildRouteMaps(manifest)).handle;
 }
 
+//#endregion
+//#region src/applicationId.ts
+/**
+* Reads the bot's own application id over REST. A gateway host takes it off the logged-in client, and
+* an http host has no session to read it from.
+*
+* @internal
+*/
+async function fetchApplicationId(rest) {
+	try {
+		return (await rest.get(discord_api_types_v10.Routes.currentApplication())).id;
+	} catch (error) {
+		throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreApplicationUnavailable, { cause: error });
+	}
+}
+
+//#endregion
+//#region src/emojis/EmojiInjector.ts
+var Emoji = class {
+	name;
+	id;
+	animated;
+	constructor(name, id, animated = false) {
+		this.name = name;
+		this.id = id;
+		this.animated = animated;
+	}
+	toString() {
+		return `<${this.animated ? "a" : ""}:${this.name}:${this.id}>`;
+	}
+};
+const emojiStorage = (0, _seedcord_core_internal.accessorStore)();
+function reasonOf(error) {
+	return Error.isError(error) ? error.message : String(error);
+}
+function byName(list) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of list) if (entry.name) map.set(entry.name, entry);
+	return map;
+}
+/**
+* The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
+* A read before that throws.
+*/
+const Emojis = (0, _seedcord_core_internal.guardedAccessor)("Emojis", emojiStorage);
+/**
+* Resolves the configured emojis over REST at startup.
+*
+* @internal
+*/
+var EmojiInjector = class {
+	core;
+	applicationId;
+	logger = new _seedcord_logger.Logger("Emojis", { channel: "bot" });
+	constructor(core, applicationId = () => fetchApplicationId(core.rest)) {
+		this.core = core;
+		this.applicationId = applicationId;
+	}
+	async init() {
+		(0, _seedcord_core_internal.clearStore)(emojiStorage);
+		const configured = this.core.config.bot.emojis;
+		if (!configured || Object.keys(configured).length === 0) {
+			this.logger.debug("No emojis configured, skipping emoji injection.");
+			return;
+		}
+		const failures = [];
+		const guilds = /* @__PURE__ */ new Map();
+		let application;
+		for (const [key, value] of Object.entries(configured)) if ((0, _seedcord_core_internal.isEmojiTuple)(value)) await this.resolveTuple(key, value, guilds, failures);
+		else if (typeof value === "string") {
+			application ??= await this.applicationEmojis(failures);
+			this.resolve(key, value, application, failures, "the application");
+		} else failures.push(`  - "${key}" has an invalid value (expected a name or [name, guildId])`);
+		if (failures.length > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ConfigEmojiUnresolved, [failures.length, failures.join("\n")]);
+		this.logger.utils.summary("Loaded emojis", { emojis: Object.keys(emojiStorage).length });
+	}
+	async applicationEmojis(failures) {
+		try {
+			const appId = await this.applicationId();
+			return byName((await this.core.rest.get(discord_api_types_v10.Routes.applicationEmojis(appId))).items);
+		} catch (error) {
+			failures.push(`  - the application emojis could not be read (${reasonOf(error)})`);
+			return /* @__PURE__ */ new Map();
+		}
+	}
+	async resolveTuple(key, [name, guildId], guilds, failures) {
+		let guild = guilds.get(guildId);
+		if (!guild) {
+			try {
+				guild = byName(await this.core.rest.get(discord_api_types_v10.Routes.guildEmojis(guildId)));
+			} catch (error) {
+				failures.push(`  - "${name}" for "${key}" targets guild ${guildId}, which could not be read (${reasonOf(error)})`);
+				return;
+			}
+			guilds.set(guildId, guild);
+		}
+		this.resolve(key, name, guild, failures, `guild ${guildId}`);
+	}
+	resolve(key, name, source, failures, where) {
+		const found = source.get(name);
+		if (!found?.id) {
+			failures.push(`  - "${name}" for "${key}" was not found in ${where}`);
+			return;
+		}
+		emojiStorage[key] = new Emoji(name, found.id, found.animated ?? false);
+	}
+};
+
 //#endregion
 //#region src/handlers/interaction/SlashHandler.ts
 /**
@@ -1013,12 +1354,12 @@ var SelectMenuHandler = class extends ComponentHandler {};
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
 */
 var ModalHandler = class extends ComponentHandler {
-	/** Rewrite the message this modal was opened from (only when a component opened it). */
+	/** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
 	update(response) {
 		this.ensureSourceMessage("update");
 		return super.update(response);
 	}
-	/** Silently acknowledge, leaving the source message untouched. */
+	/** Acknowledge the submit without changing the source message. Throws when a command opened the modal. */
 	deferUpdate() {
 		this.ensureSourceMessage("deferUpdate");
 		return super.deferUpdate();
@@ -1029,6 +1370,98 @@ var ModalHandler = class extends ComponentHandler {
 	}
 };
 
+//#endregion
+//#region src/subscribers/index.ts
+/**
+* Base class for an HTTP subscriber, binding `this.core` to the HTTP {@link Core}.
+*
+* @typeParam KeyOfSubscribers - The subscription key this handler receives
+*/
+var Subscriber = class extends _seedcord_core.Subscriber {};
+/**
+* Base class for an HTTP subscriber that delivers its event to a Discord webhook, binding
+* `this.core` to the HTTP {@link Core}.
+*
+* @typeParam KeyOfSubscribers - The subscription key this reporter receives
+*/
+var WebhookLog = class extends _seedcord_core.WebhookLog {};
+
+//#endregion
+//#region src/pagination/Paginator.ts
+function contextOf(interaction, core) {
+	return {
+		interaction,
+		user: interaction.member?.user ?? interaction.user,
+		guildId: interaction.guild_id ?? null,
+		core
+	};
+}
+/**
+* A restart-proof paginator. Each nav button's customId encodes its full target page, so clicks are
+* idempotent and survive a restart. A persistent `@ButtonRoute` on `Handler` dispatches the clicks.
+*
+* @typeParam Item - The item type, inferred from the source.
+* @typeParam Prefix - The route prefix, inferred from `config.prefix`.
+*
+* @example
+* ```ts
+* export const Bans = new Paginator({
+*     prefix: 'bans',
+*     source: new ArraySource((ctx) => loadBans(ctx.guildId), { perPage: 10 }),
+*     renderItem: (ban) => ban.user.username
+* });
+*
+* \@ButtonRoute(Bans.cursor)
+* export class BansNav extends Bans.Handler {}
+* ```
+*/
+var Paginator = class extends _seedcord_core.PaginatorBase {
+	/** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
+	Handler;
+	constructor(config) {
+		super(config);
+		const loadPage = (ctx, n) => this.page(ctx, n);
+		this.Handler = class Nav extends ButtonHandler {
+			async execute() {
+				await this.deferUpdate();
+				const response = await loadPage(contextOf(this.event, this.core), this.params.page);
+				await this.update(response);
+			}
+		};
+	}
+	/**
+	* Render page 0 and send it through the handler's sender, which picks reply, edit, or followUp from its
+	* ack state.
+	*
+	* @param handler - The handler starting the paginator, normally `this`.
+	*/
+	async start(handler) {
+		const interaction = handler.getEvent();
+		const response = await this.page(contextOf(interaction, handler.core), 0);
+		return handler.getSender().send(response, { ephemeral: this.config.ephemeral ?? false });
+	}
+};
+
+//#endregion
+//#region src/pagination/sources.ts
+/**
+* A source for a bounded list you can load whole. It loads the full list on every click, then slices the
+* page, so the real total is known (a real last button, "Page X of Y"). Cache inside your loader if the
+* load is expensive.
+*
+* @typeParam Item - The item type, inferred from the loader's return.
+*/
+var ArraySource = class extends _seedcord_core.ArraySource {};
+/**
+* A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
+* The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
+* source has no cheap total, so `totalPages` is undefined, the last button is omitted, and the indicator
+* reads "Page X".
+*
+* @typeParam Item - The item type, inferred from the fetcher's slice.
+*/
+var CursorSource = class extends _seedcord_core.CursorSource {};
+
 //#endregion
 //#region src/gates/Gated.ts
 /**
@@ -1073,9 +1506,15 @@ function Gated(...gates) {
 //#endregion
 //#region src/version.ts
 /** Package version */
-const version = "0.1.0-next.1";
+const version = "0.1.0-next.3";
 
 //#endregion
+Object.defineProperty(exports, 'ArraySource', {
+  enumerable: true,
+  get: function () {
+    return ArraySource;
+  }
+});
 Object.defineProperty(exports, 'AutocompleteHandler', {
   enumerable: true,
   get: function () {
@@ -1100,6 +1539,24 @@ Object.defineProperty(exports, 'ContextMenuHandler', {
     return ContextMenuHandler;
   }
 });
+Object.defineProperty(exports, 'CursorSource', {
+  enumerable: true,
+  get: function () {
+    return CursorSource;
+  }
+});
+Object.defineProperty(exports, 'EmojiInjector', {
+  enumerable: true,
+  get: function () {
+    return EmojiInjector;
+  }
+});
+Object.defineProperty(exports, 'Emojis', {
+  enumerable: true,
+  get: function () {
+    return Emojis;
+  }
+});
 Object.defineProperty(exports, 'Gated', {
   enumerable: true,
   get: function () {
@@ -1118,6 +1575,12 @@ Object.defineProperty(exports, 'ModalHandler', {
     return ModalHandler;
   }
 });
+Object.defineProperty(exports, 'Paginator', {
+  enumerable: true,
+  get: function () {
+    return Paginator;
+  }
+});
 Object.defineProperty(exports, 'RepliableHandler', {
   enumerable: true,
   get: function () {
@@ -1136,6 +1599,18 @@ Object.defineProperty(exports, 'SlashHandler', {
     return SlashHandler;
   }
 });
+Object.defineProperty(exports, 'Subscriber', {
+  enumerable: true,
+  get: function () {
+    return Subscriber;
+  }
+});
+Object.defineProperty(exports, 'WebhookLog', {
+  enumerable: true,
+  get: function () {
+    return WebhookLog;
+  }
+});
 Object.defineProperty(exports, '__exportAll', {
   enumerable: true,
   get: function () {
@@ -1148,6 +1623,12 @@ Object.defineProperty(exports, '__reExport', {
     return __reExport;
   }
 });
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
 Object.defineProperty(exports, 'buildEngine', {
   enumerable: true,
   get: function () {
@@ -1166,10 +1647,16 @@ Object.defineProperty(exports, 'createSeedcord', {
     return createSeedcord;
   }
 });
+Object.defineProperty(exports, 'fetchApplicationId', {
+  enumerable: true,
+  get: function () {
+    return fetchApplicationId;
+  }
+});
 Object.defineProperty(exports, 'version', {
   enumerable: true,
   get: function () {
     return version;
   }
 });
-//# sourceMappingURL=edge.index-D-60VfMn.cjs.map
+//# sourceMappingURL=edge.index-Bd6sbr37.cjs.map