@seedcord/core 0.9.4 → 0.11.0-next.0

package/dist/internal.index.mjs

@@ -1,15 +1,83 @@
-import { A as translateSerializationError, B as contextMenuRouteOf, C as NotInDm, E as OnCooldown, F as checkAckLegality, G as decodeComponentRoute, H as storeComponentRoute, I as sendTarget, K as NoticeCard, N as reportedWrite, P as AckTrace, R as interactionMiddlewareMetaOf, S as NotAllowed, T as NotOwner, U as storeInteractionRoute, V as interactionRoutesOf, W as ComponentDefsKey, _ as GateNotice, b as MissingRole, d as pickNotice, f as discardCommits, g as runCommits, h as runCheck, k as serializeReply, n as pageCursor, q as Notice, r as Silence, s as PermissionNames, t as PAGE_MAX, v as HasDangerousPermissions, w as NotInGuild, x as NeedsAny, y as MissingPermissions, z as areRoutes } from "./cursor-CgNBnJfu.mjs";
-import { C as InteractionRouteKeys, D as clearStore, E as accessorStore, N as bindBotColor, O as guardedAccessor, S as InteractionMiddlewareMetadataKey, T as WebhookUrlMetadataKey, _ as EventMetadataKey, a as RegisterSubscriber, c as VerifyWebhooks, g as CommandMetadataKey, h as sendFlags, i as RegisterDefaults, k as contextMenuLeaves, m as deferFlags, n as busLoggerOf, o as RegisteredCount, p as ReportThrottle, r as registrationFor, s as UnregisterSubscriber, v as EventMiddlewareMetadataKey, w as SubscribeMetadataKey, x as InteractionMetadataKey, y as GatedMetadataKey } from "./Bus-BxPa-Uvp.mjs";
-import { n as asError, t as PublishDefault } from "./publishDefault-BuSZPbjT.mjs";
-import { n as setDevChannel, t as getDevChannel } from "./devChannel-CQU7hq7Q.mjs";
-import { n as isCommandClass, t as slashRouteLeaves } from "./slashRouteLeaves-k1hJnXDO.mjs";
+import { At as guardedAccessor, B as NotInGuild, Bt as isBuilderComponentClass, C as PermissionNames, Ct as warnLinks, D as pickNotice, Dt as linkCommands, Et as indexById, F as MissingPermissions, Ft as skippedNote, G as serializeReply, H as OnCooldown, Ht as Notice, I as MissingRole, It as contextMenuLeaves, K as translateSerializationError, L as NeedsAny, Lt as NoticeCard, M as runCommits, Mt as commandsRoute, N as GateNotice, Nt as globalFirst, O as discardCommits, Ot as accessorStore, P as HasDangerousPermissions, Pt as scopeIdsOf, Q as sendTarget, R as NotAllowed, St as installLinks, Tt as commandRefOf, V as NotOwner, Vt as bindBotColor, X as AckTrace, Y as reportedWrite, Z as checkAckLegality, _ as pageCursor, _t as SubscribeMetadataKey, a as RegisterSubscriber, at as ComponentDefsKey, c as VerifyWebhooks, dt as EventMiddlewareMetadataKey, et as interactionMiddlewareMetaOf, f as Subscriber, ft as GatedMetadataKey, g as PAGE_MAX, gt as InteractionRouteKeys, h as sendFlags, ht as InteractionMiddlewareMetadataKey, i as RegisterDefaults, it as storeInteractionRoute, j as runCheck, jt as GLOBAL_ID, kt as clearStore, lt as CommandMetadataKey, m as deferFlags, mt as InteractionMetadataKey, n as busLoggerOf, nt as interactionRoutesOf, o as RegisteredCount, ot as decodeComponentRoute, p as ReportThrottle, r as registrationFor, rt as storeComponentRoute, s as UnregisterSubscriber, st as ConfigGuilds, tt as contextMenuRouteOf, ut as EventMetadataKey, v as ResolvedEmoji, vt as WebhookUrlMetadataKey, wt as commandKey, y as Silence, yt as CommandInjector, z as NotInDm } from "./subscribers-Ce3SWy23.mjs";
+import { t as PublishDefault } from "./publishDefault-D3dAyzZ9.mjs";
+import { c as setDevChannel, i as FixedScope, n as attachmentsOf, r as sealAttachments, s as getDevChannel } from "./PluginHost-B8kxLOeb.mjs";
+import { t as HmrModuleHandler } from "./HmrModuleHandler-8ZC-UuZh.mjs";
+import { i as logUnknownFault, t as PluginLifecycle } from "./PluginLifecycle-AhQ46NIr.mjs";
+import { t as CoordinatedStartup } from "./CoordinatedStartup-CGnJrqcl.mjs";
 import "reflect-metadata";
+import { SlashCommandBuilder } from "@discordjs/builders";
+import { Routes } from "discord-api-types/v10";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
-import { SeedcordError } from "@seedcord/errors/internal";
-import { Logger } from "@seedcord/logger";
-import { timestampFromSnowflake } from "@seedcord/utils";
+import { SeedcordError, SeedcordTypeError, throwSingleOrAggregate, validateDiscordToken } from "@seedcord/errors/internal";
+import { LEVEL_COLOR, Logger, LoggerChannelRegistry } from "@seedcord/logger";
+import { asError, botFolder, isPlainObject, pluralize, routeLeavesOf, unlessAborted } from "@seedcord/utils/internal";
+import { filterCirculars, formatFilePath, importFiles, timestampFromSnowflake } from "@seedcord/utils";
 import { Envapter } from "envapt";
+import { DiscordAPIError, HTTPError, RESTEvents } from "@discordjs/rest";
+import { format } from "node:util";
+import { CONSOLE_LEVEL, consoleRecord, routeConsole, traceError } from "@seedcord/logger/internal";
 
+//#region src/subscribers/SubscriberLoader.ts
+var SubscriberLoader = class {
+	bus;
+	directory;
+	isInitialized = false;
+	hmrHandler;
+	constructor(bus, directory) {
+		this.bus = bus;
+		this.directory = directory;
+		if (!this.directory) return;
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir: this.directory,
+			isHandler: this.isSubscriber.bind(this),
+			registerHandler: this.registerSubscriber.bind(this),
+			unregisterHandler: this.unregisterSubscriber.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: busLoggerOf(this.bus)
+		});
+	}
+	/** @internal */
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		this.bus[RegisterDefaults]();
+		const { directory } = this;
+		if (directory) {
+			busLoggerOf(this.bus).debug(paint.mute(directory));
+			await this.load(directory);
+			busLoggerOf(this.bus).utils.list([`${paint.iris.bold(this.bus[RegisteredCount])} subscribers`], paint.mint.bold("Loaded"), "debug");
+		}
+		if (!Envapter.isTest) await this.bus[VerifyWebhooks]();
+	}
+	/** @internal */
+	async onHmr(event) {
+		if (this.hmrHandler) await this.hmrHandler.handle(event);
+	}
+	async load(dir) {
+		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const value of Object.values(imported)) {
+			if (!this.isSubscriber(value)) continue;
+			this.registerSubscriber(value);
+			this.hmrHandler?.trackHandler(fullPath, value);
+			busLoggerOf(this.bus).utils.registration(value.name, relativePath, void 0, "trace");
+		}
+	}
+	registerSubscriber(ctor) {
+		this.bus[RegisterSubscriber](registrationFor(ctor));
+	}
+	unregisterSubscriber(ctor, artifacts) {
+		this.bus[UnregisterSubscriber](ctor, artifacts);
+	}
+	getArtifacts(ctor) {
+		return [Reflect.getMetadata(SubscribeMetadataKey, ctor).subscriber];
+	}
+	isSubscriber(value) {
+		if (typeof value !== "function") return false;
+		return value.prototype instanceof Subscriber && Reflect.hasMetadata(SubscribeMetadataKey, value);
+	}
+};
+
+//#endregion
 //#region src/decorators/brands.ts
 const SlashRouteBrand = Symbol("seedcord:brand:slash-route");
 const AutocompleteRouteBrand = Symbol("seedcord:brand:autocomplete-route");
@@ -49,14 +117,11 @@ var MiddlewareRegistry = class {
 	/**
 	* Adds a decorated middleware class and returns what it registered with. Returns `undefined` for an
 	* undecorated class or one already registered.
-	*
-	* @throws A **SeedcordError** If another class with the same name is registered.
 	*/
 	register(ctor) {
 		const registration = this.registrationOf(ctor);
 		if (!registration) return void 0;
 		if (this.entries.some((entry) => entry.ctor === ctor)) return void 0;
-		if (this.entries.some((entry) => entry.ctor.name === ctor.name)) throw new SeedcordError(SeedcordErrorCode.DuplicateMiddleware, [ctor.name]);
 		this.entries.push({
 			ctor,
 			priority: registration.priority,
@@ -143,31 +208,534 @@ function isEmojiTuple(value) {
 	return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "string";
 }
 
+//#endregion
+//#region src/miscellaneous/currentApplication.ts
+async function currentApplication(rest) {
+	return await rest.get(Routes.currentApplication());
+}
+
+//#endregion
+//#region src/miscellaneous/readBotToken.ts
+function readBotToken() {
+	return validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
+}
+
+//#endregion
+//#region src/miscellaneous/resolveEmojis.ts
+function byName(list) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of list) if (entry.name) map.set(entry.name, entry);
+	return map;
+}
+var EmojiResolver = class {
+	rest;
+	applicationId;
+	resolved = accessorStore();
+	problems = [];
+	guilds = /* @__PURE__ */ new Map();
+	application;
+	constructor(rest, applicationId) {
+		this.rest = rest;
+		this.applicationId = applicationId;
+	}
+	async resolve(configured) {
+		for (const [key, value] of Object.entries(configured)) if (isEmojiTuple(value)) await this.fromGuild(key, value);
+		else if (typeof value === "string") await this.fromApplication(key, value);
+		else this.problems.push(new SeedcordTypeError(SeedcordErrorCode.ConfigEmojiInvalid, [key]));
+		throwSingleOrAggregate(this.problems, SeedcordErrorCode.ConfigEmojiUnresolved);
+		return this.resolved;
+	}
+	async fromApplication(key, name) {
+		this.application ??= await this.applicationEmojis();
+		if (Error.isError(this.application)) {
+			this.unreadable(key, name, "the application", this.application, `Check that ${paint.bold("DISCORD_BOT_TOKEN")} is still valid.`);
+			return;
+		}
+		this.pick(key, name, this.application, "the application");
+	}
+	async applicationEmojis() {
+		try {
+			return byName((await this.rest.get(Routes.applicationEmojis(this.applicationId))).items);
+		} catch (error) {
+			return asError(error);
+		}
+	}
+	async fromGuild(key, [name, guildId]) {
+		let guild = this.guilds.get(guildId);
+		if (!guild) {
+			guild = await this.guildEmojis(guildId);
+			this.guilds.set(guildId, guild);
+		}
+		if (Error.isError(guild)) {
+			this.unreadable(key, name, `guild ${guildId}`, guild, "Check that the bot is in that guild.");
+			return;
+		}
+		this.pick(key, name, guild, `guild ${guildId}`);
+	}
+	async guildEmojis(guildId) {
+		try {
+			return byName(await this.rest.get(Routes.guildEmojis(guildId)));
+		} catch (error) {
+			return asError(error);
+		}
+	}
+	pick(key, name, source, where) {
+		const found = source.get(name);
+		if (!found?.id) {
+			this.problems.push(new SeedcordError(SeedcordErrorCode.ConfigEmojiNotFound, [
+				key,
+				name,
+				where
+			]));
+			return;
+		}
+		this.resolved[key] = new ResolvedEmoji(name, found.id, found.animated ?? false);
+	}
+	unreadable(key, name, where, cause, fix) {
+		this.problems.push(new SeedcordError(SeedcordErrorCode.ConfigEmojiSourceUnreadable, [
+			key,
+			name,
+			where,
+			cause.message,
+			fix
+		], { cause }));
+	}
+};
+function resolveEmojis(rest, applicationId, configured) {
+	return new EmojiResolver(rest, applicationId).resolve(configured);
+}
+
+//#endregion
+//#region src/bakedIds.ts
+const BAKED_IDS_KEY = "seedcord:core:baked-ids";
+
+//#endregion
+//#region src/commands/guildSummaries.ts
+async function guildName(rest, guildId) {
+	try {
+		return (await rest.get(Routes.guild(guildId))).name;
+	} catch {
+		return guildId;
+	}
+}
+function guildSummaries(rest, guildIds, knownNames = /* @__PURE__ */ new Map()) {
+	return Promise.all(Iterator.from(guildIds).map(async (id) => ({
+		id,
+		name: knownNames.get(id) ?? await guildName(rest, id)
+	})));
+}
+
+//#endregion
+//#region src/commands/DeployReporter.ts
+var DeployReporter = class {
+	logger;
+	guildNames = /* @__PURE__ */ new Map();
+	constructor(logger) {
+		this.logger = logger;
+	}
+	async readGuildNames(rest, scopes, signal) {
+		if (!getDevChannel()) return;
+		const unread = scopes.filter((scope) => scope !== "global" && !this.guildNames.has(scope));
+		for (const { id, name } of await unlessAborted(guildSummaries(rest, unread), signal)) this.guildNames.set(id, name);
+	}
+	skipped(scopes) {
+		if (scopes.length > 0) this.logger.info(skippedNote(scopes, (guildId) => this.guildLabel(guildId)));
+	}
+	deployed(scope, commands) {
+		const { utils } = this.logger;
+		const count = paint.iris.bold(commands.length);
+		const tag = pluralize(commands.length, "command");
+		const title = scope === "global" ? `Deployed ${count} global ${tag}` : `Deployed ${count} ${tag} to ${this.guildLabel(scope)}`;
+		utils.block(title, utils.wrap(commands.map((command) => command.name)), "info");
+	}
+	guildLabel(guildId) {
+		return paint.sky.bold(this.guildNames.get(guildId) ?? guildId);
+	}
+};
+
+//#endregion
+//#region src/commands/deployTarget.ts
+function resolveDeployTarget(meta, configured, commandName) {
+	if (meta.scope === "global") return { scope: "global" };
+	if (meta.scope === "config") return configured.length > 0 ? guildTarget(configured) : { scope: "global" };
+	if (configured.length === 0 && meta.guilds.includes("config")) throw new SeedcordTypeError(SeedcordErrorCode.CoreCommandGuildsEmpty, [commandName]);
+	return guildTarget(meta.guilds.flatMap((target) => target === "config" ? configured : target));
+}
+function guildTarget(guilds) {
+	return {
+		scope: "guild",
+		guilds: [...new Set(guilds)]
+	};
+}
+
+//#endregion
+//#region src/commands/isCommandClass.ts
+/** @internal */
+function isCommandClass(value) {
+	return isBuilderComponentClass(value) && Reflect.hasMetadata(CommandMetadataKey, value);
+}
+
+//#endregion
+//#region src/commands/LastDeploy.ts
+const ANSWER_TIMEOUT_MS = 5e3;
+var LastDeploy = class {
+	saved;
+	read(applicationId, signal) {
+		this.saved ??= askSeedcordDev(applicationId);
+		return unlessAborted(this.saved, signal);
+	}
+	save(deployed) {
+		this.saved = Promise.resolve(deployed);
+		getDevChannel()?.send("seedcord:commands-deployed", deployed);
+	}
+};
+function askSeedcordDev(applicationId) {
+	const cli = getDevChannel();
+	if (!cli) return Promise.resolve(void 0);
+	const { promise, resolve } = Promise.withResolvers();
+	const settle = (deployed) => {
+		clearTimeout(timer);
+		cli.off("seedcord:last-deploy", onAnswer);
+		resolve(deployed);
+	};
+	const onAnswer = ({ deployed }) => settle(deployed);
+	const timer = setTimeout(() => settle(void 0), ANSWER_TIMEOUT_MS);
+	cli.on("seedcord:last-deploy", onAnswer);
+	cli.send("seedcord:read-deployed", { applicationId });
+	return promise;
+}
+
+//#endregion
+//#region src/commands/planDeploy.ts
+const HEX = 16;
+function byCodePoint(a, b) {
+	return a < b ? -1 : Number(a > b);
+}
+async function hashOf(commands) {
+	const sorted = commands.toSorted((a, b) => byCodePoint(commandKey(a), commandKey(b)));
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(sorted)));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(HEX).padStart(2, "0")).join("");
+}
+async function scopeHashes(scopes) {
+	const hashed = [...scopes].map(async ([scope, commands]) => [scope, await hashOf(commands)]);
+	return Object.fromEntries(await Promise.all(hashed));
+}
+function sameCommandNames(inCode, deployed) {
+	const onDiscord = new Set(deployed?.values().map(commandKey));
+	return new Set(inCode.map(commandKey)).symmetricDifference(onDiscord).size === 0;
+}
+async function planDeploy(scopes, last, readUnchanged) {
+	const hashes = await scopeHashes(scopes);
+	const unchanged = globalFirst(scopes).filter(([scope]) => hashes[scope] === last?.[scope]);
+	const onDiscord = await readUnchanged(unchanged.map(([scope]) => scope));
+	const skipped = new Set(unchanged.filter(([scope, commands]) => sameCommandNames(commands, onDiscord.get(scope))).map(([scope]) => scope));
+	return {
+		hashes,
+		skippedHashes: Object.fromEntries(Object.entries(hashes).filter(([scope]) => skipped.has(scope))),
+		toPut: new Map(scopes.entries().filter(([scope]) => !skipped.has(scope))),
+		skipped: [...skipped],
+		onDiscord
+	};
+}
+
+//#endregion
+//#region src/commands/putCommands.ts
+const MS_PER_SECOND = 1e3;
+async function putCommands(scopes, options) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [scope, commands] of globalFirst(scopes)) {
+		result.set(scope, indexById(await putScope(scope, commands, options)));
+		options.onDeployed?.(scope, commands);
+	}
+	return result;
+}
+async function putScope(scope, commands, options) {
+	try {
+		return await put(commandsRoute(options.applicationId, scope), commands, options);
+	} catch (error) {
+		if (options.signal?.aborted) throw error;
+		const refusal = [asError(error).message, statusOf(error)];
+		throw scope === "global" ? new SeedcordError(SeedcordErrorCode.CoreCommandGlobalDeployFailed, refusal, { cause: error }) : new SeedcordError(SeedcordErrorCode.CoreCommandGuildDeployFailed, [scope, ...refusal], { cause: error });
+	}
+}
+function statusOf(error) {
+	return error instanceof DiscordAPIError || error instanceof HTTPError ? error.status : void 0;
+}
+async function put(route, body, { rest, logger, signal }) {
+	const reportWait = (info) => {
+		if (info.method !== "PUT" || !info.url.endsWith(route)) return;
+		const seconds = Math.ceil(info.timeToReset / MS_PER_SECOND);
+		logger.warn(`Discord rate-limited the command deploy. It continues in ${paint.amber(`${seconds}s`)}.`);
+	};
+	rest.on(RESTEvents.RateLimited, reportWait);
+	try {
+		return await unlessAborted(rest.put(route, {
+			body,
+			signal
+		}), signal);
+	} finally {
+		rest.off(RESTEvents.RateLimited, reportWait);
+	}
+}
+
+//#endregion
+//#region src/commands/readCommands.ts
+async function readCommandsAt(scope, { rest, applicationId, signal }) {
+	const route = commandsRoute(applicationId, scope);
+	try {
+		return indexById(await rest.get(route, { signal }));
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		const reason = asError(error).message;
+		throw new SeedcordError(SeedcordErrorCode.CoreDiscordReadFailed, scope === "global" ? ["the commands deployed globally", reason] : [
+			`the commands deployed to guild ${paint.sky(scope)}`,
+			reason,
+			`Check that ${paint.bold("DISCORD_BOT_TOKEN")} is still valid and that the bot is in that guild.`
+		], { cause: error });
+	}
+}
+async function readCommands(scopes, options) {
+	const read = Iterator.from(scopes).map(async (scope) => [scope, await readCommandsAt(scope, options)]);
+	return new Map(await Promise.all(read));
+}
+
+//#endregion
+//#region src/commands/slashRouteLeaves.ts
+/**
+* dedupes route keys since the same builder appears once per guild.
+* these come from the same {@link routeLeavesOf} that `seedcord codegen` reads, so the boot-time
+* check compares against the generated registry's keys.
+*
+* @internal
+*/
+function slashRouteLeaves(commands) {
+	const leaves = /* @__PURE__ */ new Set();
+	for (const command of commands) {
+		if (!(command instanceof SlashCommandBuilder)) continue;
+		for (const leaf of routeLeavesOf(command.toJSON())) leaves.add(leaf.route);
+	}
+	return leaves;
+}
+
+//#endregion
+//#region src/commands/CommandRegistry.ts
+const COMMAND_DEPLOY_TIMEOUT_MS = 75e3;
+/**
+* Scans the command directory, builds each command, and PUTs the global and guild scopes to Discord.
+*
+* @internal
+*/
+var CommandRegistry = class {
+	core;
+	logger = new Logger("Commands", { channel: "commands" });
+	isInitialised = false;
+	scopedCommands = /* @__PURE__ */ new Map();
+	ctorToCommand = /* @__PURE__ */ new Map();
+	loading = false;
+	loadedCommands = [];
+	hmrHandler;
+	pendingEvents = /* @__PURE__ */ new Map();
+	injector = new CommandInjector();
+	lastDeploy = new LastDeploy();
+	reporter = new DeployReporter(this.logger);
+	dir;
+	configuredGuilds;
+	constructor(core) {
+		this.core = core;
+		const { commands } = core.config.bot;
+		if (!commands.path) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
+		this.dir = commands.path;
+		this.configuredGuilds = commands.guilds ?? [];
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir: this.dir,
+			isHandler: isCommandClass,
+			registerHandler: this.registerCommand.bind(this),
+			unregisterHandler: this.unregisterCommand.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: this.logger
+		});
+	}
+	getArtifacts(ctor) {
+		return this.ctorToCommand.get(ctor);
+	}
+	/** @internal */
+	async init() {
+		if (this.isInitialised) return;
+		this.isInitialised = true;
+		this.loading = true;
+		this.loadedCommands.length = 0;
+		try {
+			await this.loadCommands(this.dir);
+		} finally {
+			this.loading = false;
+		}
+		this.reportLoad();
+		getDevChannel()?.on("seedcord:refresh-commands", (data) => {
+			this.refresh(data.shouldRefresh);
+		});
+	}
+	reportLoad() {
+		const { utils } = this.logger;
+		utils.summary("Loaded commands", {
+			global: this.scopedCommands.get("global")?.length ?? 0,
+			"guild groups": [...this.scopedCommands.keys()].filter((scope) => scope !== GLOBAL_ID).length
+		}, "debug");
+		let slash = 0;
+		let menu = 0;
+		for (const command of this.loadedCommands) if (command.kind === "slash command") slash++;
+		else menu++;
+		utils.block("Loaded commands", [...utils.entries(this.loadedCommands), ...utils.counts({
+			"slash commands": slash,
+			"context menus": menu
+		})], "debug");
+	}
+	/** @internal */
+	async refresh(shouldRefresh = true) {
+		if (!shouldRefresh) {
+			this.logger.debug(paint.italic("Command refresh cancelled."));
+			this.pendingEvents.clear();
+			return;
+		}
+		this.logger.debug(paint.italic("Refreshing commands..."));
+		for (const event of this.pendingEvents.values()) await this.hmrHandler?.handle(event);
+		this.pendingEvents.clear();
+		await this.setCommands();
+	}
+	/** @internal */
+	async onHmr(event) {
+		if (botFolder(this.dir).holds(event.file)) {
+			this.pendingEvents.delete(event.file);
+			this.pendingEvents.set(event.file, event);
+			getDevChannel()?.send("seedcord:commands-update-prompt", { files: [...this.pendingEvents.keys()].map((f) => formatFilePath(f)) });
+		} else await this.hmrHandler?.handle(event);
+	}
+	async loadCommands(dir) {
+		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const exported of Object.values(imported)) {
+			if (!isCommandClass(exported)) continue;
+			this.registerCommand(exported, relativePath);
+			this.hmrHandler?.trackHandler(fullPath, exported);
+		}
+	}
+	registerCommand(Ctor, rel) {
+		const meta = Reflect.getMetadata(CommandMetadataKey, Ctor);
+		if (!meta) return;
+		const comp = new Ctor().component;
+		const kind = comp instanceof SlashCommandBuilder ? "slash command" : "context menu";
+		const target = resolveDeployTarget(meta, this.configuredGuilds, Ctor.name);
+		for (const scope of scopeIdsOf(target)) {
+			const inScope = this.scopedCommands.get(scope);
+			if (inScope) inScope.push(comp);
+			else this.scopedCommands.set(scope, [comp]);
+		}
+		this.ctorToCommand.set(Ctor, {
+			name: comp.name,
+			...target
+		});
+		if (this.loading) this.loadedCommands.push({
+			name: comp.name,
+			from: formatFilePath(rel),
+			kind
+		});
+	}
+	unregisterCommand(ctor, artifacts) {
+		const info = artifacts ?? this.ctorToCommand.get(ctor);
+		if (!info) return;
+		for (const scope of scopeIdsOf(info)) {
+			const inScope = this.scopedCommands.get(scope) ?? [];
+			const idx = inScope.findIndex((c) => c.name === info.name);
+			if (idx !== -1) inScope.splice(idx, 1);
+		}
+		this.ctorToCommand.delete(ctor);
+	}
+	/** @internal */
+	async deploy(signal, { routes, check }) {
+		await this.init();
+		check?.(this.allCommands());
+		await this.setCommands(signal);
+		routes?.warnUnhandledRoutes(this.routeLeaves());
+		routes?.warnUnhandledContextMenuRoutes(this.contextMenuLeaves());
+	}
+	/** @internal */
+	async setCommands(signal) {
+		const { rest, applicationId } = this.core;
+		const last = await this.lastDeploy.read(applicationId, signal);
+		const plan = await planDeploy(this.commandBodies(), last?.scopes, (unchanged) => readCommands(unchanged, {
+			rest,
+			applicationId,
+			signal
+		}));
+		await this.reporter.readGuildNames(rest, [...plan.toPut.keys(), ...plan.skipped], signal);
+		if (plan.toPut.size > 0) this.lastDeploy.save({
+			applicationId,
+			scopes: plan.skippedHashes
+		});
+		const put = await putCommands(plan.toPut, {
+			rest,
+			applicationId,
+			logger: this.logger,
+			signal,
+			onDeployed: (scope, commands) => this.reporter.deployed(scope, commands)
+		});
+		this.reporter.skipped(plan.skipped);
+		const result = new Map([...plan.onDiscord, ...put]);
+		this.lastDeploy.save({
+			applicationId,
+			scopes: plan.hashes
+		});
+		this.injector.inject(result, this.allCommands());
+		this.core.bus[PublishDefault]("commandsDeployed", deployedPayload(result));
+		return result;
+	}
+	commandBodies() {
+		const deployable = this.scopedCommands.entries().filter(([scope, commands]) => scope !== "global" || commands.length > 0);
+		return new Map(deployable.map(([scope, commands]) => [scope, commands.map((c) => c.toJSON())]));
+	}
+	allCommands() {
+		return [...this.scopedCommands.values()].flat();
+	}
+	routeLeaves() {
+		return slashRouteLeaves(this.allCommands());
+	}
+	contextMenuLeaves() {
+		return contextMenuLeaves(this.allCommands().map((command) => command.toJSON()));
+	}
+};
+function deployedPayload(result) {
+	const guilds = {};
+	for (const [scope, deployed] of result) if (scope !== "global") guilds[scope] = [...deployed.values()];
+	return {
+		global: [...result.get("global")?.values() ?? []],
+		guilds
+	};
+}
+
 //#endregion
 //#region src/hmr/wrapHot.ts
 /** @internal */
 function wrapHot(hot) {
 	return {
 		send: (event, data) => hot.send(event, data),
-		on: (event, cb) => hot.on(event, cb)
+		on: (event, cb) => hot.on(event, cb),
+		off: (event, cb) => hot.off(event, cb)
 	};
 }
 
 //#endregion
 //#region src/hmr/HmrManager.ts
+function connectDevChannel() {
+	if (import.meta.hot) setDevChannel(wrapHot(import.meta.hot));
+	return getDevChannel();
+}
 var HmrManager = class {
 	logger = new Logger("HMR", { channel: "hmr" });
 	listeners = /* @__PURE__ */ new Set();
-	/** @internal */
-	init() {
-		if (!import.meta.hot) return;
-		const channel = wrapHot(import.meta.hot);
-		setDevChannel(channel);
+	init(channel) {
+		if (!channel) return;
 		if (!(Envapter.isDevelopment || Envapter.isTest)) return;
 		this.logger.debug("Enabled");
 		channel.on("seedcord:hmr", (payload) => void this.handleUpdate(payload));
 	}
-	/** @internal */
 	register(listener) {
 		this.listeners.add(listener);
 	}
@@ -183,6 +751,132 @@ var HmrManager = class {
 	}
 };
 
+//#endregion
+//#region src/hmr/wire.ts
+function toWireError(thrown) {
+	return encodeError(thrown, /* @__PURE__ */ new Set());
+}
+function encodeError(thrown, sent) {
+	if (!Error.isError(thrown)) return {
+		name: "Error",
+		message: String(thrown)
+	};
+	sent.add(thrown);
+	const unsent = (value) => !Error.isError(value) || !sent.has(value);
+	const { cause } = thrown;
+	return {
+		name: thrown.name,
+		message: thrown.message,
+		stack: thrown.stack,
+		code: Reflect.get(thrown, "code"),
+		cause: cause !== void 0 && unsent(cause) ? encodeError(cause, sent) : void 0,
+		errors: thrown instanceof AggregateError ? thrown.errors.filter(unsent).map((member) => encodeError(member, sent)) : void 0
+	};
+}
+function fromWireError({ name, message, stack, code, cause, errors }) {
+	const options = cause && { cause: fromWireError(cause) };
+	const error = errors ? new AggregateError(errors.map(fromWireError), message, options) : new Error(message, options);
+	error.name = name;
+	if (stack !== void 0) error.stack = stack;
+	if (code !== void 0) Reflect.set(error, "code", code);
+	return error;
+}
+function functionText(fn) {
+	const parent = Object.getPrototypeOf(fn);
+	if (Function.prototype.toString.call(fn).startsWith("class")) {
+		const extended = typeof parent === "function" && parent.name ? ` extends ${parent.name}` : "";
+		return `[class ${fn.name || "(anonymous)"}${extended}]`;
+	}
+	const kind = parent === null ? "Function (null prototype)" : fn.constructor.name;
+	return fn.name ? `[${kind}: ${fn.name}]` : `[${kind} (anonymous)]`;
+}
+function toWireArg(arg) {
+	if (Error.isError(arg)) return { error: toWireError(arg) };
+	switch (typeof arg) {
+		case "undefined":
+		case "symbol": return { value: String(arg) };
+		case "bigint": return { value: `${arg}n` };
+		case "function": return { value: functionText(arg) };
+		default: return { value: filterCirculars(arg, { mode: "json" }) };
+	}
+}
+function fromWireArg(arg) {
+	return "error" in arg ? fromWireError(arg.error) : arg.value;
+}
+function toWireLog({ args, ...record }) {
+	return {
+		...record,
+		args: args?.map(toWireArg)
+	};
+}
+function fromWireLog({ args, ...record }) {
+	return args ? {
+		...record,
+		args: args.map(fromWireArg)
+	} : record;
+}
+const DEV_LOG_MARKER = "seedcord:log ";
+function toDevLogLine(record) {
+	return `${DEV_LOG_MARKER}${JSON.stringify(toWireLog(record))}`;
+}
+function isLogLevel(value) {
+	return typeof value === "string" && Object.hasOwn(LEVEL_COLOR, value);
+}
+function isWireError(value) {
+	return isPlainObject(value) && typeof value.name === "string" && typeof value.message === "string" && (value.stack === void 0 || typeof value.stack === "string") && (value.cause === void 0 || isWireError(value.cause)) && (value.errors === void 0 || Array.isArray(value.errors) && value.errors.every(isWireError));
+}
+function isWireArg(value) {
+	if (!isPlainObject(value)) return false;
+	return "error" in value ? isWireError(value.error) : "value" in value;
+}
+function isWireArgs(value) {
+	return value === void 0 || Array.isArray(value) && value.every(isWireArg);
+}
+function isWireLogRecord(value) {
+	return isPlainObject(value) && isLogLevel(value.level) && typeof value.message === "string" && typeof value.label === "string" && typeof value.channel === "string" && typeof value.timestamp === "number" && isWireArgs(value.args);
+}
+function fromDevLogLine(line) {
+	if (!line.startsWith(DEV_LOG_MARKER)) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(line.slice(13));
+	} catch {
+		return;
+	}
+	return isWireLogRecord(parsed) ? fromWireLog(parsed) : void 0;
+}
+
+//#endregion
+//#region src/hmr/forwardLogsToCli.ts
+const WORKER_ROUTED = [
+	"debug",
+	"dir",
+	"dirxml",
+	"error",
+	"info",
+	"log",
+	"table",
+	"trace",
+	"warn"
+];
+function forwardLogsToCli() {
+	const registry = LoggerChannelRegistry.instance;
+	const print = console.log.bind(console);
+	registry.installSink({
+		kind: "capture",
+		onLog: (record) => print(toDevLogLine(record))
+	}, { muteConsole: true });
+	routeConsole(WORKER_ROUTED, (method, args, invoked) => {
+		const level = CONSOLE_LEVEL[method];
+		if (method === "trace") {
+			registry.dispatch(consoleRecord(level, "", [traceError(format(...args), invoked)]));
+			return;
+		}
+		const [first, ...rest] = args;
+		registry.dispatch(typeof first === "string" ? consoleRecord(level, first, rest) : consoleRecord(level, "", args));
+	});
+}
+
 //#endregion
 //#region src/dispatch/dispatchReport.ts
 let dispatchLogger;
@@ -274,5 +968,5 @@ async function runAfter(ran, result, logger) {
 }
 
 //#endregion
-export { AckTrace, AutocompleteRouteBrand, CommandMetadataKey, ComponentDefsBrand, ComponentDefsKey, ComponentKindBrand, ContextMenuKindBrand, ContextMenuNamesBrand, EventMetadataKey, EventMiddlewareMetadataKey, GateNotice, GatedMetadataKey, HasDangerousPermissions, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, InteractionRouteKeys, MiddlewareKindsBrand, MiddlewareRegistry, MissingPermissions, MissingRole, NeedsAny, NotAllowed, NotInDm, NotInGuild, NotOwner, NoticeCard, OnCooldown, PAGE_MAX, PermissionNames, PublishDefault, RegisterDefaults, RegisterSubscriber, RegisteredCount, ReportThrottle, SlashRouteBrand, SubscribeMetadataKey, UnregisterSubscriber, VerifyWebhooks, WebhookUrlMetadataKey, accessorStore, areRoutes, asError, bindBotColor, busLoggerOf, checkAckLegality, clearStore, contextMenuLeaves, contextMenuRouteOf, decodeComponentRoute, deferFlags, eventResultFor, getDevChannel, guardedAccessor, interactionMiddleware, interactionMiddlewareMetaOf, interactionRoutesOf, isCommandClass, isEmojiTuple, outcomeFor, pageCursor, pickNotice, queuedMsFor, registrationFor, reportDispatch, reportedWrite, resultFor, runAfter, runGates, runHandlerGates, sendFlags, sendTarget, serializeReply, setDevChannel, slashRouteLeaves, slowGateMonitor, storeComponentRoute, storeInteractionRoute, translateSerializationError, wrapHot };
+export { AckTrace, AutocompleteRouteBrand, BAKED_IDS_KEY, COMMAND_DEPLOY_TIMEOUT_MS, CommandMetadataKey, CommandRegistry, ComponentDefsBrand, ComponentDefsKey, ComponentKindBrand, ContextMenuKindBrand, ContextMenuNamesBrand, CoordinatedStartup, EventMetadataKey, EventMiddlewareMetadataKey, FixedScope, GLOBAL_ID, GateNotice, GatedMetadataKey, HasDangerousPermissions, HmrManager, InteractionMetadataKey, InteractionMiddlewareMetadataKey, InteractionRouteKeys, MiddlewareKindsBrand, MiddlewareRegistry, MissingPermissions, MissingRole, NeedsAny, NotAllowed, NotInDm, NotInGuild, NotOwner, NoticeCard, OnCooldown, PAGE_MAX, PermissionNames, PluginLifecycle, PublishDefault, RegisterDefaults, RegisterSubscriber, RegisteredCount, ReportThrottle, SlashRouteBrand, SubscribeMetadataKey, SubscriberLoader, UnregisterSubscriber, VerifyWebhooks, WebhookUrlMetadataKey, accessorStore, attachmentsOf, bindBotColor, busLoggerOf, checkAckLegality, clearStore, commandKey, commandRefOf, commandsRoute, connectDevChannel, contextMenuLeaves, contextMenuRouteOf, currentApplication, decodeComponentRoute, deferFlags, eventResultFor, forwardLogsToCli, fromDevLogLine, fromWireError, getDevChannel, globalFirst, guardedAccessor, guildSummaries, indexById, installLinks, interactionMiddleware, interactionMiddlewareMetaOf, interactionRoutesOf, isCommandClass, isEmojiTuple, linkCommands, logUnknownFault, outcomeFor, pageCursor, pickNotice, planDeploy, putCommands, queuedMsFor, readBotToken, readCommands, readCommandsAt, registrationFor, reportDispatch, reportedWrite, resolveDeployTarget, resolveEmojis, resultFor, runAfter, runGates, runHandlerGates, scopeIdsOf, sealAttachments, sendFlags, sendTarget, serializeReply, setDevChannel, skippedNote, slashRouteLeaves, slowGateMonitor, storeComponentRoute, storeInteractionRoute, toWireError, translateSerializationError, warnLinks, wrapHot };
 //# sourceMappingURL=internal.index.mjs.map