@seedcord/core 0.1.0-next.6 → 0.1.0-next.8

package/dist/node-internal.index.cjs

@@ -1,14 +1,24 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
-const require_phases = require('./phases-C_BGNyVo.cjs');
-const require_Plugin = require('./Plugin-C2-VHrsX.cjs');
+const require_publishDefault = require('./publishDefault-CVlwYUS5.cjs');
+const require_phases = require('./phases-DcuDHoQl.cjs');
+const require_subscribers = require('./subscribers-BSJoyKNN.cjs');
+const require_devChannel = require('./devChannel-CoCmAVDx.cjs');
+const require_Plugin = require('./Plugin-BlkhHNRm.cjs');
+const require_slashRouteLeaves = require('./slashRouteLeaves-nfxOAM7Q.cjs');
+const require_HmrModuleHandler = require('./HmrModuleHandler-CTBng7wV.cjs');
+let _discordjs_builders = require("@discordjs/builders");
+let _seedcord_logger = require("@seedcord/logger");
+let discord_api_types_v10 = require("discord-api-types/v10");
 let _seedcord_errors = require("@seedcord/errors");
 let _seedcord_errors_internal = require("@seedcord/errors/internal");
-let _seedcord_logger = require("@seedcord/logger");
+let _seedcord_utils = require("@seedcord/utils");
 let chalk = require("chalk");
 chalk = require_rolldown_runtime.__toESM(chalk, 1);
-let _seedcord_event_emitter = require("@seedcord/event-emitter");
+let envapt = require("envapt");
+let node_path = require("node:path");
 let node_http = require("node:http");
+let _seedcord_utils_node = require("@seedcord/utils/node");
 
 //#region src/node/Lifecycle/withTimeout.ts
 async function raceTimer(work, timeoutMs, onTimeout) {
@@ -39,16 +49,15 @@ function settleWithin(work, timeoutMs) {
 *
 * @internal
 */
-var CoordinatedLifecycle = class extends _seedcord_event_emitter.TypedEventEmitter {
+var CoordinatedLifecycle = class {
 	phaseOrder;
 	phaseEnum;
 	logger;
 	tasksMap = /* @__PURE__ */ new Map();
 	constructor(loggerName, phaseOrder, phaseEnum) {
-		super();
 		this.phaseOrder = phaseOrder;
 		this.phaseEnum = phaseEnum;
-		this.logger = new _seedcord_logger.Logger(loggerName);
+		this.logger = new _seedcord_logger.Logger(loggerName, { channel: "lifecycle" });
 		this.phaseOrder.forEach((phase) => this.tasksMap.set(phase, []));
 	}
 	/**
@@ -95,11 +104,9 @@ var CoordinatedLifecycle = class extends _seedcord_event_emitter.TypedEventEmitt
 			return;
 		}
 		this.logger.info(`${chalk.default.bold.yellow("Running")} ${this.getTaskType()} phase ${chalk.default.bold.magenta(this.phaseEnum[phase])} with ${chalk.default.bold.cyan(tasks.length)} tasks`);
-		this.emitPhase(phase, "start");
 		const failures = (await this.executeTasksInPhase(phase, tasks)).filter((r) => r.status === "rejected").length;
 		if (failures > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecyclePhaseFailures, [this.phaseEnum[phase], failures]);
 		this.logger.info(`Phase ${chalk.default.bold.magenta(this.phaseEnum[phase])} ${chalk.default.bold.green("completed successfully")}`);
-		this.emitPhase(phase, "complete");
 	}
 	async runTaskWithTimeout(phase, task) {
 		this.logger.info(`${chalk.default.italic("Starting")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(this.phaseEnum[phase])}`);
@@ -111,12 +118,6 @@ var CoordinatedLifecycle = class extends _seedcord_event_emitter.TypedEventEmitt
 			throw error;
 		}
 	}
-	emitPhase(phase, action) {
-		this.emitSafeRaw(`phase:${phase}:${action}`);
-	}
-	onListenerError(error, event) {
-		this.logger.error(`listener for ${String(event)} threw`, error);
-	}
 };
 
 //#endregion
@@ -179,11 +180,18 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 			this.onSigInt = null;
 		}
 	}
-	/** @internal run() awaits this so a shutdown during startup waits for startup to register its dispose tasks */
+	/** @internal run() awaits this so boot finishes registering its dispose tasks first */
 	gateOnStartup(settled) {
 		this.startupGate = settled;
 	}
-	/** Adds a shutdown-phase task. @param timeoutMs - Task timeout in ms. {@default 5000} */
+	/**
+	* Adds a shutdown-phase task.
+	*
+	* @param phase - The shutdown phase to run the task in.
+	* @param taskName - A descriptive name for the task.
+	* @param task - The async function to run.
+	* @param timeoutMs - Task timeout in ms. {@default `5000` }
+	*/
 	addTask(phase, taskName, task, timeoutMs = 5e3) {
 		super.addTask(phase, taskName, task, timeoutMs);
 	}
@@ -195,8 +203,8 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 	* Runs registered tasks across shutdown phases in `ShutdownPhase` order.
 	* Tasks within each phase run in parallel.
 	*
-	* @param exitCode - Process exit code. {@default `0`}
-	* @param exitProcess - Whether to exit the process after shutdown. {@default `true`}
+	* @param exitCode - Process exit code. {@default `0` }
+	* @param exitProcess - Whether to exit the process after shutdown. {@default `true` }
 	* @example
 	* ```typescript
 	* shutdown.addTask(ShutdownPhase.Disconnect, 'database', () => db.disconnect(), 5000);
@@ -212,7 +220,6 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 		this.isShuttingDown = true;
 		this.exitCode = exitCode;
 		this.logger.info(`${chalk.default.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk.default.bold.cyan(exitCode)}`);
-		this.emitSafe("shutdown:start");
 		try {
 			if (this.startupGate) await this.startupGate;
 			const failures = [];
@@ -221,11 +228,8 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 			} catch (error) {
 				failures.push(error);
 			}
-			if (failures.length > 0) this.emitFailures(failures);
-			else {
-				this.logger.info(`${chalk.default.bold.green("Coordinated shutdown completed")} successfully`);
-				this.emitSafe("shutdown:complete");
-			}
+			if (failures.length > 0) this.logger.error(`${chalk.default.bold.red("Coordinated shutdown failed")}`, ...failures);
+			else this.logger.info(`${chalk.default.bold.green("Coordinated shutdown completed")} successfully`);
 		} finally {
 			this.hasShutdown = true;
 			if (exitProcess) {
@@ -239,11 +243,6 @@ var CoordinatedShutdown = class extends CoordinatedLifecycle {
 			}
 		}
 	}
-	emitFailures(failures) {
-		this.logger.error(`${chalk.default.bold.red("Coordinated shutdown failed")}`);
-		const error = failures.length === 1 ? failures[0] : new AggregateError(failures, "shutdown phase failures");
-		this.emitSafe("shutdown:error", error);
-	}
 };
 
 //#endregion
@@ -262,7 +261,14 @@ var CoordinatedStartup = class extends CoordinatedLifecycle {
 	constructor() {
 		super("Startup", PHASE_ORDER, require_phases.StartupPhase);
 	}
-	/** Adds a startup-phase task. @param timeoutMs - Task timeout in ms. {@default 10000} */
+	/**
+	* Adds a startup-phase task.
+	*
+	* @param phase - The startup phase to run the task in.
+	* @param taskName - A descriptive name for the task.
+	* @param task - The async function to run.
+	* @param timeoutMs - Task timeout in ms. {@default `10000` }
+	*/
 	addTask(phase, taskName, task, timeoutMs = 1e4) {
 		super.addTask(phase, taskName, task, timeoutMs);
 	}
@@ -299,7 +305,6 @@ var CoordinatedStartup = class extends CoordinatedLifecycle {
 		}
 		this.isStartingUp = true;
 		this.logger.info(`${chalk.default.bold.green("Starting")} coordinated startup sequence`);
-		this.emitSafe("startup:start");
 		try {
 			for (const phase of PHASE_ORDER) {
 				if (!this.isStartingUp) {
@@ -310,14 +315,12 @@ var CoordinatedStartup = class extends CoordinatedLifecycle {
 			}
 			this.hasStarted = true;
 			this.logger.info(`${chalk.default.bold.green("Coordinated startup completed")} successfully`);
-			this.emitSafe("startup:complete");
 		} catch (error) {
 			if (!this.isStartingUp) {
 				this.logger.warn("Startup sequence aborted during error handling");
 				return;
 			}
 			this.logger.error(`${chalk.default.bold.red("Coordinated startup failed")}`);
-			this.emitSafe("startup:error", error);
 			throw error;
 		} finally {
 			this.isStartingUp = false;
@@ -361,7 +364,7 @@ const DEFAULT_HEALTH_CHECK_PATH = "/health";
 */
 var HealthCheck = class HealthCheck {
 	/** @internal */
-	logger = new _seedcord_logger.Logger("HealthCheck");
+	logger = new _seedcord_logger.Logger("HealthCheck", { channel: "health" });
 	port;
 	path;
 	host;
@@ -406,7 +409,7 @@ var HealthCheck = class HealthCheck {
 				server.removeListener("error", onListenError);
 				server.on("error", (err) => this.logger.error("Health check server error", err));
 				const address = this.host ?? "localhost";
-				this.logger.info(`${_seedcord_logger.paint.mint.bold("✓")} Health check server listening on ${_seedcord_logger.paint.sky(`http://${address}:${this.port}${this.path}`)}`);
+				this.logger.info(`${_seedcord_logger.paint.mint.bold("✔︎")} Health check server listening on ${_seedcord_logger.paint.sky(`http://${address}:${this.port}${this.path}`)}`);
 				resolve();
 			});
 			if (this.host) {
@@ -440,19 +443,22 @@ var HealthCheck = class HealthCheck {
 
 //#endregion
 //#region src/node/Pluggable.ts
+const RESERVED_KEYS = new Set(_seedcord_logger.FRAMEWORK_CHANNELS);
 /**
-* Base class for objects that can have plugins attached.
+* Base class for a plugin host, a transport `Seedcord` class.
 *
 * Plugins are attached during configuration and initialized during startup, sequentially in attach
-* order within each phase. Not constructed directly, the host is a transport `Seedcord` class.
+* order within each phase.
 */
-var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitter {
-	isInitialized = false;
-	startFailed = false;
+var Pluggable = class Pluggable {
+	/** @see {@link CoordinatedShutdown} */
 	shutdown;
+	/** @see {@link CoordinatedStartup} */
 	startup;
+	isInitialized = false;
+	startFailed = false;
 	plugins = [];
-	pluginLogger = new _seedcord_logger.Logger("Plugins");
+	pluginLogger = new _seedcord_logger.Logger("Plugins", { channel: "plugins" });
 	attachments = [];
 	completedInits = /* @__PURE__ */ new Set();
 	disposePhases = /* @__PURE__ */ new Set();
@@ -464,7 +470,6 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 			shutdown.removeSignalHandlers();
 			throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreSingletonViolation);
 		}
-		super();
 		Pluggable.isInstantiated = true;
 		Pluggable.liveShutdown = shutdown;
 		this.shutdown = shutdown;
@@ -488,13 +493,11 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 		this.isInitialized = true;
 		return this;
 	}
-	pluginCapabilities() {
-		return {};
-	}
-	pluginStore() {
-		return this.config.store ?? this.rateLimiter;
+	/** @internal codegen reads these to emit the `Core` augmentation */
+	get pluginKeys() {
+		return this.attachments.map((attachment) => attachment.key);
 	}
-	/** @internal releases the signal handlers and clears the singleton so the next host can construct */
+	/** @internal so the next host can construct */
 	static reset() {
 		Pluggable.liveShutdown?.removeSignalHandlers();
 		Pluggable.liveShutdown = void 0;
@@ -504,8 +507,12 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 	* Attaches a plugin to this instance.
 	*
 	* The plugin initializes during startup, after every plugin attached before it, and becomes
-	* available as a property on `core`. Augment the transport's `Core` interface with the plugin
-	* type for intellisense.
+	* available as a property on `core`. `seedcord codegen` writes the `Core` augmentation that
+	* types it.
+	*
+	* A plugin declaring a `transport` or `runtime` this host does not run is a compile error on
+	* this call. An edge host takes no plugins at all. A plugin constructor narrowing its first
+	* parameter past `CoreBase` is a compile error here too. Read the transport `Core` off `this.core`.
 	*
 	* @typeParam Key - The property name for accessing the plugin
 	* @typeParam Ctor - The plugin constructor type
@@ -513,38 +520,25 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 	* @param Plugin - Plugin constructor class
 	* @param args - Additional arguments to pass to the plugin constructor
 	* @returns This instance with the plugin attached as a typed property
-	* @throws A **SeedcordError** When called after initialization or if key already exists
+	* @throws A **SeedcordError** When called after initialization or if key already exists or is reserved
 	* @example
 	* ```typescript
-	* seedcord.attach('db', Mongo, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
+	* seedcord.attach('db', Mongoose, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
 	* ```
 	*/
 	attach(key, Plugin, ...args) {
 		if (this.isInitialized) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CorePluginAfterInit);
+		if (RESERVED_KEYS.has(key)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CorePluginReservedChannel, [key]);
 		if (key in this) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CorePluginKeyExists, [key]);
 		const instance = new Plugin(this, ...args);
+		instance.logger.setChannel(key);
 		this.plugins.push(instance);
 		this.attachments.push({
 			key,
 			instance
 		});
-		this.finalizeContext(key, instance);
 		return Object.assign(this, { [key]: instance });
 	}
-	finalizeContext(key, instance) {
-		const caps = this.pluginCapabilities();
-		const readToken = () => this.pluginCapabilities().token;
-		require_Plugin.finalizePluginContext(instance, {
-			logger: new _seedcord_logger.Logger(key),
-			config: this.config,
-			store: this.pluginStore(),
-			client: caps.client,
-			get token() {
-				return readToken();
-			},
-			rest: caps.rest
-		});
-	}
 	registerPluginTasks() {
 		if (this.pluginTasksRegistered) return;
 		this.pluginTasksRegistered = true;
@@ -558,7 +552,7 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 		for (const [phase, group] of groups) {
 			if (phase === 3) continue;
 			const budget = group.reduce((sum, a) => sum + require_Plugin.resolvedLifecycleSpecOf(a.instance).init.timeout, 0);
-			this.startup.addTask(phase, "Plugins:init", () => this.runInits(group), budget);
+			this.startup.addTask(phase, "plugins-init", () => this.runInits(group), budget);
 		}
 		this.registerReadyTask(groups.get(3) ?? []);
 	}
@@ -567,7 +561,7 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 			const { key, instance } = attachment;
 			const spec = require_Plugin.resolvedLifecycleSpecOf(instance);
 			instance.logger.utils.initialization(key, "start");
-			await withTimeout(`Plugin:${key}`, () => instance.init(), spec.init.timeout);
+			await withTimeout(`Plugin (${key})`, () => instance.init(), spec.init.timeout);
 			instance.logger.utils.initialization(key, "end");
 			this.completedInits.add(attachment);
 			if (instance.dispose) this.registerDisposeTask(spec.dispose.phase);
@@ -585,7 +579,7 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 		}, []);
 		if (readyInits.length === 0 && steps.length === 0) return;
 		const budget = readyInits.reduce((sum, a) => sum + require_Plugin.resolvedLifecycleSpecOf(a.instance).init.timeout, 0) + steps.reduce((sum, step) => sum + step.timeout, 0);
-		this.startup.addTask(3, "Plugins", async () => {
+		this.startup.addTask(3, "plugins-ready", async () => {
 			await this.runInits(readyInits);
 			for (const step of steps) await withTimeout(`Plugin:${step.key}:ready`, step.run, step.timeout);
 		}, budget);
@@ -597,7 +591,7 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 			const spec = require_Plugin.resolvedLifecycleSpecOf(a.instance);
 			return a.instance.dispose && spec.dispose.phase === phase ? sum + spec.dispose.timeout : sum;
 		}, 0);
-		this.shutdown.addTask(phase, "Plugins:dispose", () => this.runDisposals(phase), budget);
+		this.shutdown.addTask(phase, "plugins-dispose", () => this.runDisposals(phase), budget);
 	}
 	async runDisposals(phase) {
 		const failures = [];
@@ -624,22 +618,266 @@ var Pluggable = class Pluggable extends _seedcord_event_emitter.TypedEventEmitte
 		await this.disposeCompleted(void 0, (caught) => this.pluginLogger.warn("rollback dispose failed", caught));
 		this.completedInits.clear();
 	}
+};
+
+//#endregion
+//#region src/node/subscribers/SubscriberLoader.ts
+/**
+* Loads subscribers off the filesystem into a {@link Bus} and stores their hot-reload wiring. Node
+* only, a bundled isolate registers from the manifest instead.
+*
+* @internal
+*/
+var SubscriberLoader = class {
+	bus;
+	directory;
+	isInitialized = false;
+	hmrHandler;
+	constructor(bus, directory) {
+		this.bus = bus;
+		this.directory = directory;
+		if (!this.directory) return;
+		if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
+		this.hmrHandler = new require_HmrModuleHandler.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: this.bus.logger
+		});
+	}
+	/** @internal */
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		this.bus.registerDefaults();
+		const { directory } = this;
+		if (directory) {
+			this.bus.logger.info(chalk.default.bold(directory));
+			await this.load(directory);
+			this.bus.logger.utils.list([`${chalk.default.bold.magenta(this.bus.registeredCount)} subscribers`], chalk.default.bold.green("Loaded"));
+		}
+		if (!envapt.Envapter.isTest) await this.bus.verifyWebhooks();
+	}
+	/** @internal */
+	async onHmr(event) {
+		if (this.hmrHandler) await this.hmrHandler.handle(event);
+	}
+	async load(dir) {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, relativePath, imported) => {
+			for (const exportName of Object.keys(imported)) {
+				const value = imported[exportName];
+				if (!this.isSubscriber(value)) continue;
+				this.registerSubscriber(value);
+				this.hmrHandler?.trackHandler(fullPath, value);
+				this.bus.logger.utils.registration(value.name, relativePath);
+			}
+		});
+	}
+	registerSubscriber(ctor) {
+		this.bus.register(require_subscribers.registrationFor(ctor));
+	}
+	unregisterSubscriber(ctor, artifacts) {
+		this.bus.unregister(ctor, artifacts);
+	}
+	getArtifacts(ctor) {
+		return [Reflect.getMetadata(require_publishDefault.SubscribeMetadataKey, ctor).subscriber];
+	}
+	isSubscriber(value) {
+		if (typeof value !== "function") return false;
+		return value.prototype instanceof require_subscribers.Subscriber && Reflect.hasMetadata(require_publishDefault.SubscribeMetadataKey, value);
+	}
+};
+
+//#endregion
+//#region src/node/commands/CommandRegistry.ts
+function indexById(commands) {
+	return new Map(commands.map((command) => [command.id, command]));
+}
+/**
+* Scans the command directory, builds each command, and PUTs the global and guild scopes to Discord.
+*
+* @internal
+*/
+var CommandRegistry = class {
+	options;
+	logger = new _seedcord_logger.Logger("Commands", { channel: "commands" });
+	isInitialised = false;
+	globalCommands = [];
+	guildCommands = /* @__PURE__ */ new Map();
+	ctorToCommand = /* @__PURE__ */ new Map();
+	loading = false;
+	loadedCommands = [];
+	hmrHandler;
+	pendingEvents = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		if (!options.dir) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
+		if (!envapt.Envapter.isDevelopment && !envapt.Envapter.isTest) return;
+		this.hmrHandler = new require_HmrModuleHandler.HmrModuleHandler({
+			handlersDir: options.dir,
+			isHandler: this.isCommandClass.bind(this),
+			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.options.dir);
+		} finally {
+			this.loading = false;
+		}
+		this.reportLoad();
+		require_devChannel.getDevChannel()?.on("seedcord:refresh-commands", (data) => {
+			this.refresh(data.shouldRefresh);
+		});
+	}
+	reportLoad() {
+		const { utils } = this.logger;
+		utils.summary("Loaded commands", {
+			global: this.globalCommands.length,
+			"guild groups": this.guildCommands.size
+		});
+		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
+		})]);
+	}
+	/** @internal */
+	async refresh(shouldRefresh = true) {
+		if (!shouldRefresh) {
+			this.logger.info(chalk.default.italic("Command refresh cancelled."));
+			this.pendingEvents.clear();
+			return;
+		}
+		this.logger.info(chalk.default.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 (event.file.startsWith((0, node_path.resolve)(process.cwd(), this.options.dir))) {
+			this.pendingEvents.delete(event.file);
+			this.pendingEvents.set(event.file, event);
+			require_devChannel.getDevChannel()?.send("seedcord:commands-update-prompt", { files: [...this.pendingEvents.keys()].map((f) => (0, _seedcord_utils.formatFilePath)(f)) });
+		} else await this.hmrHandler?.handle(event);
+	}
+	async loadCommands(dir) {
+		await (0, _seedcord_utils_node.traverseDirectory)(dir, (fullPath, rel, mod) => {
+			for (const exported of Object.values(mod)) if (this.isCommandClass(exported)) {
+				this.registerCommand(exported, rel);
+				this.hmrHandler?.trackHandler(fullPath, exported);
+			}
+		});
+	}
+	isCommandClass(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof require_publishDefault.BuilderComponent && Reflect.hasMetadata(require_publishDefault.CommandMetadataKey, obj);
+	}
+	registerCommand(ctor, rel) {
+		const meta = Reflect.getMetadata(require_publishDefault.CommandMetadataKey, ctor);
+		if (!meta) return;
+		const comp = new ctor().component;
+		const kind = comp instanceof _discordjs_builders.SlashCommandBuilder ? "slash command" : "context menu";
+		if (meta.scope === "global") this.globalCommands.push(comp);
+		else for (const g of meta.guilds) {
+			const arr = this.guildCommands.get(g) ?? [];
+			arr.push(comp);
+			this.guildCommands.set(g, arr);
+		}
+		this.ctorToCommand.set(ctor, {
+			name: comp.name,
+			scope: meta.scope,
+			...meta.scope === "guild" && { guilds: meta.guilds }
+		});
+		if (this.loading) {
+			this.loadedCommands.push({
+				name: comp.name,
+				from: (0, _seedcord_utils.formatFilePath)(rel),
+				kind
+			});
+			return;
+		}
+		this.logger.utils.registration(comp.name, rel, `${meta.scope} ${kind}`);
+	}
+	unregisterCommand(ctor, artifacts) {
+		const info = artifacts ?? this.ctorToCommand.get(ctor);
+		if (!info) return;
+		if (info.scope === "global") {
+			const idx = this.globalCommands.findIndex((c) => c.name === info.name);
+			if (idx !== -1) this.globalCommands.splice(idx, 1);
+		} else for (const g of info.guilds ?? []) {
+			const arr = this.guildCommands.get(g);
+			if (arr) {
+				const idx = arr.findIndex((c) => c.name === info.name);
+				if (idx !== -1) arr.splice(idx, 1);
+			}
+		}
+		this.ctorToCommand.delete(ctor);
+	}
+	/** @internal */
+	async setCommands() {
+		const result = {
+			global: /* @__PURE__ */ new Map(),
+			guilds: /* @__PURE__ */ new Map()
+		};
+		const appId = this.options.applicationId();
+		if (this.globalCommands.length > 0) {
+			result.global = indexById(await this.put(discord_api_types_v10.Routes.applicationCommands(appId), this.globalCommands));
+			const tag = this.globalCommands.length === 1 ? "command" : "commands";
+			this.logger.utils.block(`Deployed ${this.globalCommands.length} global ${tag}`, this.logger.utils.wrap(this.globalCommands.map((command) => command.name)), "info");
+		}
+		for (const [guildId, commands] of this.guildCommands.entries()) {
+			const deployed = await this.put(discord_api_types_v10.Routes.applicationGuildCommands(appId, guildId), commands);
+			result.guilds.set(guildId, indexById(deployed));
+			const tag = commands.length === 1 ? "command" : "commands";
+			this.logger.utils.block(`Deployed ${commands.length} ${tag} to ${_seedcord_logger.paint.amber.bold(guildId)}`, this.logger.utils.wrap(commands.map((command) => command.name)), "info");
+		}
+		this.options.onDeployed?.(result);
+		return result;
+	}
+	async put(route, commands) {
+		const body = commands.map((command) => command.toJSON());
+		return await this.options.rest.put(route, { body });
+	}
+	/** Every registered builder, global first. A guild command in N guilds appears once per guild. @internal */
+	allCommands() {
+		return [...this.globalCommands, ...this.guildCommands.values()].flat();
+	}
 	/** @internal */
-	removeListener(event, listener) {
-		return super.removeListener(event, listener);
+	routeLeaves() {
+		return require_slashRouteLeaves.slashRouteLeaves(this.allCommands());
 	}
 	/** @internal */
-	removeAllListeners(event) {
-		return super.removeAllListeners(event);
+	contextMenuLeaves() {
+		return require_publishDefault.contextMenuLeaves(this.allCommands());
 	}
 };
 
 //#endregion
+exports.CommandRegistry = CommandRegistry;
 exports.CoordinatedShutdown = CoordinatedShutdown;
 exports.CoordinatedStartup = CoordinatedStartup;
 exports.HealthCheck = HealthCheck;
 exports.Pluggable = Pluggable;
 exports.ShutdownPhase = require_phases.ShutdownPhase;
 exports.StartupPhase = require_phases.StartupPhase;
+exports.SubscriberLoader = SubscriberLoader;
 exports.settleWithin = settleWithin;
 //# sourceMappingURL=node-internal.index.cjs.map