opticore-webapp 1.0.67 → 1.0.68

package/dist/index.js

@@ -1,10 +1,3 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/core/webServer.core.ts
 import * as path2 from "path";
 import process4 from "process";
@@ -12,6 +5,10 @@ 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 { requestCallsEvent } from "opticore-request-call-event";
+import { SContainer as SContainer2 } from "opticore-dependency-inject";
+import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
+import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
 
 // src/core/handlers/eventProcess.handler.ts
 import process from "process";
@@ -449,13 +446,11 @@ var SServerStartError = (err, environmentPath) => {
 };
 
 // src/core/webServer.core.ts
-import { requestCallsEvent } from "opticore-request-call-event";
-import { SContainer as SContainer2 } from "opticore-dependency-inject";
-import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
+import { WebServerWatcherService } from "opticore-watcher";
 var WebServerCore = class {
   serverUtility;
   expressApp = express();
+  fileWatcher;
   localLanguage;
   loggerConfig;
   routerExpressApp;
@@ -466,13 +461,9 @@ var WebServerCore = class {
   currentDependencies = [];
   server = void 0;
   errorEmitter;
-  // ✅✅✅ ÉTAT DU SERVEUR
-  serverState = "READY";
-  lastError = null;
-  // Statistiques
-  hotReloadAttempts = 0;
-  hotReloadSuccesses = 0;
-  hotReloadFailures = 0;
+  isWatcherEnabled = true;
+  serverStatus = "STARTING";
+  serverStartTime = /* @__PURE__ */ new Date();
   constructor(paramsConstructor) {
     this.getEnvironment = getEnvironnementValue2(paramsConstructor.environmentPath);
     this.routerExpressApp = paramsConstructor.app;
@@ -486,8 +477,6 @@ var WebServerCore = class {
     this.expressApp.use(corsOrigin(paramsConstructor.corsOriginOptions));
     this.serverListenEvent = new ServerListenEventError2(paramsConstructor.localLanguage);
     this.serverUtility = new CoreService(paramsConstructor.localLanguage, paramsConstructor.environmentPath);
-    this.setupSignalHandlers();
-    this.setupIPCHandlers();
   }
   onStartServer(routers, databaseCallback, dependenciesProvider) {
     loaderTranslationFile(this.localLanguage);
@@ -520,11 +509,7 @@ var WebServerCore = class {
       this.getEnvironment.appHost,
       () => {
         try {
-          SLogger(this.localLanguage).logger.info({
-            message: TranslationLoader2.t("HOT_RELOAD_READY", this.localLanguage),
-            title: TranslationLoader2.t("HOT_RELOAD", this.localLanguage)
-          });
-          if (databaseCallback) {
+          if (databaseCallback && typeof databaseCallback === "function") {
             databaseCallback(this.getEnvironment);
           }
           new SContainer2(this.localLanguage, this.currentDependencies);
@@ -532,9 +517,10 @@ var WebServerCore = class {
           this.registerRoutes(this.currentRoutes);
           this.setupErrorHandling();
           this.setupServerEvents();
-          this.serverState = "READY";
+          if (this.isWatcherEnabled) {
+            this.initializeFileWatcher();
+          }
           this.infoWebApp();
-          this.notifyServerReady();
         } catch (err) {
           SLogger(this.localLanguage).logger.error({
             title: TranslationLoader2.t("STARTUP_ERROR", this.localLanguage),
@@ -550,7 +536,7 @@ var WebServerCore = class {
     return this.server;
   }
   /**
-   * ✅✅✅ Configuration de la gestion d'erreurs
+   * Error handling configuration
    */
   setupErrorHandling() {
     SLogger(this.localLanguage).logger.info({
@@ -560,18 +546,24 @@ var WebServerCore = class {
     this.errorEmitter = eventProcessHandler(this.localLanguage, this.expressApp);
     if (this.errorEmitter) {
       this.errorEmitter.on("transformError", (error) => {
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("", this.localLanguage),
-          message: TranslationLoader2.t("", this.localLanguage)
+        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.lastError = error;
-        this.serverState = "BLOCKED";
-        this.notifyWatcherBlockedByError(error);
       });
       this.errorEmitter.on("error", (error) => {
         SLogger(this.localLanguage).logger.info({
           title: TranslationLoader2.t("ERROR_EMITTED", this.localLanguage),
-          message: `Error emitted: ${error.message}`
+          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}`
         });
       });
     }
@@ -580,6 +572,9 @@ var WebServerCore = class {
       message: TranslationLoader2.t("ERROR_HANDLING_CONFIGURED", this.localLanguage)
     });
   }
+  /**
+   * Setup server events
+   */
   setupServerEvents() {
     if (!this.server) return;
     this.server.on(eventName2.error, (err) => {
@@ -603,145 +598,353 @@ var WebServerCore = class {
       );
     });
   }
-  notifyServerReady() {
-    setTimeout(() => {
-      if (process4.send) {
-        process4.send({
-          type: "SERVER_READY",
-          timestamp: Date.now(),
-          port: Number(this.getEnvironment.appPort),
-          host: this.getEnvironment.appHost,
-          message: "Server ready for hot reload"
-        });
-      }
-    }, 100);
+  /**
+   * 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
+      });
+    }
   }
-  setupSignalHandlers() {
-    process4.on("SIGHUP", async () => {
-      if (this.serverState === "READY") {
+  /**
+   * Setup watcher events
+   */
+  setupWatcherEvents() {
+    if (!this.fileWatcher) return;
+    try {
+      this.fileWatcher.on("fileChangeDetected", (data) => {
+        this.handleFileChange(data);
+      });
+      this.fileWatcher.on("hotReloadRequired", (data) => {
+        this.handleHotReload(data);
+      });
+      this.fileWatcher.on("watcherError", (error) => {
+        this.handleWatcherError(error);
+      });
+      this.fileWatcher.on("started", () => {
         SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("SIGHUP", this.localLanguage),
-          message: TranslationLoader2.t("RECEIVED_SIGHUP", this.localLanguage)
+          title: TranslationLoader2.t("WATCHER_STARTED", this.localLanguage),
+          message: TranslationLoader2.t("FILE_WATCHER_ACTIVE", this.localLanguage)
         });
-        await this.performTrueHotReload();
-      }
-    });
-    process4.on("SIGTERM", () => {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("SIGHUP", this.localLanguage),
-        message: TranslationLoader2.t("RECEIVED_SIGHUP", this.localLanguage)
       });
-      this.shutdown();
-    });
-    process4.on("SIGINT", () => {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("SIGINT", this.localLanguage),
-        message: TranslationLoader2.t("RECEIVED_SIGINT", this.localLanguage)
+      this.fileWatcher.on("stopped", () => {
+        SLogger(this.localLanguage).logger.info({
+          title: TranslationLoader2.t("WATCHER_STOPPED", this.localLanguage),
+          message: TranslationLoader2.t("FILE_WATCHER_INACTIVE", this.localLanguage)
+        });
       });
-      this.shutdown();
-    });
+    } 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
+      });
+    }
   }
-  setupIPCHandlers() {
-    if (!process4.send) {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("IPC", this.localLanguage),
-        message: TranslationLoader2.t("IPC_NOT_AVAILABLE", this.localLanguage)
+  /**
+   * 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()
       });
-      return;
     }
+    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("IPC_READY", this.localLanguage),
-      message: TranslationLoader2.t("IPC_READY_HOT_RELOAD", this.localLanguage)
+      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)
     });
-    process4.on("message", async (message) => {
-      if (message.type === "HOT_RELOAD_REQUEST") {
-        if (this.serverState === "BLOCKED") {
-          SLogger(this.localLanguage).logger.info({
-            title: TranslationLoader2.t("BLOCKED", this.localLanguage),
-            message: TranslationLoader2.t("BLOCKED_STATE", this.localLanguage)
-          });
-          return;
-        }
-        if (this.serverState === "READY") {
-          await this.performTrueHotReload();
-        }
-      }
+    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
     });
   }
   /**
-   * ✅✅✅ HOT RELOAD avec gestion d'état stricte
+   * Notify file change without action
    */
-  async performTrueHotReload() {
-    this.serverState = "RELOADING";
-    this.hotReloadAttempts++;
-    const startTime = Date.now();
+  notifyFileChange(event2) {
     SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("RELOAD_STARTING", this.localLanguage),
-      message: TranslationLoader2.t("HOT_RELOAD_ATTEMPTED", this.localLanguage, { hotReloadAttempts: this.hotReloadAttempts })
+      title: TranslationLoader2.t("FILE_CHANGE_NOTIFIED", this.localLanguage),
+      message: TranslationLoader2.t("FILE_CHANGE_NO_ACTION", this.localLanguage).replace("{file}", path2.basename(event2.filePath))
     });
+  }
+  /**
+   * Reload environment configuration
+   */
+  reloadEnvironmentConfig() {
     try {
-      const clearedModules = this.clearApplicationModulesCache();
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("APP_MODULES_CLEARED", this.localLanguage),
-        message: TranslationLoader2.t("CLEARED_MODULES", this.localLanguage, { clearedModules })
-      });
       this.reloadConfigurations();
       SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("APP_MODULES_CLEARED", this.localLanguage),
-        message: TranslationLoader2.t("CLEARED_MODULES", this.localLanguage, { hotReloadAttempts: this.hotReloadAttempts })
+        title: TranslationLoader2.t("ENV_RELOADED", this.localLanguage),
+        message: TranslationLoader2.t("ENVIRONMENT_RELOADED_SUCCESS", this.localLanguage)
       });
-      this.reloadDependencies();
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("DEPENDENCIES", this.localLanguage),
-        message: TranslationLoader2.t("RELOAD_DEPENDENCIES", 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
       });
-      const duration = Date.now() - startTime;
-      this.hotReloadSuccesses++;
-      this.serverState = "READY";
-      this.lastError = null;
+    }
+  }
+  /**
+   * Execute hot reload for environment files
+   */
+  executeHotReloadEnvironment(filePath) {
+    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("RELOAD_SUCCESS", this.localLanguage),
-        message: TranslationLoader2.t("HOT_RELOAD_SUCCESS", this.localLanguage, { duration })
+        title: TranslationLoader2.t("HOT_RELOAD_ENV_SUCCESS", this.localLanguage),
+        message: TranslationLoader2.t("ENV_HOT_RELOAD_COMPLETE", this.localLanguage).replace("{file}", path2.basename(filePath))
       });
-      this.notifyWatcherReloadSuccess(duration);
     } catch (error) {
-      this.hotReloadFailures++;
-      const duration = Date.now() - startTime;
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("HOT_RELOAD_ENV_FAILED", this.localLanguage),
+        message: error.message,
+        errorType: "HotReloadEnvironmentError",
+        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+      });
+    }
+  }
+  /**
+   * Reload configuration files
+   */
+  reloadConfigurationFiles() {
+    try {
+      loaderTranslationFile(this.localLanguage);
       SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("RELOAD_FAILED", this.localLanguage),
-        message: TranslationLoader2.t("HOT_RELOAD_FAILED", this.localLanguage, { duration, errorMessage: error.message })
-      });
-      const isTransformError = error?.name === "TransformError" || error?.message?.includes("Transform failed") || error?.message?.includes("esbuild");
-      if (isTransformError) {
-        this.lastError = error;
-        this.serverState = "BLOCKED";
-        this.notifyWatcherBlockedByError(error);
-      } else {
-        this.serverState = "BLOCKED";
-        this.notifyWatcherReloadError(error);
+        title: TranslationLoader2.t("CONFIG_RELOADED", this.localLanguage),
+        message: TranslationLoader2.t("CONFIGURATION_RELOADED_SUCCESS", this.localLanguage)
+      });
+    } catch (error) {
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("CONFIG_RELOAD_FAILED", this.localLanguage),
+        message: error.message,
+        errorType: "ConfigurationReloadError",
+        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+      });
+    }
+  }
+  /**
+   * Execute hot reload for config files
+   */
+  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
+      });
     }
   }
   /**
-   * Nettoie le cache des modules applicatifs
+   * Reload application routes
    */
-  clearApplicationModulesCache() {
-    const baseDirs = [
-      path2.join(process4.cwd(), "src"),
-      path2.join(process4.cwd(), "dist")
-    ];
-    let clearedCount = 0;
-    for (const key in __require.cache) {
-      const isApplicationModule = baseDirs.some((dir) => key.startsWith(dir));
-      const isNodeModule = key.includes("node_modules");
-      const isJsonFile = key.endsWith(".json");
-      if (isApplicationModule && !isNodeModule && !isJsonFile) {
-        delete __require.cache[key];
-        clearedCount++;
+  reloadApplicationRoutes(filePath) {
+    try {
+      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))
+      });
+      if (filePath.includes("routes") || filePath.includes("controller")) {
+        this.reloadSpecificRoute(filePath);
+      }
+      if (this.errorEmitter) {
+        this.errorEmitter.emit("routesReloaded", {
+          timestamp: /* @__PURE__ */ new Date(),
+          file: filePath,
+          routesCount: this.currentRoutes.length
+        });
       }
+    } 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)
+      });
+    } catch (error) {
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("HOT_RELOAD_ROUTES_FAILED", this.localLanguage),
+        message: error.message,
+        errorType: "HotReloadRoutesError",
+        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+      });
+    }
+  }
+  /**
+   * Execute hot reload for 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
+      });
+    }
+  }
+  /**
+   * Notify environment reload
+   */
+  notifyEnvironmentReload() {
+    if (this.errorEmitter) {
+      this.errorEmitter.emit("environmentReloaded", {
+        timestamp: /* @__PURE__ */ new Date(),
+        environment: this.getEnvironment
+      });
     }
-    return clearedCount;
   }
+  /**
+   * 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
+   */
   reloadConfigurations() {
     try {
       const newEnv = getEnvironnementValue2(this.environmentPath);
@@ -753,6 +956,9 @@ var WebServerCore = class {
       throw new Error(`Configuration reload failed: ${error.message}`);
     }
   }
+  /**
+   * Reload dependencies
+   */
   reloadDependencies() {
     try {
       new SContainer2(this.localLanguage, this.currentDependencies);
@@ -765,57 +971,19 @@ var WebServerCore = class {
     }
   }
   /**
-   * ✅✅✅ Notifier le watcher : SUCCÈS
+   * Register routes
    */
-  notifyWatcherReloadSuccess(duration) {
-    if (process4.send && process4.env.WATCHER_MODE === "true") {
-      process4.send({
-        type: "HOT_RELOAD_SUCCESS",
-        timestamp: Date.now(),
-        duration,
-        serverState: this.serverState,
-        message: "Code reloaded successfully"
-      });
-    }
-  }
-  /**
-   * ✅✅✅ Notifier le watcher : BLOQUÉ PAR ERREUR TRANSFORM
-   */
-  notifyWatcherBlockedByError(error) {
-    if (process4.send && process4.env.WATCHER_MODE === "true") {
-      const errorDetails = this.parseTransformError(error);
-      process4.send({
-        type: "HOT_RELOAD_BLOCKED_BY_ERROR",
-        timestamp: Date.now(),
-        serverState: this.serverState,
-        error: {
-          message: error.message,
-          errorType: error.name || "TransformError",
-          file: errorDetails.file,
-          line: errorDetails.line,
-          column: errorDetails.column,
-          detail: errorDetails.errorDetail,
-          tool: errorDetails.tool
-        }
-      });
-    }
-  }
-  /**
-   * ✅✅✅ Notifier le watcher : ERREUR GÉNÉRIQUE
-   */
-  notifyWatcherReloadError(error) {
-    if (process4.send && process4.env.WATCHER_MODE === "true") {
-      process4.send({
-        type: "HOT_RELOAD_ERROR",
-        timestamp: Date.now(),
-        serverState: this.serverState,
-        error: error.message,
-        errorType: error.name || "UNKNOWN_ERROR"
-      });
-    }
+  registerRoutes(allFeatureRoutes) {
+    allFeatureRoutes.forEach((router) => {
+      if (router.routes) {
+        router.routes.forEach((route) => {
+          this.expressApp.use(route.path, route.handler);
+        });
+      }
+    });
   }
   /**
-   * ✅✅✅ Parser les détails d'une TransformError
+   * Parse transform error
    */
   parseTransformError(error) {
     const errorMessage = error.message || String(error);
@@ -837,22 +1005,43 @@ var WebServerCore = class {
       tool
     };
   }
-  registerRoutes(allFeatureRoutes) {
-    allFeatureRoutes.forEach((router) => {
-      if (router.routes) {
-        router.routes.forEach((route) => {
-          this.expressApp.use(route.path, route.handler);
-        });
-      }
-    });
-  }
+  /**
+   * Display server info
+   */
   infoWebApp() {
     this.serverUtility.infoServer(
       this.getEnvironment.appHost,
       Number(this.getEnvironment.appPort)
     );
   }
+  /**
+   * Stop file watcher
+   */
+  stopFileWatcher() {
+    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;
+      }
+    }
+  }
+  /**
+   * Shutdown server
+   */
   shutdown() {
+    this.stopFileWatcher();
     if (this.server) {
       this.server.close(() => {
         SLogger(this.localLanguage).logger.info({
@@ -862,12 +1051,193 @@ var WebServerCore = class {
         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();
+    }
+    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
+   */
+  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,
+      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
+      },
+      pid: process4.pid,
+      platform: process4.platform,
+      nodeVersion: process4.version,
+      cwd: process4.cwd()
+    };
+  }
+  /**
+   * Simple method to get just the status
+   */
+  getServerStatus() {
+    return this.serverStatus;
+  }
+  /**
+   * Get server statistics for monitoring
+   */
+  getServerStats() {
+    const uptime = this.serverStartTime ? Date.now() - this.serverStartTime.getTime() : 0;
+    const memory = process4.memoryUsage();
+    return {
+      status: this.serverStatus,
+      uptime: this.formatUptime(uptime),
+      memory: {
+        rss: this.formatBytes(memory.rss),
+        heapTotal: this.formatBytes(memory.heapTotal),
+        heapUsed: this.formatBytes(memory.heapUsed),
+        external: this.formatBytes(memory.external)
+      },
+      performance: {
+        cpuUsage: process4.cpuUsage(),
+        resourceUsage: process4.resourceUsage?.()
+      }
+    };
+  }
+  /**
+   * 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
+   */
+  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`;
+    } else if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+  /**
+   * Add watch directories
+   */
+  addWatchDirectories(directories) {
+    if (this.fileWatcher) {
+      this.fileWatcher.addWatchDirectories(directories);
+    }
+  }
+  /**
+   * Clear file cache
+   */
+  clearFileCache() {
+    if (this.fileWatcher) {
+      this.fileWatcher.clearFileCache();
+    }
+  }
+  /**
+   * Force reload configurations
+   */
+  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
+      });
+    }
+  }
+  /**
+   * Restart watcher
+   */
+  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);
+    }
+  }
 };
 export {
   WebServerCore as WebServer,