@seedcord/services 0.5.1 → 0.7.0-next.0

package/dist/index.mjs

@@ -1,1114 +1,1498 @@
-import { Envapter, Envapt } from 'envapt';
-import { format, transports, createLogger } from 'winston';
-import chalk2 from 'chalk';
-import { createServer } from 'http';
-import { EventEmitter } from 'events';
+import { a as SeedcordErrorCode, i as isSeedcordError, t as SeedcordError } from "./SeedcordError-xd-Ib_-z.mjs";
+import { Envapter } from "envapt";
+import path from "node:path";
+import winston, { createLogger, format, transports } from "winston";
+import fs from "node:fs";
+import stripAnsi from "strip-ansi";
+import TransportStream from "winston-transport";
+import { formatFilePath } from "@seedcord/utils";
+import chalk from "chalk";
+import { createServer } from "http";
+import { EventEmitter } from "node:events";
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var Logger = class _Logger {
-  static {
-    __name(this, "Logger");
-  }
-  static instances = /* @__PURE__ */ new Map();
-  static instance(prefix) {
-    let instance = this.instances.get(prefix);
-    if (!instance) {
-      instance = new _Logger(prefix);
-      this.instances.set(prefix, instance);
-    }
-    return instance;
-  }
-  constructor(transportName) {
-    const consoleTransport = this.createConsoleTransport(transportName);
-    this.initializeLogger(consoleTransport);
-  }
-  getFormatCustomizations() {
-    const padding = 7;
-    return [
-      format.errors({
-        stack: true
-      }),
-      format.splat(),
-      format.colorize({
-        level: true
-      }),
-      format.timestamp({
-        format: "D MMM, hh:mm:ss a"
-      }),
-      format.printf((info) => {
-        const ts = String(info.timestamp ?? "");
-        const lvl = String(info.level).padEnd(padding);
-        const lbl = String(info.label ?? "");
-        const msg = String(info.message ?? "");
-        const base = `${ts} [${lvl}]: ${lbl} - ${msg}`;
-        const splatSym = Symbol.for("splat");
-        const raw = info[splatSym];
-        const extras = Array.isArray(raw) ? raw : [];
-        const cleaned = extras.filter((x) => !(x instanceof Error)).filter((x) => {
-          if (!x) return false;
-          if (typeof x !== "object") return true;
-          return Object.keys(x).length > 0;
-        });
-        let rendered = base;
-        if (typeof info.stack === "string") {
-          rendered += `
-${String(info.stack)}`;
-        }
-        if (cleaned.length) {
-          const parts = [];
-          for (const x of cleaned) {
-            if (typeof x === "string") parts.push(x);
-            else {
-              try {
-                parts.push(JSON.stringify(x, null, 2));
-              } catch {
-                parts.push(String(x));
-              }
-            }
-          }
-          rendered += `
-${parts.join(" ")}`;
-        }
-        return rendered;
-      })
-    ];
-  }
-  createConsoleTransport(transportName) {
-    return new transports.Console({
-      format: format.combine(format.label({
-        label: transportName
-      }), ...this.getFormatCustomizations()),
-      level: Envapter.isDevelopment ? "silly" : Envapter.isStaging ? "debug" : "info"
-    });
-  }
-  initializeLogger(consoleTransport) {
-    const transportsArray = [
-      consoleTransport
-    ];
-    if (Envapter.isDevelopment) {
-      const maxSizeInMB = 10;
-      transportsArray.push(new transports.File({
-        filename: "logs/application.log",
-        level: "debug",
-        format: format.combine(format.uncolorize(), format.errors({
-          stack: true
-        }), format.timestamp(), format.json({
-          bigint: true,
-          space: 2
-        })),
-        maxsize: maxSizeInMB * 1024 * 1024,
-        maxFiles: 5,
-        tailable: true
-      }));
-    }
-    this.logger = createLogger({
-      transports: transportsArray
-    });
-  }
-  /**
-   * Logs an error message with optional additional data.
-   *
-   * @param msg - The error message to log
-   * @param args - Additional data to include in the log entry
-   */
-  error(msg, ...args) {
-    this.logger.error(msg, ...args);
-  }
-  /**
-   * Logs a warning message with optional additional data.
-   *
-   * @param msg - The warning message to log
-   * @param args - Additional data to include in the log entry
-   */
-  warn(msg, ...args) {
-    this.logger.warn(msg, ...args);
-  }
-  /**
-   * Logs an informational message with optional additional data.
-   *
-   * @param msg - The informational message to log
-   * @param args - Additional data to include in the log entry
-   */
-  info(msg, ...args) {
-    this.logger.info(msg, ...args);
-  }
-  /**
-   * Logs an HTTP-related message with optional additional data.
-   *
-   * @param msg - The HTTP message to log
-   * @param args - Additional data to include in the log entry
-   */
-  http(msg, ...args) {
-    this.logger.http(msg, ...args);
-  }
-  /**
-   * Logs a verbose message with optional additional data.
-   *
-   * @param msg - The verbose message to log
-   * @param args - Additional data to include in the log entry
-   */
-  verbose(msg, ...args) {
-    this.logger.verbose(msg, ...args);
-  }
-  /**
-   * Logs a debug message with optional additional data.
-   *
-   * @param msg - The debug message to log
-   * @param args - Additional data to include in the log entry
-   */
-  debug(msg, ...args) {
-    this.logger.debug(msg, ...args);
-  }
-  /**
-   * Logs a silly/trace level message with optional additional data.
-   *
-   * @param msg - The silly message to log
-   * @param args - Additional data to include in the log entry
-   */
-  silly(msg, ...args) {
-    this.logger.silly(msg, ...args);
-  }
-  /**
-   * Static method to log an error message with a specific prefix.
-   * Creates or retrieves a logger instance for the given prefix.
-   *
-   * @param prefix - The logger prefix/label to use
-   * @param msg - The error message to log
-   * @param args - Additional data to include in the log entry
-   */
-  static Error(prefix, msg, ...args) {
-    const logger = this.instance(prefix);
-    logger.error(msg, ...args);
-  }
-  /**
-   * Static method to log an informational message with a specific prefix.
-   * Creates or retrieves a logger instance for the given prefix.
-   *
-   * @param prefix - The logger prefix/label to use
-   * @param msg - The informational message to log
-   * @param args - Additional data to include in the log entry
-   */
-  static Info(prefix, msg, ...args) {
-    const logger = this.instance(prefix);
-    logger.info(msg, ...args);
-  }
-  /**
-   * Static method to log a warning message with a specific prefix.
-   * Creates or retrieves a logger instance for the given prefix.
-   *
-   * @param prefix - The logger prefix/label to use
-   * @param msg - The warning message to log
-   * @param args - Additional data to include in the log entry
-   */
-  static Warn(prefix, msg, ...args) {
-    const logger = this.instance(prefix);
-    logger.warn(msg, ...args);
-  }
-  /**
-   * Static method to log a debug message with a specific prefix.
-   * Creates or retrieves a logger instance for the given prefix.
-   *
-   * @param prefix - The logger prefix/label to use
-   * @param msg - The debug message to log
-   * @param args - Additional data to include in the log entry
-   */
-  static Debug(prefix, msg, ...args) {
-    const logger = this.instance(prefix);
-    logger.debug(msg, ...args);
-  }
-  /**
-   * Static method to log a silly/trace level message with a specific prefix.
-   * Creates or retrieves a logger instance for the given prefix.
-   *
-   * @param prefix - The logger prefix/label to use
-   * @param msg - The silly message to log
-   * @param args - Additional data to include in the log entry
-   */
-  static Silly(prefix, msg, ...args) {
-    const logger = this.instance(prefix);
-    logger.silly(msg, ...args);
-  }
+//#region src/Logger/LogFormatter.ts
+/**
+* Formats log records for console and file outputs.
+*
+* Supports pretty-printed colored logs for development
+* and JSON logs for production with optional ANSI stripping.
+* @internal
+*/
+var LogFormatter = class {
+	DEFAULT_PADDING = 7;
+	SPLAT = Symbol.for("splat");
+	safeString(value) {
+		if (typeof value === "string") return value;
+		if (value === void 0 || value === null) return "";
+		if (typeof value.toString === "function") return String(value.toString());
+		if (typeof value === "object") try {
+			return JSON.stringify(value);
+		} catch {
+			return "";
+		}
+		return "";
+	}
+	sanitizeAnsi(value) {
+		if (typeof value === "string") return stripAnsi(value);
+		if (value instanceof Error) {
+			const error = value;
+			const sanitized = new Error(stripAnsi(error.message));
+			sanitized.name = error.name;
+			if (typeof error.stack === "string") sanitized.stack = stripAnsi(error.stack);
+			return sanitized;
+		}
+		return value;
+	}
+	getExtras(info) {
+		const raw = info[this.SPLAT];
+		return Array.isArray(raw) ? raw : [];
+	}
+	FORMAT_SPECIFIERS = /%[sdifjoO]/gu;
+	HAD_FORMAT_KEY = Symbol.for("hadFormatSpecifiers");
+	SAVED_SPLAT_KEY = Symbol.for("savedSplat");
+	markFormatSpecifiers() {
+		return format((info) => {
+			const msg = typeof info.message === "string" ? info.message : "";
+			const extras = this.getExtras(info);
+			const matches = msg.match(this.FORMAT_SPECIFIERS);
+			const formatCount = matches ? matches.length : 0;
+			info[this.HAD_FORMAT_KEY] = formatCount;
+			info[this.SAVED_SPLAT_KEY] = [...extras];
+			return info;
+		})();
+	}
+	createPreFormat() {
+		return this.markFormatSpecifiers();
+	}
+	preserveErrorFormatting() {
+		return format((info) => {
+			const extras = this.getExtras(info);
+			for (const item of extras) if (item instanceof Error && /\u001b/.test(item.name)) {
+				const originalName = item.name;
+				const plainName = stripAnsi(item.name);
+				const formatted = item;
+				formatted.__formattedName = originalName;
+				formatted.__plainName = plainName;
+			}
+			return info;
+		})();
+	}
+	restoreErrorFormatting() {
+		return format((info) => {
+			if (typeof info.stack === "string") {
+				const extras = this.getExtras(info);
+				for (const item of extras) if (item instanceof Error) {
+					const { __formattedName: formattedName, __plainName: plainName } = item;
+					if (typeof formattedName === "string" && typeof plainName === "string") info.stack = info.stack.replace(new RegExp(`^${this.escapeRegex(plainName)}`, "m"), formattedName);
+				}
+			}
+			return info;
+		})();
+	}
+	escapeRegex(str) {
+		return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+	/**
+	* Creates pretty-printed format with colors and timestamps.
+	*
+	* Ideal for development environments where human readability matters.
+	*
+	* @param options - Formatting options including padding and ANSI stripping
+	* @returns Array of Winston format transformers
+	*/
+	pretty(options = {}) {
+		const padding = options.padding ?? this.DEFAULT_PADDING;
+		return [
+			this.preserveErrorFormatting(),
+			format.errors({ stack: true }),
+			this.restoreErrorFormatting(),
+			format.splat(),
+			format.colorize({ level: true }),
+			format.timestamp({ format: "D MMM, hh:mm:ss a" }),
+			format.printf((info) => {
+				let ts = this.safeString(info.timestamp);
+				let lvl = this.safeString(info.level).padEnd(padding);
+				let lbl = this.safeString(info.label);
+				let msg = this.safeString(info.message);
+				if (options.stripExtras) {
+					ts = stripAnsi(ts);
+					lvl = stripAnsi(lvl);
+					lbl = stripAnsi(lbl);
+					msg = stripAnsi(msg);
+				}
+				const base = `${ts} [${lvl}]: ${lbl} - ${msg}`;
+				const savedExtras = info[this.SAVED_SPLAT_KEY];
+				const extras = Array.isArray(savedExtras) ? savedExtras : this.getExtras(info);
+				let rendered = base;
+				if (typeof info.stack === "string") {
+					let stack = this.safeString(info.stack);
+					if (options.stripExtras) stack = stripAnsi(stack);
+					rendered += `\n${stack}`;
+				}
+				const cleaned = options.stripExtras ? extras.map((entry) => this.sanitizeAnsi(entry)) : extras;
+				const rawFormatCount = info[this.HAD_FORMAT_KEY];
+				const formatSpecifierCount = typeof rawFormatCount === "number" ? rawFormatCount : 0;
+				const filtered = cleaned.filter((x, index) => {
+					if (x === null || x === void 0) return false;
+					if (x instanceof Error && typeof info.stack === "string") return false;
+					if (typeof x !== "object") return index >= formatSpecifierCount;
+					return Object.keys(x).length > 0;
+				});
+				if (filtered.length) {
+					const primitives = [];
+					const objects = [];
+					for (const x of filtered) if (typeof x === "string" || typeof x === "number" || typeof x === "boolean") primitives.push(String(x));
+					else try {
+						objects.push(JSON.stringify(x, null, 2));
+					} catch {
+						objects.push(String(x));
+					}
+					if (primitives.length) rendered += ` ${primitives.join(" ")}`;
+					if (objects.length) rendered += `\n${objects.join("\n")}`;
+				}
+				return rendered;
+			})
+		];
+	}
+	/**
+	* Creates JSON format for structured logging.
+	*
+	* Best for production environments where logs are parsed by tools.
+	*
+	* @param options - JSON formatting options including ANSI stripping and minimal mode
+	* @returns Array of Winston format transformers
+	*/
+	json(options = {}) {
+		const base = [format.timestamp(), format.errors({ stack: true })];
+		if (options.stripAnsi) base.push(format((info) => {
+			info.message = typeof info.message === "string" ? stripAnsi(info.message) : info.message;
+			if (typeof info.stack === "string") info.stack = stripAnsi(info.stack);
+			const extras = this.getExtras(info);
+			if (extras.length) info.extras = extras.map((entry) => this.sanitizeAnsi(entry));
+			return info;
+		})());
+		base.push(options.minimal ? format.json({}) : format.json({
+			bigint: true,
+			space: 0
+		}));
+		return base;
+	}
 };
 
-// src/CooldownManager.ts
-var CooldownManager = class {
-  static {
-    __name(this, "CooldownManager");
-  }
-  window;
-  Err;
-  msg;
-  map = /* @__PURE__ */ new Map();
-  /**
-   * Creates a new CooldownManager instance.
-   *
-   * @param opts - Configuration options for the cooldown behavior
-   */
-  constructor(opts = {}) {
-    this.window = opts.cooldown ?? 1e3;
-    this.Err = opts.err ?? Error;
-    this.msg = opts.message ?? "Cooldown active";
-  }
-  /**
-   * Records usage timestamp for a key without any cooldown checks.
-   *
-   * @param key - The unique identifier for the cooldown entry
-   */
-  set(key) {
-    this.map.set(key, Date.now());
-  }
-  /**
-   * Verifies cooldown status for a key and updates timestamp if not active.
-   *
-   * If the cooldown is still active, throws the configured error.
-   * If not active, updates the timestamp and returns successfully.
-   *
-   * @param key - The unique identifier to check cooldown for
-   * @throws An {@link Err} When the cooldown is still active for the given key
-   */
-  check(key) {
-    const now = Date.now();
-    const last = this.map.get(key);
-    const remaining = this.window - (now - (last ?? 0));
-    if (Envapter.isDevelopment && remaining > 0) {
-      Logger.Debug("CooldownManager", `${key} - ${remaining}ms remaining`);
-    }
-    if (last !== void 0 && remaining > 0) {
-      throw new this.Err(this.msg, remaining);
-    }
-    this.map.set(key, now);
-  }
-  /**
-   * Checks if a key is currently cooling down without updating timestamp.
-   *
-   * @param key - The unique identifier to check
-   * @returns True if the key is still cooling down, false otherwise
-   */
-  isActive(key) {
-    const last = this.map.get(key);
-    return last !== void 0 && Date.now() - last < this.window;
-  }
-  /**
-   * Removes a key from the cooldown map.
-   *
-   * @param key - The unique identifier to remove (useful for manual resets)
-   */
-  clear(key) {
-    this.map.delete(key);
-  }
+//#endregion
+//#region src/Logger/Transports/SinkTransport.ts
+/**
+* Winston transport that forwards logs to custom sinks.
+* @internal
+*/
+var SinkTransport = class extends TransportStream {
+	channelName;
+	sink;
+	constructor(options) {
+		super(options);
+		this.channelName = options.channel;
+		this.sink = options.sink;
+	}
+	log(info, callback) {
+		setImmediate(() => this.emit("logged", info));
+		const rendered = this.resolveRendered(info);
+		const channel = this.resolveChannel(info);
+		this.sink.onLog({
+			channel,
+			rendered,
+			info
+		});
+		callback();
+	}
+	resolveChannel(info) {
+		const channel = info.channel;
+		return typeof channel === "string" ? channel : this.channelName;
+	}
+	resolveRendered(info) {
+		const msg = info[Symbol.for("message")];
+		if (typeof msg === "string") return msg;
+		const fallback = info.message;
+		if (typeof fallback === "string") return fallback;
+		if (fallback instanceof Error) return fallback.stack ?? fallback.message;
+		return String(fallback ?? "");
+	}
 };
 
-// src/Errors/ErrorCodes.ts
-var SeedcordErrorCode = /* @__PURE__ */ (function(SeedcordErrorCode2) {
-  SeedcordErrorCode2[SeedcordErrorCode2["ConfigMissingDiscordToken"] = 1001] = "ConfigMissingDiscordToken";
-  SeedcordErrorCode2[SeedcordErrorCode2["ConfigUnknownExceptionWebhookMissing"] = 1002] = "ConfigUnknownExceptionWebhookMissing";
-  SeedcordErrorCode2[SeedcordErrorCode2["ConfigUnknownExceptionWebhookInvalid"] = 1003] = "ConfigUnknownExceptionWebhookInvalid";
-  SeedcordErrorCode2[SeedcordErrorCode2["LifecycleAddAfterCompletion"] = 1101] = "LifecycleAddAfterCompletion";
-  SeedcordErrorCode2[SeedcordErrorCode2["LifecycleAddDuringRun"] = 1102] = "LifecycleAddDuringRun";
-  SeedcordErrorCode2[SeedcordErrorCode2["LifecycleRemoveDuringRun"] = 1103] = "LifecycleRemoveDuringRun";
-  SeedcordErrorCode2[SeedcordErrorCode2["LifecycleUnknownPhase"] = 1104] = "LifecycleUnknownPhase";
-  SeedcordErrorCode2[SeedcordErrorCode2["LifecyclePhaseFailures"] = 1105] = "LifecyclePhaseFailures";
-  SeedcordErrorCode2[SeedcordErrorCode2["LifecycleTaskTimeout"] = 1106] = "LifecycleTaskTimeout";
-  SeedcordErrorCode2[SeedcordErrorCode2["CoreSingletonViolation"] = 1201] = "CoreSingletonViolation";
-  SeedcordErrorCode2[SeedcordErrorCode2["CorePluginAfterInit"] = 1202] = "CorePluginAfterInit";
-  SeedcordErrorCode2[SeedcordErrorCode2["CorePluginKeyExists"] = 1203] = "CorePluginKeyExists";
-  SeedcordErrorCode2[SeedcordErrorCode2["CoreBotRoleMissing"] = 1204] = "CoreBotRoleMissing";
-  SeedcordErrorCode2[SeedcordErrorCode2["DecoratorInteractionEventFilter"] = 1301] = "DecoratorInteractionEventFilter";
-  SeedcordErrorCode2[SeedcordErrorCode2["DecoratorMethodNotFound"] = 1302] = "DecoratorMethodNotFound";
-  SeedcordErrorCode2[SeedcordErrorCode2["DecoratorCommandAlreadyRegistered"] = 1303] = "DecoratorCommandAlreadyRegistered";
-  SeedcordErrorCode2[SeedcordErrorCode2["DecoratorCommandGlobalWithGuilds"] = 1304] = "DecoratorCommandGlobalWithGuilds";
-  SeedcordErrorCode2[SeedcordErrorCode2["DecoratorCommandGuildWithoutGuilds"] = 1305] = "DecoratorCommandGuildWithoutGuilds";
-  SeedcordErrorCode2[SeedcordErrorCode2["DecoratorInvalidMiddlewarePriority"] = 1306] = "DecoratorInvalidMiddlewarePriority";
-  SeedcordErrorCode2[SeedcordErrorCode2["UtilHexInputType"] = 1401] = "UtilHexInputType";
-  SeedcordErrorCode2[SeedcordErrorCode2["UtilHexInvalid"] = 1402] = "UtilHexInvalid";
-  SeedcordErrorCode2[SeedcordErrorCode2["UtilInvalidSlashRouteArgument"] = 1403] = "UtilInvalidSlashRouteArgument";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginMongoServiceDecoratorMissing"] = 2101] = "PluginMongoServiceDecoratorMissing";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginMongoModelDecoratorMissing"] = 2102] = "PluginMongoModelDecoratorMissing";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginMongoConnectionFailed"] = 2103] = "PluginMongoConnectionFailed";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgServiceDecoratorMissing"] = 2201] = "PluginKpgServiceDecoratorMissing";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgServiceTableMissing"] = 2202] = "PluginKpgServiceTableMissing";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgInvalidStepCount"] = 2203] = "PluginKpgInvalidStepCount";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgUnknownDirection"] = 2204] = "PluginKpgUnknownDirection";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgUnresolvedMigrationsPath"] = 2205] = "PluginKpgUnresolvedMigrationsPath";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgNoMigrationFiles"] = 2206] = "PluginKpgNoMigrationFiles";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgInvalidMigrationModule"] = 2207] = "PluginKpgInvalidMigrationModule";
-  SeedcordErrorCode2[SeedcordErrorCode2["PluginKpgNonErrorFailure"] = 2208] = "PluginKpgNonErrorFailure";
-  return SeedcordErrorCode2;
-})({});
+//#endregion
+//#region src/Logger/TransportFactory.ts
+/**
+* Creates Winston transports with proper formatting and file path resolution.
+*
+* Builds console and file transports with environment-aware defaults,
+* filename template expansion, and format selection.
+* @internal
+*/
+var TransportFactory = class {
+	formatter;
+	MILLISECOND_PAD = 3;
+	cachedSessionTimestamp = null;
+	constructor() {
+		this.formatter = new LogFormatter();
+	}
+	ensureDir(filepath) {
+		const dir = path.dirname(filepath);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	}
+	withDefaultLabel(label) {
+		return format.combine(format((info) => {
+			info.label ??= label;
+			return info;
+		})());
+	}
+	buildPreFormat() {
+		return format.combine(this.formatter.createPreFormat());
+	}
+	buildConsoleFormat(label) {
+		if (Envapter.isProduction) return format.combine(this.withDefaultLabel(label), ...this.formatter.json({ stripAnsi: true }));
+		return format.combine(this.withDefaultLabel(label), ...this.formatter.pretty());
+	}
+	buildFileFormat(label, mode, stripAnsi) {
+		const formats = mode === "pretty" ? this.formatter.pretty({ stripExtras: stripAnsi }) : this.formatter.json({ stripAnsi });
+		return format.combine(this.withDefaultLabel(label), ...formats);
+	}
+	buildStreamFormat(label, mode, stripAnsi) {
+		const formats = mode === "pretty" ? this.formatter.pretty({ stripExtras: stripAnsi }) : this.formatter.json({ stripAnsi });
+		return format.combine(this.withDefaultLabel(label), ...formats);
+	}
+	pad(value) {
+		return value.toString().padStart(2, "0");
+	}
+	buildTimestamp() {
+		if (this.cachedSessionTimestamp) return this.cachedSessionTimestamp;
+		const now = /* @__PURE__ */ new Date();
+		const yyyy = now.getFullYear();
+		const mm = this.pad(now.getMonth() + 1);
+		const dd = this.pad(now.getDate());
+		const hh = this.pad(now.getHours());
+		const min = this.pad(now.getMinutes());
+		const ss = this.pad(now.getSeconds());
+		const ms = now.getMilliseconds().toString().padStart(this.MILLISECOND_PAD, "0");
+		const date = `${yyyy}-${mm}-${dd}`;
+		const timestamp = `${date}-${hh}${min}${ss}-${ms}`;
+		this.cachedSessionTimestamp = {
+			date,
+			timestamp
+		};
+		return this.cachedSessionTimestamp;
+	}
+	resolveFilename(template, channel) {
+		const { date, timestamp } = this.buildTimestamp();
+		return template.replaceAll("{channel}", channel).replaceAll("{date}", date).replaceAll("{timestamp}", timestamp);
+	}
+	/**
+	* Builds a Winston transport from configuration.
+	*
+	* Creates console, file, or stream transport with proper formatting,
+	* level filtering, and file rotation settings.
+	*
+	* @param input - Transport configuration parameters
+	* @returns Configured Winston transport instance
+	*/
+	build(input) {
+		const effectiveFormat = input.config.format ?? input.defaultFormat;
+		const shouldStripAnsi = input.config.stripAnsi ?? input.stripAnsi;
+		const level = input.config.level ?? input.level;
+		if (input.config.type === "console") return new transports.Console({
+			level,
+			format: this.buildConsoleFormat(input.label)
+		});
+		if (input.config.type === "stream") return new transports.Stream({
+			level,
+			stream: input.config.stream,
+			format: this.buildStreamFormat(input.label, effectiveFormat, shouldStripAnsi)
+		});
+		const filenameTemplate = input.config.filename ?? "logs/application-{timestamp}.log";
+		const resolvedFilename = this.resolveFilename(filenameTemplate, input.channel);
+		this.ensureDir(resolvedFilename);
+		return new transports.File({
+			level,
+			filename: resolvedFilename,
+			...input.config.maxSize !== void 0 ? { maxsize: input.config.maxSize } : {},
+			...input.config.maxFiles !== void 0 ? { maxFiles: input.config.maxFiles } : {},
+			tailable: true,
+			format: this.buildFileFormat(input.label, effectiveFormat, shouldStripAnsi)
+		});
+	}
+	/**
+	* Builds a sink transport for routing logs to custom destinations.
+	*
+	* @param input - Transport configuration with channel and level info
+	* @param sink - Custom sink to receive log entries
+	* @returns Configured sink transport instance
+	*/
+	buildSinkTransport(input, sink) {
+		const format = this.buildConsoleFormat(input.label);
+		return new SinkTransport({
+			level: input.level,
+			channel: input.channel,
+			sink,
+			format
+		});
+	}
+};
 
-// src/Errors/ErrorMessages.ts
-var messages = {
-  [SeedcordErrorCode.ConfigMissingDiscordToken]: () => "Missing DISCORD_BOT_TOKEN environment variable.",
-  [SeedcordErrorCode.ConfigUnknownExceptionWebhookMissing]: () => "Missing UNKNOWN_EXCEPTION_WEBHOOK_URL environment variable.",
-  [SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid]: () => "Invalid UNKNOWN_EXCEPTION_WEBHOOK_URL value.",
-  [SeedcordErrorCode.LifecycleAddAfterCompletion]: () => "Cannot add tasks after startup sequence has already completed.",
-  [SeedcordErrorCode.LifecycleAddDuringRun]: () => "Cannot add tasks while startup sequence is in progress.",
-  [SeedcordErrorCode.LifecycleRemoveDuringRun]: () => "Cannot remove tasks while startup sequence is in progress.",
-  [SeedcordErrorCode.LifecycleUnknownPhase]: (phase) => `Unknown phase: ${String(phase)}.`,
-  [SeedcordErrorCode.LifecyclePhaseFailures]: (phase, failures) => `Phase ${phase} completed with ${failures} failed task${failures === 1 ? "" : "s"}.`,
-  [SeedcordErrorCode.LifecycleTaskTimeout]: (taskName, timeout) => `Task "${taskName}" timed out after ${timeout}ms.`,
-  [SeedcordErrorCode.CoreSingletonViolation]: () => "Seedcord can only be instantiated once. Use the existing instance instead.",
-  [SeedcordErrorCode.CorePluginAfterInit]: () => "Cannot attach a plugin after initialization.",
-  [SeedcordErrorCode.CorePluginKeyExists]: (key) => `Plugin with key "${key}" already exists.`,
-  [SeedcordErrorCode.CoreBotRoleMissing]: (guildId) => guildId ? `Bot role not found in guild ${guildId}.` : "Bot role not found in guild.",
-  [SeedcordErrorCode.DecoratorInteractionEventFilter]: () => "Interaction middleware cannot specify event filters.",
-  [SeedcordErrorCode.DecoratorMethodNotFound]: () => "Decorator could not locate the original method. Ensure the method exists before applying the decorator.",
-  [SeedcordErrorCode.DecoratorCommandAlreadyRegistered]: (commandName, existingScope, requestedScope) => `Command "${commandName}" is already registered as a "${existingScope}" command and cannot be re-registered as a "${requestedScope}" command.`,
-  [SeedcordErrorCode.DecoratorCommandGlobalWithGuilds]: () => 'RegisterCommand("global") cannot have guilds specified.',
-  [SeedcordErrorCode.DecoratorCommandGuildWithoutGuilds]: () => 'RegisterCommand("guild") requires a non-empty guilds array.',
-  [SeedcordErrorCode.DecoratorInvalidMiddlewarePriority]: () => "Middleware priority must be a finite number.",
-  [SeedcordErrorCode.UtilHexInputType]: () => "hexToNumber expects a string input.",
-  [SeedcordErrorCode.UtilHexInvalid]: () => "Invalid hex string.",
-  [SeedcordErrorCode.UtilInvalidSlashRouteArgument]: () => "Invalid argument passed to buildSlashRoute.",
-  [SeedcordErrorCode.PluginMongoServiceDecoratorMissing]: (className) => `Missing @RegisterMongoService on ${className}.`,
-  [SeedcordErrorCode.PluginMongoModelDecoratorMissing]: (className) => `Missing @RegisterMongoModel on ${className}.`,
-  [SeedcordErrorCode.PluginMongoConnectionFailed]: (databaseName) => databaseName ? `Could not connect to MongoDB (${databaseName}).` : "Could not connect to MongoDB.",
-  [SeedcordErrorCode.PluginKpgServiceDecoratorMissing]: (className) => `Missing @RegisterKpgService on ${className}.`,
-  [SeedcordErrorCode.PluginKpgServiceTableMissing]: (className) => `Missing table metadata for ${className}. Provide a table via @RegisterKpgService().`,
-  [SeedcordErrorCode.PluginKpgInvalidStepCount]: () => "Migration step count must be a non-negative integer.",
-  [SeedcordErrorCode.PluginKpgUnknownDirection]: (direction) => `Unknown migration direction: ${String(direction)}.`,
-  [SeedcordErrorCode.PluginKpgUnresolvedMigrationsPath]: (label) => `Unable to resolve migrations at path: ${label}.`,
-  [SeedcordErrorCode.PluginKpgNoMigrationFiles]: () => "No migration files provided.",
-  [SeedcordErrorCode.PluginKpgInvalidMigrationModule]: (filePath) => `Migration file ${filePath} must export async functions up and down.`,
-  [SeedcordErrorCode.PluginKpgNonErrorFailure]: (message) => `Migration failure: ${message}.`
+//#endregion
+//#region src/Logger/LoggerChannelRegistry.ts
+/**
+* Manages Winston logger instances per channel with caching.
+*
+* Stores channel configuration and creates transports for each channel
+* with environment-aware defaults.
+*/
+var LoggerChannelRegistry = class LoggerChannelRegistry {
+	static _instance = null;
+	nextSinkId = 1;
+	sinks = /* @__PURE__ */ new Map();
+	DEFAULT_LEVEL = Envapter.isDevelopment ? "silly" : Envapter.isStaging ? "debug" : "info";
+	config = {
+		defaultChannel: "default",
+		channels: {},
+		files: {
+			maxSizeMB: 10,
+			maxFiles: 5,
+			patterns: {
+				dev: "logs/{channel}-{timestamp}.log",
+				staging: "logs/staging-{date}-{timestamp}.jsonl",
+				prod: "logs/production-{date}.jsonl"
+			}
+		}
+	};
+	FORMAT = Envapter.isDevelopment ? "pretty" : "json";
+	cache = /* @__PURE__ */ new Map();
+	transportFactory;
+	constructor() {
+		this.transportFactory = new TransportFactory();
+	}
+	/**
+	* Gets the singleton instance of the registry.
+	*/
+	static get instance() {
+		return this._instance ??= new LoggerChannelRegistry();
+	}
+	getDefaultChannelConfig(name) {
+		return {
+			name,
+			level: this.DEFAULT_LEVEL,
+			transports: [{
+				type: "console",
+				level: this.DEFAULT_LEVEL,
+				format: this.FORMAT,
+				stripAnsi: !Envapter.isDevelopment
+			}, {
+				type: "file",
+				level: this.DEFAULT_LEVEL,
+				filename: Envapter.isDevelopment ? this.config.files.patterns.dev : Envapter.isStaging ? this.config.files.patterns.staging : this.config.files.patterns.prod,
+				format: this.FORMAT,
+				stripAnsi: true,
+				maxSize: this.config.files.maxSizeMB * 1024 * 1024,
+				maxFiles: this.config.files.maxFiles
+			}]
+		};
+	}
+	mergeChannelConfig(base, override) {
+		if (!override) return base;
+		const level = override.level ?? base.level;
+		const stripAnsi = override.stripAnsi ?? base.stripAnsi;
+		const format = override.format ?? base.format;
+		const transports = override.transports ?? base.transports;
+		return {
+			name: override.name || base.name,
+			...level !== void 0 ? { level } : {},
+			...stripAnsi !== void 0 ? { stripAnsi } : {},
+			...format !== void 0 ? { format } : {},
+			...transports !== void 0 ? { transports } : {}
+		};
+	}
+	/**
+	* Updates global logger configuration and clears cache.
+	*
+	* @param config - Partial configuration to merge with existing settings
+	*/
+	configure(config) {
+		this.disposeCachedLoggers();
+		this.config = {
+			...this.config,
+			...config,
+			channels: {
+				...this.config.channels,
+				...config.channels ?? {}
+			}
+		};
+		this.cache.clear();
+	}
+	disposeCachedLoggers() {
+		for (const logger of this.cache.values()) for (const transport of [...logger.transports]) {
+			logger.remove(transport);
+			transport.close?.();
+		}
+		for (const record of this.sinks.values()) {
+			record.transportsByChannel.clear();
+			record.removedConsoleByChannel.clear();
+		}
+	}
+	/**
+	* Returns the name of the default channel.
+	*/
+	getDefaultChannel() {
+		return this.config.defaultChannel;
+	}
+	/**
+	* Returns a list of all known channels (configured or cached).
+	*/
+	getChannels() {
+		const configuredChannels = Object.keys(this.config.channels);
+		const cachedChannels = Array.from(this.cache.keys());
+		const allChannels = new Set([
+			...configuredChannels,
+			...cachedChannels,
+			this.config.defaultChannel
+		]);
+		return Array.from(allChannels).sort();
+	}
+	/**
+	* Gets the log file path for a specific channel, if one exists.
+	*
+	* @param channel - Channel name to get log file path for
+	* @returns The log file path, or null if no file transport exists
+	*/
+	getLogFilePath(channel) {
+		const logger = this.cache.get(channel);
+		if (!logger) return null;
+		for (const transport of logger.transports) if (transport instanceof winston.transports.File) return path.resolve(transport.dirname, transport.filename);
+		return null;
+	}
+	/**
+	* Gets or creates a Winston logger instance for the given channel.
+	*
+	* @param channel - Channel name to get logger for
+	* @returns Configured Winston logger instance
+	*/
+	get(channel) {
+		const cached = this.cache.get(channel);
+		if (cached) return cached;
+		const channelConfig = this.mergeChannelConfig(this.getDefaultChannelConfig(channel), this.config.channels[channel]);
+		const effectiveLevel = channelConfig.level ?? this.DEFAULT_LEVEL;
+		const consoleMuted = this.isConsoleMuted();
+		const transports = (channelConfig.transports ?? []).filter((transportConfig) => !(consoleMuted && transportConfig.type === "console")).map((transportConfig) => this.transportFactory.build({
+			channel,
+			label: channel,
+			level: effectiveLevel,
+			config: transportConfig,
+			defaultFormat: channelConfig.format ?? "pretty",
+			stripAnsi: channelConfig.stripAnsi ?? true
+		}));
+		const logger = createLogger({
+			level: effectiveLevel,
+			format: this.transportFactory.buildPreFormat(),
+			transports
+		});
+		for (const entry of this.sinks.values()) this.applySinkToCachedLogger(channel, logger, entry);
+		this.cache.set(channel, logger);
+		return logger;
+	}
+	isConsoleMuted() {
+		for (const entry of this.sinks.values()) if (entry.muteConsole) return true;
+		return false;
+	}
+	/**
+	* Installs a custom sink to capture log output across all channels.
+	*
+	* Useful for routing logs to custom destinations like TUIs or remote services.
+	*
+	* @param sink - Custom sink implementation to receive log entries
+	* @param options - Optional configuration for console muting behavior
+	* @returns Handle to dispose the sink when no longer needed
+	*/
+	installSink(sink, options) {
+		const id = this.nextSinkId;
+		this.nextSinkId += 1;
+		const record = {
+			sink,
+			muteConsole: options?.muteConsole ?? true,
+			transportsByChannel: /* @__PURE__ */ new Map(),
+			removedConsoleByChannel: /* @__PURE__ */ new Map()
+		};
+		this.sinks.set(id, record);
+		for (const [channel, logger] of this.cache.entries()) this.applySinkToCachedLogger(channel, logger, record);
+		return new class {
+			registry;
+			key;
+			constructor(registry, key) {
+				this.registry = registry;
+				this.key = key;
+			}
+			dispose() {
+				this.registry.uninstallSink(this.key);
+			}
+		}(this, id);
+	}
+	uninstallSink(id) {
+		const record = this.sinks.get(id);
+		if (!record) return;
+		for (const [channel, logger] of this.cache.entries()) {
+			const sinkTransport = record.transportsByChannel.get(channel);
+			if (sinkTransport) logger.remove(sinkTransport);
+			const removed = record.removedConsoleByChannel.get(channel);
+			if (removed?.length) for (const t of removed) logger.add(t);
+		}
+		this.sinks.delete(id);
+	}
+	applySinkToCachedLogger(channel, logger, record) {
+		if (record.muteConsole) {
+			const removed = [];
+			for (const t of logger.transports) if (t instanceof winston.transports.Console) removed.push(t);
+			if (removed.length) {
+				for (const t of removed) logger.remove(t);
+				record.removedConsoleByChannel.set(channel, removed);
+			}
+		}
+		const sinkTransport = this.transportFactory.buildSinkTransport({
+			channel,
+			label: channel,
+			level: logger.level
+		}, record.sink);
+		logger.add(sinkTransport);
+		record.transportsByChannel.set(channel, sinkTransport);
+	}
 };
-function formatSeedcordErrorMessage(code, args) {
-  const formatter = messages[code];
-  const resolvedArgs = args ?? [];
-  return formatter(...resolvedArgs);
-}
-__name(formatSeedcordErrorMessage, "formatSeedcordErrorMessage");
-function resolveIdentifier(code) {
-  return SeedcordErrorCode[code];
-}
-__name(resolveIdentifier, "resolveIdentifier");
-function resolveMessage(code, args) {
-  return formatSeedcordErrorMessage(code, args);
-}
-__name(resolveMessage, "resolveMessage");
-function formatErrorName(name, _identifier, code) {
-  return `${chalk2.bold.red(name)}[${chalk2.gray(code)}]`;
-}
-__name(formatErrorName, "formatErrorName");
-var SeedcordError = class extends Error {
-  static {
-    __name(this, "SeedcordError");
-  }
-  code;
-  identifier;
-  constructor(code, args, options) {
-    const message = resolveMessage(code, args);
-    super(message, options);
-    this.code = code;
-    this.identifier = resolveIdentifier(code);
-    this.name = formatErrorName(new.target.name, this.identifier, this.code);
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, new.target);
-    }
-  }
+
+//#endregion
+//#region src/Logger/LoggerUtilities.ts
+/**
+* Provides access to common logging utilities.
+*/
+var LoggerUtilities = class {
+	logger;
+	constructor(logger) {
+		this.logger = logger;
+	}
+	arrow(text) {
+		return `${chalk.gray("→")} ${text}`;
+	}
+	/**
+	* Logs a single item with an arrow prefix.
+	* @param text - The text to log
+	*/
+	item(text, level = "info") {
+		this.logger[level](this.arrow(text));
+	}
+	/**
+	* Logs a list of items with optional heading.
+	*
+	* @param items - Array of items to log as a list
+	* @param heading - Optional heading to display above the list
+	*/
+	list(items, heading, level = "info") {
+		if (heading) this.logger[level](heading);
+		for (const item of items) this.logger[level](this.arrow(item));
+	}
+	/**
+	* Logs a summary with title and key-value pairs.
+	* Example: "Loaded: 5 handlers, 3 commands"
+	*
+	* @param title - The title of the summary
+	* @param items - Object with counts/values to display
+	*/
+	summary(title, items, level = "info") {
+		const entries = Object.entries(items).map(([key, value]) => `${chalk.magenta.bold(String(value))} ${key}`);
+		this.logger[level](`${chalk.bold.green(title)}: ${entries.join(", ")}`);
+	}
+	/**
+	* Logs a component registration message.
+	*
+	* @param name - Name of the component being registered
+	* @param from - File path the component is from
+	* @param type - Optional type label (e.g., 'middleware', 'handler')
+	*/
+	registration(name, from, type, level = "info") {
+		const scope = type ? `${type} ` : "";
+		this.logger[level](`${chalk.italic("Registered")} ${chalk.bold.yellow(scope)}${chalk.cyan.bold(name)} from ${chalk.gray(formatFilePath(from))}`);
+	}
+	/**
+	* Logs component initialization start/end.
+	*
+	* @param component - Name of the component
+	* @param action - 'start' or 'end' to indicate initialization phase
+	*/
+	initialization(component, action, level = "info") {
+		const verb = action === "start" ? "Initializing" : "Initialized";
+		this.logger[level](chalk.bold(`${verb} ${component}`));
+	}
+	/**
+	* Logs progress as "[current/total]" with optional item label.
+	*
+	* @param current - Current progress count
+	* @param total - Total count
+	* @param item - Optional item label to append
+	*/
+	progress(current, total, item, level = "info") {
+		const base = `[${current}/${total}]`;
+		const suffix = item ? ` ${item}` : "";
+		this.logger[level](`${chalk.cyan(base)}${suffix}`);
+	}
+	/**
+	* Logs content in a decorative box.
+	*
+	* @param title - Title to display in the box
+	* @param content - Lines of content to display in the box
+	*/
+	box(title, content, level = "info") {
+		const width = Math.max(title.length, ...content.map((line) => line.length)) + 2;
+		const horizontal = "─".repeat(width);
+		this.logger[level](`╭${horizontal}╮`);
+		this.logger[level](`│ ${title.padEnd(width - 1, " ")}│`);
+		for (const line of content) this.logger[level](`│ ${line.padEnd(width - 1, " ")}│`);
+		this.logger[level](`╰${horizontal}╯`);
+	}
 };
-var SeedcordTypeError = class extends TypeError {
-  static {
-    __name(this, "SeedcordTypeError");
-  }
-  code;
-  identifier;
-  constructor(code, args, options) {
-    const message = resolveMessage(code, args);
-    super(message, options);
-    this.code = code;
-    this.identifier = resolveIdentifier(code);
-    this.name = formatErrorName(new.target.name, this.identifier, this.code);
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, new.target);
-    }
-  }
+
+//#endregion
+//#region src/Logger/Logger.ts
+/**
+* Public logging service with channel-aware transports and per-run file output.
+*
+* - Channel separation (e.g., bot, cli, hmr)
+* - Production-safe JSON logs with ANSI stripping
+* - Unique log files per run via filename templates
+*/
+var Logger = class Logger {
+	label;
+	channel;
+	registry = LoggerChannelRegistry.instance;
+	utils;
+	static instances = /* @__PURE__ */ new Map();
+	static instance(prefix, channel) {
+		const key = channel ? `${channel}::${prefix}` : prefix;
+		let instance = this.instances.get(key);
+		if (!instance) {
+			instance = new Logger(prefix, channel ? { channel } : void 0);
+			this.instances.set(key, instance);
+		}
+		return instance;
+	}
+	/**
+	* Configures global logger settings.
+	*
+	* Applies configuration to all channels and clears instance cache.
+	*
+	* @param config - Partial configuration to merge with defaults
+	*/
+	static configure(config) {
+		LoggerChannelRegistry.instance.configure(config);
+		this.instances.clear();
+	}
+	/**
+	* Creates a new Logger instance.
+	*
+	* @param label - Prefix/label for all log entries from this logger
+	* @param options - Optional configuration for channel, format, and ANSI handling
+	*/
+	constructor(label, options) {
+		this.label = label;
+		this.channel = options?.channel ?? this.registry.getDefaultChannel();
+		this.logger = this.registry.get(this.channel).child({
+			label: this.label,
+			channel: this.channel
+		});
+		this.utils = new LoggerUtilities(this);
+	}
+	/**
+	* Switches this logger to a different channel.
+	*
+	* @param channel - Channel name to switch to
+	*/
+	setChannel(channel) {
+		this.channel = channel;
+		this.logger = this.registry.get(channel).child({
+			label: this.label,
+			channel
+		});
+	}
+	/**
+	* Returns a new Logger instance configured for the specified channel. Loggers are cached per (label, channel) pair.
+	*
+	* @param channel - Channel name to use
+	*/
+	inChannel(channel) {
+		return Logger.instance(this.label, channel);
+	}
+	/**
+	* Logs an error message with optional additional data.
+	*
+	* @param msg - The error message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	error(msg, ...args) {
+		this.logger.error(msg, ...args);
+	}
+	/**
+	* Logs a warning message with optional additional data.
+	*
+	* @param msg - The warning message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	warn(msg, ...args) {
+		this.logger.warn(msg, ...args);
+	}
+	/**
+	* Logs an informational message with optional additional data.
+	*
+	* @param msg - The informational message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	info(msg, ...args) {
+		this.logger.info(msg, ...args);
+	}
+	/**
+	* Logs an HTTP-related message with optional additional data.
+	*
+	* @param msg - The HTTP message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	http(msg, ...args) {
+		this.logger.http(msg, ...args);
+	}
+	/**
+	* Logs a verbose message with optional additional data.
+	*
+	* @param msg - The verbose message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	verbose(msg, ...args) {
+		this.logger.verbose(msg, ...args);
+	}
+	/**
+	* Logs a debug message with optional additional data.
+	*
+	* @param msg - The debug message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	debug(msg, ...args) {
+		this.logger.debug(msg, ...args);
+	}
+	/**
+	* Logs a silly/trace level message with optional additional data.
+	*
+	* @param msg - The silly message to log
+	* @param args - Additional data to include in the log entry
+	*/
+	silly(msg, ...args) {
+		this.logger.silly(msg, ...args);
+	}
 };
-var SeedcordRangeError = class extends RangeError {
-  static {
-    __name(this, "SeedcordRangeError");
-  }
-  code;
-  identifier;
-  constructor(code, args, options) {
-    const message = resolveMessage(code, args);
-    super(message, options);
-    this.code = code;
-    this.identifier = resolveIdentifier(code);
-    this.name = formatErrorName(new.target.name, this.identifier, this.code);
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, new.target);
-    }
-  }
+
+//#endregion
+//#region src/CooldownManager.ts
+const logger = new Logger("CooldownManager");
+/**
+* Lightweight utility for per-key cooldowns.
+*
+* Manages time-based restrictions on operations by key,
+* useful for rate limiting, command cooldowns, and spam prevention.
+*/
+var CooldownManager = class {
+	window;
+	Err;
+	msg;
+	map = /* @__PURE__ */ new Map();
+	/**
+	* Creates a new CooldownManager instance.
+	*
+	* @param opts - Configuration options for the cooldown behavior
+	*/
+	constructor(opts = {}) {
+		this.window = opts.cooldown ?? 1e3;
+		this.Err = opts.err ?? Error;
+		this.msg = opts.message ?? "Cooldown active";
+	}
+	/**
+	* Records usage timestamp for a key without any cooldown checks.
+	*
+	* @param key - The unique identifier for the cooldown entry
+	*/
+	set(key) {
+		this.map.set(key, Date.now());
+	}
+	/**
+	* Verifies cooldown status for a key and updates timestamp if not active.
+	*
+	* If the cooldown is still active, throws the configured error.
+	* If not active, updates the timestamp and returns successfully.
+	*
+	* @param key - The unique identifier to check cooldown for
+	* @throws An {@link Err} When the cooldown is still active for the given key
+	*/
+	check(key) {
+		const now = Date.now();
+		const last = this.map.get(key);
+		const remaining = this.window - (now - (last ?? 0));
+		if (Envapter.isDevelopment && remaining > 0) logger.debug(`${key} - ${remaining}ms remaining`);
+		if (last !== void 0 && remaining > 0) throw new this.Err(this.msg, remaining);
+		this.map.set(key, now);
+	}
+	/**
+	* Checks if a key is currently cooling down without updating timestamp.
+	*
+	* @param key - The unique identifier to check
+	* @returns True if the key is still cooling down, false otherwise
+	*/
+	isActive(key) {
+		const last = this.map.get(key);
+		return last !== void 0 && Date.now() - last < this.window;
+	}
+	/**
+	* Removes a key from the cooldown map.
+	*
+	* @param key - The unique identifier to remove (useful for manual resets)
+	*/
+	clear(key) {
+		this.map.delete(key);
+	}
 };
-var SeedcordErrors = {
-  Error: SeedcordError,
-  TypeError: SeedcordTypeError,
-  RangeError: SeedcordRangeError
+
+//#endregion
+//#region src/StrictEventEmitter.ts
+/**
+* Typed wrapper around Node.js {@link EventEmitter} enforcing tuple payloads per event name.
+*
+* @typeParam TEvents - Map of event names to readonly tuple payloads
+*/
+var StrictEventEmitter = class extends EventEmitter {
+	/**
+	* Registers a persistent listener with tuple-safe arguments for the given event.
+	*
+	* @param event - The event name to attach to
+	* @param listener - Callback operating on the typed argument tuple for the event
+	* @returns This emitter instance for chaining
+	*/
+	on(event, listener) {
+		return super.on(event, listener);
+	}
+	/**
+	* Registers a one time listener that is removed after the first invocation.
+	*
+	* @param event - The event name to attach to
+	* @param listener - Callback operating on the typed argument tuple for the event
+	* @returns This emitter instance for chaining
+	*/
+	once(event, listener) {
+		return super.once(event, listener);
+	}
+	/**
+	* Removes a previously registered listener for the given event.
+	*
+	* @param event - The event name whose listener should be removed
+	* @param listener - Callback originally registered for the event
+	* @returns This emitter instance for chaining
+	*/
+	off(event, listener) {
+		return super.off(event, listener);
+	}
+	/**
+	* Alias of {@link StrictEventEmitter.on} for compatibility with Node.js EventEmitter APIs.
+	*
+	* @param event - The event name to attach to
+	* @param listener - Callback operating on the typed argument tuple for the event
+	* @returns This emitter instance for chaining
+	*/
+	addListener(event, listener) {
+		return this.on(event, listener);
+	}
+	/**
+	* Alias of {@link StrictEventEmitter.off} for compatibility with Node.js EventEmitter APIs.
+	*
+	* @param event - The event name whose listener should be removed
+	* @param listener - Callback originally registered for the event
+	* @returns This emitter instance for chaining
+	*/
+	removeListener(event, listener) {
+		return super.removeListener(event, listener);
+	}
+	/**
+	* Emits an event with the strictly typed argument tuple for the event name.
+	*
+	* @param event - The event name to emit
+	* @param args - Tuple payload for the event
+	* @returns True when the event had listeners, false otherwise
+	*/
+	emit(event, ...args) {
+		return super.emit(event, ...args);
+	}
+	/**
+	* Retrieves the listener list for a given event with the correct tuple signature.
+	*
+	* @param event - The event name to inspect
+	* @returns Array of listeners registered for the event
+	*/
+	listeners(event) {
+		return super.listeners(event);
+	}
+	/**
+	* Counts listeners for an event without widening the return type of {@link EventEmitter.listenerCount}.
+	*
+	* @param event - The event name to inspect
+	* @returns The total number of listeners registered for the event
+	*/
+	listenerCountTyped(event) {
+		return super.listenerCount(event);
+	}
+	/**
+	* Returns the list of event names known to the emitter with the mapped key type.
+	*
+	* @returns Array of event keys supported by the emitter
+	*/
+	eventNamesTyped() {
+		return super.eventNames();
+	}
+	/**
+	* Waits for an event to be emitted, resolving with the listener arguments tuple once triggered.
+	* Supports optional abort signals and timeouts for cancellation semantics.
+	*
+	* @param event - The event name to wait for
+	* @param opts - Optional abort signal or timeout in milliseconds
+	* @returns Promise resolving with the emitted argument tuple; rejects when aborted or timed out
+	*/
+	waitFor(event, opts) {
+		return new Promise((resolve, reject) => {
+			const onEvent = (...args) => {
+				cleanup();
+				resolve(args);
+			};
+			const onAbort = () => {
+				cleanup();
+				reject(new SeedcordError(1501));
+			};
+			let timeoutId = null;
+			const cleanup = () => {
+				this.off(event, onEvent);
+				opts?.signal?.removeEventListener("abort", onAbort);
+				if (timeoutId) clearTimeout(timeoutId);
+			};
+			this.once(event, onEvent);
+			if (opts?.signal) {
+				if (opts.signal.aborted) return onAbort();
+				opts.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			if (opts?.timeoutMs !== void 0) {
+				const timeoutMs = opts.timeoutMs;
+				timeoutId = setTimeout(() => {
+					cleanup();
+					reject(new SeedcordError(1502, [timeoutMs]));
+				}, timeoutMs);
+			}
+		});
+	}
 };
-function isSeedcordError(error) {
-  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "number" && "identifier" in error && typeof error.identifier === "string";
-}
-__name(isSeedcordError, "isSeedcordError");
-var CoordinatedLifecycle = class {
-  static {
-    __name(this, "CoordinatedLifecycle");
-  }
-  phaseOrder;
-  phaseEnum;
-  logger;
-  events = new EventEmitter();
-  tasksMap = /* @__PURE__ */ new Map();
-  constructor(loggerName, phaseOrder, phaseEnum) {
-    this.phaseOrder = phaseOrder;
-    this.phaseEnum = phaseEnum;
-    this.logger = new Logger(loggerName);
-    this.phaseOrder.forEach((phase) => this.tasksMap.set(phase, []));
-  }
-  /**
-   * Adds a lifecycle task to a specific phase.
-   *
-   * Tasks are executed in phase order during lifecycle operations.
-   * Each task has a timeout to prevent hanging operations.
-   *
-   * @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
-   * @example
-   * ```typescript
-   * lifecycle.addTask(StartupPhase.Services, 'start-database', async () => {
-   *   await database.connect();
-   * }, 10000);
-   * ```
-   */
-  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(`${chalk2.italic("Added")} ${this.getTaskType()} task ${chalk2.bold.cyan(taskName)} to phase ${chalk2.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(`${chalk2.italic("Removed")} ${this.getTaskType()} task ${chalk2.bold.cyan(taskName)} from phase ${chalk2.bold.magenta(this.phaseEnum[phase])}`);
-    }
-    return removed;
-  }
-  /**
-   * Run all tasks in a specific phase
-   */
-  async runPhase(phase) {
-    const tasks = this.tasksMap.get(phase) ?? [];
-    if (tasks.length === 0) {
-      this.logger.warn(`No tasks to run in phase ${chalk2.bold.magenta(this.phaseEnum[phase])}`);
-      return;
-    }
-    this.logger.info(`${chalk2.bold.yellow("Running")} ${this.getTaskType()} phase ${chalk2.bold.magenta(this.phaseEnum[phase])} with ${chalk2.bold.cyan(tasks.length)} tasks`);
-    this.emit(`phase:${phase}:start`);
-    const results = await this.executeTasksInPhase(phase, tasks);
-    const failures = results.filter((r) => r.status === "rejected").length;
-    if (failures > 0) {
-      throw new SeedcordError(SeedcordErrorCode.LifecyclePhaseFailures, [
-        chalk2.bold.magenta(this.phaseEnum[phase]),
-        failures
-      ]);
-    } else {
-      this.logger.info(`Phase ${chalk2.bold.magenta(this.phaseEnum[phase])} ${chalk2.bold.green("completed successfully")}`);
-    }
-    this.emit(`phase:${phase}:complete`);
-  }
-  /**
-   * Run a single task with timeout
-   */
-  async runTaskWithTimeout(phase, task) {
-    this.logger.info(`${chalk2.italic("Starting")} task ${chalk2.bold.cyan(task.name)} in phase ${chalk2.bold.magenta(this.phaseEnum[phase])}`);
-    try {
-      await Promise.race([
-        task.task(),
-        new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(new SeedcordError(SeedcordErrorCode.LifecycleTaskTimeout, [
-              task.name,
-              task.timeout
-            ]));
-          }, task.timeout);
-        })
-      ]);
-      this.logger.info(`${chalk2.italic("Completed")} task ${chalk2.bold.cyan(task.name)} in phase ${chalk2.bold.magenta(this.phaseEnum[phase])}`);
-    } catch (error) {
-      this.logger.error(`${chalk2.italic("Failed")} task ${chalk2.bold.cyan(task.name)} in phase ${chalk2.bold.magenta(this.phaseEnum[phase])}:`, error);
-      throw error;
-    }
-  }
-  /**
-   * Subscribe to lifecycle events
-   */
-  on(event, listener) {
-    this.events.on(event, listener);
-  }
-  /**
-   * Unsubscribe from lifecycle events
-   */
-  off(event, listener) {
-    this.events.off(event, listener);
-  }
-  emit(event, ...args) {
-    return this.events.emit(event, ...args);
-  }
+
+//#endregion
+//#region src/Lifecycle/CoordinatedLifecycle.ts
+/**
+* Abstract base class for coordinated lifecycle management (startup/shutdown)
+*/
+var CoordinatedLifecycle = class extends StrictEventEmitter {
+	phaseOrder;
+	phaseEnum;
+	logger;
+	tasksMap = /* @__PURE__ */ new Map();
+	constructor(loggerName, phaseOrder, phaseEnum) {
+		super();
+		this.phaseOrder = phaseOrder;
+		this.phaseEnum = phaseEnum;
+		this.logger = new Logger(loggerName);
+		this.phaseOrder.forEach((phase) => this.tasksMap.set(phase, []));
+	}
+	/**
+	* Adds a lifecycle task to a specific phase.
+	*
+	* Tasks are executed in phase order during lifecycle operations.
+	* Each task has a timeout to prevent hanging operations.
+	*
+	* @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
+	* @example
+	* ```typescript
+	* lifecycle.addTask(StartupPhase.Services, 'start-database', async () => {
+	*   await database.connect();
+	* }, 10000);
+	* ```
+	*/
+	addTask(phase, taskName, task, timeoutMs) {
+		if (!this.canAddTask()) return;
+		const tasks = this.tasksMap.get(phase);
+		if (!tasks) throw new SeedcordError(1104, [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;
+	}
+	/**
+	* Run all tasks in a specific phase
+	*/
+	async runPhase(phase) {
+		const tasks = this.tasksMap.get(phase) ?? [];
+		if (tasks.length === 0) {
+			this.logger.warn(`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`);
+		this.emitPhase(phase, "start");
+		const failures = (await this.executeTasksInPhase(phase, tasks)).filter((r) => r.status === "rejected").length;
+		if (failures > 0) throw new SeedcordError(1105, [this.phaseEnum[phase], failures]);
+		else this.logger.info(`Phase ${chalk.bold.magenta(this.phaseEnum[phase])} ${chalk.bold.green("completed successfully")}`);
+		this.emitPhase(phase, "complete");
+	}
+	/**
+	* Run a single task with timeout
+	*/
+	async runTaskWithTimeout(phase, task) {
+		this.logger.info(`${chalk.italic("Starting")} task ${chalk.bold.cyan(task.name)} in phase ${chalk.bold.magenta(this.phaseEnum[phase])}`);
+		let timeoutId;
+		try {
+			await Promise.race([task.task(), new Promise((_, reject) => {
+				timeoutId = setTimeout(() => {
+					reject(new SeedcordError(1106, [task.name, task.timeout]));
+				}, 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;
+		} finally {
+			if (timeoutId) clearTimeout(timeoutId);
+		}
+	}
+	emitPhase(phase, action) {
+		EventEmitter.prototype.emit.call(this, `phase:${phase}:${action}`);
+	}
 };
 
-// src/Lifecycle/CoordinatedShutdown.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-var ShutdownPhase = /* @__PURE__ */ (function(ShutdownPhase2) {
-  ShutdownPhase2[ShutdownPhase2["StopAcceptingRequests"] = 1] = "StopAcceptingRequests";
-  ShutdownPhase2[ShutdownPhase2["StopServices"] = 2] = "StopServices";
-  ShutdownPhase2[ShutdownPhase2["ExternalResources"] = 3] = "ExternalResources";
-  ShutdownPhase2[ShutdownPhase2["DiscordCleanup"] = 4] = "DiscordCleanup";
-  ShutdownPhase2[ShutdownPhase2["FinalCleanup"] = 5] = "FinalCleanup";
-  return ShutdownPhase2;
-})({});
-var PHASE_ORDER = [
-  1,
-  2,
-  3,
-  4,
-  5
+//#endregion
+//#region src/Lifecycle/CoordinatedShutdown.ts
+/**
+* Shutdown phases for coordinated application shutdown.
+*/
+let ShutdownPhase = /* @__PURE__ */ function(ShutdownPhase) {
+	/** Stop accepting new requests/interactions */
+	ShutdownPhase[ShutdownPhase["StopAcceptingRequests"] = 1] = "StopAcceptingRequests";
+	/** Stop background services (health checks, etc.) */
+	ShutdownPhase[ShutdownPhase["StopServices"] = 2] = "StopServices";
+	/** Disconnect from external resources (database, APIs) */
+	ShutdownPhase[ShutdownPhase["ExternalResources"] = 3] = "ExternalResources";
+	/** Disconnect from Discord */
+	ShutdownPhase[ShutdownPhase["DiscordCleanup"] = 4] = "DiscordCleanup";
+	/** Final cleanup tasks */
+	ShutdownPhase[ShutdownPhase["FinalCleanup"] = 5] = "FinalCleanup";
+	return ShutdownPhase;
+}({});
+/** Define the order of phases */
+const PHASE_ORDER$1 = [
+	1,
+	2,
+	3,
+	4,
+	5
 ];
-var LOG_FLUSH_DELAY_MS = 500;
+const LOG_FLUSH_DELAY_MS = 500;
+/**
+* CoordinatedShutdown manages graceful application shutdown by executing registered tasks across defined phases.
+*
+* It listens for termination signals (SIGINT, SIGTERM) and runs tasks in parallel within each phase.
+* Tasks can be added or removed dynamically, and each task has an associated timeout.
+*/
 var CoordinatedShutdown = class extends CoordinatedLifecycle {
-  static {
-    __name(this, "CoordinatedShutdown");
-  }
-  isShuttingDown = false;
-  exitCode = 0;
-  constructor() {
-    super("CoordinatedShutdown", PHASE_ORDER, ShutdownPhase);
-    this.registerSignalHandlers();
-  }
-  canAddTask() {
-    return this.isShutdownEnabled;
-  }
-  canRemoveTask() {
-    return true;
-  }
-  getTaskType() {
-    return "shutdown";
-  }
-  async executeTasksInPhase(phase, tasks) {
-    const results = [];
-    for (const task of tasks) {
-      results.push(await Promise.resolve().then(() => this.runTaskWithTimeout(phase, task)).then(
-        () => ({
-          status: "fulfilled",
-          value: void 0
-        }),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        (reason) => ({
-          status: "rejected",
-          reason
-        })
-      ));
-    }
-    return results;
-  }
-  registerSignalHandlers() {
-    if (!this.isShutdownEnabled) return;
-    process.on("SIGTERM", () => {
-      this.logger.info(`Received ${chalk2.yellow.bold("SIGTERM")} signal`);
-      void this.run(0);
-    });
-    process.on("SIGINT", () => {
-      this.logger.info(`Received ${chalk2.yellow.bold("SIGINT")} signal`);
-      void this.run(0);
-    });
-  }
-  /**
-   * Adds a task to a specific shutdown phase with timeout.
-   *
-   * @param phase - The shutdown phase from {@link ShutdownPhase}
-   * @param taskName - Unique identifier for the task
-   * @param task - Async function to execute
-   * @param timeoutMs - Task timeout in milliseconds (default: 5000)
-   */
-  addTask(phase, taskName, task, timeoutMs = 5e3) {
-    super.addTask(phase, taskName, task, timeoutMs);
-  }
-  /**
-   * Removes a task from a specific shutdown phase.
-   *
-   * @param phase - The shutdown phase to remove from
-   * @param taskName - Name of the task to remove
-   * @returns True if task was found and removed
-   */
-  removeTask(phase, taskName) {
-    return super.removeTask(phase, taskName);
-  }
-  /**
-   * Executes the coordinated shutdown sequence.
-   *
-   * Runs all registered tasks across shutdown phases in reverse order.
-   * Tasks within each phase are executed in parallel for faster shutdown.
-   * Process exits with the specified code when complete.
-   *
-   * @param exitCode - Process exit code (default: `0`)
-   * @returns Promise that resolves when shutdown is complete
-   * @example
-   * ```typescript
-   * shutdown.addTask(ShutdownPhase.Services, 'database', () => db.disconnect(), 5000);
-   * await shutdown.run(0); // Graceful shutdown
-   * ```
-   */
-  async run(exitCode = 0) {
-    if (this.isShuttingDown) {
-      this.logger.warn("Shutdown sequence already in progress");
-      return;
-    }
-    this.isShuttingDown = true;
-    this.exitCode = exitCode;
-    this.logger.info(`${chalk2.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk2.bold.cyan(exitCode)}`);
-    this.emit("shutdown:start");
-    try {
-      for (const phase of PHASE_ORDER) {
-        await this.runPhase(phase);
-      }
-      this.logger.info(`${chalk2.bold.green("Coordinated shutdown completed")} successfully`);
-      this.emit("shutdown:complete");
-    } catch (error) {
-      this.logger.error(`${chalk2.bold.red("Coordinated shutdown failed")}`);
-      this.emit("shutdown:error", error);
-    } finally {
-      this.logger.info(`${chalk2.bold.red("Exiting")} process with code ${chalk2.bold.cyan(this.exitCode)}`);
-      setTimeout(() => {
-        process.exit(this.exitCode);
-      }, LOG_FLUSH_DELAY_MS);
-    }
-  }
-  /**
-   * Subscribe to shutdown events
-   */
-  on(event, listener) {
-    super.on(event, listener);
-  }
-  /**
-   * Unsubscribe from shutdown events
-   */
-  off(event, listener) {
-    super.off(event, listener);
-  }
+	isShutdownEnabled;
+	isShuttingDown = false;
+	exitCode = 0;
+	onSigTerm = null;
+	onSigInt = null;
+	constructor(enabled = true) {
+		super("CoordinatedShutdown", PHASE_ORDER$1, ShutdownPhase);
+		this.isShutdownEnabled = enabled;
+		this.registerSignalHandlers();
+	}
+	canAddTask() {
+		return this.isShutdownEnabled;
+	}
+	canRemoveTask() {
+		return true;
+	}
+	getTaskType() {
+		return "shutdown";
+	}
+	async executeTasksInPhase(phase, tasks) {
+		const promises = tasks.map((task) => this.runTaskWithTimeout(phase, task));
+		return Promise.allSettled(promises);
+	}
+	registerSignalHandlers() {
+		if (!this.isShutdownEnabled) return;
+		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);
+	}
+	removeSignalHandlers() {
+		if (this.onSigTerm) {
+			process.off("SIGTERM", this.onSigTerm);
+			this.onSigTerm = null;
+		}
+		if (this.onSigInt) {
+			process.off("SIGINT", this.onSigInt);
+			this.onSigInt = null;
+		}
+	}
+	/**
+	* Adds a task to a specific shutdown phase with timeout.
+	*
+	* @param phase - The shutdown phase from {@link ShutdownPhase}
+	* @param taskName - Unique identifier for the task
+	* @param task - Async function to execute
+	* @param timeoutMs - Task timeout in milliseconds {@default 5000}
+	*/
+	addTask(phase, taskName, task, timeoutMs = 5e3) {
+		super.addTask(phase, taskName, task, timeoutMs);
+	}
+	/**
+	* Removes a task from a specific shutdown phase.
+	*
+	* @param phase - The shutdown phase to remove from
+	* @param taskName - Name of the task to remove
+	* @returns True if task was found and removed
+	*/
+	removeTask(phase, taskName) {
+		return super.removeTask(phase, taskName);
+	}
+	/**
+	* Executes the coordinated shutdown sequence.
+	*
+	* Runs all registered tasks across shutdown phases in reverse order.
+	* Tasks within each phase are executed in parallel for faster shutdown.
+	* Process exits with the specified code when complete.
+	*
+	* @param exitCode - Process exit code {@default 0}
+	* @param exitProcess - Whether to exit the process after shutdown {@default true}
+	* @returns Promise that resolves when shutdown is complete
+	* @example
+	* ```typescript
+	* shutdown.addTask(ShutdownPhase.Services, 'database', () => db.disconnect(), 5000);
+	* await shutdown.run(0); // Graceful shutdown
+	* ```
+	*/
+	async run(exitCode = 0, exitProcess = true) {
+		this.removeSignalHandlers();
+		if (this.isShuttingDown) {
+			this.logger.warn("Shutdown sequence already 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)}`);
+		this.emit("shutdown:start");
+		try {
+			for (const phase of PHASE_ORDER$1) await this.runPhase(phase);
+			this.logger.info(`${chalk.bold.green("Coordinated shutdown completed")} successfully`);
+			this.emit("shutdown:complete");
+		} catch (error) {
+			this.logger.error(`${chalk.bold.red("Coordinated shutdown failed")}`);
+			this.emit("shutdown:error", error);
+		} finally {
+			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;
+			}
+		}
+	}
 };
-_ts_decorate([
-  Envapt("SHUTDOWN_IS_ENABLED", {
-    fallback: false
-  }),
-  _ts_metadata("design:type", Boolean)
-], CoordinatedShutdown.prototype, "isShutdownEnabled", void 0);
 
-// src/HealthCheck.ts
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate2, "_ts_decorate");
-function _ts_metadata2(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata2, "_ts_metadata");
-var HTTP_OK = 200;
-var HTTP_NOT_FOUND = 404;
+//#endregion
+//#region src/HealthCheck.ts
+const HTTP_OK = 200;
+const HTTP_NOT_FOUND = 404;
+const DEFAULT_HEALTH_CHECK_PORT = 6967;
+const DEFAULT_HEALTH_CHECK_PATH = "/healthcheck";
+/**
+* HTTP health check service for monitoring bot status.
+*
+* Provides a simple HTTP endpoint that responds with JSON status
+* information, useful for container orchestration and monitoring.
+*/
 var HealthCheck = class {
-  static {
-    __name(this, "HealthCheck");
-  }
-  logger = new Logger("HealthCheck");
-  server;
-  constructor(shutdown) {
-    shutdown.addTask(ShutdownPhase.StopServices, "stop-healthcheck-server", async () => await this.stop());
-  }
-  /**
-   * Starts the health check server.
-   * @returns Promise that resolves when the server is listening
-   */
-  async init() {
-    return new Promise((resolve, reject) => {
-      this.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.on("error", reject);
-      this.server.once("listening", () => {
-        const address = this.host ?? "localhost";
-        this.logger.info(`${chalk2.green.bold("\u2713")} Health check server listening on ${chalk2.cyan(`http://${address}:${this.port}${this.path}`)}`);
-        resolve();
-      });
-      if (this.host) {
-        this.logger.debug(`Binding health check server to ${this.host}`);
-        this.server.listen(this.port, this.host);
-      } else {
-        this.logger.debug("Binding health check server to all interfaces");
-        this.server.listen(this.port);
-      }
-    });
-  }
-  /**
-   * Stops the health check server.
-   *
-   * @returns Promise that resolves when the server is closed
-   */
-  stop() {
-    if (this.server !== void 0) {
-      const server = this.server;
-      return new Promise((resolve) => {
-        server.once("close", () => resolve());
-        server.close(() => {
-          this.logger.info(chalk2.bold.red("Health check server stopped"));
-        });
-      });
-    }
-    return Promise.resolve();
-  }
-};
-_ts_decorate2([
-  Envapt("HEALTH_CHECK_PORT", {
-    fallback: 6956
-  }),
-  _ts_metadata2("design:type", Number)
-], HealthCheck.prototype, "port", void 0);
-_ts_decorate2([
-  Envapt("HEALTH_CHECK_PATH", {
-    fallback: "/healthcheck"
-  }),
-  _ts_metadata2("design:type", String)
-], HealthCheck.prototype, "path", void 0);
-_ts_decorate2([
-  Envapt("HEALTH_CHECK_HOST"),
-  _ts_metadata2("design:type", Object)
-], HealthCheck.prototype, "host", void 0);
-var StrictEventEmitter = class extends EventEmitter {
-  static {
-    __name(this, "StrictEventEmitter");
-  }
-  /**
-   * Registers a persistent listener with tuple-safe arguments for the given event.
-   *
-   * @param event - The event name to attach to
-   * @param listener - Callback operating on the typed argument tuple for the event
-   * @returns This emitter instance for chaining
-   */
-  on(event, listener) {
-    return super.on(event, listener);
-  }
-  /**
-   * Registers a one time listener that is removed after the first invocation.
-   *
-   * @param event - The event name to attach to
-   * @param listener - Callback operating on the typed argument tuple for the event
-   * @returns This emitter instance for chaining
-   */
-  once(event, listener) {
-    return super.once(event, listener);
-  }
-  /**
-   * Removes a previously registered listener for the given event.
-   *
-   * @param event - The event name whose listener should be removed
-   * @param listener - Callback originally registered for the event
-   * @returns This emitter instance for chaining
-   */
-  off(event, listener) {
-    return super.off(event, listener);
-  }
-  /**
-   * Alias of {@link StrictEventEmitter.on} for compatibility with Node.js EventEmitter APIs.
-   *
-   * @param event - The event name to attach to
-   * @param listener - Callback operating on the typed argument tuple for the event
-   * @returns This emitter instance for chaining
-   */
-  addListener(event, listener) {
-    return this.on(event, listener);
-  }
-  /**
-   * Alias of {@link StrictEventEmitter.off} for compatibility with Node.js EventEmitter APIs.
-   *
-   * @param event - The event name whose listener should be removed
-   * @param listener - Callback originally registered for the event
-   * @returns This emitter instance for chaining
-   */
-  removeListener(event, listener) {
-    return super.removeListener(event, listener);
-  }
-  /**
-   * Emits an event with the strictly typed argument tuple for the event name.
-   *
-   * @param event - The event name to emit
-   * @param args - Tuple payload for the event
-   * @returns True when the event had listeners, false otherwise
-   */
-  emit(event, ...args) {
-    return super.emit(event, ...args);
-  }
-  /**
-   * Retrieves the listener list for a given event with the correct tuple signature.
-   *
-   * @param event - The event name to inspect
-   * @returns Array of listeners registered for the event
-   */
-  listeners(event) {
-    return super.listeners(event);
-  }
-  /**
-   * Counts listeners for an event without widening the return type of {@link EventEmitter.listenerCount}.
-   *
-   * @param event - The event name to inspect
-   * @returns The total number of listeners registered for the event
-   */
-  listenerCountTyped(event) {
-    return super.listenerCount(event);
-  }
-  /**
-   * Returns the list of event names known to the emitter with the mapped key type.
-   *
-   * @returns Array of event keys supported by the emitter
-   */
-  eventNamesTyped() {
-    return super.eventNames();
-  }
-  /**
-   * Waits for an event to be emitted, resolving with the listener arguments tuple once triggered.
-   * Supports optional abort signals and timeouts for cancellation semantics.
-   *
-   * @param event - The event name to wait for
-   * @param opts - Optional abort signal or timeout in milliseconds
-   * @returns Promise resolving with the emitted argument tuple; rejects when aborted or timed out
-   */
-  waitFor(event, opts) {
-    return new Promise((resolve, reject) => {
-      const onEvent = /* @__PURE__ */ __name((...args) => {
-        cleanup();
-        resolve(args);
-      }, "onEvent");
-      const onAbort = /* @__PURE__ */ __name(() => {
-        cleanup();
-        reject(Object.assign(new Error("Aborted"), {
-          name: "AbortError"
-        }));
-      }, "onAbort");
-      let timeoutId = null;
-      const cleanup = /* @__PURE__ */ __name(() => {
-        this.off(event, onEvent);
-        opts?.signal?.removeEventListener("abort", onAbort);
-        if (timeoutId) clearTimeout(timeoutId);
-      }, "cleanup");
-      this.once(event, onEvent);
-      if (opts?.signal) {
-        if (opts.signal.aborted) return onAbort();
-        opts.signal.addEventListener("abort", onAbort, {
-          once: true
-        });
-      }
-      if (opts?.timeoutMs !== void 0) {
-        timeoutId = setTimeout(() => {
-          cleanup();
-          reject(new Error("Timed out"));
-        }, opts.timeoutMs);
-      }
-    });
-  }
+	logger = new 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", async () => await this.stop());
+	}
+	/**
+	* Starts the health check server.
+	* @returns Promise that resolves when the server is listening
+	*/
+	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(`${chalk.green.bold("✓")} Health check server listening on ${chalk.cyan(`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.
+	*
+	* @returns Promise that resolves when the server is closed
+	*/
+	stop() {
+		const server = this.server;
+		if (!server?.listening) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			server.once("close", () => resolve());
+			server.close((err) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				this.logger.info(chalk.bold.red("Health check server stopped"));
+			});
+		});
+	}
 };
-var StartupPhase = /* @__PURE__ */ (function(StartupPhase2) {
-  StartupPhase2[StartupPhase2["Validation"] = 1] = "Validation";
-  StartupPhase2[StartupPhase2["Discovery"] = 2] = "Discovery";
-  StartupPhase2[StartupPhase2["Registration"] = 3] = "Registration";
-  StartupPhase2[StartupPhase2["Configuration"] = 4] = "Configuration";
-  StartupPhase2[StartupPhase2["Instantiation"] = 5] = "Instantiation";
-  StartupPhase2[StartupPhase2["Activation"] = 6] = "Activation";
-  StartupPhase2[StartupPhase2["Ready"] = 7] = "Ready";
-  return StartupPhase2;
-})({});
-var PHASE_ORDER2 = [
-  1,
-  2,
-  3,
-  4,
-  5,
-  6,
-  7
+
+//#endregion
+//#region src/Lifecycle/CoordinatedStartup.ts
+/**
+* Startup phases for coordinated initialization
+*
+* Defines the order in which different components are initialized during bot startup.
+*/
+let StartupPhase = /* @__PURE__ */ function(StartupPhase) {
+	/** Validate environment variables and config files */
+	StartupPhase[StartupPhase["Validation"] = 1] = "Validation";
+	/** Discover plugin constructors via decorators or registry */
+	StartupPhase[StartupPhase["Discovery"] = 2] = "Discovery";
+	/** Register plugin metadata and declared dependencies */
+	StartupPhase[StartupPhase["Registration"] = 3] = "Registration";
+	/** Inject and validate plugin-specific configuration */
+	StartupPhase[StartupPhase["Configuration"] = 4] = "Configuration";
+	/** Instantiate plugin classes with Core and arguments */
+	StartupPhase[StartupPhase["Instantiation"] = 5] = "Instantiation";
+	/** Activate plugins by calling their init/setup methods */
+	StartupPhase[StartupPhase["Activation"] = 6] = "Activation";
+	/** Mark seedcord as ready and start handling interactions */
+	StartupPhase[StartupPhase["Ready"] = 7] = "Ready";
+	return StartupPhase;
+}({});
+/** Define the order of phases */
+const PHASE_ORDER = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7
 ];
+/**
+* Manages bot startup lifecycle with ordered phases
+*
+* Coordinates initialization of all bot components in a predictable sequence.
+* Tasks are executed within their designated phases to ensure proper dependency order.
+*/
 var CoordinatedStartup = class extends CoordinatedLifecycle {
-  static {
-    __name(this, "CoordinatedStartup");
-  }
-  isStartingUp = false;
-  hasStarted = false;
-  constructor() {
-    super("CoordinatedStartup", PHASE_ORDER2, StartupPhase);
-  }
-  /**
-   * Adds a task to a specific startup phase with timeout.
-   *
-   * @param phase - The startup phase from {@link StartupPhase}
-   * @param taskName - Unique identifier for the task
-   * @param task - Async function to execute
-   * @param timeoutMs - Task timeout in milliseconds (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 results = [];
-    for (const task of tasks) {
-      results.push(await Promise.resolve().then(() => this.runTaskWithTimeout(phase, task)).then(
-        () => ({
-          status: "fulfilled",
-          value: void 0
-        }),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        (reason) => ({
-          status: "rejected",
-          reason
-        })
-      ));
-    }
-    return results;
-  }
-  /**
-   * Executes the coordinated startup sequence.
-   *
-   * Runs all registered tasks across startup phases in the correct order.
-   * Each phase completes before the next phase begins. Tasks within a phase
-   * are executed sequentially to maintain predictable initialization.
-   *
-   * @returns Promise that resolves when startup is complete
-   * @throws An {@link Error} If startup fails or is called multiple times
-   * @example
-   * ```typescript
-   * const startup = new CoordinatedStartup();
-   * startup.addTask(StartupPhase.Services, 'database', () => db.connect(), 10000);
-   * await startup.run();
-   * ```
-   */
-  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(`${chalk2.bold.green("Starting")} coordinated startup sequence`);
-    this.emit("startup:start");
-    try {
-      for (const phase of PHASE_ORDER2) await this.runPhase(phase);
-      this.hasStarted = true;
-      this.logger.info(`${chalk2.bold.green("Coordinated startup completed")} successfully`);
-      this.emit("startup:complete");
-    } catch (error) {
-      this.logger.error(`${chalk2.bold.red("Coordinated startup failed")}`);
-      this.emit("startup:error", error);
-      throw error;
-    } finally {
-      this.isStartingUp = false;
-    }
-  }
-  /**
-   * Subscribe to startup events
-   */
-  on(event, listener) {
-    super.on(event, listener);
-  }
-  /**
-   * Unsubscribe from startup events
-   */
-  off(event, listener) {
-    super.off(event, listener);
-  }
-  /**
-   * Check if startup has completed
-   */
-  get isReady() {
-    return this.hasStarted;
-  }
-  /**
-   * Check if startup is currently running
-   */
-  get isRunning() {
-    return this.isStartingUp;
-  }
+	isStartingUp = false;
+	hasStarted = false;
+	constructor() {
+		super("CoordinatedStartup", PHASE_ORDER, StartupPhase);
+	}
+	/**
+	* Adds a task to a specific startup phase with timeout.
+	*
+	* @param phase - The startup phase from {@link StartupPhase}
+	* @param taskName - Unique identifier for the task
+	* @param task - Async function to execute
+	* @param timeoutMs - Task timeout in milliseconds {@default 10000}
+	*/
+	addTask(phase, taskName, task, timeoutMs = 1e4) {
+		super.addTask(phase, taskName, task, timeoutMs);
+	}
+	canAddTask() {
+		if (this.hasStarted) throw new SeedcordError(1101);
+		if (this.isStartingUp) throw new SeedcordError(1102);
+		return true;
+	}
+	canRemoveTask() {
+		if (this.isStartingUp) throw new SeedcordError(1103);
+		return true;
+	}
+	getTaskType() {
+		return "startup";
+	}
+	async executeTasksInPhase(phase, tasks) {
+		const promises = tasks.map((task) => this.runTaskWithTimeout(phase, task));
+		return Promise.allSettled(promises);
+	}
+	/**
+	* Executes the coordinated startup sequence.
+	*
+	* Runs all registered tasks across startup phases in the correct order.
+	* Each phase completes before the next phase begins. Tasks within a phase
+	* are executed sequentially to maintain predictable initialization.
+	*
+	* @returns Promise that resolves when startup is complete
+	* @throws An {@link Error} If startup fails or is called multiple times
+	* @example
+	* ```typescript
+	* const startup = new CoordinatedStartup();
+	* startup.addTask(StartupPhase.Services, 'database', () => db.connect(), 10000);
+	* await startup.run();
+	* ```
+	*/
+	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`);
+		this.emit("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.bold.green("Coordinated startup completed")} successfully`);
+			this.emit("startup:complete");
+		} catch (error) {
+			if (!this.isStartingUp) {
+				this.logger.warn("Startup sequence aborted during error handling");
+				return;
+			}
+			this.logger.error(`${chalk.bold.red("Coordinated startup failed")}`);
+			this.emit("startup:error", error);
+			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])}`);
+		let timeoutId;
+		try {
+			await Promise.race([task.task(), new Promise((_, reject) => {
+				timeoutId = setTimeout(() => {
+					reject(new SeedcordError(1106, [task.name, task.timeout]));
+				}, 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;
+		} finally {
+			if (timeoutId) clearTimeout(timeoutId);
+		}
+	}
+	/**
+	* Aborts the startup sequence if it is currently running.
+	*/
+	abort() {
+		if (this.isStartingUp) {
+			this.isStartingUp = false;
+			this.logger.warn("Aborting coordinated startup sequence");
+		}
+	}
+	/**
+	* Check if startup has completed
+	*/
+	get isReady() {
+		return this.hasStarted;
+	}
+	/**
+	* Check if startup is currently running
+	*/
+	get isRunning() {
+		return this.isStartingUp;
+	}
 };
 
-export { CooldownManager, CoordinatedLifecycle, CoordinatedShutdown, CoordinatedStartup, HealthCheck, Logger, SeedcordError, SeedcordErrorCode, SeedcordErrors, SeedcordRangeError, SeedcordTypeError, ShutdownPhase, StartupPhase, StrictEventEmitter, formatSeedcordErrorMessage, isSeedcordError, messages as seedcordErrorMessages };
-//# sourceMappingURL=index.mjs.map
+//#endregion
+//#region src/index.ts
+/** Package version */
+const version = "0.7.0-next.0";
+
+//#endregion
+export { CooldownManager, CoordinatedLifecycle, CoordinatedShutdown, CoordinatedStartup, HealthCheck, Logger, LoggerChannelRegistry, LoggerUtilities, SeedcordErrorCode, ShutdownPhase, StartupPhase, StrictEventEmitter, isSeedcordError, version };
 //# sourceMappingURL=index.mjs.map