@seedcord/core 0.3.1 → 0.4.1

package/dist/node-internal.index.mjs

@@ -1,300 +1,22 @@
-import { D as contextMenuLeaves, S as SubscribeMetadataKey, c as Subscriber, f as BuilderComponent, h as CommandMetadataKey, i as PublishDefault, n as busLoggerOf, r as registrationFor } from "./Bus-BvF4VShN.mjs";
-import { t as CommandInjector } from "./subscribers-wnMyNYZd.mjs";
+import { C as SubscribeMetadataKey, O as contextMenuLeaves, a as RegisterSubscriber, c as VerifyWebhooks, f as Subscriber, g as CommandMetadataKey, i as RegisterDefaults, n as busLoggerOf, o as RegisteredCount, r as registrationFor, s as UnregisterSubscriber } from "./Bus-yJGE6Fs2.mjs";
+import { t as CommandInjector } from "./subscribers-DVa-Pr45.mjs";
+import { t as PublishDefault } from "./publishDefault-D826XXDQ.mjs";
 import { n as StartupPhase, t as ShutdownPhase } from "./phases-BauKJOTT.mjs";
 import { t as getDevChannel } from "./devChannel-CQU7hq7Q.mjs";
-import { n as pluginLoggerOf, r as resolvedLifecycleSpecOf } from "./Plugin-D9ykXA5g.mjs";
-import { t as slashRouteLeaves } from "./slashRouteLeaves-De1SxqnX.mjs";
+import { n as isCommandClass, t as slashRouteLeaves } from "./slashRouteLeaves-BQmbFm-S.mjs";
 import { t as HmrModuleHandler } from "./HmrModuleHandler-9AUfKXRl.mjs";
+import { i as settleWithin, n as shutdownOf, r as assertNodeVersion } from "./Pluggable-BI_LQuPm.mjs";
 import { SlashCommandBuilder } from "@discordjs/builders";
-import { SeedcordErrorCode, paint } from "@seedcord/errors";
-import { FRAMEWORK_CHANNELS, Logger } from "@seedcord/logger";
 import { Routes } from "discord-api-types/v10";
-import { SeedcordAggregateError, SeedcordError } from "@seedcord/errors/internal";
+import { SeedcordErrorCode, paint } from "@seedcord/errors";
+import { SeedcordError } from "@seedcord/errors/internal";
+import { Logger } from "@seedcord/logger";
 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/assertNodeVersion.ts
-const RANGE = new RegExp(String.raw`^>=(\d+)(?:\.(\d+))?`);
-const VERSION = /^v?(\d+)\.(\d+)/;
-const SPACES = /\s/g;
-/** @internal */
-function assertNodeVersion(range, running) {
-	const required = RANGE.exec(range.replaceAll(SPACES, ""));
-	const current = VERSION.exec(running);
-	if (!required || !current) return;
-	const [, requiredMajor, requiredMinor = "0"] = required;
-	const [, currentMajor, currentMinor] = current;
-	if (Number(currentMajor) > Number(requiredMajor) || Number(currentMajor) === Number(requiredMajor) && Number(currentMinor) >= Number(requiredMinor)) return;
-	throw new SeedcordError(SeedcordErrorCode.UnsupportedNodeVersion, [range, running]);
-}
-
-//#endregion
-//#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";
@@ -385,181 +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.
-*
-* You attach plugins while configuring the bot. Within one startup phase, their `init()` calls run
-* one after another in attach order.
-*/
-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) {
-		assertNodeVersion(">=24.11", process.version);
-		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 under `key`. Read the instance back as `core[key]`. `seedcord codegen`
-	* writes the `Core` augmentation that types it there.
-	*
-	* Startup runs each plugin's `init()` in attach order within its phase.
-	*
-	* Attaching a plugin whose `transport` or `runtime` differs from this host fails to compile.
-	* Your constructor takes `CoreBase` as its first parameter (you don't need to pass it though).
-	* A narrower one fails to compile here.
-	*
-	* @param key - Also the channel the plugin logs on. Reserved channel names throw.
-	* @param args - Whatever your constructor takes after the host.
-	* @throws A **SeedcordError** if you attach after the bot has started. A taken or reserved key throws too.
-	* @example
-	* ```ts
-	* 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 {
@@ -585,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) {
@@ -610,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];
@@ -655,7 +202,7 @@ var CommandRegistry = class {
 		if (!Envapter.isDevelopment && !Envapter.isTest) return;
 		this.hmrHandler = new HmrModuleHandler({
 			handlersDir: dir,
-			isHandler: this.isCommandClass.bind(this),
+			isHandler: isCommandClass,
 			registerHandler: this.registerCommand.bind(this),
 			unregisterHandler: this.unregisterCommand.bind(this),
 			getArtifacts: this.getArtifacts.bind(this),
@@ -718,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;
@@ -819,5 +362,5 @@ function deployedPayload(result) {
 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