@seedcord/http 0.1.0-next.0 → 0.1.0-next.2

package/dist/index.mjs

@@ -1,1014 +1,424 @@
-import { SeedcordErrorCode } from "@seedcord/errors";
+import { n as __reExport, t as __exportAll } from "./rolldown-runtime-BUUfjzRC.mjs";
+import { a as ModalHandler, c as ComponentHandler, d as createSeedcord, f as buildEngine, g as RepliableHandler, h as AutocompleteHandler, i as WebhookLog, l as ContextMenuHandler, m as InteractionHandler, n as Gated, o as SelectMenuHandler, p as buildRouteMaps, r as Subscriber, s as ButtonHandler, t as version, u as SlashHandler } from "./edge.index-BBRnxxkS.mjs";
 import { SeedcordError, validateDiscordToken } from "@seedcord/errors/internal";
-import { Logger, paint } from "@seedcord/logger";
-import { ApplicationCommandOptionType, ApplicationCommandType, ComponentType, InteractionResponseType, InteractionType, MessageFlags, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
-import { Converters, Envapter } from "envapt";
-import { DiscordAPIError, REST } from "@discordjs/rest";
-import { BaseHandler, DispatchContext, Fault, Notice, RepliableHandler as RepliableHandler$1, Silence } from "@seedcord/core";
-import { BaseReplySender, GatedMetadataKey, decodeComponentRoute, deferFlags, prefixOf, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { Envapter } from "envapt";
+import { REST } from "@discordjs/rest";
+import { Bus } from "@seedcord/core";
+import { HmrManager, InteractionMetadataKey, InteractionRoutes, interactionRoutesOf, setBotColor } from "@seedcord/core/internal";
+import { Logger, LoggerChannelRegistry, paint } from "@seedcord/logger";
 import { MemoryRateLimiter } from "@seedcord/rate-limiter";
-import { buildSlashRoute } from "@seedcord/utils/internal";
+import { Routes } from "discord-api-types/v10";
+import { SeedcordErrorCode } from "@seedcord/errors";
+import { once } from "node:events";
+import { createServer } from "node:http";
+import { CoordinatedShutdown, CoordinatedStartup, HealthCheck, Pluggable, ShutdownPhase, StartupPhase, SubscriberLoader } from "@seedcord/core/node/internal";
+import { installNodeDefaults } from "@seedcord/logger/node";
+import { SeedcordBrand } from "@seedcord/types/internal";
+import { HmrModuleHandler } from "@seedcord/core/hmr";
+import { formatFilePath } from "@seedcord/utils";
+import { traverseDirectory } from "@seedcord/utils/node";
+import { Plugin as Plugin$1 } from "@seedcord/core/plugin";
 
 export * from "@seedcord/core"
 
-//#region src/reply/ReplySender.ts
-function wireAllowedMentions(mentions) {
-	const { repliedUser, ...wire } = mentions;
-	return {
-		...wire,
-		...repliedUser !== void 0 && { replied_user: repliedUser }
-	};
-}
-function wireAttachments(files) {
-	if (!files?.some((file) => file.description)) return null;
-	return files.map((file, index) => ({
-		id: index,
-		...file.name && { filename: file.name },
-		...file.description && { description: file.description }
-	}));
-}
-function callbackData(reply, flags) {
-	const attachments = wireAttachments(reply.files);
-	return {
-		flags,
-		components: reply.components,
-		...reply.allowedMentions && { allowed_mentions: wireAllowedMentions(reply.allowedMentions) },
-		...attachments && { attachments }
-	};
-}
-/**
-* Writes interaction responses over the Discord REST callback and webhook endpoints. Construction is
-* internal to the repliable handler bases and the dispatcher.
-*/
-var ReplySender = class extends BaseReplySender {
-	ref;
-	rest;
-	constructor(ref, rest, routeId) {
-		super(routeId);
-		this.ref = ref;
-		this.rest = rest;
-	}
-	async writeReply(response, opts) {
-		const reply = this.serialize(response);
-		const result = await this.callback(InteractionResponseType.ChannelMessageWithSource, callbackData(reply, sendFlags(opts)), reply.files);
-		return this.createdMessage(result);
-	}
-	async writeDefer(opts) {
-		await this.callback(InteractionResponseType.DeferredChannelMessageWithSource, { flags: deferFlags(opts) });
-	}
-	async writeDeferUpdate() {
-		await this.callback(InteractionResponseType.DeferredMessageUpdate);
-	}
-	async writeUpdate(response) {
-		const reply = this.serialize(response);
-		const result = await this.callback(InteractionResponseType.UpdateMessage, callbackData(reply, MessageFlags.IsComponentsV2), reply.files);
-		return this.createdMessage(result);
-	}
-	async writeFollowUp(response, opts) {
-		const reply = this.serialize(response);
-		return await this.rest.post(Routes.webhook(this.ref.application_id, this.ref.token), {
-			body: callbackData(reply, sendFlags(opts)),
-			query: new URLSearchParams({ wait: "true" }),
-			...reply.files && { files: this.rawFiles(reply.files) }
-		});
-	}
-	writeEditOriginal(response) {
-		return this.editMessage(Routes.webhookMessage(this.ref.application_id, this.ref.token), this.serialize(response));
-	}
-	writeEditTarget(targetId, response) {
-		const route = Routes.webhookMessage(this.ref.application_id, this.ref.token, targetId);
-		return this.editMessage(route, this.serialize(response));
-	}
-	async writeDeleteOriginal() {
-		await this.rest.delete(Routes.webhookMessage(this.ref.application_id, this.ref.token));
-	}
-	async writeDeleteTarget(targetId) {
-		await this.rest.delete(Routes.webhookMessage(this.ref.application_id, this.ref.token, targetId));
-	}
-	async writeModal(data) {
-		await this.callback(InteractionResponseType.Modal, data);
-	}
-	async callback(type, data, files) {
-		const withResponse = type === InteractionResponseType.ChannelMessageWithSource || type === InteractionResponseType.UpdateMessage;
-		return await this.rest.post(Routes.interactionCallback(this.ref.id, this.ref.token), {
-			body: {
-				type,
-				...data !== void 0 && { data }
-			},
-			...withResponse && { query: new URLSearchParams({ with_response: "true" }) },
-			...files && { files: this.rawFiles(files) }
-		});
-	}
-	async editMessage(route, reply) {
-		return await this.rest.patch(route, {
-			body: callbackData(reply, MessageFlags.IsComponentsV2),
-			...reply.files && { files: this.rawFiles(reply.files) }
-		});
-	}
-	rawFiles(files) {
-		return files.map((file, index) => ({
-			name: file.name ?? `file-${index}`,
-			data: file.attachment
-		}));
-	}
-	createdMessage(result) {
-		return result.resource?.message;
-	}
+//#region src/manifest/RouteManifest.ts
+/** @internal */
+const EMPTY_MANIFEST = {
+	commandRoutes: [],
+	componentRoutes: [],
+	autocompleteRoutes: [],
+	subscriberRoutes: [],
+	middlewareRoutes: []
 };
 
 //#endregion
-//#region src/handlers/RepliableHandler.ts
+//#region src/node/InteractionDispatcher.ts
 /**
-* Shared base the repliable HTTP interaction handlers extend.
+* Discovers interaction handlers from the filesystem into the engine's live route maps.
 *
-* Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
-* {@link SelectMenuHandler}, or {@link ContextMenuHandler} instead. This class binds the core reply base
-* to the http sender.
-*
-* @typeParam Event - The repliable interaction type this handler processes
+* The node host runs it at startup and dev HMR swaps map entries in place. The engine's `resolve`
+* reads `maps` per request. The edge path builds its maps from the generated manifest.
 */
-var RepliableHandler = class extends RepliableHandler$1 {
-	buildSender(event, core, routeId) {
-		return new ReplySender({
-			application_id: event.application_id,
-			id: event.id,
-			token: event.token
-		}, core.rest, routeId);
-	}
-};
-
-//#endregion
-//#region src/gates/context.ts
-function interactionGateContext(payload, core, routeId) {
-	const member = payload.member ?? null;
-	const resolved = member?.user ?? payload.user;
-	return {
-		kind: "interaction",
-		core,
-		interaction: payload,
-		user: resolved,
-		member,
-		userId: resolved?.id ?? null,
-		guildId: payload.guild_id ?? null,
-		channelId: payload.channel?.id ?? null,
-		memberRoleIds: member?.roles ?? [],
-		memberPermissions: member ? BigInt(member.permissions) : null,
-		appPermissions: BigInt(payload.app_permissions),
-		routeId
-	};
-}
-
-//#endregion
-//#region src/dispatch/dispatchInteraction.ts
-let dispatchLogger;
-function logger() {
-	dispatchLogger ??= new Logger("Dispatcher");
-	return dispatchLogger;
-}
-function createCore(config, token) {
-	return {
-		config,
-		rateLimiter: config.store ?? new MemoryRateLimiter(),
-		rest: new REST().setToken(token),
-		version: "0.1.0-next.0",
-		username: void 0,
-		augmentTarget: "@seedcord/http"
-	};
-}
-function isHandlerCtor(value) {
-	return typeof value === "function" && value.prototype instanceof 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([
-	RESTJSONErrorCodes.UnknownInteraction,
-	RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
-	RESTJSONErrorCodes.UnknownMessage
-]);
-async function sendGuarded(routeId, send) {
-	try {
-		await send();
-	} catch (error) {
-		if (error instanceof DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
-			logger().debug(`boundary send hit harmless code ${paint.amber(String(error.code))}`);
-			return;
-		}
-		logger().error(`boundary send failed for route ${paint.sky.bold(routeId)}`, error);
-	}
-}
-async function respondEmptyChoices(scope) {
-	await scope.core.rest.post(Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
-		type: InteractionResponseType.ApplicationCommandAutocompleteResult,
-		data: { choices: [] }
-	} });
-}
-function renderContext(core, uuid) {
-	const developerUsername = core.config.notifications?.developerUsername;
-	return developerUsername === void 0 ? { uuid } : {
-		uuid,
-		developerUsername
-	};
-}
-async function handleNotice(notice, uuid, scope) {
-	if (notice.report) logger().error(`${notice.name}: ${paint.mute(uuid)}`, notice);
-	const { sender } = scope;
-	if (!sender) {
-		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
-		return;
-	}
-	const response = notice.render(renderContext(scope.core, uuid));
-	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: notice.ephemeral }));
-}
-async function handleRawFault(error, uuid, scope) {
-	const { core, sender } = scope;
-	if (core.config.errors?.errorStack ?? false) logger().error(paint.mute(uuid), error);
-	else logger().error(`${paint.mute(uuid)} | ${error.message}`);
-	if (!sender) {
-		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
-		return;
-	}
-	const override = core.config.errors?.defaultError;
-	const response = (override ? new override(uuid) : new Fault()).render(renderContext(core, uuid));
-	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: true }));
-}
-async function handleFault(caught, scope) {
-	if (caught instanceof Silence) {
-		if (caught.reason !== void 0) logger().debug(`Silence: ${caught.reason}`);
-		return;
-	}
-	const uuid = crypto.randomUUID();
-	if (caught instanceof Notice) {
-		await handleNotice(caught, uuid, scope);
-		return;
-	}
-	const error = Error.isError(caught) ? caught : new Error(String(caught));
-	const ignore = new Set(scope.core.config.errors?.ignoreApiCodes ?? []);
-	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
-		logger().debug(`swallowed api code ${paint.amber(String(error.code))}`);
-		return;
-	}
-	await handleRawFault(error, uuid, scope);
-}
-function freshScope(match, payload, core) {
-	const ref = {
-		application_id: payload.application_id,
-		id: payload.id,
-		token: payload.token
-	};
-	const routeId = match.routeId ?? "unhandled";
-	return {
-		core,
-		payload,
-		routeId,
-		sender: match.kind === "autocomplete" ? null : new ReplySender(ref, core.rest, routeId)
-	};
-}
-/**
-* 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;
-	try {
-		moduleExports = await match.load();
-	} catch (caught) {
-		logger().error(`Route ${paint.sky.bold(match.routeId ?? "unhandled")} failed to load its module.`, caught);
-		await handleFault(caught, freshScope(match, payload, core));
-		return null;
-	}
-	const ctor = handlerCtorOf(moduleExports);
-	if (!ctor) {
-		const routeId = match.routeId ?? "unhandled";
-		logger().error(`Route ${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));
-		return null;
-	}
-	const dispatch = new DispatchContext(match.routeId);
-	let handler;
-	try {
-		handler = new ctor(payload, core, dispatch);
-	} catch (caught) {
-		await handleFault(caught, freshScope(match, payload, core));
-		return null;
+var InteractionDispatcher = class {
+	handlersDir;
+	maps;
+	targets;
+	/** @internal */
+	logger = new Logger("Interactions", { channel: "interactions" });
+	isInitialized = false;
+	hmrHandler;
+	rowOwners = /* @__PURE__ */ new Map();
+	loading = false;
+	loadedHandlers = [];
+	constructor(handlersDir) {
+		this.handlersDir = handlersDir;
+		this.maps = buildRouteMaps(EMPTY_MANIFEST);
+		this.targets = this.buildTargets();
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir,
+			isHandler: this.isHandler.bind(this),
+			registerHandler: this.registerHandler.bind(this),
+			unregisterHandler: this.unregisterHandler.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: this.logger
+		});
 	}
-	const scope = {
-		core,
-		payload,
-		routeId: match.routeId ?? handler.constructor.name,
-		sender: handler instanceof RepliableHandler ? handler.getSender() : null
-	};
-	if (!await passedGates(ctor, match, payload, core, scope)) return null;
-	return async () => {
+	/** @internal */
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		this.loading = true;
+		this.loadedHandlers.length = 0;
 		try {
-			await handler.execute();
-		} catch (caught) {
-			await handleFault(caught, scope);
+			await traverseDirectory(this.handlersDir, (fullPath, relativePath, imported) => {
+				for (const value of Object.values(imported)) {
+					if (!this.isHandler(value)) continue;
+					this.registerHandler(value, relativePath);
+					this.hmrHandler?.trackHandler(fullPath, value);
+				}
+			});
+		} finally {
+			this.loading = false;
 		}
-	};
-}
-async function passedGates(ctor, match, payload, core, scope) {
-	if (match.kind === "autocomplete" || payload.type === InteractionType.ApplicationCommandAutocomplete) return true;
-	const monitor = slowGateMonitor();
-	try {
-		await runHandlerGates(ctor, interactionGateContext(payload, core, match.routeId), match.routeId ?? void 0, monitor?.observe);
-		return true;
-	} catch (caught) {
-		await handleFault(caught, scope);
-		return false;
-	} finally {
-		monitor?.report(match.routeId);
-	}
-}
-
-//#endregion
-//#region src/inputs/HttpSlashOptions.ts
-var HttpSlashOptions = class {
-	leaves = /* @__PURE__ */ new Map();
-	resolved;
-	constructor(data) {
-		this.resolved = data.resolved;
-		let options = data.options ?? [];
-		const first = options[0];
-		if (first?.type === ApplicationCommandOptionType.SubcommandGroup) options = first.options;
-		const second = options[0];
-		if (second?.type === ApplicationCommandOptionType.Subcommand) options = second.options ?? [];
-		for (const option of options) if (option.type !== ApplicationCommandOptionType.Subcommand && option.type !== ApplicationCommandOptionType.SubcommandGroup) this.leaves.set(option.name, option);
-	}
-	getString(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.String ? leaf.value : null;
-	}
-	getInteger(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.Integer ? numeric(leaf.value) : null;
-	}
-	getNumber(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.Number ? numeric(leaf.value) : null;
-	}
-	getBoolean(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.Boolean ? leaf.value : null;
-	}
-	getUser(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.User) return null;
-		return this.resolved?.users?.[leaf.value] ?? null;
-	}
-	getMember(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.User) return null;
-		return this.resolved?.members?.[leaf.value] ?? null;
+		this.logger.utils.block("Loaded handlers", [...this.logger.utils.entries(this.loadedHandlers), ...this.logger.utils.counts({ routes: this.rowOwners.size })]);
 	}
-	getChannel(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Channel) return null;
-		return this.resolved?.channels?.[leaf.value] ?? null;
+	/** @internal */
+	async onHmr(event) {
+		await this.hmrHandler?.handle(event);
 	}
-	getRole(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Role) return null;
-		return this.resolved?.roles?.[leaf.value] ?? null;
+	isHandler(value) {
+		if (typeof value !== "function") return false;
+		return (value.prototype instanceof InteractionHandler || value.prototype instanceof AutocompleteHandler) && Reflect.hasMetadata(InteractionMetadataKey, value);
 	}
-	getAttachment(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Attachment) return null;
-		return this.resolved?.attachments?.[leaf.value] ?? null;
+	getArtifacts(ctor) {
+		const routeIds = [];
+		for (const [routeId, owner] of this.rowOwners) if (owner.ctor === ctor) routeIds.push(routeId);
+		return routeIds;
 	}
-	getMentionable(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Mentionable) return null;
-		const resolved = this.resolved;
-		return resolved?.members?.[leaf.value] ?? resolved?.users?.[leaf.value] ?? resolved?.roles?.[leaf.value] ?? null;
+	targetFor(route) {
+		return this.targets[route];
 	}
-	getFocused() {
-		for (const leaf of this.leaves.values()) if ("focused" in leaf && leaf.focused === true) return {
-			name: leaf.name,
-			value: String(leaf.value)
+	buildTargets() {
+		return {
+			[InteractionRoutes.Slash]: {
+				map: this.maps.slash,
+				kind: "slash"
+			},
+			[InteractionRoutes.UserContextMenu]: {
+				map: this.maps.userContextMenu,
+				kind: "userContextMenu"
+			},
+			[InteractionRoutes.MessageContextMenu]: {
+				map: this.maps.messageContextMenu,
+				kind: "messageContextMenu"
+			},
+			[InteractionRoutes.Autocomplete]: {
+				map: this.maps.autocomplete,
+				kind: "autocomplete"
+			},
+			[InteractionRoutes.Button]: {
+				map: this.maps.components.button,
+				kind: "button"
+			},
+			[InteractionRoutes.StringMenu]: {
+				map: this.maps.components.stringSelect,
+				kind: "stringMenu"
+			},
+			[InteractionRoutes.UserMenu]: {
+				map: this.maps.components.userSelect,
+				kind: "userMenu"
+			},
+			[InteractionRoutes.RoleMenu]: {
+				map: this.maps.components.roleSelect,
+				kind: "roleMenu"
+			},
+			[InteractionRoutes.ChannelMenu]: {
+				map: this.maps.components.channelSelect,
+				kind: "channelMenu"
+			},
+			[InteractionRoutes.MentionableMenu]: {
+				map: this.maps.components.mentionableSelect,
+				kind: "mentionableMenu"
+			},
+			[InteractionRoutes.Modal]: {
+				map: this.maps.components.modal,
+				kind: "modal"
+			}
 		};
-		return null;
+	}
+	registerHandler(ctor, relativePath) {
+		const from = formatFilePath(relativePath);
+		const writes = [];
+		for (const [route, keys] of interactionRoutesOf(ctor)) {
+			const target = this.targetFor(route);
+			for (const key of keys) {
+				const routeId = `${target.kind}:${key}`;
+				const existing = this.rowOwners.get(routeId);
+				if (existing && existing.ctor !== ctor) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateRoute, [
+					routeId,
+					`${existing.ctor.name} (${existing.from})`,
+					`${ctor.name} (${from})`
+				]);
+				writes.push([target, key]);
+			}
+		}
+		if (writes.length === 0) return;
+		for (const [target, key] of writes) {
+			const routeId = `${target.kind}:${key}`;
+			target.map.set(key, {
+				kind: target.kind,
+				routeId,
+				load: () => Promise.resolve(ctor)
+			});
+			this.rowOwners.set(routeId, {
+				ctor,
+				target,
+				key,
+				from
+			});
+		}
+		if (this.loading) this.loadedHandlers.push({
+			name: ctor.name,
+			from
+		});
+		else this.logger.utils.registration(ctor.name, from);
+	}
+	unregisterHandler(ctor, artifacts) {
+		const routeIds = artifacts ?? this.getArtifacts(ctor);
+		for (const routeId of routeIds) {
+			const owner = this.rowOwners.get(routeId);
+			if (owner?.ctor !== ctor) continue;
+			this.rowOwners.delete(routeId);
+			owner.target.map.delete(owner.key);
+		}
 	}
 };
-function numeric(value) {
-	if (typeof value === "number") return value;
-	if (value.trim() === "") return null;
-	const parsed = Number(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 === ApplicationCommandOptionType.SubcommandGroup) return buildSlashRoute(data.name, first.options[0]?.name, first.name);
-	if (first?.type === ApplicationCommandOptionType.Subcommand) return buildSlashRoute(data.name, first.name);
-	return data.name;
+//#region src/node/webBridge.ts
+function toHeaders(raw) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(raw)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else headers.set(name, value);
+	}
+	return headers;
+}
+async function toWebRequest(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(chunk);
+	const method = request.method ?? "GET";
+	const body = method === "GET" || method === "HEAD" ? void 0 : new Uint8Array(Buffer.concat(chunks));
+	return new Request(`http://${request.headers.host ?? "localhost"}${request.url ?? "/"}`, {
+		method,
+		headers: toHeaders(request.headers),
+		...body !== void 0 && { body }
+	});
+}
+async function writeWebResponse(response, out) {
+	const headers = Object.fromEntries(response.headers);
+	const cookies = response.headers.getSetCookie();
+	if (cookies.length > 0) headers["set-cookie"] = cookies;
+	out.writeHead(response.status, headers);
+	out.end(response.body === null ? void 0 : Buffer.from(await response.arrayBuffer()));
 }
 
 //#endregion
-//#region src/handlers/interaction/AutocompleteHandler.ts
+//#region src/node/Seedcord.ts
+const DEFAULT_PORT = 3e3;
+const SERVER_SHUTDOWN_TIMEOUT_MS = 5e3;
+const DRAIN_TIMEOUT_MS = 1e4;
 /**
-* Base class for an autocomplete handler on the HTTP transport.
-*
-* Pass the command route(s) from the generated registry as the generic. Branch on the focused field with
-* `this.match`, read already-entered sibling options with `this.options`, and find which command fired
-* with `this.route`.
+* The HTTP-interactions bot host, a long-running node server around the engine.
 *
-* @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'search'`.
+* Discovers handlers from `config.bot.interactions.path`, verifies and dispatches interactions on
+* `start(port)`, and runs coordinated shutdown with an in-flight drain. The edge deploy path calls
+* `createSeedcord` from a generated entry.
 */
-var AutocompleteHandler = class extends BaseHandler {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
-	}
-	resolver;
-	get reader() {
-		this.resolver ??= new HttpSlashOptions(this.event.data);
-		return this.resolver;
-	}
-	/**
-	* The focused option for this interaction. `value` is always the raw partial string the user is typing,
-	* even for an integer or number option, so coerce it yourself when you need a number.
-	*/
-	get focused() {
-		const focused = this.reader.getFocused();
-		if (!focused) throw new SeedcordError(SeedcordErrorCode.AutocompleteNoFocusedOption);
-		return focused;
+var Seedcord = class Seedcord extends Pluggable {
+	config;
+	/** @internal */
+	[SeedcordBrand] = true;
+	/** @internal */
+	augmentTarget = "@seedcord/http";
+	/** @internal */
+	version = version;
+	/** Workerd-compatible Discord REST client. `start()` sets the token. */
+	rest = new REST();
+	/** @see {@link IRateLimiter} */
+	rateLimiter;
+	/** @see {@link Bus} */
+	bus;
+	subscribers;
+	interactions;
+	healthCheck;
+	hmrManager;
+	logger = new Logger("Server", { channel: "bot" });
+	server;
+	boundPort;
+	requestedPort = DEFAULT_PORT;
+	fetchedUsername;
+	constructor(config) {
+		super(new CoordinatedShutdown(), new CoordinatedStartup());
+		this.config = config;
+		installNodeDefaults(config.logger);
+		setBotColor(config.botColor);
+		this.hmrManager = new HmrManager();
+		this.hmrManager.init();
+		if (this.config.bot.interactions.path) this.interactions = new InteractionDispatcher(this.config.bot.interactions.path);
+		this.rateLimiter = config.store ?? new MemoryRateLimiter();
+		this.bus = new Bus(this);
+		this.subscribers = new SubscriberLoader(this.bus, config.subscribers.path);
+		this.healthCheck = config.runtime === "edge" ? void 0 : HealthCheck.fromOption(this.shutdown, config.healthCheck);
+		this.registerStartupTasks();
+	}
+	/** The bot's discord username, populated by the ready fetch. */
+	get username() {
+		return this.fetchedUsername;
+	}
+	/** The bound server port, populated once `start()` is listening. */
+	get port() {
+		return this.boundPort;
+	}
+	pluginCapabilities() {
+		const token = Envapter.get("DISCORD_BOT_TOKEN");
+		return {
+			rest: this.rest,
+			...token !== void 0 && { token }
+		};
 	}
 	/**
-	* Run the arm for the focused field. An autocomplete always dispatches by which field is focused, so
-	* match is how you read it.
+	* Starts the host and runs the startup tasks.
 	*
-	* Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
-	* arm receives the focused partial value and a `respond` typed to that field's choice value. The
-	* arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
-	* focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
-	*
-	* @param arms - One handler per autocompletable field, keyed by field name.
-	* @returns The result of the arm that ran.
-	*/
-	async match(arms) {
-		const { name, value } = this.focused;
-		const respond = (choices) => this.respond(choices);
-		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-		if (!arm) throw new SeedcordError(SeedcordErrorCode.AutocompleteMatchArmMissing, [name]);
-		return await arm(value, respond);
-	}
-	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
-	async respond(choices) {
-		await this.core.rest.post(Routes.interactionCallback(this.event.id, this.event.token), { body: {
-			type: InteractionResponseType.ApplicationCommandAutocompleteResult,
-			data: { choices }
-		} });
-	}
-	/** The firing command route, for a field whose completion differs per registered command. */
-	get route() {
-		return slashRouteOf(this.event.data);
-	}
-	/**
-	* The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
-	* (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
-	* types the focused field. The focused field is on `this.focused`.
-	*/
-	get options() {
-		return this.reader;
-	}
-};
-
-//#endregion
-//#region src/handlers/defaults/UnhandledAutocomplete.ts
-/**
-* Default handler for autocomplete no manifest row matches.
-* Empty choices are the only legal answer, they clear the pending state.
-*
-* @internal
-*/
-var UnhandledAutocomplete = class extends AutocompleteHandler {
-	async execute() {
-		await this.respond([]);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/InteractionHandler.ts
-/**
-* Shared base the repliable interaction handlers extend.
-*
-* Not a public entry point. Extend {@link SlashHandler}, {@link ContextMenuHandler}, {@link ButtonHandler},
-* {@link SelectMenuHandler}, or {@link ModalHandler} instead. This class adds `showModal` on top of the
-* reply members.
-*
-* @typeParam Event - The repliable interaction type this handler processes
-*/
-var InteractionHandler = class extends RepliableHandler {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
-	}
-	/**
-	* Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
-	* compile time (Discord forbids a modal in response to a modal).
+	* @param port - The port the interaction server binds. {@default `3000` }
 	*/
-	showModal(modal) {
-		return this.sender.showModal(modal);
-	}
-};
-
-//#endregion
-//#region src/handlers/defaults/UnhandledRepliable.ts
-/**
-* Default handler for interactions no manifest row matches. A reply failure here
-* goes directly to the dispatch fault boundary, so it needs no guard of its own.
-*
-* @internal
-*/
-var UnhandledRepliable = class extends InteractionHandler {
-	async execute() {
-		await this.reply("Feature not implemented yet.");
-	}
-};
-
-//#endregion
-//#region src/dispatch/resolve.ts
-const COMPONENT_KIND = {
-	button: "button",
-	stringSelect: "stringMenu",
-	userSelect: "userMenu",
-	roleSelect: "roleMenu",
-	channelSelect: "channelMenu",
-	mentionableSelect: "mentionableMenu",
-	modal: "modal"
-};
-function commandKind(type) {
-	switch (type) {
-		case ApplicationCommandType.ChatInput: return "slash";
-		case ApplicationCommandType.User: return "userContextMenu";
-		case ApplicationCommandType.Message: return "messageContextMenu";
-		default: return null;
-	}
-}
-function componentMapKey(type) {
-	switch (type) {
-		case ComponentType.Button: return "button";
-		case ComponentType.StringSelect: return "stringSelect";
-		case ComponentType.UserSelect: return "userSelect";
-		case ComponentType.RoleSelect: return "roleSelect";
-		case ComponentType.ChannelSelect: return "channelSelect";
-		case ComponentType.MentionableSelect: return "mentionableSelect";
-		default: return null;
-	}
-}
-function set(map, kind, key, load) {
-	map.set(key, {
-		kind,
-		routeId: `${kind}:${key}`,
-		load
-	});
-}
-/** Builds the per-kind lookup maps. */
-function buildRouteMaps(manifest) {
-	const maps = {
-		slash: /* @__PURE__ */ new Map(),
-		userContextMenu: /* @__PURE__ */ new Map(),
-		messageContextMenu: /* @__PURE__ */ new Map(),
-		autocomplete: /* @__PURE__ */ new Map(),
-		components: {
-			button: /* @__PURE__ */ new Map(),
-			stringSelect: /* @__PURE__ */ new Map(),
-			userSelect: /* @__PURE__ */ new Map(),
-			roleSelect: /* @__PURE__ */ new Map(),
-			channelSelect: /* @__PURE__ */ new Map(),
-			mentionableSelect: /* @__PURE__ */ new Map(),
-			modal: /* @__PURE__ */ new Map()
-		}
-	};
-	for (const row of manifest.commands) {
-		const kind = commandKind(row.type);
-		if (kind) set(maps[kind], kind, row.name, row.load);
-	}
-	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);
-	return maps;
-}
-function unhandled(kind) {
-	return {
-		kind,
-		routeId: null,
-		load: () => Promise.resolve(kind === "autocomplete" ? { UnhandledAutocomplete } : { UnhandledRepliable })
-	};
-}
-/**
-* Matches a verified non-PING interaction to its manifest row. A known kind with no row resolves to the
-* unhandled default, whose handler replies "Feature not implemented yet." (empty choices on autocomplete).
-* Null is an unrecognized payload shape, which the engine acks with a 202 without dispatching.
-* Components and modals route by the stable customId prefix, so a wire whose layout hash drifted still
-* routes to its handler, where decode refuses with `StaleCustomId`.
-*/
-function resolve(maps, interaction) {
-	switch (interaction.type) {
-		case InteractionType.ApplicationCommand: {
-			if (interaction.data.type === ApplicationCommandType.ChatInput) return maps.slash.get(slashRouteOf(interaction.data)) ?? unhandled("slash");
-			const kind = commandKind(interaction.data.type);
-			return kind ? maps[kind].get(interaction.data.name) ?? unhandled(kind) : null;
-		}
-		case InteractionType.ApplicationCommandAutocomplete: return maps.autocomplete.get(slashRouteOf(interaction.data)) ?? unhandled("autocomplete");
-		case InteractionType.MessageComponent: {
-			const key = componentMapKey(interaction.data.component_type);
-			if (!key) return null;
-			return maps.components[key].get(prefixOf(interaction.data.custom_id)) ?? unhandled(COMPONENT_KIND[key]);
+	async start(port = DEFAULT_PORT) {
+		this.requestedPort = port;
+		try {
+			await super.init();
+		} catch (caught) {
+			await this.shutdown.run(1, false);
+			Seedcord.reset();
+			throw caught;
 		}
-		case InteractionType.ModalSubmit: return maps.components.modal.get(prefixOf(interaction.data.custom_id)) ?? unhandled("modal");
-		default: return null;
-	}
-}
-
-//#endregion
-//#region src/receiver/Ed25519Verifier.ts
-const PUBLIC_KEY_BYTES = 32;
-const SIGNATURE_BYTES = 64;
-const HEX_RADIX = 16;
-const HEX_PATTERN = /^[0-9a-f]+$/i;
-function hexToBytes(hex, byteLength) {
-	if (hex.length !== byteLength * 2 || !HEX_PATTERN.test(hex)) return null;
-	const bytes = new Uint8Array(byteLength);
-	for (let index = 0; index < byteLength; index++) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), HEX_RADIX);
-	return bytes;
-}
-const encoder = new TextEncoder();
-var Ed25519Verifier = class {
-	key;
-	constructor(publicKeyHex) {
-		const publicKey = hexToBytes(publicKeyHex, PUBLIC_KEY_BYTES);
-		if (!publicKey) throw new SeedcordError(SeedcordErrorCode.ConfigIncorrectPublicKey);
-		this.key = crypto.subtle.importKey("raw", publicKey, "Ed25519", false, ["verify"]);
-	}
-	async verify(signatureHex, timestamp, body) {
-		const signature = hexToBytes(signatureHex, SIGNATURE_BYTES);
-		if (!signature) return false;
-		const timestampBytes = encoder.encode(timestamp);
-		const message = new Uint8Array(timestampBytes.length + body.length);
-		message.set(timestampBytes, 0);
-		message.set(body, timestampBytes.length);
-		return crypto.subtle.verify("Ed25519", await this.key, signature, message);
-	}
-};
-
-//#endregion
-//#region src/receiver/ReplayGuard.ts
-const REPLAY_WINDOW_MS = 3e5;
-const SWEEP_GAP_MS = 6e4;
-const MS_PER_SECOND = 1e3;
-const TIMESTAMP_PATTERN = /^\d+$/;
-var ReplayGuard = class {
-	seen = /* @__PURE__ */ new Map();
-	lastSweep = Date.now();
-	accepts(signatureHex, timestampHeader) {
-		const now = Date.now();
-		this.maybeSweep(now);
-		if (!TIMESTAMP_PATTERN.test(timestampHeader)) return false;
-		const timestampMs = Number(timestampHeader) * MS_PER_SECOND;
-		if (Math.abs(now - timestampMs) > REPLAY_WINDOW_MS) return false;
-		const rejectUntil = this.seen.get(signatureHex);
-		if (rejectUntil !== void 0 && rejectUntil >= now) return false;
-		this.seen.set(signatureHex, timestampMs + REPLAY_WINDOW_MS);
-		return true;
-	}
-	maybeSweep(now) {
-		if (now - this.lastSweep < SWEEP_GAP_MS) return;
-		this.lastSweep = now;
-		for (const [signature, rejectUntil] of this.seen) if (rejectUntil < now) this.seen.delete(signature);
+		return this;
+	}
+	static reset() {
+		super.reset();
+		LoggerChannelRegistry.instance.reset();
+	}
+	registerStartupTasks() {
+		if (Envapter.isDevelopment || Envapter.isTest) this.registerHmrAwareModules();
+		this.startup.addTask(StartupPhase.Configuration, "bus-initialization", async () => {
+			this.bus.logger.utils.initialization("Subscribers", "start");
+			await this.subscribers.init();
+			this.bus.logger.utils.initialization("Subscribers", "end");
+		});
+		const { interactions } = this;
+		if (interactions) this.startup.addTask(StartupPhase.Configuration, "interactions-initialization", async () => {
+			interactions.logger.utils.initialization("Interactions", "start");
+			await interactions.init();
+			interactions.logger.utils.initialization("Interactions", "end");
+		});
+		this.startup.addTask(StartupPhase.Ready, "http-server", () => this.listen());
+		if (!Envapter.isTest) this.startup.addTask(StartupPhase.Ready, "identity", () => this.fetchUsername());
+		const { healthCheck } = this;
+		if (healthCheck) this.startup.addTask(StartupPhase.Ready, "health-check", async () => {
+			healthCheck.logger.utils.initialization("HealthCheck", "start");
+			await healthCheck.init();
+			healthCheck.logger.utils.initialization("HealthCheck", "end");
+		});
 	}
-};
-
-//#endregion
-//#region src/createSeedcord.ts
-const SIGNATURE_HEADER = "x-signature-ed25519";
-const TIMESTAMP_HEADER = "x-signature-timestamp";
-const ACCEPTED = 202;
-const BAD_REQUEST = 400;
-const UNAUTHORIZED = 401;
-const METHOD_NOT_ALLOWED = 405;
-const PING = InteractionType.Ping;
-const decoder = new TextDecoder();
-function hasInteractionType(payload) {
-	return typeof payload === "object" && payload !== null && "type" in payload && typeof payload.type === "number";
-}
-/**
-* Builds the HTTP-interactions engine, a `(request, ctx?) => Promise<Response>` handler.
-*
-* The handler verifies the Ed25519 signature over the raw request bytes, rejects stale or replayed
-* requests, answers a PING with an in-body PONG, and acks every other interaction with an empty 202.
-* The engine dispatches a matched interaction through the manifest before the 202 goes out. Gates run
-* first and the sender posts any refusal over the REST callback. `execute()` continues past the 202 under
-* `ctx.waitUntil` when the caller passes one (the edge entry), and an engine-held in-flight set tracks
-* it otherwise (node paths). It reads only the method, headers, and body. Mount it at any path.
-*
-* Reads `DISCORD_PUBLIC_KEY` and `DISCORD_BOT_TOKEN` from the environment through envapt and throws a
-* `SeedcordError` when either is missing or malformed.
-*/
-function createSeedcord(config, manifest) {
-	if (!Envapter.has("DISCORD_PUBLIC_KEY")) throw new SeedcordError(SeedcordErrorCode.ConfigMissingPublicKey);
-	const publicKey = Envapter.getRequired("DISCORD_PUBLIC_KEY", Converters.String);
-	const token = validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
-	const verifier = new Ed25519Verifier(publicKey);
-	const replays = new ReplayGuard();
-	const maps = buildRouteMaps(manifest);
-	const inFlight = /* @__PURE__ */ new Set();
-	const core = createCore(config, token);
-	const logger = new Logger("Engine");
-	async function dispatchMatched(match, payload, ctx) {
-		const start = await dispatchInteraction({
-			match,
-			payload,
-			core
+	registerHmrAwareModules() {
+		this.startup.addTask(StartupPhase.Configuration, "hmr-registration", async () => {
+			if (this.interactions) this.hmrManager.register(this.interactions);
+			this.hmrManager.register(this.subscribers);
+			for (const plugin of this.plugins) this.hmrManager.register(plugin);
+			await Promise.resolve();
 		});
-		if (!start) return;
-		const work = start();
-		if (ctx) ctx.waitUntil(work);
-		else {
-			inFlight.add(work);
-			work.finally(() => inFlight.delete(work));
-		}
 	}
-	return async (request, ctx) => {
-		if (request.method !== "POST") return new Response(null, {
-			status: METHOD_NOT_ALLOWED,
-			headers: { allow: "POST" }
+	async listen() {
+		const token = validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
+		this.rest.setToken(token);
+		const maps = this.interactions?.maps ?? buildRouteMaps(EMPTY_MANIFEST);
+		const { handle, inFlight } = buildEngine(this, maps);
+		const server = createServer((incoming, outgoing) => {
+			(async () => {
+				await writeWebResponse(await handle(await toWebRequest(incoming)), outgoing);
+			})().catch((error) => {
+				outgoing.destroy(Error.isError(error) ? error : new Error(String(error)));
+			});
 		});
-		const signature = request.headers.get(SIGNATURE_HEADER);
-		const timestamp = request.headers.get(TIMESTAMP_HEADER);
-		if (signature === null || timestamp === null) return new Response(null, { status: UNAUTHORIZED });
-		const body = new Uint8Array(await request.arrayBuffer());
-		if (!await verifier.verify(signature, timestamp, body)) return new Response(null, { status: UNAUTHORIZED });
-		if (!replays.accepts(signature, timestamp)) return new Response(null, { status: UNAUTHORIZED });
-		let payload;
-		try {
-			payload = JSON.parse(decoder.decode(body));
-		} catch {
-			return new Response(null, { status: BAD_REQUEST });
-		}
-		if (!hasInteractionType(payload)) return new Response(null, { status: BAD_REQUEST });
-		if (payload.type === PING) return Response.json({ type: InteractionResponseType.Pong });
+		this.server = server;
+		server.listen(this.requestedPort);
+		await once(server, "listening");
+		this.boundPort = server.address().port;
+		this.logger.info(`Interactions server listening on port ${paint.sky.bold(String(this.boundPort))}`);
+		this.shutdown.addTask(ShutdownPhase.Unbind, "stop-http-server", () => this.stopServer(), SERVER_SHUTDOWN_TIMEOUT_MS);
+		this.shutdown.addTask(ShutdownPhase.Drain, "drain-inflight", async () => {
+			await Promise.allSettled(inFlight);
+		}, DRAIN_TIMEOUT_MS);
+	}
+	async fetchUsername() {
 		try {
-			const match = resolve(maps, payload);
-			if (match) await dispatchMatched(match, payload, ctx);
+			const me = await this.rest.get(Routes.user("@me"));
+			this.fetchedUsername = me.username;
 		} catch (caught) {
-			logger.error("dispatch failed, acking anyway", caught);
+			this.logger.warn("could not fetch the bot identity", caught);
 		}
-		return new Response(null, { status: ACCEPTED });
-	};
-}
-
-//#endregion
-//#region src/handlers/interaction/SlashHandler.ts
-/**
-* Base class for a chat-input (slash) command handler on the HTTP transport.
-*
-* Pass the route from the generated registry as the generic, then read `this.options` for a single
-* command or `this.match` for several. Command authoring stays plain discord.js, `seedcord codegen`
-* reads its `toJSON()` to type these options.
-*
-* @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
-*/
-var SlashHandler = class extends InteractionHandler {
-	resolver;
-	/**
-	* The typed options for this command's route. Required options drop the null, choices narrow to their
-	* literal union, and only the getters for kinds this command actually uses appear. Rich kinds resolve
-	* from the interaction's `resolved` data.
-	*/
-	get options() {
-		this.resolver ??= new HttpSlashOptions(this.event.data);
-		return this.resolver;
 	}
-	/**
-	* Run the arm for whichever command fired. Use this only when the handler is registered for several
-	* routes.
-	*
-	* Provide one arm per registered route, keyed by its route string, and each arm receives that route's
-	* own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
-	* key is a compile error.
-	*
-	* @param arms - One handler per registered route, keyed by route string.
-	* @returns The result of the arm that ran.
-	*/
-	async match(arms) {
-		const route = slashRouteOf(this.event.data);
-		const arm = Object.hasOwn(arms, route) ? arms[route] : void 0;
-		if (!arm) throw new SeedcordError(SeedcordErrorCode.SlashMatchArmMissing, [route]);
-		return await arm(this.options);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/ContextMenuHandler.ts
-/**
-* Base class for a context-menu command handler on the HTTP transport (right-click a user or a message).
-*
-* Pass the kind from {@link ApplicationCommandType} as the generic. Read the right-clicked entity from
-* `this.target`, an `APIUser` for a user menu and an `APIMessage` for a message menu. Context menus carry
-* no options, so a handler registered for several names reads `this.target` uniformly with no per-name
-* branch.
-*
-* @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
-*/
-var ContextMenuHandler = class extends InteractionHandler {
-	get target() {
-		const data = this.event.data;
-		return data.type === ApplicationCommandType.User ? data.resolved.users[data.target_id] : data.resolved.messages[data.target_id];
-	}
-	/**
-	* The right-clicked user's guild member, resolved only on user menus fired in a guild. Reading it on a
-	* message menu is a compile error.
-	*/
-	get targetMember() {
-		const data = this.event.data;
-		return data.type === ApplicationCommandType.User ? data.resolved.members?.[data.target_id] ?? null : null;
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/ComponentHandler.ts
-/**
-* Shared base the customId-routed component handlers extend on the HTTP transport.
-*
-* Not a public entry point. Extend {@link ButtonHandler}, {@link SelectMenuHandler}, or {@link ModalHandler}
-* instead. This class defines the customId decode, the route matching, and the source-message verbs
-* `update` and `deferUpdate`.
-*
-* @typeParam Event - The component or modal interaction type this handler processes
-* @typeParam Defs - The customId route definitions registered on the concrete handler
-*/
-var ComponentHandler = class extends InteractionHandler {
-	/** Rewrite the source message this component interaction came from. */
-	update(response) {
-		return this.sender.update(response);
-	}
-	/** Acknowledge the component without changing the source message. */
-	deferUpdate() {
-		return this.sender.deferUpdate();
-	}
-	decoded;
-	get route() {
-		this.decoded ??= decodeComponentRoute(this.constructor, this.event.data.custom_id);
-		return this.decoded;
-	}
-	/**
-	* The decoded params of the single route this handler is registered for.
-	*
-	* Reading this decodes `this.event.data.custom_id` once (cached after the first read) and throws
-	* `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
-	* dispatcher boundary turns into a reply. On a handler registered for several routes this is
-	* `never`, so use {@link match} instead.
-	*/
-	get params() {
-		return this.route.params;
-	}
-	/**
-	* Run the arm for whichever route the component was minted from. Use this only when the handler is
-	* registered for several routes. A single-route handler reads `this.params` directly. On a multi-route
-	* handler `this.params` is `never`, so match is the only way to read the decoded params.
-	*
-	* Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
-	* decoded params. The arms cover every registered route prefix, checked at compile time, and a prefix
-	* unmatched at runtime throws `CustomIdMatchArmMissing`. Decoding runs before any arm, so a stale or
-	* corrupt wire throws before an arm body executes.
-	*
-	* @param arms - One callback per registered route, keyed by prefix.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@ButtonRoute(Approve, Reject)
-	* class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
-	*     async execute() {
-	*         await this.match({
-	*             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
-	*             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		const { prefix, params } = this.route;
-		const arm = Object.hasOwn(arms, prefix) ? arms[prefix] : void 0;
-		if (!arm) throw new SeedcordError(SeedcordErrorCode.CustomIdMatchArmMissing, [prefix]);
-		return await arm(params);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/ButtonHandler.ts
-/**
-* Base class for a button interaction handler on the HTTP transport.
-*
-* Register the customId definitions this handler decodes with `@ButtonRoute`, list the same ones in the
-* generic, then read `this.params` for a single route or `this.match` for several. Reply through the
-* handler members, or rewrite the source message with `this.update`. Passing different definitions to the
-* decorator and the generic is a compile error.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ApproveId]`.
-*/
-var ButtonHandler = class extends ComponentHandler {};
-
-//#endregion
-//#region src/handlers/interaction/components/SelectMenuHandler.ts
-/**
-* Base class for a select menu handler on the HTTP transport.
-*
-* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
-* so `this.event.data` and its `values`/`resolved` are narrowed to that kind. Read `this.params` for a
-* single route or `this.match` for several, and reply through the handler members or rewrite the source
-* message with `this.update`.
-*
-* @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
-*/
-var SelectMenuHandler = class extends ComponentHandler {};
-
-//#endregion
-//#region src/handlers/interaction/components/ModalHandler.ts
-/**
-* Base class for a modal submit handler on the HTTP transport.
-*
-* Register the customId definitions this handler decodes with `@ModalRoute` and list the same ones in the
-* generic. Read the submitted inputs off `this.event.data.components`. Reply through the handler members.
-* Discord forbids opening a modal in response to a modal, so `showModal` fails compilation on this kind.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
-*/
-var ModalHandler = class extends ComponentHandler {
-	/** Rewrite the message this modal was opened from (only when a component opened it). */
-	update(response) {
-		this.ensureSourceMessage("update");
-		return super.update(response);
-	}
-	/** Silently acknowledge, leaving the source message untouched. */
-	deferUpdate() {
-		this.ensureSourceMessage("deferUpdate");
-		return super.deferUpdate();
-	}
-	ensureSourceMessage(method) {
-		if (this.event.message) return;
-		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
+	stopServer() {
+		const server = this.server;
+		if (!server?.listening) return Promise.resolve();
+		return new Promise((resolveClose, rejectClose) => {
+			server.close((err) => {
+				if (err) {
+					rejectClose(err);
+					return;
+				}
+				this.logger.info(paint.coral.bold("Interactions server stopped"));
+				resolveClose();
+			});
+			server.closeIdleConnections();
+		});
 	}
 };
 
 //#endregion
-//#region src/gates/Gated.ts
+//#region src/plugin.ts
 /**
-* Attaches gates to an HTTP interaction handler. The gates run before `execute`, and a gate refusing stops
-* the handler with the reply or drop the gate threw. Multiple gates are ANDed, so each must pass. A gate
-* that requires a context the handler does not provide (a button gate on a slash handler, a gate on an
-* autocomplete handler, or a `RequirePermissions([...], { in: 'guild' })` gate the http transport cannot
-* satisfy) is a compile error at this line, and the error names the gate and the handler kind. Place it
-* above the route decorator.
-*
-* Combine gates with {@link and} or {@link or} to build a single gate from multiple arms.
+* Base class for an HTTP plugin, binding `this.core` to the HTTP {@link Core}.
 *
-* @example
-* ```ts
-* import { PermissionFlagsBits } from 'discord-api-types/v10';
+* A plugin that runs on either transport extends the base from `@seedcord/core/plugin`, whose
+* `this.core` carries the shared members only.
 *
-* \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.ManageMessages]))
-* \@SlashRoute('purge')
-* class Purge extends SlashHandler<'purge'> {
-*     async execute() {
-*         // both gates passed, so this runs in a guild with a caller who can moderate this channel
-*     }
-* }
-* ```
-*
-* @typeParam Gates - The non-empty tuple of gates to run, in order, against the handler's context.
-* @typeParam TCtor - The decorated handler's constructor, checked against every gate's required context.
-* @param gates - One or more gates to attach, each ANDed so the handler runs only when all pass.
-* @param ctor - The handler class being decorated, rejected at compile time when a gate requires a context it lacks.
-*
-* @see {@link defineGate}
-* @see {@link defineEffectGate}
-* @decorator
+* @typeParam Opts - The transport, runtime, and capabilities the plugin declares.
 */
-function Gated(...gates) {
-	return function(ctor) {
-		const existing = Reflect.getMetadata(GatedMetadataKey, ctor) ?? [];
-		Reflect.defineMetadata(GatedMetadataKey, [...existing, ...gates], ctor);
-	};
-}
+var Plugin = class extends Plugin$1 {};
 
 //#endregion
 //#region src/index.ts
-/** Package version */
-const version = "0.1.0-next.0";
+var src_exports = /* @__PURE__ */ __exportAll({
+	AutocompleteHandler: () => AutocompleteHandler,
+	ButtonHandler: () => ButtonHandler,
+	ComponentHandler: () => ComponentHandler,
+	ContextMenuHandler: () => ContextMenuHandler,
+	Gated: () => Gated,
+	InteractionHandler: () => InteractionHandler,
+	ModalHandler: () => ModalHandler,
+	Plugin: () => Plugin,
+	RepliableHandler: () => RepliableHandler,
+	Seedcord: () => Seedcord,
+	SelectMenuHandler: () => SelectMenuHandler,
+	SlashHandler: () => SlashHandler,
+	Subscriber: () => Subscriber,
+	WebhookLog: () => WebhookLog,
+	createSeedcord: () => createSeedcord,
+	version: () => version
+});
 
 //#endregion
-export { AutocompleteHandler, ButtonHandler, ComponentHandler, ContextMenuHandler, Gated, InteractionHandler, ModalHandler, RepliableHandler, SelectMenuHandler, SlashHandler, createSeedcord, version };
+export { AutocompleteHandler, ButtonHandler, ComponentHandler, ContextMenuHandler, Gated, InteractionHandler, ModalHandler, Plugin, RepliableHandler, Seedcord, SelectMenuHandler, SlashHandler, Subscriber, WebhookLog, createSeedcord, version };
 //# sourceMappingURL=index.mjs.map