opticore-webapp 1.0.66 → 1.0.68

package/dist/index.js

@@ -1,41 +1,111 @@
-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');
-});
-
-// node_modules/tsup/assets/esm_shims.js
-import { fileURLToPath } from "url";
-import path from "path";
-var getFilename = () => fileURLToPath(import.meta.url);
-var getDirname = () => path.dirname(getFilename());
-var __dirname = /* @__PURE__ */ getDirname();
-
 // src/core/webServer.core.ts
-import * as path3 from "path";
-import process4 from "node:process";
+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 as express2 } from "opticore-express";
+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 "node:process";
-import EventEmitter from "node:events";
-import { express } from "opticore-express";
+import process from "process";
+import EventEmitter from "events";
 import {
   ServerListenEventError,
   CEventNameError as eventName,
   CEvent as event
 } from "opticore-catch-exception-error";
-function eventProcessHandler(localeLanguage) {
+
+// src/utils/isTransformError.utils.ts
+var isTransformErrorUtils = (error) => {
+  return error?.name === "TransformError" || error?.message?.includes("Transform failed") || error?.message?.includes("esbuild");
+};
+
+// src/core/handlers/eventProcess.handler.ts
+function eventProcessHandler(localeLanguage, expressApp) {
   const errorEmitter = new EventEmitter();
-  const app = express();
   const serverListenEvent = new ServerListenEventError(localeLanguage);
+  console.log("[Server] Setting up error event handlers...");
   errorEmitter.on(eventName.error, (error) => {
+    console.error("[Server] EventEmitter error caught:", error.message);
+    if (isTransformErrorUtils(error)) {
+      handleTransformError(error);
+    }
     serverListenEvent.listenerError(error);
   });
+  function handleTransformError(error) {
+    console.error("[Server] ============================================");
+    console.error("[Server] TRANSFORM ERROR DETECTED");
+    console.error("[Server] ============================================");
+    console.error("[Server] Message:", error.message);
+    console.error("[Server] Stack:", error.stack);
+    if (error.errors && Array.isArray(error.errors)) {
+      error.errors.forEach((err, index) => {
+        console.error(`[Server] Error ${index + 1}:`, err.text);
+        if (err.location) {
+          console.error(`[Server]   File: ${err.location.file}`);
+          console.error(`[Server]   Line: ${err.location.line}, Column: ${err.location.column}`);
+        }
+      });
+    }
+    const fileMatch = error.message.match(/([^:]+\.ts):(\d+):(\d+):/);
+    if (fileMatch) {
+      console.error("[Server] Problem file:", fileMatch[1]);
+      console.error("[Server] Line:", fileMatch[2], "Column:", fileMatch[3]);
+    }
+    const errorDetailMatch = error.message.match(/ERROR: (.+)$/m);
+    if (errorDetailMatch) {
+      console.error("[Server] Error detail:", errorDetailMatch[1]);
+    }
+    console.error("[Server] ============================================");
+    if (process.send) {
+      process.send({
+        type: "TRANSFORM_ERROR",
+        error: error.message,
+        stack: error.stack,
+        errorName: error.name,
+        details: error.errors,
+        timestamp: Date.now()
+      });
+    }
+  }
+  process.on(event.uncaughtException, (error) => {
+    console.error("[Server] UNCAUGHT EXCEPTION:", error.message);
+    console.error("[Server] Stack:", error.stack);
+    if (isTransformErrorUtils(error)) {
+      errorEmitter.emit("transformError", error);
+    }
+    serverListenEvent.uncaughtException(error);
+    if (process.send) {
+      const messageType = isTransformErrorUtils(error) ? "TRANSFORM_ERROR" : "HOT_RELOAD_ERROR";
+      process.send({
+        type: messageType,
+        error: error.message,
+        stack: error.stack,
+        errorName: error.name,
+        timestamp: Date.now()
+      });
+    }
+  });
+  process.on(event.unhandledRejection, (reason, promise) => {
+    console.error("[Server] UNHANDLED REJECTION:", reason);
+    if (isTransformErrorUtils(reason)) {
+      errorEmitter.emit("transformError", reason);
+    }
+    serverListenEvent.unhandledRejection(reason, promise);
+    if (process.send) {
+      const messageType = isTransformErrorUtils(reason) ? "TRANSFORM_ERROR" : "HOT_RELOAD_ERROR";
+      process.send({
+        type: messageType,
+        error: reason?.message || String(reason),
+        errorName: reason?.name,
+        timestamp: Date.now()
+      });
+    }
+  });
   process.on(event.beforeExit, (code) => {
     setTimeout(() => {
       serverListenEvent.processBeforeExit(code);
@@ -50,20 +120,20 @@ function eventProcessHandler(localeLanguage) {
   process.on(event.rejectionHandled, (promise) => {
     serverListenEvent.promiseRejectionHandled(promise);
   });
-  process.on(event.uncaughtException, (error) => {
-    serverListenEvent.uncaughtException(error);
-  });
   process.on(event.uncaughtExceptionMonitor, (error) => {
+    console.error("[Server] UNCAUGHT EXCEPTION MONITOR:", error.message);
+    if (isTransformErrorUtils(error)) {
+      errorEmitter.emit("transformError", error);
+    }
     serverListenEvent.uncaughtExceptionMonitor(error);
   });
-  process.on(event.unhandledRejection, (reason, promise) => {
-    serverListenEvent.unhandledRejection(reason, promise);
-  });
   process.on(event.warning, (warning) => {
     serverListenEvent.warning(warning);
   });
   process.on(event.message, (message) => {
-    serverListenEvent.message(message);
+    if (message.type !== "HOT_RELOAD_REQUEST" && message.type !== "SERVER_READY") {
+      serverListenEvent.message(message);
+    }
   });
   process.on(event.multipleResolves, (type, promise, reason) => {
     serverListenEvent.multipleResolves(type, promise, reason);
@@ -74,67 +144,26 @@ function eventProcessHandler(localeLanguage) {
   process.on(event.sigterm, (signal) => {
     serverListenEvent.sigtermSignalReceived(signal);
   });
-  app.use((err, req, res, next) => {
+  expressApp.use((err, req, res, next) => {
+    console.error("[Server] Express error middleware triggered:", err.message);
+    console.error("[Server] Request URL:", req.url);
+    console.error("[Server] Request method:", req.method);
+    errorEmitter.emit(eventName.error, err);
     serverListenEvent.expressErrorHandlingMiddleware(errorEmitter, err, req, res, next);
   });
+  console.log("[Server] Error event handlers configured successfully");
+  return errorEmitter;
 }
 
 // src/application/service/core.service.ts
-import process3 from "node:process";
+import process3 from "process";
 import chalk from "chalk";
-import * as path2 from "path";
+import * as path from "path";
 import * as fs from "fs";
-import colors3 from "ansi-colors";
-import { HttpStatusCode as status } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
-import { getEnvironnementValue } from "opticore-env-access";
-
-// src/core/helpers/modulesLoaded.utils.ts
-import colors2 from "ansi-colors";
-
-// src/core/helpers/logMessage.utils.ts
 import colors from "ansi-colors";
-
-// src/core/helpers/dateTimeFormatted.utils.ts
-var dateTimeFormattedUtils = `${(/* @__PURE__ */ new Date()).getMonth()}-${(/* @__PURE__ */ new Date()).getDate()}-${(/* @__PURE__ */ new Date()).getFullYear()} ${(/* @__PURE__ */ new Date()).getHours()}:${(/* @__PURE__ */ new Date()).getMinutes()}:${(/* @__PURE__ */ new Date()).getSeconds()}`;
-
-// src/core/helpers/logMessage.utils.ts
-var LogMessageUtils = class {
-  static success(title, action, contentAction) {
-    console.log(`${colors.green(`\u2714`)} ${colors.bgGreen(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${colors.bgGreen(`${colors.white(` Success `)}`)} [ ${action} ] ${contentAction} - [ Status ] ${colors.bgGreen(`${colors.white(` 200 `)}`)}`);
-  }
-  static warning(title, action, contentAction) {
-    console.warn(`${colors.yellow(`\u26A0\uFE0F`)} ${colors.bgYellow(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${colors.bgYellow(`${colors.white(` Warning `)}`)} ${contentAction}`);
-  }
-  static info(title, action, contentAction) {
-    console.info(`${colors.cyan(`\u24D8`)} ${colors.bgCyan(` ${colors.bold(`${colors.white(`${title}`)}`)} `)}  ${dateTimeFormattedUtils} | ${colors.bgCyan(`${colors.white(` Info `)}`)} ${contentAction}`);
-  }
-  static error(title, errorType, stackTrace, messageContent, httpCodeValue) {
-    console.error(`${colors.red(`\u2718`)} ${colors.bgRed(` ${colors.bold(`${colors.white(`${title}`)}`)} `)} | ${dateTimeFormattedUtils} | [ ${colors.red(`${colors.bold(` ${errorType} `)}`)} ] | [ ${colors.bold(`stack trace`)} ] ${colors.red(`${stackTrace}`)} - ${colors.red(`${messageContent}`)} - [ ${colors.red(`${colors.bold(` HttpCode `)}`)} ] ${colors.red(`${colors.bold(` ${httpCodeValue} `)}`)} `);
-  }
-  static requestError(title, errorName, errorMessage, errorCode) {
-    console.error(`[ ${colors.red(`${title}`)} ] ${dateTimeFormattedUtils} | ${colors.bgRed(`${colors.white(` ERROR `)}`)} ${colors.red(`[ ${errorName} ]`)} ${colors.red(`${errorMessage}`)} - [ Status ] ${colors.bgRed(`${colors.white(` ${errorCode} `)}`)}`);
-  }
-};
-
-// src/core/helpers/modulesLoaded.utils.ts
+import { HttpStatusCode, HttpStatusCode as status } from "opticore-http-response";
 import { TranslationLoader } from "opticore-translator";
-function modulesLoadedUtils(allAppRoutes, dbConChecker, localeLanguage) {
-  LogMessageUtils.success(
-    `${TranslationLoader.t("kernel", localeLanguage)}`,
-    `${TranslationLoader.t("loadKernel", localeLanguage)}`,
-    `${TranslationLoader.t("moduleAppLoaded", localeLanguage)}`
-  );
-  console.log(`${colors2.whiteBright(`  ${TranslationLoader.t("content", localeLanguage)}`)} ${colors2.green(`${TranslationLoader.t("kernel", localeLanguage)} :`)} ${colors2.cyan(`${colors2.bold(`${TranslationLoader.t("serverSide", localeLanguage)}`)}`)} ${TranslationLoader.t("hasBeenLoadedSuccessfully", localeLanguage)} ${colors2.green(`\u2714`)}`);
-  allAppRoutes ? console.log(`${colors2.whiteBright(`  ${TranslationLoader.t("content", localeLanguage)}`)} ${colors2.green(`${TranslationLoader.t("kernel", localeLanguage)} :`)} ${colors2.cyan(`${colors2.bold(`${TranslationLoader.t("routerService", localeLanguage)}`)} `)} ${colors2.green(`\u2714`)}`) : console.log(`${colors2.red(`\u2718`)} ${colors2.bgRed(` ${colors2.bold(`${colors2.white(` ${TranslationLoader.t("registerRoutes", localeLanguage)} `)}`)} `)} | ${dateTimeFormattedUtils} | [ ${colors2.red(`${colors2.bold(` ${TranslationLoader.t("fail", localeLanguage)} `)}`)} ] | [ ${colors2.bold(` ${TranslationLoader.t("loading", localeLanguage)} `)} ] - ${colors2.red(` ${TranslationLoader.t("routers", localeLanguage)} `)} - ${TranslationLoader.t("registerLoadingFailed", localeLanguage)} `);
-  typeof dbConChecker == "function" ? console.log(`${colors2.whiteBright(`  ${TranslationLoader.t("content", localeLanguage)}`)} ${colors2.green(`${TranslationLoader.t("kernel", localeLanguage)} :`)} ${colors2.cyan(`${colors2.bold(`${TranslationLoader.t("dbConnChecker", localeLanguage)}`)}`)} ${TranslationLoader.t("hasBeenLoadedSuccessfully", localeLanguage)} ${colors2.green(`\u2714`)}`) : "";
-}
-
-// src/application/service/traceError.service.ts
-import { StackTraceError } from "opticore-catch-exception-error";
-var STraceError = (props, name, httpCode, isOperational) => {
-  return new StackTraceError(props, name, httpCode, isOperational);
-};
+import { getEnvironnementValue } from "opticore-env-access";
 
 // src/utils/envPath.utils.ts
 import process2 from "process";
@@ -174,6 +203,21 @@ var dependenciesContainerProvider = (localLang) => {
   return new SContainer(localLang, dependencies);
 };
 
+// src/application/service/core.service.ts
+import { LoggerCore as LoggerCore2 } from "opticore-logger";
+
+// src/application/service/logger.service.ts
+var SLogger = (localLang) => {
+  return {
+    get serverLog() {
+      return dependenciesContainerProvider(localLang).resolve("OpticoreLogger");
+    },
+    get logger() {
+      return dependenciesContainerProvider(localLang).resolve("LoggerCore");
+    }
+  };
+};
+
 // src/application/service/core.service.ts
 var CoreService = class {
   localLanguage;
@@ -183,6 +227,7 @@ var CoreService = class {
   constructor(localLang, environmentPath) {
     this.environmentPath = environmentPath;
     this.localLanguage = localLang;
+    loaderTranslationFile(this.localLanguage);
     this.serverLog = dependenciesContainerProvider(localLang).resolve("OpticoreLogger");
     this.logger = dependenciesContainerProvider(localLang).resolve("LoggerCore");
   }
@@ -223,20 +268,20 @@ var CoreService = class {
     loaderTranslationFile(this.localLanguage);
     const memoryData = process3.memoryUsage();
     const data = {
-      [TranslationLoader2.t("totalMemoryAllocated", this.localLanguage)]: this.formatMemoryUsage(memoryData.rss),
-      [TranslationLoader2.t("sizeAllocatedHeap", this.localLanguage)]: this.formatMemoryUsage(memoryData.heapTotal),
-      [TranslationLoader2.t("memoryUsedExecution", this.localLanguage)]: this.formatMemoryUsage(memoryData.heapUsed),
-      [TranslationLoader2.t("externalMemory", this.localLanguage)]: this.formatMemoryUsage(memoryData.external),
-      [TranslationLoader2.t("memoryUsageUser", this.localLanguage)]: this.formatMemoryUsage(process3.cpuUsage().user),
-      [TranslationLoader2.t("memoryUsageSystem", this.localLanguage)]: this.formatMemoryUsage(process3.cpuUsage().system)
+      [TranslationLoader.t("totalMemoryAllocated", this.localLanguage)]: this.formatMemoryUsage(memoryData.rss),
+      [TranslationLoader.t("sizeAllocatedHeap", this.localLanguage)]: this.formatMemoryUsage(memoryData.heapTotal),
+      [TranslationLoader.t("memoryUsedExecution", this.localLanguage)]: this.formatMemoryUsage(memoryData.heapUsed),
+      [TranslationLoader.t("externalMemory", this.localLanguage)]: this.formatMemoryUsage(memoryData.external),
+      [TranslationLoader.t("memoryUsageUser", this.localLanguage)]: this.formatMemoryUsage(process3.cpuUsage().user),
+      [TranslationLoader.t("memoryUsageSystem", this.localLanguage)]: this.formatMemoryUsage(process3.cpuUsage().system)
     };
     return {
-      "rss": data[TranslationLoader2.t("totalMemoryAllocated", this.localLanguage)],
-      "heapTotal": data[TranslationLoader2.t("sizeAllocatedHeap", this.localLanguage)],
-      "heapUsed": data[TranslationLoader2.t("memoryUsedExecution", this.localLanguage)],
-      "external": data[TranslationLoader2.t("externalMemory", this.localLanguage)],
-      "user": data[TranslationLoader2.t("memoryUsageUser", this.localLanguage)],
-      "system": data[TranslationLoader2.t("memoryUsageSystem", this.localLanguage)],
+      "rss": data[TranslationLoader.t("totalMemoryAllocated", this.localLanguage)],
+      "heapTotal": data[TranslationLoader.t("sizeAllocatedHeap", this.localLanguage)],
+      "heapUsed": data[TranslationLoader.t("memoryUsedExecution", this.localLanguage)],
+      "external": data[TranslationLoader.t("externalMemory", this.localLanguage)],
+      "user": data[TranslationLoader.t("memoryUsageUser", this.localLanguage)],
+      "system": data[TranslationLoader.t("memoryUsageSystem", this.localLanguage)],
       "pid": process3.pid
     };
   }
@@ -248,7 +293,7 @@ var CoreService = class {
     const endTime = process3.hrtime(startTime);
     const executionTime = (endTime[0] * 1e9 + endTime[1]) / 1e6;
     return {
-      "projectPath": path2.join(process3.cwd()),
+      "projectPath": path.join(process3.cwd()),
       "startingTime": `${executionTime.toFixed(5)} ms`
     };
   }
@@ -261,7 +306,7 @@ var CoreService = class {
    */
   getEnvFileLoading(filePath) {
     try {
-      const fullPath = path2.resolve(process3.cwd(), filePath);
+      const fullPath = path.resolve(process3.cwd(), filePath);
       if (fs.existsSync(fullPath)) {
         const env = fs.readFileSync(fullPath, "utf-8");
         const lines = env.split("\n");
@@ -276,7 +321,7 @@ var CoreService = class {
     } catch (err) {
       this.logger.error({
         message: err.message,
-        title: TranslationLoader2.t("EnvFileLoading", this.localLanguage),
+        title: TranslationLoader.t("EnvFileLoading", this.localLanguage),
         errorType: err.code,
         stackTrace: err.stack,
         httpCodeValue: status.INTERNAL_SERVER_ERROR
@@ -294,19 +339,19 @@ var CoreService = class {
     try {
       loaderTranslationFile(this.localLanguage);
       this.getEnvFileLoading(".env");
-      const env = getEnvironnementValue(path2.join(envPath));
+      const env = getEnvironnementValue(path.join(envPath));
       const isDevelopment = env.devEnv === development && env.prodEnv === "";
       if (isDevelopment) {
-        return `${TranslationLoader2.t("serverRunning", this.localLanguage)} ${colors3.bgBlue(`${colors3.bold(`${development}`)}`)} mode`;
+        return `${TranslationLoader.t("serverRunning", this.localLanguage)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
       } else if (!isDevelopment) {
-        return `${TranslationLoader2.t("serverRunning", this.localLanguage)} ${colors3.bgBlue(`${colors3.bold(`${production}`)}`)} mode`;
+        return `${TranslationLoader.t("serverRunning", this.localLanguage)} ${colors.bgBlue(`${colors.bold(`${production}`)}`)} mode`;
       } else {
-        return `${TranslationLoader2.t("serverRunning", this.localLanguage)} ${colors3.bgBlue(`${colors3.bold(`${development}`)}`)} mode`;
+        return `${TranslationLoader.t("serverRunning", this.localLanguage)} ${colors.bgBlue(`${colors.bold(`${development}`)}`)} mode`;
       }
     } catch (err) {
       this.logger.error({
         message: err.message,
-        title: TranslationLoader2.t("serverRunning mode", this.localLanguage),
+        title: TranslationLoader.t("serverRunning mode", this.localLanguage),
         errorType: err.code,
         stackTrace: err.stack,
         httpCodeValue: status.INTERNAL_SERVER_ERROR
@@ -317,20 +362,17 @@ var CoreService = class {
     try {
       loaderTranslationFile(this.localLanguage);
       const getEnvironment = getEnvironnementValue(this.environmentPath);
-      const msg5 = getEnvironment.protocolTransfert === "" ? colors3.underline(`http://${host}:${port}`) : colors3.underline(`${getEnvironment.protocolTransfert}://${host}:${port}`);
+      const msg5 = getEnvironment.protocolTransfert === "" ? colors.underline(`http://${host}:${port}`) : colors.underline(`${getEnvironment.protocolTransfert}://${host}:${port}`);
       const messages = [
-        TranslationLoader2.t("webServerListening", this.localLanguage),
-        TranslationLoader2.t("webServerUsingNodeVersion", this.localLanguage, { nodeVersion: this.getVersions().nodeVersion }),
-        TranslationLoader2.t("startTime", this.localLanguage, { startTime: this.getProjectInfo().startingTime }),
-        this.getServerRunningMode(
-          TranslationLoader2.t("runningModeDev", this.localLanguage),
-          TranslationLoader2.t("runningModeProd", this.localLanguage)
-        )
+        TranslationLoader.t("webServerListening", this.localLanguage),
+        TranslationLoader.t("webServerUsingNodeVersion", this.localLanguage, { nodeVersion: this.getVersions().nodeVersion }),
+        TranslationLoader.t("startTime", this.localLanguage, { startTime: this.getProjectInfo().startingTime }),
+        this.getServerRunningMode(TranslationLoader.t("runningModeDev", this.localLanguage), TranslationLoader.t("runningModeProd", this.localLanguage))
       ];
       const maxLength = Math.max(...messages.map((m) => {
         return m.replace(/\u001b\[[0-9]{1,2}m/g, "").length;
       })) + 4;
-      console.log(chalk.blackBright(`${TranslationLoader2.t("tailingServerLog", this.localLanguage)} (${path2.join(path2.basename(process3.cwd()), "logs", "app.log")})`));
+      console.log(chalk.blackBright(`${TranslationLoader.t("tailingServerLog", this.localLanguage)} (${path.join(path.basename(process3.cwd()), "logs", "app.log")})`));
       const border = chalk.bgGreen.white(" ".repeat(maxLength));
       console.log(border);
       messages.forEach((msg) => {
@@ -340,67 +382,39 @@ var CoreService = class {
       });
       console.log(border);
       console.log("\n");
-      this.serverLog.serverLog({
+      const logCore = new LoggerCore2();
+      logCore.success({
+        title: TranslationLoader.t("serverRunningTitle", this.localLanguage),
+        message: TranslationLoader.t("serverRunningAt", this.localLanguage, { server: msg5 })
+      });
+      SLogger(this.localLanguage).serverLog.serverLog({
         timestamp: (/* @__PURE__ */ new Date()).toString(),
         level: "SERVER",
-        title: TranslationLoader2.t("serverRunningTitle", this.localLanguage),
-        typeName: TranslationLoader2.t("opticoreServerTypeName", this.localLanguage),
-        message: TranslationLoader2.t("serverRunningAt", this.localLanguage, { server: msg5 })
+        title: TranslationLoader.t("serverRunningTitle", this.localLanguage),
+        typeName: TranslationLoader.t("opticoreServerTypeName", this.localLanguage),
+        message: TranslationLoader.t("serverRunningAt", this.localLanguage, { server: msg5 })
       });
     } catch (err) {
-      this.logger.error({
+      SLogger(this.localLanguage).logger.error({
         message: err.message,
-        title: TranslationLoader2.t("server", this.localLanguage),
+        title: TranslationLoader.t("server", this.localLanguage),
         errorType: err.code,
         stackTrace: err.stack,
-        httpCodeValue: status.INTERNAL_SERVER_ERROR
+        httpCodeValue: HttpStatusCode.INTERNAL_SERVER_ERROR
       });
     }
   }
-  coreListenerEventLoaderModuleService(kernelModule) {
-    loaderTranslationFile(this.localLanguage);
-    let router = [];
-    let dbCon;
-    kernelModule.forEach((module) => {
-      if (Array.isArray(module)) {
-        router = module;
-      } else if (typeof module === "function") {
-        dbCon = module;
-      }
-    });
-    if (router && dbCon) {
-      modulesLoadedUtils(router, dbCon, this.localLanguage);
-      (() => {
-        dbCon();
-      })();
-    } else {
-      const stackTrace = STraceError(
-        TranslationLoader2.t("loadedModulesError", this.localLanguage),
-        TranslationLoader2.t("loadedModules", this.localLanguage),
-        status.NOT_ACCEPTABLE,
-        true
-      );
-      throw new Error(stackTrace.message);
-    }
-  }
 };
 
+// src/core/helpers/dateTimeFormatted.utils.ts
+var dateTimeFormattedUtils = `${(/* @__PURE__ */ new Date()).getMonth()}-${(/* @__PURE__ */ new Date()).getDate()}-${(/* @__PURE__ */ new Date()).getFullYear()} ${(/* @__PURE__ */ new Date()).getHours()}:${(/* @__PURE__ */ new Date()).getMinutes()}:${(/* @__PURE__ */ new Date()).getSeconds()}`;
+
 // src/application/service/serverStartError.service.ts
 import {
   CCodeError,
   CErrorName
 } from "opticore-catch-exception-error";
-
-// src/application/service/logger.service.ts
-var SLogger = (localLang) => {
-  return {
-    serverLog: dependenciesContainerProvider(localLang).resolve("OpticoreLogger"),
-    logger: dependenciesContainerProvider(localLang).resolve("LoggerCore")
-  };
-};
-
-// src/application/service/serverStartError.service.ts
-import { HttpStatusCode } from "opticore-http-response";
+import { HttpStatusCode as HttpStatusCode2 } from "opticore-http-response";
 var SServerStartError = (err, environmentPath) => {
   if (err.name) {
     for (const [key, code] of Object.entries(CErrorName)) {
@@ -410,7 +424,7 @@ var SServerStartError = (err, environmentPath) => {
           title: code,
           errorType: code,
           stackTrace: err.stack,
-          httpCodeValue: HttpStatusCode.INTERNAL_SERVER_ERROR
+          httpCodeValue: HttpStatusCode2.INTERNAL_SERVER_ERROR
         });
         break;
       }
@@ -423,7 +437,7 @@ var SServerStartError = (err, environmentPath) => {
           title: code,
           errorType: key,
           stackTrace: err.stack,
-          httpCodeValue: HttpStatusCode.INTERNAL_SERVER_ERROR
+          httpCodeValue: HttpStatusCode2.INTERNAL_SERVER_ERROR
         });
         break;
       }
@@ -432,119 +446,147 @@ 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 HttpStatusCode2 } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader3 } from "opticore-translator";
+import { WebServerWatcherService } from "opticore-watcher";
 var WebServerCore = class {
   serverUtility;
-  expressApp = express2();
+  expressApp = express();
+  fileWatcher;
   localLanguage;
   loggerConfig;
   routerExpressApp;
   getEnvironment;
   environmentPath;
   serverListenEvent;
-  isHotReloading = false;
   currentRoutes = [];
   currentDependencies = [];
-  constructor(app, loggerConfig, localLanguage, environmentPath, corsOriginOptions) {
-    this.stackTraceErrorHandling(localLanguage);
-    this.getEnvironment = getEnvironnementValue2(environmentPath);
-    this.routerExpressApp = app;
-    this.loggerConfig = loggerConfig;
-    this.localLanguage = localLanguage;
-    this.environmentPath = environmentPath;
-    this.expressApp.use(express2.json());
-    this.expressApp.use(express2.raw());
-    this.expressApp.use(express2.text());
-    this.expressApp.use(express2.urlencoded({ extended: true }));
-    this.expressApp.use(corsOrigin(corsOriginOptions));
-    this.serverListenEvent = new ServerListenEventError2(localLanguage);
-    this.serverUtility = new CoreService(localLanguage, environmentPath);
-    this.setupSignalHandlers();
+  server = void 0;
+  errorEmitter;
+  isWatcherEnabled = true;
+  serverStatus = "STARTING";
+  serverStartTime = /* @__PURE__ */ new Date();
+  constructor(paramsConstructor) {
+    this.getEnvironment = getEnvironnementValue2(paramsConstructor.environmentPath);
+    this.routerExpressApp = paramsConstructor.app;
+    this.loggerConfig = paramsConstructor.loggerConfig;
+    this.localLanguage = paramsConstructor.localLanguage;
+    this.environmentPath = paramsConstructor.environmentPath;
+    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);
   }
-  /**
-   *
-   * @param dependencies
-   */
-  registerDependencies(dependencies2) {
-    try {
-      dependenciesContainerProvider(this.localLanguage).getServices();
-    } catch (err) {
-      SLogger(this.localLanguage).logger.error({
-        message: err.message,
-        title: TranslationLoader3.t("registerDependencies", this.localLanguage),
-        errorType: err.code,
-        stackTrace: err.stack,
-        httpCodeValue: HttpStatusCode2.INTERNAL_SERVER_ERROR
-      });
-    }
-  }
-  /**
-   *
-   * @param routers
-   * @param databaseCallback
-   * @param dependenciesProvider
-   */
   onStartServer(routers, databaseCallback, dependenciesProvider) {
     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));
-    } else if (this.getEnvironment.appHost === "") {
+      return void 0;
+    }
+    if (this.getEnvironment.appHost === "") {
       this.serverListenEvent.hostUndefined(this.getEnvironment.appHost);
-    } else if (Number(this.getEnvironment.appPort) === 0) {
+      return void 0;
+    }
+    if (Number(this.getEnvironment.appPort) === 0) {
       this.serverListenEvent.portUndefined();
-    } else if (this.localLanguage === "") {
+      return void 0;
+    }
+    if (this.localLanguage === "") {
       SLogger(this.localLanguage).logger.error({
-        message: TranslationLoader3.t("noDefaultLocalLang", this.localLanguage),
-        title: TranslationLoader3.t("noLocalLang", this.localLanguage),
-        errorType: TranslationLoader3.t("localLangMissing", this.localLanguage),
+        message: TranslationLoader2.t("noDefaultLocalLang", this.localLanguage),
+        title: TranslationLoader2.t("noLocalLang", this.localLanguage),
+        errorType: TranslationLoader2.t("localLangMissing", this.localLanguage),
         stackTrace: void 0,
-        httpCodeValue: HttpStatusCode2.NOT_FOUND
+        httpCodeValue: HttpStatusCode3.NOT_FOUND
       });
-    } else {
-      return this.expressApp.listen(
-        Number(this.getEnvironment.appPort),
-        () => {
-          loaderTranslationFile(this.localLanguage);
-          try {
+      return void 0;
+    }
+    this.server = this.expressApp.listen(
+      Number(this.getEnvironment.appPort),
+      this.getEnvironment.appHost,
+      () => {
+        try {
+          if (databaseCallback && typeof databaseCallback === "function") {
             databaseCallback(this.getEnvironment);
-            new SContainer2(this.localLanguage, this.currentDependencies);
-            this.expressApp.use(express2.static(path3.join(process4.cwd(), "public/template")));
-            this.registerRoutes(this.currentRoutes);
-          } catch (err) {
-            SServerStartError(err, this.environmentPath);
           }
+          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
+          });
+          SServerStartError(err, this.environmentPath);
         }
-      );
+      }
+    );
+    return this.server;
+  }
+  /**
+   * Error handling configuration
+   */
+  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}`
+        });
+      });
     }
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("ERROR_HANDLING", this.localLanguage),
+      message: TranslationLoader2.t("ERROR_HANDLING_CONFIGURED", this.localLanguage)
+    });
   }
   /**
-   *
-   * @param serverWeb
+   * Setup server events
    */
-  onListeningOnServerEvent(serverWeb) {
-    loaderTranslationFile(this.localLanguage);
-    serverWeb.on(eventName2.error, (err) => {
+  setupServerEvents() {
+    if (!this.server) return;
+    this.server.on(eventName2.error, (err) => {
       this.serverListenEvent.onEventError(err);
-    }).on(eventName2.close, () => {
+    });
+    this.server.on(eventName2.close, () => {
       this.serverListenEvent.serverClosing();
-    }).on(eventName2.drop, () => {
+    });
+    this.server.on(eventName2.drop, () => {
       this.serverListenEvent.dropNewConnection();
-    }).on(eventName2.listening, () => {
-      this.infoWebApp();
     });
-  }
-  /**
-   *
-   * @param serverWeb
-   */
-  onRequestOnServerEvent(serverWeb) {
-    loaderTranslationFile(this.localLanguage);
-    serverWeb.on(eventName2.request, (req, res) => {
+    this.server.on(eventName2.request, (req, res) => {
       requestCallsEvent(
         req,
         res,
@@ -557,144 +599,643 @@ var WebServerCore = class {
     });
   }
   /**
-   *
-   * @param allFeatureRoutes
-   * @private
+   * Initialize file watcher
    */
-  registerRoutes(allFeatureRoutes) {
-    allFeatureRoutes.map((router) => {
-      router.featureRoute.map((route) => {
-        this.expressApp.use(route.path, route.handler);
+  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
+   */
+  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("WATCHER_STARTED", this.localLanguage),
+          message: TranslationLoader2.t("FILE_WATCHER_ACTIVE", 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)
+        });
+      });
+    } 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;
+    }
   }
   /**
-   *
-   * @param localLanguage
-   * @private
+   * Handle hot reload requested by watcher
    */
-  stackTraceErrorHandling(localLanguage) {
-    eventProcessHandler(localLanguage);
+  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;
+    }
   }
   /**
-   *
-   * @private
+   * Handle watcher errors
    */
-  infoWebApp() {
-    this.serverUtility.infoServer(
-      this.getEnvironment.appHost,
-      Number(this.getEnvironment.appPort)
-    );
+  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
+    });
   }
-  setupSignalHandlers() {
-    process4.on("SIGHUP", async () => {
-      if (!this.isHotReloading) {
-        console.log(`${dateTimeFormattedUtils} | [Server] Received SIGHUP signal, hot reloading...`);
-        try {
-          this.isHotReloading = true;
-          await this.handleHotReload();
-          console.log(`${dateTimeFormattedUtils} | [Server] Hot reload completed successfully`);
-        } catch (error) {
-          console.error(`${dateTimeFormattedUtils} | [Server] Hot reload failed:`, error);
-          this.serverListenEvent.onEventError(error);
-        } finally {
-          this.isHotReloading = false;
-        }
-      }
+  /**
+   * Notify file change without action
+   */
+  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))
     });
   }
   /**
-   * Logique de rechargement à chaud
+   * Reload environment configuration
    */
-  async handleHotReload() {
-    const context = {
-      clearedModules: [],
-      reloadedRoutes: [],
-      reloadedServices: []
-    };
+  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
+      });
+    }
+  }
+  /**
+   * Execute hot reload for environment files
+   */
+  executeHotReloadEnvironment(filePath) {
     try {
-      this.clearServerCache(context);
-      await this.reloadConfigurations(context);
-      await this.reloadDependencies(context);
-      await this.reloadRoutes(context);
-      await this.reloadServices(context);
+      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) {
-      console.error(`${dateTimeFormattedUtils} | [Server] Hot reload error:`, error);
-      throw 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
+      });
     }
   }
   /**
-   * Clear server module cache
+   * Reload configuration files
    */
-  clearServerCache(context) {
-    const baseDirs = [
-      path3.join(process4.cwd(), "src"),
-      path3.join(process4.cwd(), "dist"),
-      path3.join(__dirname, "..")
-    ];
-    for (const key in __require.cache) {
-      if (!key.includes("node_modules") && !key.endsWith(".json") && baseDirs.some((dir) => key.startsWith(dir))) {
-        delete __require.cache[key];
-        context.clearedModules.push(path3.basename(key));
+  reloadConfigurationFiles() {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      SLogger(this.localLanguage).logger.info({
+        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
+      });
     }
-    console.log(`${dateTimeFormattedUtils} | [Server] Cleared ${context.clearedModules.length} modules from cache`);
   }
   /**
-   * Recharger les configurations
+   * Reload application routes
+   */
+  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
+      });
+    }
+  }
+  /**
+   * 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
    */
-  async reloadConfigurations(context) {
+  reloadConfigurations() {
     try {
       const newEnv = getEnvironnementValue2(this.environmentPath);
-      Object.assign(this.getEnvironment, newEnv);
+      Object.keys(newEnv).forEach((key) => {
+        this.getEnvironment[key] = newEnv[key];
+      });
       loaderTranslationFile(this.localLanguage);
-      console.log(`${dateTimeFormattedUtils} | [Server] Configurations reloaded`);
     } catch (error) {
-      console.warn(`${dateTimeFormattedUtils} | [Server] Configuration reload warning:`, error.message);
+      throw new Error(`Configuration reload failed: ${error.message}`);
     }
   }
   /**
-   * Recharger les dépendances
+   * Reload dependencies
    */
-  async reloadDependencies(context) {
+  reloadDependencies() {
     try {
       new SContainer2(this.localLanguage, this.currentDependencies);
-      console.log(`${dateTimeFormattedUtils} | [Server] Dependencies reloaded`);
+      const container = dependenciesContainerProvider(this.localLanguage);
+      if (!container) {
+        throw new Error("Dependency container is not available");
+      }
     } catch (error) {
-      console.warn(`${dateTimeFormattedUtils} | [Server] Dependencies reload warning:`, error.message);
+      throw new Error(`Dependency reload failed: ${error.message}`);
     }
   }
   /**
-   * Recharger les routes
+   * Register routes
    */
-  async reloadRoutes(context) {
-    try {
-      this.expressApp._router.stack = this.expressApp._router.stack.filter((layer) => {
-        return !layer.route;
+  registerRoutes(allFeatureRoutes) {
+    allFeatureRoutes.forEach((router) => {
+      if (router.routes) {
+        router.routes.forEach((route) => {
+          this.expressApp.use(route.path, route.handler);
+        });
+      }
+    });
+  }
+  /**
+   * Parse transform error
+   */
+  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
+    };
+  }
+  /**
+   * 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({
+          title: TranslationLoader2.t("CLOSED", this.localLanguage),
+          message: TranslationLoader2.t("SERVER_CLOSED", this.localLanguage)
+        });
+        process4.exit(0);
       });
-      this.registerRoutes(this.currentRoutes);
-      context.reloadedRoutes = this.currentRoutes.map((route, index) => {
-        if (route.featureName && typeof route.featureName === "string") {
-          return route.featureName;
-        }
-        return `RouteGroup_${index + 1}`;
-      }).filter((name) => !!name);
-      console.log(`${dateTimeFormattedUtils} | [Server] Routes reloaded: ${context.reloadedRoutes.join(", ")}`);
-    } catch (error) {
-      console.error(`${dateTimeFormattedUtils} | [Server] Routes reload error:`, error.message);
-      throw error;
+      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);
     }
   }
   /**
-   * Recharger les services
+   * 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
    */
-  async reloadServices(context) {
+  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 {
-      const services = dependenciesContainerProvider(this.localLanguage).getServices();
-      context.reloadedServices = Array.from(services.keys());
-      console.log(`${dateTimeFormattedUtils} | [Server] Services reloaded: ${context.reloadedServices.length} services`);
+      this.reloadConfigurations();
+      this.reloadDependencies();
+      SLogger(this.localLanguage).logger.info({
+        title: "Force Reload",
+        message: "All configurations and dependencies have been reloaded"
+      });
     } catch (error) {
-      console.warn(`${dateTimeFormattedUtils} | [Server] Services reload warning:`, error.message);
+      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);
     }
   }
 };