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

package/dist/node-internal.index.cjs

@@ -0,0 +1,645 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
+const require_phases = require('./phases-C_BGNyVo.cjs');
+const require_Plugin = require('./Plugin-C2-VHrsX.cjs');
+let _seedcord_errors = require("@seedcord/errors");
+let _seedcord_errors_internal = require("@seedcord/errors/internal");
+let _seedcord_logger = require("@seedcord/logger");
+let chalk = require("chalk");
+chalk = require_rolldown_runtime.__toESM(chalk, 1);
+let _seedcord_event_emitter = require("@seedcord/event-emitter");
+let node_http = require("node:http");
+
+//#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 _seedcord_errors_internal.SeedcordError(_seedcord_errors.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 extends _seedcord_event_emitter.TypedEventEmitter {
+	phaseOrder;
+	phaseEnum;
+	logger;
+	tasksMap = /* @__PURE__ */ new Map();
+	constructor(loggerName, phaseOrder, phaseEnum) {
+		super();
+		this.phaseOrder = phaseOrder;
+		this.phaseEnum = phaseEnum;
+		this.logger = new _seedcord_logger.Logger(loggerName);
+		this.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 _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 ${chalk.default.bold.cyan(taskName)} to phase ${chalk.default.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.default.italic("Removed")} ${this.getTaskType()} task ${chalk.default.bold.cyan(taskName)} from phase ${chalk.default.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.default.bold.magenta(this.phaseEnum[phase])}`);
+			return;
+		}
+		this.logger.info(`${chalk.default.bold.yellow("Running")} ${this.getTaskType()} phase ${chalk.default.bold.magenta(this.phaseEnum[phase])} with ${chalk.default.bold.cyan(tasks.length)} tasks`);
+		this.emitPhase(phase, "start");
+		const failures = (await this.executeTasksInPhase(phase, tasks)).filter((r) => r.status === "rejected").length;
+		if (failures > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.LifecyclePhaseFailures, [this.phaseEnum[phase], failures]);
+		this.logger.info(`Phase ${chalk.default.bold.magenta(this.phaseEnum[phase])} ${chalk.default.bold.green("completed successfully")}`);
+		this.emitPhase(phase, "complete");
+	}
+	async runTaskWithTimeout(phase, task) {
+		this.logger.info(`${chalk.default.italic("Starting")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(this.phaseEnum[phase])}`);
+		try {
+			await withTimeout(task.name, task.task, task.timeout);
+			this.logger.info(`${chalk.default.italic("Completed")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(this.phaseEnum[phase])}`);
+		} catch (error) {
+			this.logger.error(`${chalk.default.italic("Failed")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(this.phaseEnum[phase])}:`, error);
+			throw error;
+		}
+	}
+	emitPhase(phase, action) {
+		this.emitSafeRaw(`phase:${phase}:${action}`);
+	}
+	onListenerError(error, event) {
+		this.logger.error(`listener for ${String(event)} threw`, 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, 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 a shutdown during startup waits for startup to register its dispose tasks */
+	gateOnStartup(settled) {
+		this.startupGate = settled;
+	}
+	/** Adds a shutdown-phase task. @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.default.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk.default.bold.cyan(exitCode)}`);
+		this.emitSafe("shutdown:start");
+		try {
+			if (this.startupGate) await this.startupGate;
+			const failures = [];
+			for (const phase of PHASE_ORDER$1) try {
+				await this.runPhase(phase);
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length > 0) this.emitFailures(failures);
+			else {
+				this.logger.info(`${chalk.default.bold.green("Coordinated shutdown completed")} successfully`);
+				this.emitSafe("shutdown:complete");
+			}
+		} finally {
+			this.hasShutdown = true;
+			if (exitProcess) {
+				this.logger.info(`${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.info(`${chalk.default.bold.yellow("Skipping")} process exit (dev mode)`);
+				this.isShuttingDown = false;
+			}
+		}
+	}
+	emitFailures(failures) {
+		this.logger.error(`${chalk.default.bold.red("Coordinated shutdown failed")}`);
+		const error = failures.length === 1 ? failures[0] : new AggregateError(failures, "shutdown phase failures");
+		this.emitSafe("shutdown:error", error);
+	}
+};
+
+//#endregion
+//#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, require_phases.StartupPhase);
+	}
+	/** Adds a startup-phase task. @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 _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);
+	}
+	/**
+	* 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.default.bold.green("Starting")} coordinated startup sequence`);
+		this.emitSafe("startup:start");
+		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`);
+			this.emitSafe("startup:complete");
+		} catch (error) {
+			if (!this.isStartingUp) {
+				this.logger.warn("Startup sequence aborted during error handling");
+				return;
+			}
+			this.logger.error(`${chalk.default.bold.red("Coordinated startup failed")}`);
+			this.emitSafe("startup:error", error);
+			throw error;
+		} finally {
+			this.isStartingUp = false;
+		}
+	}
+	async runTaskWithTimeout(phase, task) {
+		this.logger.info(`${chalk.default.italic("Starting")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(require_phases.StartupPhase[phase])}`);
+		try {
+			await withTimeout(task.name, task.task, task.timeout);
+			this.logger.info(`${chalk.default.italic("Completed")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(require_phases.StartupPhase[phase])}`);
+		} catch (error) {
+			if (!this.isStartingUp) return;
+			this.logger.error(`${chalk.default.italic("Failed")} task ${chalk.default.bold.cyan(task.name)} in phase ${chalk.default.bold.magenta(require_phases.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 _seedcord_logger.Logger("HealthCheck");
+	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 = (0, node_http.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(`${_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);
+			}
+		});
+	}
+	/**
+	* 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(_seedcord_logger.paint.coral.bold("Health check server stopped"));
+				resolve();
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/node/Pluggable.ts
+/**
+* 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 extends _seedcord_event_emitter.TypedEventEmitter {
+	isInitialized = false;
+	startFailed = false;
+	shutdown;
+	startup;
+	plugins = [];
+	pluginLogger = new _seedcord_logger.Logger("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);
+		}
+		super();
+		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;
+	}
+	pluginCapabilities() {
+		return {};
+	}
+	pluginStore() {
+		return this.config.store ?? this.rateLimiter;
+	}
+	/** @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`. Augment the transport's `Core` interface with the plugin
+	* type for intellisense.
+	*
+	* @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
+	* @example
+	* ```typescript
+	* seedcord.attach('db', Mongo, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
+	* ```
+	*/
+	attach(key, Plugin, ...args) {
+		if (this.isInitialized) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.CorePluginAfterInit);
+		if (key in this) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.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;
+		require_Plugin.finalizePluginContext(instance, {
+			logger: new _seedcord_logger.Logger(key),
+			config: this.config,
+			store: this.pluginStore(),
+			client: caps.client,
+			get token() {
+				return readToken();
+			},
+			rest: caps.rest
+		});
+	}
+	registerPluginTasks() {
+		if (this.pluginTasksRegistered) return;
+		this.pluginTasksRegistered = true;
+		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", 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();
+	}
+	/** @internal */
+	removeListener(event, listener) {
+		return super.removeListener(event, listener);
+	}
+	/** @internal */
+	removeAllListeners(event) {
+		return super.removeAllListeners(event);
+	}
+};
+
+//#endregion
+exports.CoordinatedShutdown = CoordinatedShutdown;
+exports.CoordinatedStartup = CoordinatedStartup;
+exports.HealthCheck = HealthCheck;
+exports.Pluggable = Pluggable;
+exports.ShutdownPhase = require_phases.ShutdownPhase;
+exports.StartupPhase = require_phases.StartupPhase;
+exports.settleWithin = settleWithin;
+//# sourceMappingURL=node-internal.index.cjs.map