@seedcord/services 0.1.0

package/dist/index.mjs

@@ -0,0 +1,803 @@
+import { Envapter, Envapt } from 'envapt';
+import { format, transports, createLogger } from 'winston';
+import { createServer } from 'http';
+import chalk from 'chalk';
+import { EventEmitter } from '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);
+  }
+};
+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 Error(`Unknown phase: ${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.emit(`phase:${phase}:start`);
+    const results = await this.executeTasksInPhase(phase, tasks);
+    const failures = results.filter((r) => r.status === "rejected").length;
+    if (failures > 0) {
+      const errorMessage = `Phase ${chalk.bold.magenta(this.phaseEnum[phase])} completed with ${chalk.bold.red(failures)} failed tasks`;
+      throw new Error(errorMessage);
+    } else {
+      this.logger.info(`Phase ${chalk.bold.magenta(this.phaseEnum[phase])} ${chalk.bold.green("completed successfully")}`);
+    }
+    this.emit(`phase:${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])}`);
+    try {
+      await Promise.race([
+        task.task(),
+        new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`Task '${task.name}' timed out after ${task.timeout}ms`));
+          }, 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;
+    }
+  }
+  /**
+  * 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);
+  }
+};
+
+// 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
+];
+var LOG_FLUSH_DELAY_MS = 500;
+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 ${chalk.yellow.bold("SIGTERM")} signal`);
+      void this.run(0);
+    });
+    process.on("SIGINT", () => {
+      this.logger.info(`Received ${chalk.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(`${chalk.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk.bold.cyan(exitCode)}`);
+    this.emit("shutdown:start");
+    try {
+      for (const phase of PHASE_ORDER) {
+        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 {
+      this.logger.info(`${chalk.bold.red("Exiting")} process with code ${chalk.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);
+  }
+};
+_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;
+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", () => resolve());
+      this.server.listen(this.port, () => {
+        this.logger.info(`${chalk.green.bold("\u2713")} Health check server listening on ${chalk.cyan(`http://localhost:${this.port}${this.path}`)}`);
+      });
+    });
+  }
+  /**
+  * 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(chalk.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);
+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);
+  }
+};
+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
+];
+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 Error("Cannot add tasks after startup sequence has already completed");
+    }
+    if (this.isStartingUp) {
+      throw new Error("Cannot add tasks while startup sequence is in progress");
+    }
+    return true;
+  }
+  canRemoveTask() {
+    if (this.isStartingUp) {
+      throw new Error("Cannot remove tasks while startup sequence is in progress");
+    }
+    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(`${chalk.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(`${chalk.bold.green("Coordinated startup completed")} successfully`);
+      this.emit("startup:complete");
+    } catch (error) {
+      this.logger.error(`${chalk.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;
+  }
+};
+
+export { CooldownManager, CoordinatedLifecycle, CoordinatedShutdown, CoordinatedStartup, HealthCheck, Logger, ShutdownPhase, StartupPhase };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map