@seedcord/core 0.1.4 → 0.2.0-next.0

package/dist/node-internal.index.cjs

@@ -1,799 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_subscribers = require('./subscribers-6x4xw39Z.cjs');
-const require_publishDefault = require('./publishDefault-D52iT8mF.cjs');
-const require_phases = require('./phases-8qiiLKjS.cjs');
-const require_devChannel = require('./devChannel-Cdnmz6hd.cjs');
-const require_Plugin = require('./Plugin-DVNh1kvX.cjs');
-const require_slashRouteLeaves = require('./slashRouteLeaves-HVl6Ymr0.cjs');
-const require_HmrModuleHandler = require('./HmrModuleHandler-CxGOo1LT.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_utils = require("@seedcord/utils");
-let chalk = require("chalk");
-chalk = require_subscribers.__toESM(chalk, 1);
-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) {
-	let timer;
-	try {
-		await Promise.race([work, new Promise((resolve, reject) => {
-			timer = setTimeout(() => onTimeout(resolve, reject), timeoutMs);
-		})]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-function withTimeout(name, run, timeoutMs) {
-	return raceTimer(run(), timeoutMs, (_, reject) => {
-		reject(new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecycleTaskTimeout, [name, timeoutMs]));
-	});
-}
-function settleWithin(work, timeoutMs) {
-	return raceTimer(work, timeoutMs, (resolve) => resolve());
-}
-
-//#endregion
-//#region src/node/Lifecycle/CoordinatedLifecycle.ts
-var CoordinatedLifecycle = class {
-	phaseOrder;
-	phaseEnum;
-	logger;
-	tasksMap = /* @__PURE__ */ new Map();
-	constructor(loggerName, phaseOrder, phaseEnum) {
-		this.phaseOrder = phaseOrder;
-		this.phaseEnum = phaseEnum;
-		this.logger = new _seedcord_logger.Logger(loggerName, { channel: "lifecycle" });
-		this.phaseOrder.forEach((phase) => this.tasksMap.set(phase, []));
-	}
-	addTask(phase, taskName, task, timeoutMs) {
-		if (!this.canAddTask()) return;
-		const tasks = this.tasksMap.get(phase);
-		if (!tasks) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecycleUnknownPhase, [phase]);
-		tasks.push({
-			name: taskName,
-			task,
-			timeout: timeoutMs
-		});
-		this.logger.debug(`${chalk.default.italic("Added")} ${this.getTaskType()} task ${_seedcord_logger.paint.sky.bold(taskName)} to phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])}`);
-	}
-	removeTask(phase, taskName) {
-		if (!this.canRemoveTask()) return false;
-		const tasks = this.tasksMap.get(phase);
-		if (!tasks) return false;
-		const initialLength = tasks.length;
-		const filteredTasks = tasks.filter((task) => task.name !== taskName);
-		this.tasksMap.set(phase, filteredTasks);
-		const removed = initialLength !== filteredTasks.length;
-		if (removed) this.logger.debug(`${chalk.default.italic("Removed")} ${this.getTaskType()} task ${_seedcord_logger.paint.sky.bold(taskName)} from phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])}`);
-		return removed;
-	}
-	async runPhase(phase) {
-		const tasks = this.tasksMap.get(phase) ?? [];
-		if (tasks.length === 0) {
-			this.logger.trace(`No tasks to run in phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])}`);
-			return;
-		}
-		this.logger.debug(`${_seedcord_logger.paint.amber.bold("Running")} ${this.getTaskType()} phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])} with ${_seedcord_logger.paint.sky.bold(String(tasks.length))} tasks`);
-		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.debug(`Phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])} ${_seedcord_logger.paint.mint.bold("completed successfully")}`);
-	}
-	async runTaskWithTimeout(phase, task) {
-		this.logger.trace(`${chalk.default.italic("Starting")} task ${_seedcord_logger.paint.sky.bold(task.name)} in phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])}`);
-		try {
-			await withTimeout(task.name, task.task, task.timeout);
-			this.logger.trace(`${chalk.default.italic("Completed")} task ${_seedcord_logger.paint.sky.bold(task.name)} in phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])}`);
-		} catch (error) {
-			if (this.isAborted()) return;
-			this.logger.error(`${chalk.default.italic("Failed")} task ${_seedcord_logger.paint.sky.bold(task.name)} in phase ${_seedcord_logger.paint.iris.bold(this.phaseEnum[phase])}:`, error);
-			throw error;
-		}
-	}
-	isAborted() {
-		return false;
-	}
-};
-
-//#endregion
-//#region src/node/Lifecycle/CoordinatedShutdown.ts
-const PHASE_ORDER$1 = [
-	1,
-	2,
-	3,
-	4
-];
-const LOG_FLUSH_DELAY_MS = 3e3;
-var CoordinatedShutdown = class extends CoordinatedLifecycle {
-	isShuttingDown = false;
-	hasShutdown = false;
-	exitCode = 0;
-	onSigTerm = null;
-	onSigInt = null;
-	startupGate;
-	constructor() {
-		super("Shutdown", PHASE_ORDER$1, require_phases.ShutdownPhase);
-		this.registerSignalHandlers();
-	}
-	canAddTask() {
-		return true;
-	}
-	canRemoveTask() {
-		return true;
-	}
-	getTaskType() {
-		return "shutdown";
-	}
-	async executeTasksInPhase(phase, tasks) {
-		const promises = tasks.map((task) => this.runTaskWithTimeout(phase, task));
-		return Promise.allSettled(promises);
-	}
-	registerSignalHandlers() {
-		this.onSigTerm = () => {
-			this.logger.info(`Received ${chalk.default.yellow.bold("SIGTERM")} signal`);
-			this.run(0);
-		};
-		this.onSigInt = () => {
-			this.logger.info(`Received ${chalk.default.yellow.bold("SIGINT")} signal`);
-			this.run(0);
-		};
-		process.on("SIGTERM", this.onSigTerm);
-		process.on("SIGINT", this.onSigInt);
-	}
-	/** @internal */
-	removeSignalHandlers() {
-		if (this.onSigTerm) {
-			process.off("SIGTERM", this.onSigTerm);
-			this.onSigTerm = null;
-		}
-		if (this.onSigInt) {
-			process.off("SIGINT", this.onSigInt);
-			this.onSigInt = null;
-		}
-	}
-	/** @internal run() awaits this so boot finishes registering its dispose tasks first */
-	gateOnStartup(settled) {
-		this.startupGate = settled;
-	}
-	addTask(phase, taskName, task, timeoutMs = 5e3) {
-		super.addTask(phase, taskName, task, timeoutMs);
-	}
-	removeTask(phase, taskName) {
-		return super.removeTask(phase, taskName);
-	}
-	async run(exitCode = 0, exitProcess = true) {
-		this.removeSignalHandlers();
-		if (this.hasShutdown || this.isShuttingDown) {
-			this.logger.warn("Shutdown sequence already ran or is in progress");
-			return;
-		}
-		this.isShuttingDown = true;
-		this.exitCode = exitCode;
-		this.logger.info(`${chalk.default.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk.default.bold.cyan(exitCode)}`);
-		try {
-			if (this.startupGate) await this.startupGate;
-			const failures = [];
-			for (const phase of PHASE_ORDER$1) try {
-				await this.runPhase(phase);
-			} catch (error) {
-				failures.push(error);
-			}
-			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) {
-				this.logger.debug(`${chalk.default.bold.red("Exiting")} process with code ${chalk.default.bold.cyan(this.exitCode)}`);
-				setTimeout(() => {
-					process.exit(this.exitCode);
-				}, LOG_FLUSH_DELAY_MS);
-			} else {
-				this.logger.debug(`${chalk.default.bold.yellow("Skipping")} process exit (dev mode)`);
-				this.isShuttingDown = false;
-			}
-		}
-	}
-};
-
-//#endregion
-//#region src/node/Lifecycle/CoordinatedStartup.ts
-const PHASE_ORDER = [
-	1,
-	2,
-	3
-];
-var CoordinatedStartup = class extends CoordinatedLifecycle {
-	isStartingUp = false;
-	hasStarted = false;
-	constructor() {
-		super("Startup", PHASE_ORDER, require_phases.StartupPhase);
-	}
-	addTask(phase, taskName, task, timeoutMs = 1e4) {
-		super.addTask(phase, taskName, task, timeoutMs);
-	}
-	canAddTask() {
-		if (this.hasStarted) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecycleAddAfterCompletion);
-		if (this.isStartingUp) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecycleAddDuringRun);
-		return true;
-	}
-	canRemoveTask() {
-		if (this.isStartingUp) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecycleRemoveDuringRun);
-		return true;
-	}
-	getTaskType() {
-		return "startup";
-	}
-	async executeTasksInPhase(phase, tasks) {
-		const promises = tasks.map((task) => this.runTaskWithTimeout(phase, task));
-		return Promise.allSettled(promises);
-	}
-	async run() {
-		if (this.hasStarted) {
-			this.logger.warn("Startup sequence has already completed");
-			return;
-		}
-		if (this.isStartingUp) {
-			this.logger.warn("Startup sequence already in progress");
-			return;
-		}
-		this.isStartingUp = true;
-		this.logger.info(`${chalk.default.bold.green("Starting")} coordinated startup sequence`);
-		try {
-			for (const phase of PHASE_ORDER) {
-				if (!this.isStartingUp) {
-					this.logger.warn("Startup sequence aborted");
-					return;
-				}
-				await this.runPhase(phase);
-			}
-			this.hasStarted = true;
-			this.logger.info(`${chalk.default.bold.green("Coordinated startup completed")} successfully`);
-		} 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")}`);
-			throw error;
-		} finally {
-			this.isStartingUp = false;
-		}
-	}
-	isAborted() {
-		return !this.isStartingUp;
-	}
-	abort() {
-		if (!this.isStartingUp) return;
-		this.isStartingUp = false;
-		this.logger.warn("Aborting coordinated startup sequence");
-	}
-	get isReady() {
-		return this.hasStarted;
-	}
-	get isRunning() {
-		return this.isStartingUp;
-	}
-};
-
-//#endregion
-//#region src/node/HealthResponder.ts
-const HTTP_OK = 200;
-const DEFAULT_HEALTH_CHECK_PATH = "/health";
-var HealthResponder = class {
-	path;
-	constructor(path) {
-		this.path = path ?? DEFAULT_HEALTH_CHECK_PATH;
-	}
-	tryRespond(req, res) {
-		if (req.method !== "GET" || req.url !== this.path) return false;
-		res.writeHead(HTTP_OK, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({
-			status: "ok",
-			timestamp: Date.now()
-		}));
-		return true;
-	}
-};
-
-//#endregion
-//#region src/node/HealthCheck.ts
-const HTTP_NOT_FOUND = 404;
-const DEFAULT_HEALTH_CHECK_PORT = 6967;
-var HealthCheck = class HealthCheck {
-	logger = new _seedcord_logger.Logger("HealthCheck", { channel: "health" });
-	port;
-	host;
-	responder;
-	server;
-	constructor(shutdown, options) {
-		this.port = options?.port ?? DEFAULT_HEALTH_CHECK_PORT;
-		this.host = options?.host;
-		this.responder = new HealthResponder(options?.path);
-		shutdown.addTask(2, "stop-healthcheck-server", () => this.stop());
-	}
-	get path() {
-		return this.responder.path;
-	}
-	static fromOption(shutdown, option) {
-		if (option === false) return void 0;
-		return new HealthCheck(shutdown, typeof option === "object" ? option : void 0);
-	}
-	async init() {
-		return new Promise((resolve, reject) => {
-			const server = (0, node_http.createServer)((req, res) => {
-				if (this.responder.tryRespond(req, res)) return;
-				res.writeHead(HTTP_NOT_FOUND, { "Content-Type": "application/json" });
-				res.end(JSON.stringify({ status: "not found" }));
-			});
-			this.server = server;
-			const onListenError = (err) => reject(err);
-			server.on("error", onListenError);
-			server.once("listening", () => {
-				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}`)}`);
-				resolve();
-			});
-			if (this.host) {
-				this.logger.debug(`Binding health check server to ${this.host}`);
-				server.listen(this.port, this.host);
-			} else {
-				this.logger.debug("Binding health check server to all interfaces");
-				server.listen(this.port);
-			}
-		});
-	}
-	stop() {
-		const server = this.server;
-		if (!server?.listening) return Promise.resolve();
-		return new Promise((resolve, reject) => {
-			server.close((err) => {
-				if (err) {
-					reject(err);
-					return;
-				}
-				this.logger.info(_seedcord_logger.paint.coral.bold("Health check server stopped"));
-				resolve();
-			});
-		});
-	}
-};
-
-//#endregion
-//#region src/node/Pluggable.ts
-const RESERVED_KEYS = new Set(_seedcord_logger.FRAMEWORK_CHANNELS);
-/**
-* 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.
-*/
-var Pluggable = class Pluggable {
-	/** @see {@link CoordinatedShutdown} */
-	shutdown;
-	/** @see {@link CoordinatedStartup} */
-	startup;
-	isInitialized = false;
-	startFailed = false;
-	plugins = [];
-	pluginLogger = new _seedcord_logger.Logger("Plugins", { channel: "plugins" });
-	attachments = [];
-	completedInits = /* @__PURE__ */ new Set();
-	disposePhases = /* @__PURE__ */ new Set();
-	pluginTasksRegistered = false;
-	static isInstantiated = false;
-	static liveShutdown;
-	constructor(shutdown, startup) {
-		if (Pluggable.isInstantiated) {
-			shutdown.removeSignalHandlers();
-			throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CoreSingletonViolation);
-		}
-		Pluggable.isInstantiated = true;
-		Pluggable.liveShutdown = shutdown;
-		this.shutdown = shutdown;
-		this.startup = startup;
-	}
-	/** @internal */
-	async init() {
-		if (this.isInitialized) return this;
-		if (this.startFailed) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecycleRestartAfterFailure);
-		this.registerPluginTasks();
-		const startupSettled = Promise.withResolvers();
-		this.shutdown.gateOnStartup(startupSettled.promise);
-		try {
-			await this.startup.run();
-		} catch (caught) {
-			await this.rollback();
-			throw caught;
-		} finally {
-			startupSettled.resolve();
-		}
-		this.isInitialized = true;
-		return this;
-	}
-	/** @internal codegen reads these to emit the `Core` augmentation */
-	get pluginKeys() {
-		return this.attachments.map((attachment) => attachment.key);
-	}
-	/** @internal so the next host can construct */
-	static reset() {
-		Pluggable.liveShutdown?.removeSignalHandlers();
-		Pluggable.liveShutdown = void 0;
-		Pluggable.isInstantiated = false;
-	}
-	/**
-	* 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`. `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
-	* @param key - Property name to access the plugin instance
-	* @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 or is reserved
-	* @example
-	* ```typescript
-	* 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
-		});
-		return Object.assign(this, { [key]: instance });
-	}
-	registerPluginTasks() {
-		if (this.pluginTasksRegistered) return;
-		this.pluginTasksRegistered = true;
-		const groups = /* @__PURE__ */ new Map();
-		for (const attachment of this.attachments) {
-			const phase = require_Plugin.resolvedLifecycleSpecOf(attachment.instance).init.phase;
-			const group = groups.get(phase) ?? [];
-			group.push(attachment);
-			groups.set(phase, group);
-		}
-		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.registerReadyTask(groups.get(3) ?? []);
-	}
-	async runInits(group) {
-		for (const attachment of group) {
-			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);
-			instance.logger.utils.initialization(key, "end");
-			this.completedInits.add(attachment);
-			if (instance.dispose) this.registerDisposeTask(spec.dispose.phase);
-		}
-	}
-	registerReadyTask(readyInits) {
-		const steps = this.attachments.reduce((acc, a) => {
-			const ready = a.instance.ready?.bind(a.instance);
-			if (ready) acc.push({
-				key: a.key,
-				run: ready,
-				timeout: require_Plugin.resolvedLifecycleSpecOf(a.instance).ready.timeout
-			});
-			return acc;
-		}, []);
-		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-ready", async () => {
-			await this.runInits(readyInits);
-			for (const step of steps) await withTimeout(`Plugin:${step.key}:ready`, step.run, step.timeout);
-		}, budget);
-	}
-	registerDisposeTask(phase) {
-		if (this.disposePhases.has(phase)) return;
-		this.disposePhases.add(phase);
-		const budget = this.attachments.reduce((sum, a) => {
-			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);
-	}
-	async runDisposals(phase) {
-		const failures = [];
-		await this.disposeCompleted(phase, (caught) => failures.push(caught));
-		if (failures.length === 1) throw failures[0];
-		if (failures.length > 1) throw new AggregateError(failures, "plugin dispose failures");
-	}
-	async disposeCompleted(phase, onError) {
-		for (const attachment of [...this.attachments].reverse()) {
-			if (!this.completedInits.has(attachment)) continue;
-			const dispose = attachment.instance.dispose?.bind(attachment.instance);
-			if (!dispose) continue;
-			const spec = require_Plugin.resolvedLifecycleSpecOf(attachment.instance);
-			if (phase !== void 0 && spec.dispose.phase !== phase) continue;
-			try {
-				await withTimeout(`Plugin:${attachment.key}:dispose`, dispose, spec.dispose.timeout);
-			} catch (caught) {
-				onError(caught);
-			}
-		}
-	}
-	async rollback() {
-		this.startFailed = true;
-		await this.disposeCompleted(void 0, (caught) => this.pluginLogger.warn("rollback dispose failed", caught));
-		this.completedInits.clear();
-	}
-};
-
-//#endregion
-//#region src/node/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 (!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.debug(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"), "debug");
-		}
-		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, void 0, "trace");
-			}
-		});
-	}
-	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
-		}, "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(chalk.default.italic("Command refresh cancelled."));
-			this.pendingEvents.clear();
-			return;
-		}
-		this.logger.debug(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
-		});
-	}
-	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 */
-	routeLeaves() {
-		return require_slashRouteLeaves.slashRouteLeaves(this.allCommands());
-	}
-	/** @internal */
-	contextMenuLeaves() {
-		return require_publishDefault.contextMenuLeaves(this.allCommands());
-	}
-};
-
-//#endregion
-exports.CommandRegistry = CommandRegistry;
-exports.CoordinatedShutdown = CoordinatedShutdown;
-exports.CoordinatedStartup = CoordinatedStartup;
-exports.HealthCheck = HealthCheck;
-exports.HealthResponder = HealthResponder;
-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