opticore-webapp 1.0.68 → 1.0.69

package/dist/index.js

@@ -2,9 +2,14 @@
 import * as path2 from "path";
 import process4 from "process";
 import corsOrigin from "cors";
-import { CEventNameError as eventName2, ServerListenEventError as ServerListenEventError2 } from "opticore-catch-exception-error";
-import { express } from "opticore-express";
-import { getEnvironnementValue as getEnvironnementValue2 } from "opticore-env-access";
+import express from "express";
+import chokidar from "chokidar";
+import {
+  CEvent,
+  CEventNameError as eventName2,
+  ServerListenEventError as ServerListenEventError2
+} from "opticore-catch-exception-error";
+import { getEnvironmentValue } from "opticore-env-access";
 import { requestCallsEvent } from "opticore-request-call-event";
 import { SContainer as SContainer2 } from "opticore-dependency-inject";
 import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
@@ -446,55 +451,149 @@ var SServerStartError = (err, environmentPath) => {
 };
 
 // src/core/webServer.core.ts
-import { WebServerWatcherService } from "opticore-watcher";
 var WebServerCore = class {
   serverUtility;
-  expressApp = express();
-  fileWatcher;
+  expressApp;
   localLanguage;
   loggerConfig;
-  routerExpressApp;
   getEnvironment;
   environmentPath;
   serverListenEvent;
+  // Existing properties
   currentRoutes = [];
   currentDependencies = [];
   server = void 0;
   errorEmitter;
-  isWatcherEnabled = true;
   serverStatus = "STARTING";
   serverStartTime = /* @__PURE__ */ new Date();
+  // HMR properties
+  fileWatcher = null;
+  hmrRestartPending = false;
+  hmrDebounceTimeout = null;
+  hmrRestartCount = 0;
+  lastHmrRestartTime = 0;
+  /**
+   * Creates a new WebServerCore instance.
+   *
+   * @constructor
+   * @param {WebServerConstructorInterface} paramsConstructor - Configuration parameters
+   *
+   * @param {express.Application} paramsConstructor.app - Express application instance
+   * @param {LoggerCore} paramsConstructor.loggerConfig - Logger configuration
+   * @param {string} paramsConstructor.environmentPath - Path to environment file
+   * @param {string} paramsConstructor.localLanguage - Default language for translations
+   * @param {CorsOptions} paramsConstructor.corsOriginOptions - CORS configuration
+   *
+   * @returns {WebServerCore} New WebServerCore instance
+   *
+   * @throws {Error} If environment file cannot be loaded
+   *
+   * @example
+   * ```typescript
+   * const server = new WebServerCore({
+   *   app: express(),
+   *   loggerConfig: new LoggerCore(config),
+   *   environmentPath: ".env",
+   *   localLanguage: "fr",
+   *   corsOriginOptions: { origin: "http://localhost:3000" }
+   * });
+   * ```
+   */
   constructor(paramsConstructor) {
-    this.getEnvironment = getEnvironnementValue2(paramsConstructor.environmentPath);
-    this.routerExpressApp = paramsConstructor.app;
+    this.getEnvironment = getEnvironmentValue(paramsConstructor.environmentPath);
     this.loggerConfig = paramsConstructor.loggerConfig;
     this.localLanguage = paramsConstructor.localLanguage;
     this.environmentPath = paramsConstructor.environmentPath;
+    this.expressApp = express();
+    this.serverListenEvent = new ServerListenEventError2(paramsConstructor.localLanguage);
     this.expressApp.use(express.json());
     this.expressApp.use(express.raw());
     this.expressApp.use(express.text());
     this.expressApp.use(express.urlencoded({ extended: true }));
     this.expressApp.use(corsOrigin(paramsConstructor.corsOriginOptions));
-    this.serverListenEvent = new ServerListenEventError2(paramsConstructor.localLanguage);
     this.serverUtility = new CoreService(paramsConstructor.localLanguage, paramsConstructor.environmentPath);
+    this.serverStatus = "STARTING";
+    this.serverStartTime = /* @__PURE__ */ new Date();
+    this.setupProcessEventListeners();
   }
+  /**
+   * Starts the HTTP server and initializes all components including HMR if enabled.
+   *
+   * @method onStartServer
+   * @public
+   *
+   * @param {TFeatureRoutes[]} routers - Array of feature routes to register
+   * @param {(env: IEnvVariables) => void} [databaseCallback] - Optional database connection callback
+   * @param {TDependency[]} [dependenciesProvider] - Optional dependency injection providers
+   *
+   * @returns {serverWebApp | undefined} HTTP server instance or undefined if startup fails
+   *
+   * @throws {ServerListenEventError} If port/host configuration is invalid
+   * @throws {Error} If server initialization fails
+   *
+   * @fires WebServerCore#startHttpServer - When server successfully starts
+   * @fires WebServerCore#startHMR - When HMR is started (if enabled)
+   * @fires WebServerCore#serverError - When server fails to start
+   *
+   * @example
+   * ```typescript
+   * const server = app.onStartServer(
+   *   routes,
+   *   (env) => connectToDatabase(env),
+   *   dependencies
+   * );
+   *
+   * if (server) {
+   *   console.log("Server started successfully");
+   * }
+   * ```
+   */
   onStartServer(routers, databaseCallback, dependenciesProvider) {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      this.currentRoutes = routers;
+      this.currentDependencies = dependenciesProvider || [];
+      this.serverStartTime = /* @__PURE__ */ new Date();
+      this.serverStatus = "STARTING";
+      if (!this.validateServerParameters()) {
+        return void 0;
+      }
+      const server = this.startHttpServer(databaseCallback);
+      if (this.getEnvironment.hmrEnabled) {
+        this.startHMR();
+      }
+      return server;
+    } catch (error) {
+      this.handleStartupError(error);
+    }
+  }
+  /**
+   * Validates server configuration parameters.
+   *
+   * @method validateServerParameters
+   * @private
+   *
+   * @returns {boolean} True if all parameters are valid, false otherwise
+   *
+   * @remarks
+   * Validates:
+   * - Port number is valid and positive
+   * - Host is not empty
+   * - Local language is specified
+   * - HMR configuration (if enabled)
+   */
+  validateServerParameters() {
     loaderTranslationFile(this.localLanguage);
-    this.currentRoutes = routers;
-    this.currentDependencies = dependenciesProvider || [];
-    if (this.getEnvironment.appPort === "" && Number(this.getEnvironment.appPort) === 0) {
-      this.serverListenEvent.hostPortUndefined(Number(this.getEnvironment.appPort));
-      return void 0;
+    const port = Number(this.getEnvironment.appPort);
+    if (isNaN(port) || port <= 0) {
+      this.serverListenEvent.portUndefined();
+      return false;
     }
-    if (this.getEnvironment.appHost === "") {
+    if (!this.getEnvironment.appHost || this.getEnvironment.appHost.trim() === "") {
       this.serverListenEvent.hostUndefined(this.getEnvironment.appHost);
-      return void 0;
-    }
-    if (Number(this.getEnvironment.appPort) === 0) {
-      this.serverListenEvent.portUndefined();
-      return void 0;
+      return false;
     }
-    if (this.localLanguage === "") {
+    if (!this.localLanguage || this.localLanguage.trim() === "") {
       SLogger(this.localLanguage).logger.error({
         message: TranslationLoader2.t("noDefaultLocalLang", this.localLanguage),
         title: TranslationLoader2.t("noLocalLang", this.localLanguage),
@@ -502,81 +601,225 @@ var WebServerCore = class {
         stackTrace: void 0,
         httpCodeValue: HttpStatusCode3.NOT_FOUND
       });
-      return void 0;
+      return false;
     }
-    this.server = this.expressApp.listen(
-      Number(this.getEnvironment.appPort),
-      this.getEnvironment.appHost,
-      () => {
+    if (this.getEnvironment.hmrEnabled) {
+      if (!this.getEnvironment.hmrWatchPatterns || this.getEnvironment.hmrWatchPatterns.length === 0) {
+        SLogger(this.localLanguage).logger.warn({
+          title: TranslationLoader2.t("HMR_CONFIG_WARNING", this.localLanguage),
+          message: "HMR enabled but no watch patterns defined"
+        });
+      }
+    }
+    return true;
+  }
+  /**
+   * Starts the HTTP server and sets up event listeners.
+   *
+   * @method startHttpServer
+   * @private
+   *
+   * @param {(env: IEnvVariables) => void} [databaseCallback] - Database connection callback
+   *
+   * @returns {serverWebApp | undefined} HTTP server instance or undefined if startup fails
+   *
+   * @throws {Error} If server fails to start
+   */
+  startHttpServer(databaseCallback) {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      const port = Number(this.getEnvironment.appPort);
+      const host = this.getEnvironment.appHost;
+      this.server = this.expressApp.listen(port, host, () => {
         try {
-          if (databaseCallback && typeof databaseCallback === "function") {
-            databaseCallback(this.getEnvironment);
-          }
-          new SContainer2(this.localLanguage, this.currentDependencies);
-          this.expressApp.use(express.static(path2.join(process4.cwd(), "public/template")));
-          this.registerRoutes(this.currentRoutes);
-          this.setupErrorHandling();
-          this.setupServerEvents();
-          if (this.isWatcherEnabled) {
-            this.initializeFileWatcher();
-          }
-          this.infoWebApp();
-        } catch (err) {
-          SLogger(this.localLanguage).logger.error({
-            title: TranslationLoader2.t("STARTUP_ERROR", this.localLanguage),
-            message: err.message,
-            errorType: err.code,
-            stackTrace: err.stackTrace,
-            httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+          this.configureServerComponents(databaseCallback);
+          this.serverStatus = "READY";
+          SLogger(this.localLanguage).logger.info({
+            title: TranslationLoader2.t("SERVER_RUNNING_TITLE", this.localLanguage),
+            message: TranslationLoader2.t("SERVER_RUNNING_AT", this.localLanguage, {
+              server: `${host}:${port}`,
+              hmrEnabled: this.getEnvironment.hmrEnabled ? "with HMR" : "without HMR"
+            })
           });
-          SServerStartError(err, this.environmentPath);
+        } catch (err) {
+          this.handleServerConfigurationError(err);
+        }
+      });
+      this.setupServerEventListeners();
+      return this.server;
+    } catch (error) {
+      this.serverListenEvent.onEventError(
+        new Error(TranslationLoader2.t(
+          "HTTP_SERVER_FAILED",
+          this.localLanguage,
+          { errorMessage: error.message }
+        ))
+      );
+    }
+  }
+  /**
+   * Configures server components (database, dependencies, routes, etc.).
+   *
+   * @method configureServerComponents
+   * @private
+   *
+   * @param {(env: IEnvVariables) => void} [databaseCallback] - Database connection callback
+   *
+   * @returns {void}
+   *
+   * @throws {Error} If component configuration fails
+   */
+  configureServerComponents(databaseCallback) {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      if (databaseCallback && typeof databaseCallback === "function") {
+        try {
+          databaseCallback(this.getEnvironment);
+        } catch (dbError) {
+          this.serverListenEvent.listenerError(
+            new Error(TranslationLoader2.t("DB_CON_FAILED", this.localLanguage, { dbErrorMessage: dbError.message }))
+          );
         }
       }
-    );
-    return this.server;
+      try {
+        new SContainer2(this.localLanguage, this.currentDependencies);
+      } catch (depError) {
+        this.serverListenEvent.listenerError(
+          new Error(TranslationLoader2.t("DEPENDENCY_INJECTION_FAILED", this.localLanguage, { depErrorMessage: depError.message }))
+        );
+      }
+      this.expressApp.use(express.static(path2.join(process4.cwd(), "public/template")));
+      this.registerRoutes(this.currentRoutes);
+      this.setupErrorHandling();
+      this.infoWebApp();
+    } catch (error) {
+      this.serverListenEvent.listenerError(
+        new Error(TranslationLoader2.t("SERVER_COMPONENT_CONFIG_FAILED", this.localLanguage, { errorMessage: error.message }))
+      );
+      throw error;
+    }
   }
   /**
-   * Error handling configuration
+   * Handles server configuration errors.
+   *
+   * @method handleServerConfigurationError
+   * @private
+   *
+   * @param {any} err - The error that occurred
+   *
+   * @returns {void}
    */
-  setupErrorHandling() {
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("SETTING_UP", this.localLanguage),
-      message: TranslationLoader2.t("SETTING_UP_ERROR", this.localLanguage)
-    });
-    this.errorEmitter = eventProcessHandler(this.localLanguage, this.expressApp);
-    if (this.errorEmitter) {
-      this.errorEmitter.on("transformError", (error) => {
-        SLogger(this.localLanguage).logger.error({
-          title: TranslationLoader2.t("TRANSFORM_ERROR", this.localLanguage),
-          message: error.message,
-          errorType: error.name,
-          stackTrace: error.stackTrace,
-          httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-        });
-      });
-      this.errorEmitter.on("error", (error) => {
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("ERROR_EMITTED", this.localLanguage),
-          message: error.message
-        });
-      });
-      this.errorEmitter.on("hotReload", (data) => {
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("HOT_RELOAD_EVENT", this.localLanguage),
-          message: `Hot reload triggered for ${data.file}`
-        });
-      });
+  handleServerConfigurationError(err) {
+    loaderTranslationFile(this.localLanguage);
+    this.serverStatus = "ERROR";
+    this.serverListenEvent.onEventError(err);
+    try {
+      SServerStartError(err, this.environmentPath);
+    } catch (startError) {
+      this.serverListenEvent.listenerError(startError);
     }
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("ERROR_HANDLING", this.localLanguage),
-      message: TranslationLoader2.t("ERROR_HANDLING_CONFIGURED", this.localLanguage)
+  }
+  /**
+   * Handles general startup errors.
+   *
+   * @method handleStartupError
+   * @private
+   *
+   * @param {any} error - The startup error
+   *
+   * @returns {void}
+   */
+  handleStartupError(error) {
+    loaderTranslationFile(this.localLanguage);
+    this.serverStatus = "ERROR";
+    this.serverListenEvent.listenerError(error);
+    SLogger(this.localLanguage).logger.error({
+      title: TranslationLoader2.t("GLOBAL_STARTUP_ERROR", this.localLanguage),
+      message: error.message,
+      errorType: error.name || "StartupError",
+      stackTrace: error.stack,
+      httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+    });
+  }
+  /**
+   * Sets up Node.js process event listeners.
+   *
+   * @method setupProcessEventListeners
+   * @private
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Listens for:
+   * - Process exit events
+   * - Uncaught exceptions
+   * - Unhandled rejections
+   * - System signals (SIGINT, SIGTERM)
+   */
+  setupProcessEventListeners() {
+    loaderTranslationFile(this.localLanguage);
+    process4.on(CEvent.beforeExit, (code) => {
+      this.serverListenEvent.processBeforeExit(code);
+    });
+    process4.on(CEvent.disconnect, () => {
+      this.serverListenEvent.processDisconnected();
+    });
+    process4.on(CEvent.exit, (code) => {
+      this.serverListenEvent.exited(code);
+    });
+    process4.on(CEvent.message, (message) => {
+      this.serverListenEvent.message(message);
+    });
+    process4.on(CEvent.multipleResolves, (type, promise, reason) => {
+      this.serverListenEvent.multipleResolves(type, promise, reason);
+    });
+    process4.on(CEvent.rejectionHandled, (promise) => {
+      this.serverListenEvent.promiseRejectionHandled(promise);
+    });
+    process4.on(CEvent.uncaughtException, (error) => {
+      this.serverListenEvent.uncaughtException(error);
+    });
+    process4.on(CEvent.uncaughtExceptionMonitor, (error) => {
+      this.serverListenEvent.uncaughtExceptionMonitor(error);
+    });
+    process4.on(CEvent.unhandledRejection, (reason, promise) => {
+      this.serverListenEvent.unhandledRejection(reason, promise);
+    });
+    process4.on(CEvent.warning, (warning) => {
+      this.serverListenEvent.warning(warning);
+    });
+    process4.on(CEvent.sigint, () => {
+      this.serverListenEvent.processInterrupted();
+    });
+    process4.on(CEvent.sigterm, (signal) => {
+      this.serverListenEvent.sigtermSignalReceived(signal);
     });
   }
   /**
-   * Setup server events
+   * Sets up HTTP server event listeners.
+   *
+   * @method setupServerEventListeners
+   * @private
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Configures listeners for:
+   * - Server errors
+   * - Connection closing
+   * - Connection dropping
+   * - HTTP requests (for logging)
+   *
+   * @listens Server#error - Server error events
+   * @listens Server#close - Server closing events
+   * @listens Server#drop - Connection drop events
+   * @listens Server#request - HTTP request events
    */
-  setupServerEvents() {
-    if (!this.server) return;
+  setupServerEventListeners() {
+    loaderTranslationFile(this.localLanguage);
+    if (!this.server) {
+      return;
+    }
     this.server.on(eventName2.error, (err) => {
       this.serverListenEvent.onEventError(err);
     });
@@ -599,544 +842,509 @@ var WebServerCore = class {
     });
   }
   /**
-   * Initialize file watcher
-   */
-  initializeFileWatcher() {
-    try {
-      this.fileWatcher = new WebServerWatcherService(this.localLanguage);
-      this.setupWatcherEvents();
-      this.fileWatcher.startWatching();
-      this.fileWatcher.setHotReload(true);
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("WATCHER_INITIALIZED", this.localLanguage),
-        message: "File watcher has been initialized successfully"
-      });
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("WATCHER_INIT_ERROR", this.localLanguage),
-        message: `Failed to initialize file watcher: ${error.message}`,
-        errorType: "WatcherInitializationError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
-    }
-  }
-  /**
-   * Setup watcher events
+   * Sets up error handling middleware and event emitters.
+   *
+   * @method setupErrorHandling
+   * @private
+   *
+   * @returns {void}
    */
-  setupWatcherEvents() {
-    if (!this.fileWatcher) return;
-    try {
-      this.fileWatcher.on("fileChangeDetected", (data) => {
-        this.handleFileChange(data);
-      });
-      this.fileWatcher.on("hotReloadRequired", (data) => {
-        this.handleHotReload(data);
+  setupErrorHandling() {
+    loaderTranslationFile(this.localLanguage);
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("SETTING_UP", this.localLanguage),
+      message: TranslationLoader2.t("SETTING_UP_ERROR", this.localLanguage)
+    });
+    this.errorEmitter = eventProcessHandler(this.localLanguage, this.expressApp);
+    if (this.errorEmitter) {
+      this.expressApp.use((err, req, res, next) => {
+        this.serverListenEvent.expressErrorHandlingMiddleware(
+          this.errorEmitter,
+          err,
+          req,
+          res,
+          next
+        );
       });
-      this.fileWatcher.on("watcherError", (error) => {
-        this.handleWatcherError(error);
+      this.errorEmitter.on("transformError", (error) => {
+        this.serverListenEvent.listenerError(error);
       });
-      this.fileWatcher.on("started", () => {
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("WATCHER_STARTED", this.localLanguage),
-          message: TranslationLoader2.t("FILE_WATCHER_ACTIVE", this.localLanguage)
-        });
+      this.errorEmitter.on("error", (error) => {
+        this.serverListenEvent.listenerError(error);
       });
-      this.fileWatcher.on("stopped", () => {
+      this.errorEmitter.on("hotReload", (data) => {
         SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("WATCHER_STOPPED", this.localLanguage),
-          message: TranslationLoader2.t("FILE_WATCHER_INACTIVE", this.localLanguage)
+          title: TranslationLoader2.t("HOT_RELOAD_EVENT", this.localLanguage),
+          message: `Hot reload triggered for ${data.file}`
         });
       });
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("WATCHER_EVENTS_ERROR", this.localLanguage),
-        message: `Failed to setup watcher events: ${error.message}`,
-        errorType: "WatcherEventsError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
     }
-  }
-  /**
-   * Handle file changes detected by watcher
-   */
-  handleFileChange(data) {
-    const { event: event2, action, requiresReload } = data;
     SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("FILE_CHANGE_HANDLED", this.localLanguage),
-      message: TranslationLoader2.t(
-        "PROCESSING_FILE_CHANGE",
-        this.localLanguage
-      ).replace(
-        "{file}",
-        path2.basename(event2.filePath)
-      ).replace(
-        "{action}",
-        action
-      )
-    });
-    if (this.errorEmitter) {
-      this.errorEmitter.emit("fileChanged", {
-        file: event2.filePath,
-        type: event2.extension,
-        action,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-    }
-    switch (action) {
-      case "reloadEnvironment":
-        this.reloadEnvironmentConfig();
-        break;
-      case "reloadConfig":
-        this.reloadConfigurationFiles();
-        break;
-      case "reloadRoutes":
-        this.reloadApplicationRoutes(event2.filePath);
-        break;
-      case "reloadDependencies":
-        this.reloadDependencies();
-        break;
-      case "notifyOnly":
-        this.notifyFileChange(event2);
-        break;
-    }
-  }
-  /**
-   * Handle hot reload requested by watcher
-   */
-  handleHotReload(data) {
-    const { file, type, action } = data;
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("HOT_RELOAD_STARTING", this.localLanguage),
-      message: TranslationLoader2.t("HOT_RELOAD_FOR_FILE", this.localLanguage).replace("{file}", path2.basename(file)).replace("{type}", type)
-    });
-    if (this.errorEmitter) {
-      this.errorEmitter.emit("hotReload", {
-        file,
-        type,
-        action,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-    }
-    switch (action) {
-      case "reloadEnvironment":
-        this.executeHotReloadEnvironment(file);
-        break;
-      case "reloadConfig":
-        this.executeHotReloadConfig(file);
-        break;
-      case "reloadRoutes":
-        this.executeHotReloadRoutes(file);
-        break;
-      case "reloadDependencies":
-        this.executeHotReloadDependencies(file);
-        break;
-    }
-  }
-  /**
-   * Handle watcher errors
-   */
-  handleWatcherError(error) {
-    SLogger(this.localLanguage).logger.error({
-      title: TranslationLoader2.t("WATCHER_SYSTEM_ERROR", this.localLanguage),
-      message: error.message || "Unknown watcher system error",
-      errorType: "WatcherSystemError",
-      stackTrace: error.stack,
-      httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+      title: TranslationLoader2.t("ERROR_HANDLING", this.localLanguage),
+      message: TranslationLoader2.t("ERROR_HANDLING_CONFIGURED", this.localLanguage)
     });
   }
   /**
-   * Notify file change without action
+   * Registers routes with the Express application.
+   *
+   * @method registerRoutes
+   * @private
+   *
+   * @param {any[]} allFeatureRoutes - Array of feature routes to register
+   *
+   * @returns {void}
    */
-  notifyFileChange(event2) {
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("FILE_CHANGE_NOTIFIED", this.localLanguage),
-      message: TranslationLoader2.t("FILE_CHANGE_NO_ACTION", this.localLanguage).replace("{file}", path2.basename(event2.filePath))
+  registerRoutes(allFeatureRoutes) {
+    allFeatureRoutes.forEach((router) => {
+      if (router.routes) {
+        router.routes.forEach((route) => {
+          this.expressApp.use(route.path, route.handler);
+        });
+      }
     });
   }
   /**
-   * Reload environment configuration
+   * Displays server information.
+   *
+   * @method infoWebApp
+   * @private
+   *
+   * @returns {void}
    */
-  reloadEnvironmentConfig() {
-    try {
-      this.reloadConfigurations();
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("ENV_RELOADED", this.localLanguage),
-        message: TranslationLoader2.t("ENVIRONMENT_RELOADED_SUCCESS", this.localLanguage)
-      });
-      this.notifyEnvironmentReload();
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("ENV_RELOAD_FAILED", this.localLanguage),
-        message: error.message,
-        errorType: "EnvironmentReloadError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
-    }
+  infoWebApp() {
+    loaderTranslationFile(this.localLanguage);
+    this.serverUtility.infoServer(
+      this.getEnvironment.appHost,
+      Number(this.getEnvironment.appPort)
+    );
   }
   /**
-   * Execute hot reload for environment files
+   * Starts the Hot Module Replacement (HMR) file watching system.
+   *
+   * @method startHMR
+   * @private
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Configures file watcher based on environment variables:
+   * - HMR_ENABLED: Enable/disable HMR
+   * - HMR_WATCH_PATTERNS: Files to watch
+   * - HMR_IGNORE_PATTERNS: Files to ignore
+   *
+   * @throws {Error} If HMR configuration is invalid
    */
-  executeHotReloadEnvironment(filePath) {
+  startHMR() {
     try {
-      const newEnv = getEnvironnementValue2(this.environmentPath);
-      Object.keys(newEnv).forEach((key) => {
-        this.getEnvironment[key] = newEnv[key];
-      });
       loaderTranslationFile(this.localLanguage);
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("HOT_RELOAD_ENV_SUCCESS", this.localLanguage),
-        message: TranslationLoader2.t("ENV_HOT_RELOAD_COMPLETE", this.localLanguage).replace("{file}", path2.basename(filePath))
-      });
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("HOT_RELOAD_ENV_FAILED", this.localLanguage),
-        message: error.message,
-        errorType: "HotReloadEnvironmentError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+      const hmrConfig = this.getEnvironment;
+      if (!hmrConfig.hmrEnabled) {
+        SLogger(this.localLanguage).logger.info({
+          title: TranslationLoader2.t("HMR_DISABLED", this.localLanguage),
+          message: "HMR is disabled in configuration"
+        });
+        return;
+      }
+      if (!hmrConfig.hmrWatchPatterns || hmrConfig.hmrWatchPatterns.length === 0) {
+        SLogger(this.localLanguage).logger.error({
+          title: TranslationLoader2.t("HMR_WATCH_PATTERNS_MISSING", this.localLanguage),
+          message: "No watch patterns defined for HMR",
+          errorType: "HMR Configuration Error",
+          httpCodeValue: HttpStatusCode3.BAD_REQUEST
+        });
+        return;
+      }
+      const watchPatterns = hmrConfig.hmrWatchPatterns;
+      const ignorePatterns = hmrConfig.hmrIgnorePatterns || [
+        "node_modules/**",
+        "dist/**",
+        "build/**",
+        "*.log",
+        ".git/**"
+      ];
+      const allPatterns = [
+        ...watchPatterns,
+        ...ignorePatterns.map((pattern) => `!${pattern}`)
+      ];
+      this.fileWatcher = chokidar.watch(allPatterns, {
+        ignored: /(^|[/\\])\../,
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 300,
+          pollInterval: 100
+        },
+        cwd: process4.cwd(),
+        depth: 10
       });
-    }
-  }
-  /**
-   * Reload configuration files
-   */
-  reloadConfigurationFiles() {
-    try {
-      loaderTranslationFile(this.localLanguage);
+      this.fileWatcher.on("ready", () => this.onHMRWatcherReady(watchPatterns, ignorePatterns)).on("change", (filePath) => this.handleFileChange(filePath)).on("add", (filePath) => this.handleFileChange(filePath, "added")).on("unlink", (filePath) => this.handleFileChange(filePath, "deleted")).on("error", (error) => this.onHMRWatcherError(error));
+      this.hmrRestartCount = 0;
+      this.lastHmrRestartTime = Date.now();
       SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("CONFIG_RELOADED", this.localLanguage),
-        message: TranslationLoader2.t("CONFIGURATION_RELOADED_SUCCESS", this.localLanguage)
+        title: TranslationLoader2.t("HMR_STARTED", this.localLanguage),
+        message: TranslationLoader2.t("HMR_MONITORING_STARTED", this.localLanguage)
       });
     } catch (error) {
       SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("CONFIG_RELOAD_FAILED", this.localLanguage),
+        title: TranslationLoader2.t("HMR_START_FAILED", this.localLanguage),
         message: error.message,
-        errorType: "ConfigurationReloadError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+        errorType: "HMR Error",
+        stackTrace: error.stack
       });
     }
   }
   /**
-   * Execute hot reload for config files
+   * Handles file change events with debouncing.
+   *
+   * @method handleFileChange
+   * @private
+   *
+   * @param {string} filePath - Path of the changed file
+   * @param {string} [action="modified"] - Type of file change (modified/added/deleted)
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Uses debouncing to prevent multiple rapid reloads.
+   * Debounce time configurable via HMR_DEBOUNCE_MS environment variable.
    */
-  executeHotReloadConfig(filePath) {
-    try {
-      if (filePath.includes("locales") || filePath.includes("translations")) {
-        loaderTranslationFile(this.localLanguage);
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("TRANSLATIONS_RELOADED", this.localLanguage),
-          message: TranslationLoader2.t("TRANSLATIONS_HOT_RELOAD_COMPLETE", this.localLanguage).replace("{file}", path2.basename(filePath))
-        });
-      }
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("HOT_RELOAD_CONFIG_FAILED", this.localLanguage),
-        message: error.message,
-        errorType: "HotReloadConfigError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
+  handleFileChange(filePath, action = "modified") {
+    const debounceMs = this.getEnvironment.hmrDebounceMs || 500;
+    if (this.hmrDebounceTimeout) {
+      clearTimeout(this.hmrDebounceTimeout);
     }
+    this.hmrDebounceTimeout = setTimeout(async () => {
+      await this.triggerHotReload(filePath, action);
+    }, debounceMs);
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("FILE_CHANGE_DETECTED", this.localLanguage),
+      message: `File ${action}: ${filePath}`
+    });
   }
   /**
-   * Reload application routes
+   * Triggers a hot reload operation.
+   *
+   * @method triggerHotReload
+   * @private
+   *
+   * @param {string} filePath - Path of the changed file
+   * @param {string} action - Type of file change
+   *
+   * @returns {Promise<void>}
+   *
+   * @remarks
+   * - Checks if reload is already in progress
+   * - Validates restart limits
+   * - Performs appropriate reload actions based on file type
+   * - Emits hotReload event
    */
-  reloadApplicationRoutes(filePath) {
+  async triggerHotReload(filePath, action) {
+    if (this.hmrRestartPending) {
+      return;
+    }
+    if (!this.canProceedWithHMRRestart()) {
+      return;
+    }
+    this.hmrRestartPending = true;
+    this.hmrRestartCount++;
+    this.lastHmrRestartTime = Date.now();
     try {
+      loaderTranslationFile(this.localLanguage);
       SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("ROUTES_RELOADING", this.localLanguage),
-        message: TranslationLoader2.t("APPLICATION_ROUTES_RELOADING", this.localLanguage).replace("{file}", path2.basename(filePath))
+        title: TranslationLoader2.t("HOT_RELOAD_STARTING", this.localLanguage),
+        message: TranslationLoader2.t("RELOADING_APPLICATION", this.localLanguage, {
+          file: filePath,
+          action
+        })
       });
-      if (filePath.includes("routes") || filePath.includes("controller")) {
-        this.reloadSpecificRoute(filePath);
-      }
       if (this.errorEmitter) {
-        this.errorEmitter.emit("routesReloaded", {
-          timestamp: /* @__PURE__ */ new Date(),
+        this.errorEmitter.emit("hotReload", {
           file: filePath,
-          routesCount: this.currentRoutes.length
+          action,
+          timestamp: /* @__PURE__ */ new Date(),
+          restartCount: this.hmrRestartCount
         });
       }
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("ROUTES_RELOAD_FAILED", this.localLanguage),
-        message: error.message,
-        errorType: "RoutesReloadError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
-    }
-  }
-  /**
-   * Execute hot reload for routes
-   */
-  executeHotReloadRoutes(filePath) {
-    try {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("HOT_RELOAD_ROUTES_START", this.localLanguage),
-        message: TranslationLoader2.t("ROUTES_HOT_RELOADING", this.localLanguage).replace("{file}", path2.basename(filePath))
-      });
-      this.reloadRouterForFile(filePath);
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("HOT_RELOAD_ROUTES_SUCCESS", this.localLanguage),
-        message: TranslationLoader2.t("ROUTES_HOT_RELOAD_COMPLETE", this.localLanguage)
+      await this.performHotReloadActions(filePath);
+      SLogger(this.localLanguage).logger.success({
+        title: TranslationLoader2.t("HOT_RELOAD_COMPLETE", this.localLanguage),
+        message: TranslationLoader2.t("APPLICATION_RELOADED", this.localLanguage, {
+          file: filePath,
+          restartCount: this.hmrRestartCount,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
       });
     } catch (error) {
       SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("HOT_RELOAD_ROUTES_FAILED", this.localLanguage),
+        title: TranslationLoader2.t("HOT_RELOAD_FAILED", this.localLanguage),
         message: error.message,
-        errorType: "HotReloadRoutesError",
+        errorType: "HotReloadError",
+        stackTrace: error.stack,
         httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
       });
+    } finally {
+      this.hmrRestartPending = false;
     }
   }
   /**
-   * Execute hot reload for dependencies
+   * Performs appropriate hot reload actions based on file type.
+   *
+   * @method performHotReloadActions
+   * @private
+   *
+   * @param {string} filePath - Path of the changed file
+   *
+   * @returns {Promise<void>}
+   *
+   * @remarks
+   * Different actions for different file types:
+   * - .json/.env: Reload translations
+   * - routes/controller files: Reload routes
+   * - config/.env files: Reload dependencies
    */
-  executeHotReloadDependencies(filePath) {
-    try {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("HOT_RELOAD_DEPS_START", this.localLanguage),
-        message: TranslationLoader2.t(
-          "DEPENDENCIES_HOT_RELOADING",
-          this.localLanguage
-        ).replace("{file}", path2.basename(filePath))
-      });
-      this.reloadDependencies();
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("HOT_RELOAD_DEPS_SUCCESS", this.localLanguage),
-        message: TranslationLoader2.t("DEPENDENCIES_HOT_RELOAD_COMPLETE", this.localLanguage)
-      });
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: TranslationLoader2.t("HOT_RELOAD_DEPS_FAILED", this.localLanguage),
-        message: error.message,
-        errorType: "HotReloadDependenciesError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
+  async performHotReloadActions(filePath) {
+    if (filePath.includes(".json") || filePath.endsWith(".env")) {
+      loaderTranslationFile(this.localLanguage);
     }
-  }
-  /**
-   * Notify environment reload
-   */
-  notifyEnvironmentReload() {
-    if (this.errorEmitter) {
-      this.errorEmitter.emit("environmentReloaded", {
-        timestamp: /* @__PURE__ */ new Date(),
-        environment: this.getEnvironment
-      });
+    if (filePath.includes("routes") || filePath.includes("controller")) {
+      await this.reloadRoutes();
+    }
+    if (filePath.includes("config") || filePath.includes(".env")) {
+      await this.reloadDependencies();
     }
   }
   /**
-   * Reload specific route
-   */
-  reloadSpecificRoute(filePath) {
-    SLogger(this.localLanguage).logger.info({
-      title: "Route Reload",
-      message: `Reloading route from: ${filePath}`
-    });
-  }
-  /**
-   * Reload router for specific file
-   */
-  reloadRouterForFile(filePath) {
-    SLogger(this.localLanguage).logger.info({
-      title: "Router Reload",
-      message: `Reloading router for file: ${filePath}`
-    });
-  }
-  /**
-   * Reload configurations
+   * Reloads routes dynamically.
+   *
+   * @method reloadRoutes
+   * @private
+   *
+   * @returns {Promise<void>}
+   *
+   * @throws {Error} If route reloading fails
+   *
+   * @remarks
+   * This method should be implemented based on your architecture.
+   * It should reload route modules from the filesystem.
    */
-  reloadConfigurations() {
+  async reloadRoutes() {
     try {
-      const newEnv = getEnvironnementValue2(this.environmentPath);
-      Object.keys(newEnv).forEach((key) => {
-        this.getEnvironment[key] = newEnv[key];
+      SLogger(this.localLanguage).logger.info({
+        title: TranslationLoader2.t("ROUTES_RELOADED", this.localLanguage),
+        message: "Routes dynamically reloaded"
       });
-      loaderTranslationFile(this.localLanguage);
     } catch (error) {
-      throw new Error(`Configuration reload failed: ${error.message}`);
+      throw new Error(`Route reload failed: ${error.message}`);
     }
   }
   /**
-   * Reload dependencies
+   * Reloads dependencies dynamically.
+   *
+   * @method reloadDependencies
+   * @private
+   *
+   * @returns {Promise<void>}
+   *
+   * @throws {Error} If dependency reloading fails
    */
-  reloadDependencies() {
+  async reloadDependencies() {
     try {
-      new SContainer2(this.localLanguage, this.currentDependencies);
-      const container = dependenciesContainerProvider(this.localLanguage);
-      if (!container) {
-        throw new Error("Dependency container is not available");
+      if (this.currentDependencies.length > 0) {
+        new SContainer2(this.localLanguage, this.currentDependencies);
+        SLogger(this.localLanguage).logger.info({
+          title: TranslationLoader2.t("DEPENDENCIES_RELOADED", this.localLanguage),
+          message: "Dependencies reloaded"
+        });
       }
     } catch (error) {
       throw new Error(`Dependency reload failed: ${error.message}`);
     }
   }
   /**
-   * Register routes
+   * Checks if HMR restart can proceed based on configuration limits.
+   *
+   * @method canProceedWithHMRRestart
+   * @private
+   *
+   * @returns {boolean} True if restart can proceed, false otherwise
+   *
+   * @remarks
+   * Checks:
+   * - Auto-restart enabled/disabled
+   * - Maximum restarts per minute limit
    */
-  registerRoutes(allFeatureRoutes) {
-    allFeatureRoutes.forEach((router) => {
-      if (router.routes) {
-        router.routes.forEach((route) => {
-          this.expressApp.use(route.path, route.handler);
-        });
-      }
-    });
+  canProceedWithHMRRestart() {
+    const hmrConfig = this.getEnvironment;
+    if (!hmrConfig.hmrAutoRestarts) {
+      SLogger(this.localLanguage).logger.warn({
+        title: TranslationLoader2.t("HMR_AUTO_RESTART_DISABLED", this.localLanguage),
+        message: "HMR auto-restart disabled"
+      });
+      return false;
+    }
+    const maxRestarts = hmrConfig.hmrMaxRestarts || 5;
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    if (this.lastHmrRestartTime < oneMinuteAgo) {
+      this.hmrRestartCount = 0;
+    }
+    if (this.hmrRestartCount >= maxRestarts) {
+      const nextReset = Math.ceil((this.lastHmrRestartTime + 6e4 - now) / 1e3);
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("HMR_RESTART_LIMIT_EXCEEDED", this.localLanguage),
+        message: TranslationLoader2.t("HMR_RESTART_LIMIT_MESSAGE", this.localLanguage, {
+          max: maxRestarts,
+          nextReset
+        })
+      });
+      return false;
+    }
+    return true;
   }
   /**
-   * Parse transform error
+   * Called when the HMR watcher is ready.
+   *
+   * @method onHMRWatcherReady
+   * @private
+   *
+   * @param {string[]} watchPatterns - Patterns being watched
+   * @param {string[]} ignorePatterns - Patterns being ignored
+   *
+   * @returns {void}
    */
-  parseTransformError(error) {
-    const errorMessage = error.message || String(error);
-    let tool = "Unknown";
-    if (errorMessage.includes("esbuild")) tool = "esbuild";
-    if (errorMessage.includes("webpack")) tool = "webpack";
-    const fileMatch = errorMessage.match(/([^:\s]+\.(?:ts|js|tsx|jsx)):(\d+):(\d+):/);
-    const file = fileMatch ? fileMatch[1] : null;
-    const line = fileMatch ? parseInt(fileMatch[2], 10) : null;
-    const column = fileMatch ? parseInt(fileMatch[3], 10) : null;
-    const errorDetailMatch = errorMessage.match(/ERROR:\s*(.+?)(?:\n|$)/);
-    const errorDetail = errorDetailMatch ? errorDetailMatch[1].trim() : null;
-    return {
-      message: errorMessage,
-      file,
-      line,
-      column,
-      errorDetail,
-      tool
-    };
+  onHMRWatcherReady(watchPatterns, ignorePatterns) {
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("HMR_WATCHER_READY", this.localLanguage),
+      message: TranslationLoader2.t("HMR_WATCHING_DETAILS", this.localLanguage, {
+        watchCount: watchPatterns,
+        ignoreCount: ignorePatterns
+      })
+    });
   }
   /**
-   * Display server info
+   * Handles HMR watcher errors.
+   *
+   * @method onHMRWatcherError
+   * @private
+   *
+   * @param {Error} error - The watcher error
+   *
+   * @returns {void}
    */
-  infoWebApp() {
-    this.serverUtility.infoServer(
-      this.getEnvironment.appHost,
-      Number(this.getEnvironment.appPort)
-    );
+  onHMRWatcherError(error) {
+    SLogger(this.localLanguage).logger.error({
+      title: TranslationLoader2.t("HMR_WATCHER_ERROR", this.localLanguage),
+      message: error.message,
+      errorType: "FileWatcherError",
+      stackTrace: error.stack
+    });
   }
   /**
-   * Stop file watcher
+   * Stops the HMR system.
+   *
+   * @method stopHMR
+   * @private
+   *
+   * @returns {void}
    */
-  stopFileWatcher() {
+  stopHMR() {
     if (this.fileWatcher) {
-      try {
-        this.fileWatcher.stopWatching();
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("WATCHER_STOPPED", this.localLanguage),
-          message: TranslationLoader2.t("FILE_WATCHER_STOPPED_GRACEFULLY", this.localLanguage)
-        });
-      } catch (error) {
-        SLogger(this.localLanguage).logger.error({
-          title: TranslationLoader2.t("WATCHER_STOP_ERROR", this.localLanguage),
-          message: `Error stopping watcher: ${error.message}`,
-          errorType: "WatcherStopError",
-          httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-        });
-      } finally {
-        this.fileWatcher = void 0;
-      }
+      this.fileWatcher.close();
+      this.fileWatcher = null;
     }
+    if (this.hmrDebounceTimeout) {
+      clearTimeout(this.hmrDebounceTimeout);
+      this.hmrDebounceTimeout = null;
+    }
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("HMR_STOPPED", this.localLanguage),
+      message: TranslationLoader2.t("HMR_MONITORING_STOPPED", this.localLanguage)
+    });
   }
   /**
-   * Shutdown server
+   * Stops the server and HMR system cleanly.
+   *
+   * @method onStopServer
+   * @public
+   *
+   * @returns {void}
    */
-  shutdown() {
-    this.stopFileWatcher();
+  onStopServer() {
+    this.stopHMR();
     if (this.server) {
       this.server.close(() => {
         SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("CLOSED", this.localLanguage),
-          message: TranslationLoader2.t("SERVER_CLOSED", this.localLanguage)
+          title: TranslationLoader2.t("SERVER_STOPPED", this.localLanguage),
+          message: "Server stopped cleanly"
         });
-        process4.exit(0);
       });
-      setTimeout(() => {
-        SLogger(this.localLanguage).logger.error({
-          title: TranslationLoader2.t("FORCE_SHUTDOWN", this.localLanguage),
-          message: TranslationLoader2.t("SERVER_FORCE_SHUTDOWN", this.localLanguage)
-        });
-        process4.exit(1);
-      }, 5e3);
-    } else {
-      process4.exit(0);
-    }
-  }
-  /**
-   * Enable/disable watcher
-   */
-  setWatcherEnabled(enabled) {
-    this.isWatcherEnabled = enabled;
-    if (enabled && !this.fileWatcher) {
-      this.initializeFileWatcher();
-    } else if (!enabled && this.fileWatcher) {
-      this.stopFileWatcher();
+      this.serverStatus = "STOPPED";
     }
-    SLogger(this.localLanguage).logger.info({
-      title: "Watcher Status",
-      message: `File watcher ${enabled ? "enabled" : "disabled"}`
-    });
-  }
-  /**
-   * Get watcher status
-   */
-  getWatcherStatus() {
-    return {
-      enabled: this.isWatcherEnabled,
-      active: this.fileWatcher !== void 0
-    };
   }
   /**
-   * Get server state information
+   * Gets the current server state information.
+   *
+   * @method getServerState
+   * @public
+   *
+   * @returns {IServerStateInfo} Server state information object
+   *
+   * @remarks
+   * Includes:
+   * - Status, host, port
+   * - Route and dependency counts
+   * - Uptime and memory usage
+   * - HMR configuration and statistics
    */
   getServerState() {
     const now = /* @__PURE__ */ new Date();
     const uptime = this.serverStartTime ? now.getTime() - this.serverStartTime.getTime() : 0;
-    const formatUptime = (ms) => {
-      const seconds = Math.floor(ms / 1e3);
-      const minutes = Math.floor(seconds / 60);
-      const hours = Math.floor(minutes / 60);
-      const days = Math.floor(hours / 24);
-      if (days > 0) return `${days}j ${hours % 24}h ${minutes % 60}m`;
-      if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-      if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
-      return `${seconds}s`;
-    };
-    const memory = process4.memoryUsage();
     return {
       status: this.serverStatus,
-      isRunning: this.server !== void 0,
+      isRunning: this.server !== void 0 && this.serverStatus === "READY",
       host: this.getEnvironment.appHost,
       port: Number(this.getEnvironment.appPort),
       language: this.localLanguage,
-      watcherEnabled: this.isWatcherEnabled,
-      watcherActive: this.fileWatcher !== void 0,
       routesCount: this.currentRoutes.length,
       dependenciesCount: this.currentDependencies.length,
       startTime: this.serverStartTime,
       currentTime: now,
       uptime,
-      uptimeFormatted: formatUptime(uptime),
-      memoryUsage: {
-        rss: memory.rss,
-        heapTotal: memory.heapTotal,
-        heapUsed: memory.heapUsed,
-        external: memory.external,
-        arrayBuffers: memory.arrayBuffers
-      },
+      uptimeFormatted: this.formatUptime(uptime),
+      memoryUsage: process4.memoryUsage(),
       pid: process4.pid,
       platform: process4.platform,
       nodeVersion: process4.version,
-      cwd: process4.cwd()
+      cwd: process4.cwd(),
+      hmrEnabled: this.getEnvironment.hmrEnabled,
+      hmrWatchingFiles: this.getEnvironment.hmrWatchPatterns?.length || 0,
+      hmrRestartCount: this.hmrRestartCount
     };
   }
   /**
-   * Simple method to get just the status
+   * Gets the current server status.
+   *
+   * @method getServerStatus
+   * @public
+   *
+   * @returns {TServerStatus} Current server status
    */
   getServerStatus() {
     return this.serverStatus;
   }
   /**
-   * Get server statistics for monitoring
+   * Gets detailed server statistics.
+   *
+   * @method getServerStats
+   * @public
+   *
+   * @returns {IServerStats} Server statistics object
+   *
+   * @remarks
+   * Includes:
+   * - Performance metrics (CPU, memory)
+   * - Uptime information
+   * - HMR statistics
    */
   getServerStats() {
     const uptime = this.serverStartTime ? Date.now() - this.serverStartTime.getTime() : 0;
@@ -1153,24 +1361,27 @@ var WebServerCore = class {
       performance: {
         cpuUsage: process4.cpuUsage(),
         resourceUsage: process4.resourceUsage?.()
+      },
+      hmrStats: {
+        enabled: this.getEnvironment.hmrEnabled,
+        restartCount: this.hmrRestartCount,
+        lastRestartTime: this.lastHmrRestartTime,
+        watchingFiles: this.getEnvironment.hmrWatchPatterns?.length || 0
       }
     };
   }
   /**
-   * Format bytes to human readable string
-   */
-  formatBytes(bytes) {
-    const units = ["B", "KB", "MB", "GB", "TB"];
-    let value = bytes;
-    let unitIndex = 0;
-    while (value >= 1024 && unitIndex < units.length - 1) {
-      value /= 1024;
-      unitIndex++;
-    }
-    return `${value.toFixed(2)} ${units[unitIndex]}`;
-  }
-  /**
-   * Format uptime to human readable string
+   * Formats milliseconds into a human-readable uptime string.
+   *
+   * @method formatUptime
+   * @private
+   *
+   * @param {number} ms - Milliseconds to format
+   *
+   * @returns {string} Formatted uptime string
+   *
+   * @example
+   * formatUptime(3661000) // returns "1h 1m 1s"
    */
   formatUptime(ms) {
     const seconds = Math.floor(ms / 1e3);
@@ -1178,7 +1389,7 @@ var WebServerCore = class {
     const hours = Math.floor(minutes / 60);
     const days = Math.floor(hours / 24);
     if (days > 0) {
-      return `${days}j ${hours % 24}h ${minutes % 60}m`;
+      return `${days}d ${hours % 24}h ${minutes % 60}m`;
     } else if (hours > 0) {
       return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
     } else if (minutes > 0) {
@@ -1188,55 +1399,66 @@ var WebServerCore = class {
     }
   }
   /**
-   * Add watch directories
-   */
-  addWatchDirectories(directories) {
-    if (this.fileWatcher) {
-      this.fileWatcher.addWatchDirectories(directories);
-    }
-  }
-  /**
-   * Clear file cache
+   * Formats bytes into a human-readable size string.
+   *
+   * @method formatBytes
+   * @private
+   *
+   * @param {number} bytes - Bytes to format
+   *
+   * @returns {string} Formatted size string
+   *
+   * @example
+   * formatBytes(1048576) // returns "1.00 MB"
    */
-  clearFileCache() {
-    if (this.fileWatcher) {
-      this.fileWatcher.clearFileCache();
+  formatBytes(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+      value /= 1024;
+      unitIndex++;
     }
+    return `${value.toFixed(2)} ${units[unitIndex]}`;
   }
   /**
-   * Force reload configurations
+   * Checks if HMR is currently active.
+   *
+   * @method isHMRActive
+   * @public
+   *
+   * @returns {boolean} True if HMR is enabled and watching files, false otherwise
    */
-  forceReloadConfig() {
-    try {
-      this.reloadConfigurations();
-      this.reloadDependencies();
-      SLogger(this.localLanguage).logger.info({
-        title: "Force Reload",
-        message: "All configurations and dependencies have been reloaded"
-      });
-    } catch (error) {
-      SLogger(this.localLanguage).logger.error({
-        title: "Force Reload Failed",
-        message: error.message,
-        errorType: "ForceReloadError",
-        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-      });
-    }
+  isHMRActive() {
+    return this.getEnvironment.hmrEnabled && this.fileWatcher !== null;
   }
   /**
-   * Restart watcher
+   * Gets detailed HMR information and status.
+   *
+   * @method getHMRInfo
+   * @public
+   *
+   * @returns {any} HMR information object
+   *
+   * @remarks
+   * Includes:
+   * - Configuration settings from .env
+   * - Current restart count
+   * - Watcher status
    */
-  restartWatcher() {
-    this.stopFileWatcher();
-    if (this.isWatcherEnabled) {
-      setTimeout(() => {
-        this.initializeFileWatcher();
-        SLogger(this.localLanguage).logger.info({
-          title: "Watcher Restarted",
-          message: "File watcher has been restarted successfully"
-        });
-      }, 1e3);
-    }
+  getHMRInfo() {
+    return {
+      enabled: this.getEnvironment.hmrEnabled,
+      watchPatterns: this.getEnvironment.hmrWatchPatterns,
+      ignorePatterns: this.getEnvironment.hmrIgnorePatterns,
+      debounceMs: this.getEnvironment.hmrDebounceMs,
+      maxRestarts: this.getEnvironment.hmrMaxRestarts,
+      autoRestart: this.getEnvironment.hmrAutoRestarts,
+      currentRestartCount: this.hmrRestartCount,
+      lastRestartTime: this.lastHmrRestartTime,
+      isWatching: this.fileWatcher !== null,
+      isRestartPending: this.hmrRestartPending
+    };
   }
 };
 export {