@seedcord/core 0.3.0 → 0.4.0

package/dist/node-internal.index.mjs

@@ -1,284 +1,22 @@
-import { S as SubscribeMetadataKey, c as Subscriber, f as BuilderComponent, h as CommandMetadataKey, n as busLoggerOf, r as registrationFor, w as contextMenuLeaves } from "./Bus-DcuUtOEL.mjs";
+import { D as SubscribeMetadataKey, M as contextMenuLeaves, a as RegisterSubscriber, b as CommandMetadataKey, c as VerifyWebhooks, f as Subscriber, i as RegisterDefaults, n as busLoggerOf, o as RegisteredCount, r as registrationFor, s as UnregisterSubscriber } from "./Bus-BVwmKc-A.mjs";
+import { t as CommandInjector } from "./subscribers-CGGQkUfM.mjs";
+import { t as PublishDefault } from "./publishDefault-D826XXDQ.mjs";
 import { n as StartupPhase, t as ShutdownPhase } from "./phases-BauKJOTT.mjs";
-import "./subscribers-DuHg-bGT.mjs";
 import { t as getDevChannel } from "./devChannel-CQU7hq7Q.mjs";
-import { n as pluginLoggerOf, r as resolvedLifecycleSpecOf } from "./Plugin-Bkeqcjy6.mjs";
-import { t as slashRouteLeaves } from "./slashRouteLeaves-De1SxqnX.mjs";
+import { n as isCommandClass, t as slashRouteLeaves } from "./slashRouteLeaves-CbYRwqMY.mjs";
 import { t as HmrModuleHandler } from "./HmrModuleHandler-9AUfKXRl.mjs";
+import { i as settleWithin, n as shutdownOf, r as assertNodeVersion } from "./Pluggable-Cf5-WWmW.mjs";
 import { SlashCommandBuilder } from "@discordjs/builders";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
-import { FRAMEWORK_CHANNELS, Logger } from "@seedcord/logger";
+import { Logger } from "@seedcord/logger";
 import { Routes } from "discord-api-types/v10";
-import { SeedcordAggregateError, SeedcordError } from "@seedcord/errors/internal";
+import { SeedcordError } from "@seedcord/errors/internal";
 import { formatFilePath } from "@seedcord/utils";
 import { Envapter } from "envapt";
 import { resolve } from "node:path";
 import { createServer } from "node:http";
 import { traverseDirectory } from "@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 SeedcordError(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 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 SeedcordError(SeedcordErrorCode.LifecycleUnknownPhase, [phase]);
-		tasks.push({
-			name: taskName,
-			task,
-			timeout: timeoutMs
-		});
-		this.logger.debug(`${paint.italic("Added")} ${this.getTaskType()} task ${paint.sky.bold(taskName)} to phase ${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(`${paint.italic("Removed")} ${this.getTaskType()} task ${paint.sky.bold(taskName)} from phase ${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 ${paint.iris.bold(this.phaseEnum[phase])}`);
-			return;
-		}
-		this.logger.debug(`${paint.amber.bold("Running")} ${this.getTaskType()} phase ${paint.iris.bold(this.phaseEnum[phase])} with ${paint.sky.bold(String(tasks.length))} tasks`);
-		const reasons = (await this.executeTasksInPhase(phase, tasks)).reduce((rejected, result) => {
-			if (result.status === "rejected") rejected.push(result.reason);
-			return rejected;
-		}, []);
-		if (reasons.length > 0) throw new SeedcordAggregateError(SeedcordErrorCode.LifecyclePhaseFailures, reasons, [this.phaseEnum[phase], reasons.length]);
-		this.logger.debug(`Phase ${paint.iris.bold(this.phaseEnum[phase])} ${paint.mint.bold("completed successfully")}`);
-	}
-	async runTaskWithTimeout(phase, task) {
-		this.logger.trace(`${paint.italic("Starting")} task ${paint.sky.bold(task.name)} in phase ${paint.iris.bold(this.phaseEnum[phase])}`);
-		try {
-			await withTimeout(task.name, task.task, task.timeout);
-			this.logger.trace(`${paint.italic("Completed")} task ${paint.sky.bold(task.name)} in phase ${paint.iris.bold(this.phaseEnum[phase])}`);
-		} catch (error) {
-			if (this.isAborted()) return;
-			this.logger.error(`${paint.italic("Failed")} task ${paint.sky.bold(task.name)} in phase ${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, 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 ${paint.amber.bold("SIGTERM")} signal`);
-			this.run(0);
-		};
-		this.onSigInt = () => {
-			this.logger.info(`Received ${paint.amber.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(`${paint.amber.bold("Starting")} coordinated shutdown with exit code ${paint.sky.bold(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(`${paint.coral.bold("Coordinated shutdown failed")}`, ...failures);
-			else this.logger.info(`${paint.mint.bold("Coordinated shutdown completed")} successfully`);
-		} finally {
-			this.hasShutdown = true;
-			if (exitProcess) {
-				this.logger.debug(`${paint.coral.bold("Exiting")} process with code ${paint.sky.bold(this.exitCode)}`);
-				setTimeout(() => {
-					process.exit(this.exitCode);
-				}, LOG_FLUSH_DELAY_MS);
-			} else {
-				this.logger.debug(`${paint.amber.bold("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, StartupPhase);
-	}
-	addTask(phase, taskName, task, timeoutMs = 1e4) {
-		super.addTask(phase, taskName, task, timeoutMs);
-	}
-	canAddTask() {
-		if (this.hasStarted) throw new SeedcordError(SeedcordErrorCode.LifecycleAddAfterCompletion);
-		if (this.isStartingUp) throw new SeedcordError(SeedcordErrorCode.LifecycleAddDuringRun);
-		return true;
-	}
-	canRemoveTask() {
-		if (this.isStartingUp) throw new SeedcordError(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(`${paint.mint.bold("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(`${paint.mint.bold("Coordinated startup completed")} successfully`);
-		} catch (error) {
-			if (!this.isStartingUp) {
-				this.logger.warn("Startup sequence aborted during error handling");
-				return;
-			}
-			this.logger.error(`${paint.coral.bold("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;
-	}
-};
-
-//#endregion
 //#region src/node/HealthResponder.ts
 const HTTP_OK = 200;
 const DEFAULT_HEALTH_CHECK_PATH = "/health";
@@ -369,185 +107,6 @@ var HealthCheck = class HealthCheck {
 	}
 };
 
-//#endregion
-//#region src/node/Pluggable.ts
-const RESERVED_KEYS = new Set(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 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 SeedcordError(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 SeedcordError(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 SeedcordError(SeedcordErrorCode.CorePluginAfterInit);
-		if (RESERVED_KEYS.has(key)) throw new SeedcordError(SeedcordErrorCode.CorePluginReservedChannel, [key]);
-		if (key in this) throw new SeedcordError(SeedcordErrorCode.CorePluginKeyExists, [key]);
-		const instance = new Plugin(this, ...args);
-		pluginLoggerOf(instance).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 = 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 + 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 = resolvedLifecycleSpecOf(instance);
-			pluginLoggerOf(instance).utils.initialization(key, "start");
-			await withTimeout(`Plugin (${key})`, () => instance.init(), spec.init.timeout);
-			pluginLoggerOf(instance).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: resolvedLifecycleSpecOf(a.instance).ready.timeout
-			});
-			return acc;
-		}, []);
-		if (readyInits.length === 0 && steps.length === 0) return;
-		const budget = readyInits.reduce((sum, a) => sum + 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 = 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 SeedcordAggregateError(SeedcordErrorCode.PluginDisposeFailures, failures, [failures.length]);
-	}
-	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 = 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 {
@@ -573,14 +132,14 @@ var SubscriberLoader = class {
 	async init() {
 		if (this.isInitialized) return;
 		this.isInitialized = true;
-		this.bus.registerDefaults();
+		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");
+			busLoggerOf(this.bus).utils.list([`${paint.iris.bold(this.bus[RegisteredCount])} subscribers`], paint.mint.bold("Loaded"), "debug");
 		}
-		if (!Envapter.isTest) await this.bus.verifyWebhooks();
+		if (!Envapter.isTest) await this.bus[VerifyWebhooks]();
 	}
 	/** @internal */
 	async onHmr(event) {
@@ -598,10 +157,10 @@ var SubscriberLoader = class {
 		});
 	}
 	registerSubscriber(ctor) {
-		this.bus.register(registrationFor(ctor));
+		this.bus[RegisterSubscriber](registrationFor(ctor));
 	}
 	unregisterSubscriber(ctor, artifacts) {
-		this.bus.unregister(ctor, artifacts);
+		this.bus[UnregisterSubscriber](ctor, artifacts);
 	}
 	getArtifacts(ctor) {
 		return [Reflect.getMetadata(SubscribeMetadataKey, ctor).subscriber];
@@ -623,7 +182,7 @@ function indexById(commands) {
 * @internal
 */
 var CommandRegistry = class {
-	options;
+	core;
 	logger = new Logger("Commands", { channel: "commands" });
 	isInitialised = false;
 	globalCommands = [];
@@ -633,13 +192,17 @@ var CommandRegistry = class {
 	loadedCommands = [];
 	hmrHandler;
 	pendingEvents = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.options = options;
-		if (!options.dir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
+	injector = new CommandInjector();
+	dir;
+	constructor(core) {
+		this.core = core;
+		const dir = core.config.bot.commands.path;
+		if (!dir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
+		this.dir = dir;
 		if (!Envapter.isDevelopment && !Envapter.isTest) return;
 		this.hmrHandler = new HmrModuleHandler({
-			handlersDir: options.dir,
-			isHandler: this.isCommandClass.bind(this),
+			handlersDir: dir,
+			isHandler: isCommandClass,
 			registerHandler: this.registerCommand.bind(this),
 			unregisterHandler: this.unregisterCommand.bind(this),
 			getArtifacts: this.getArtifacts.bind(this),
@@ -656,7 +219,7 @@ var CommandRegistry = class {
 		this.loading = true;
 		this.loadedCommands.length = 0;
 		try {
-			await this.loadCommands(this.options.dir);
+			await this.loadCommands(this.dir);
 		} finally {
 			this.loading = false;
 		}
@@ -694,7 +257,7 @@ var CommandRegistry = class {
 	}
 	/** @internal */
 	async onHmr(event) {
-		if (event.file.startsWith(resolve(process.cwd(), this.options.dir))) {
+		if (event.file.startsWith(resolve(process.cwd(), this.dir))) {
 			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)) });
@@ -702,16 +265,12 @@ var CommandRegistry = class {
 	}
 	async loadCommands(dir) {
 		await traverseDirectory(dir, (fullPath, rel, mod) => {
-			for (const exported of Object.values(mod)) if (this.isCommandClass(exported)) {
+			for (const exported of Object.values(mod)) if (isCommandClass(exported)) {
 				this.registerCommand(exported, rel);
 				this.hmrHandler?.trackHandler(fullPath, exported);
 			}
 		});
 	}
-	isCommandClass(obj) {
-		if (typeof obj !== "function") return false;
-		return obj.prototype instanceof BuilderComponent && Reflect.hasMetadata(CommandMetadataKey, obj);
-	}
 	registerCommand(ctor, rel) {
 		const meta = Reflect.getMetadata(CommandMetadataKey, ctor);
 		if (!meta) return;
@@ -755,7 +314,7 @@ var CommandRegistry = class {
 			global: /* @__PURE__ */ new Map(),
 			guilds: /* @__PURE__ */ new Map()
 		};
-		const appId = this.options.applicationId();
+		const appId = this.core.applicationId;
 		if (this.globalCommands.length > 0) {
 			result.global = indexById(await this.put(Routes.applicationCommands(appId), this.globalCommands));
 			const tag = this.globalCommands.length === 1 ? "command" : "commands";
@@ -767,12 +326,14 @@ var CommandRegistry = class {
 			const tag = commands.length === 1 ? "command" : "commands";
 			this.logger.utils.block(`Deployed ${paint.iris.bold(commands.length)} ${tag} to ${paint.sky.bold(guildId)}`, this.logger.utils.wrap(commands.map((command) => command.name)), "info");
 		}
-		this.options.onDeployed?.(result);
+		this.injector.inject(result, this.allCommands());
+		this.core.bus[PublishDefault]("commandsDeployed", deployedPayload(result));
 		return result;
 	}
 	async put(route, commands) {
 		const body = commands.map((command) => command.toJSON());
-		return await this.options.rest.put(route, { body });
+		const { rest } = this.core;
+		return await rest.put(route, { body });
 	}
 	/** Every registered builder, global first. A guild command in N guilds appears once per guild. @internal */
 	allCommands() {
@@ -787,7 +348,19 @@ var CommandRegistry = class {
 		return contextMenuLeaves(this.allCommands());
 	}
 };
+function deployedPayload(result) {
+	const guilds = {};
+	for (const [guildId, deployed] of result.guilds) guilds[guildId] = [...deployed.values()];
+	return {
+		global: [...result.global.values()],
+		guilds
+	};
+}
+
+//#endregion
+//#region src/node-internal.index.ts
+assertNodeVersion(">=24.11", process.version);
 
 //#endregion
-export { CommandRegistry, CoordinatedShutdown, CoordinatedStartup, HealthCheck, HealthResponder, Pluggable, ShutdownPhase, StartupPhase, SubscriberLoader, settleWithin };
+export { CommandRegistry, HealthCheck, HealthResponder, ShutdownPhase, StartupPhase, SubscriberLoader, settleWithin, shutdownOf };
 //# sourceMappingURL=node-internal.index.mjs.map