@seedcord/core 0.1.0-next.5 → 0.1.0-next.7

package/dist/node-internal.index.mjs

@@ -0,0 +1,706 @@
+import { m as SubscribeMetadataKey } from "./publishDefault-CCf1azzW.mjs";
+import { n as StartupPhase, t as ShutdownPhase } from "./phases-BfpAG6w3.mjs";
+import { n as registrationFor, o as Subscriber } from "./subscribers-DYqFVP1X.mjs";
+import { n as resolvedLifecycleSpecOf, r as finalizePluginContext } from "./Plugin-j9GYdroS.mjs";
+import { t as HmrModuleHandler } from "./HmrModuleHandler-3sNgKHdf.mjs";
+import { SeedcordErrorCode } from "@seedcord/errors";
+import { SeedcordError } from "@seedcord/errors/internal";
+import { FRAMEWORK_CHANNELS, Logger, paint } from "@seedcord/logger";
+import chalk from "chalk";
+import { Envapter } from "envapt";
+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);
+	}
+}
+/** @internal rejects with a `LifecycleTaskTimeout` when `run` outlasts the bound. */
+function withTimeout(name, run, timeoutMs) {
+	return raceTimer(run(), timeoutMs, (_, reject) => {
+		reject(new SeedcordError(SeedcordErrorCode.LifecycleTaskTimeout, [name, timeoutMs]));
+	});
+}
+/** @internal resolves when `work` settles or the bound elapses, whichever is first. */
+function settleWithin(work, timeoutMs) {
+	return raceTimer(work, timeoutMs, (resolve) => resolve());
+}
+
+//#endregion
+//#region src/node/Lifecycle/CoordinatedLifecycle.ts
+/**
+* Base for the startup and shutdown coordinators. Runs phase-ordered tasks off a per-phase map.
+*
+* @internal
+*/
+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, []));
+	}
+	/**
+	* Adds a task to `phase`. Tasks run in phase order, each bounded by `timeoutMs`.
+	*
+	* @param phase - The lifecycle phase to add the task to
+	* @param taskName - Unique name for the task, used for logging and removal
+	* @param task - Async function to execute during the phase
+	* @param timeoutMs - Maximum time allowed for task execution in milliseconds
+	*/
+	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(`${chalk.italic("Added")} ${this.getTaskType()} task ${chalk.bold.cyan(taskName)} to phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
+	}
+	/**
+	* Removes a lifecycle task from a specific phase.
+	*
+	* @param phase - The lifecycle phase to remove the task from
+	* @param taskName - Name of the task to remove
+	* @returns True if the task was found and removed, false otherwise
+	*/
+	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.italic("Removed")} ${this.getTaskType()} task ${chalk.bold.cyan(taskName)} from phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
+		return removed;
+	}
+	async runPhase(phase) {
+		const tasks = this.tasksMap.get(phase) ?? [];
+		if (tasks.length === 0) {
+			this.logger.debug(`No tasks to run in phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
+			return;
+		}
+		this.logger.info(`${chalk.bold.yellow("Running")} ${this.getTaskType()} phase ${chalk.bold.magenta(this.phaseEnum[phase])} with ${chalk.bold.cyan(tasks.length)} tasks`);
+		const failures = (await this.executeTasksInPhase(phase, tasks)).filter((r) => r.status === "rejected").length;
+		if (failures > 0) throw new SeedcordError(SeedcordErrorCode.LifecyclePhaseFailures, [this.phaseEnum[phase], failures]);
+		this.logger.info(`Phase ${chalk.bold.magenta(this.phaseEnum[phase])} ${chalk.bold.green("completed successfully")}`);
+	}
+	async runTaskWithTimeout(phase, task) {
+		this.logger.info(`${chalk.italic("Starting")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
+		try {
+			await withTimeout(task.name, task.task, task.timeout);
+			this.logger.info(`${chalk.italic("Completed")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
+		} catch (error) {
+			this.logger.error(`${chalk.italic("Failed")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(this.phaseEnum[phase])}:`, error);
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/node/Lifecycle/CoordinatedShutdown.ts
+const PHASE_ORDER$1 = [
+	1,
+	2,
+	3,
+	4
+];
+const LOG_FLUSH_DELAY_MS = 3e3;
+/**
+* Runs registered shutdown tasks across `ShutdownPhase` in order. Registers SIGINT and SIGTERM
+* handlers. Tasks within a phase run in parallel.
+*/
+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 ${chalk.yellow.bold("SIGTERM")} signal`);
+			this.run(0);
+		};
+		this.onSigInt = () => {
+			this.logger.info(`Received ${chalk.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;
+	}
+	/**
+	* 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);
+	}
+	/** Removes a shutdown-phase task, returning whether one was removed. */
+	removeTask(phase, taskName) {
+		return super.removeTask(phase, taskName);
+	}
+	/**
+	* 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` }
+	* @example
+	* ```typescript
+	* shutdown.addTask(ShutdownPhase.Disconnect, 'database', () => db.disconnect(), 5000);
+	* await shutdown.run(0);
+	* ```
+	*/
+	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.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk.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.bold.red("Coordinated shutdown failed")}`, ...failures);
+			else this.logger.info(`${chalk.bold.green("Coordinated shutdown completed")} successfully`);
+		} finally {
+			this.hasShutdown = true;
+			if (exitProcess) {
+				this.logger.info(`${chalk.bold.red("Exiting")} process with code ${chalk.bold.cyan(this.exitCode)}`);
+				setTimeout(() => {
+					process.exit(this.exitCode);
+				}, LOG_FLUSH_DELAY_MS);
+			} else {
+				this.logger.info(`${chalk.bold.yellow("Skipping")} process exit (dev mode)`);
+				this.isShuttingDown = false;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/node/Lifecycle/CoordinatedStartup.ts
+const PHASE_ORDER = [
+	1,
+	2,
+	3
+];
+/**
+* Runs registered startup tasks across `StartupPhase` in order. Tasks within a phase run in parallel.
+*/
+var CoordinatedStartup = class extends CoordinatedLifecycle {
+	isStartingUp = false;
+	hasStarted = false;
+	constructor() {
+		super("Startup", PHASE_ORDER, StartupPhase);
+	}
+	/**
+	* 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);
+	}
+	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);
+	}
+	/**
+	* Runs the registered tasks across startup phases in `StartupPhase` order. Each phase completes
+	* before the next begins, and tasks within a phase run concurrently.
+	*
+	* @throws {@link SeedcordError} if a startup task throws.
+	*/
+	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.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.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.bold.red("Coordinated startup failed")}`);
+			throw error;
+		} finally {
+			this.isStartingUp = false;
+		}
+	}
+	async runTaskWithTimeout(phase, task) {
+		this.logger.info(`${chalk.italic("Starting")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(StartupPhase[phase])}`);
+		try {
+			await withTimeout(task.name, task.task, task.timeout);
+			this.logger.info(`${chalk.italic("Completed")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(StartupPhase[phase])}`);
+		} catch (error) {
+			if (!this.isStartingUp) return;
+			this.logger.error(`${chalk.italic("Failed")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(StartupPhase[phase])}:`, error);
+			throw error;
+		}
+	}
+	/**
+	* Aborts the startup sequence if it is currently running.
+	*/
+	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/HealthCheck.ts
+const HTTP_OK = 200;
+const HTTP_NOT_FOUND = 404;
+const DEFAULT_HEALTH_CHECK_PORT = 6967;
+const DEFAULT_HEALTH_CHECK_PATH = "/health";
+/**
+* HTTP server answering `GET` on the configured path with a JSON `{ status, timestamp }` body.
+*/
+var HealthCheck = class HealthCheck {
+	/** @internal */
+	logger = new Logger("HealthCheck", { channel: "health" });
+	port;
+	path;
+	host;
+	server;
+	constructor(shutdown, options) {
+		this.port = options?.port ?? DEFAULT_HEALTH_CHECK_PORT;
+		this.path = options?.path ?? DEFAULT_HEALTH_CHECK_PATH;
+		this.host = options?.host;
+		shutdown.addTask(2, "stop-healthcheck-server", () => this.stop());
+	}
+	/**
+	* Resolves the `healthCheck` option. `undefined` and `true` build the defaults, an object uses
+	* its config, `false` returns `undefined`.
+	*/
+	static fromOption(shutdown, option) {
+		if (option === false) return void 0;
+		return new HealthCheck(shutdown, typeof option === "object" ? option : void 0);
+	}
+	/**
+	* Starts the health check server.
+	* @returns Promise that resolves when the server is listening
+	* @internal
+	*/
+	async init() {
+		return new Promise((resolve, reject) => {
+			const server = createServer((req, res) => {
+				if (req.method === "GET" && req.url === this.path) {
+					res.writeHead(HTTP_OK, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						status: "ok",
+						timestamp: Date.now()
+					}));
+				} else {
+					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(`${paint.mint.bold("✔︎")} Health check server listening on ${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);
+			}
+		});
+	}
+	/**
+	* Stops the health check server.
+	* @internal
+	*/
+	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(paint.coral.bold("Health check server stopped"));
+				resolve();
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/node/Pluggable.ts
+const RESERVED_KEYS = new Set(FRAMEWORK_CHANNELS);
+/**
+* Base class for objects that can have plugins attached.
+*
+* 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.
+*/
+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;
+	}
+	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 */
+	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);
+		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;
+		instance.logger.setChannel(key);
+		finalizePluginContext(instance, {
+			config: this.config,
+			store: this.pluginStore(),
+			client: caps.client,
+			get token() {
+				return readToken();
+			},
+			rest: caps.rest
+		});
+	}
+	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);
+			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: 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 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 = 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
+/**
+* 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 (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir: this.directory,
+			isHandler: this.isSubscriber.bind(this),
+			registerHandler: this.registerSubscriber.bind(this),
+			unregisterHandler: this.unregisterSubscriber.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: 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.bold(directory));
+			await this.load(directory);
+			this.bus.logger.utils.list([`${chalk.bold.magenta(this.bus.registeredCount)} subscribers`], chalk.bold.green("Loaded"));
+		}
+		if (!Envapter.isTest) await this.bus.verifyWebhooks();
+	}
+	/** @internal */
+	async onHmr(event) {
+		if (this.hmrHandler) await this.hmrHandler.handle(event);
+	}
+	async load(dir) {
+		await 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(registrationFor(ctor));
+	}
+	unregisterSubscriber(ctor, artifacts) {
+		this.bus.unregister(ctor, artifacts);
+	}
+	getArtifacts(ctor) {
+		return [Reflect.getMetadata(SubscribeMetadataKey, ctor).subscriber];
+	}
+	isSubscriber(value) {
+		if (typeof value !== "function") return false;
+		return value.prototype instanceof Subscriber && Reflect.hasMetadata(SubscribeMetadataKey, value);
+	}
+};
+
+//#endregion
+export { CoordinatedShutdown, CoordinatedStartup, HealthCheck, Pluggable, ShutdownPhase, StartupPhase, SubscriberLoader, settleWithin };
+//# sourceMappingURL=node-internal.index.mjs.map