opticore-webapp 1.0.70 → 1.0.72

package/dist/index.js

@@ -1,16 +1,16 @@
 // src/core/webServer.core.ts
-import * as path2 from "path";
-import process4 from "process";
+import * as path3 from "path";
+import process6 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 { getEnvironmentValue as getEnvironmentValue2 } from "opticore-env-access";
 import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
+import { TranslationLoader as TranslationLoader3 } from "opticore-translator";
 import { requestCallsEvent } from "opticore-request-call-event";
 
 // src/core/handlers/eventProcess.handler.ts
-import process from "process";
+import process2 from "process";
 import EventEmitter from "events";
 import { express } from "opticore-express";
 import { ServerListenEventError, CEventNameError as eventName, CEvent as event } from "opticore-catch-exception-error";
@@ -21,42 +21,42 @@ function eventProcessHandler(localeLanguage) {
   errorEmitter.on(eventName.error, (error) => {
     serverListenEvent.listenerError(error);
   });
-  process.on(event.beforeExit, (code) => {
+  process2.on(event.beforeExit, (code) => {
     setTimeout(() => {
       serverListenEvent.processBeforeExit(code);
     }, 100);
   });
-  process.on(event.disconnect, () => {
+  process2.on(event.disconnect, () => {
     serverListenEvent.processDisconnected();
   });
-  process.on(event.exit, (code) => {
+  process2.on(event.exit, (code) => {
     serverListenEvent.exited(code);
   });
-  process.on(event.rejectionHandled, (promise) => {
+  process2.on(event.rejectionHandled, (promise) => {
     serverListenEvent.promiseRejectionHandled(promise);
   });
-  process.on(event.uncaughtException, (error) => {
+  process2.on(event.uncaughtException, (error) => {
     serverListenEvent.uncaughtException(error);
   });
-  process.on(event.uncaughtExceptionMonitor, (error) => {
+  process2.on(event.uncaughtExceptionMonitor, (error) => {
     serverListenEvent.uncaughtExceptionMonitor(error);
   });
-  process.on(event.unhandledRejection, (reason, promise) => {
+  process2.on(event.unhandledRejection, (reason, promise) => {
     serverListenEvent.unhandledRejection(reason, promise);
   });
-  process.on(event.warning, (warning) => {
+  process2.on(event.warning, (warning) => {
     serverListenEvent.warning(warning);
   });
-  process.on(event.message, (message) => {
+  process2.on(event.message, (message) => {
     serverListenEvent.message(message);
   });
-  process.on(event.multipleResolves, (type, promise, reason) => {
+  process2.on(event.multipleResolves, (type, promise, reason) => {
     serverListenEvent.multipleResolves(type, promise, reason);
   });
-  process.on(event.sigint, () => {
+  process2.on(event.sigint, () => {
     serverListenEvent.processInterrupted();
   });
-  process.on(event.sigterm, (signal) => {
+  process2.on(event.sigterm, (signal) => {
     serverListenEvent.sigtermSignalReceived(signal);
   });
   app.use((err, req, res, next) => {
@@ -65,7 +65,7 @@ function eventProcessHandler(localeLanguage) {
 }
 
 // src/application/service/core.service.ts
-import process3 from "process";
+import process4 from "process";
 import chalk from "chalk";
 import * as path from "path";
 import * as fs from "fs";
@@ -75,8 +75,8 @@ import { TranslationLoader } from "opticore-translator";
 import { getEnvironmentValue } from "opticore-env-access";
 
 // src/utils/envPath.utils.ts
-import process2 from "process";
-var envPath = process2.cwd() + "/config/env/.env";
+import process3 from "process";
+var envPath = process3.cwd() + "/config/env/.env";
 
 // src/application/service/loaderTranslationFile.service.ts
 import { translationLoaderConfig } from "opticore-loader-translation";
@@ -112,16 +112,35 @@ var dependenciesContainerProvider = (localLang) => {
   return new SContainer(localLang, dependencies);
 };
 
+// src/application/service/core.service.ts
+import { SContainer as SContainer2 } from "opticore-dependency-inject";
+
+// src/utils/parsingDateTime.utils.ts
+var parsingDateTimeUtils = (localFormatTime) => {
+  const now = /* @__PURE__ */ new Date();
+  const formatter = new Intl.DateTimeFormat(localFormatTime, {
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  return formatter.format(now);
+};
+
 // src/application/service/core.service.ts
 var CoreService = class {
   localLanguage;
   environmentPath;
   serverLog;
   logger;
+  container;
   constructor(localLang, environmentPath) {
     this.loadTranslationFiles();
     this.environmentPath = environmentPath;
     this.localLanguage = localLang;
+    this.container = new SContainer2(localLang);
     this.serverLog = dependenciesContainerProvider(localLang).resolve("OpticoreLogger");
     this.logger = dependenciesContainerProvider(localLang).resolve("LoggerCore");
   }
@@ -148,7 +167,7 @@ var CoreService = class {
   getEnvFileLoading(filePath) {
     this.loadTranslationFiles();
     try {
-      const fullPath = path.resolve(process3.cwd(), filePath);
+      const fullPath = path.resolve(process4.cwd(), filePath);
       if (fs.existsSync(fullPath)) {
         const env = fs.readFileSync(fullPath, "utf-8");
         const lines = env.split("\n");
@@ -156,7 +175,7 @@ var CoreService = class {
           const match = line.match(/^([^#=]+)=([^#]+)$/);
           if (match) {
             const key = match[1].trim();
-            process3.env[key] = match[2].trim();
+            process4.env[key] = match[2].trim();
           }
         });
       }
@@ -174,7 +193,7 @@ var CoreService = class {
    * Returns an Object containing a node version, openssl, and v0
    */
   getVersions() {
-    const { node, openssl, v8 } = process3.versions;
+    const { node, openssl, v8 } = process4.versions;
     const data = {
       "node version": node,
       "openssl": openssl,
@@ -195,14 +214,14 @@ var CoreService = class {
    */
   getUsageMemory() {
     this.loadTranslationFiles();
-    const memoryData = process3.memoryUsage();
+    const memoryData = process4.memoryUsage();
     const data = {
       [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)
+      [TranslationLoader.t("memoryUsageUser", this.localLanguage)]: this.formatMemoryUsage(process4.cpuUsage().user),
+      [TranslationLoader.t("memoryUsageSystem", this.localLanguage)]: this.formatMemoryUsage(process4.cpuUsage().system)
     };
     return {
       "rss": data[TranslationLoader.t("totalMemoryAllocated", this.localLanguage)],
@@ -211,18 +230,18 @@ var CoreService = class {
       "external": data[TranslationLoader.t("externalMemory", this.localLanguage)],
       "user": data[TranslationLoader.t("memoryUsageUser", this.localLanguage)],
       "system": data[TranslationLoader.t("memoryUsageSystem", this.localLanguage)],
-      "pid": process3.pid
+      "pid": process4.pid
     };
   }
   /**
    * Return an Object containing a project path and running server time
    */
   getProjectInfo() {
-    const startTime = process3.hrtime();
-    const endTime = process3.hrtime(startTime);
+    const startTime = process4.hrtime();
+    const endTime = process4.hrtime(startTime);
     const executionTime = (endTime[0] * 1e9 + endTime[1]) / 1e6;
     return {
-      "projectPath": path.join(process3.cwd()),
+      "projectPath": path.join(process4.cwd()),
       "startingTime": `${executionTime.toFixed(5)} ms`
     };
   }
@@ -261,7 +280,7 @@ var CoreService = class {
     this.loadTranslationFiles();
     try {
       const getEnvironment = getEnvironmentValue(this.environmentPath);
-      const msg5 = getEnvironment.protocolTransfert === "" ? colors.underline(`http://${host}:${port}`) : colors.underline(`${getEnvironment.protocolTransfert}://${host}:${port}`);
+      const msg5 = getEnvironment.protocolTransfer === "" ? colors.underline(`http://${host}:${port}`) : colors.underline(`${getEnvironment.protocolTransfer}://${host}:${port}`);
       const messages = [
         TranslationLoader.t("webServerListening", this.localLanguage),
         TranslationLoader.t("webServerUsingNodeVersion", this.localLanguage, { nodeVersion: this.getVersions().nodeVersion }),
@@ -271,7 +290,7 @@ var CoreService = class {
       const maxLength = Math.max(...messages.map((m) => {
         return m.replace(/\u001b\[[0-9]{1,2}m/g, "").length;
       })) + 4;
-      console.log(chalk.blackBright(`${TranslationLoader.t("tailingServerLog", this.localLanguage)} (${path.join(path.basename(process3.cwd()), "logs", "app.log")})`));
+      console.log(chalk.blackBright(`${TranslationLoader.t("tailingServerLog", this.localLanguage)} (${path.join(path.basename(process4.cwd()), "logs", "app.log")})`));
       const border = chalk.bgGreen.white(" ".repeat(maxLength));
       console.log(border);
       messages.forEach((msg) => {
@@ -281,17 +300,31 @@ var CoreService = class {
       });
       console.log(border);
       console.log("\n");
-      this.logger.success({
-        title: TranslationLoader.t("serverRunningTitle", this.localLanguage),
-        message: TranslationLoader.t("serverRunningAt", this.localLanguage, { server: msg5 })
-      });
       this.serverLog.serverLog({
-        timestamp: (/* @__PURE__ */ new Date()).toString(),
+        timestamp: parsingDateTimeUtils(getEnvironment.localFormatTime),
         level: "SERVER",
         title: TranslationLoader.t("serverRunningTitle", this.localLanguage),
         typeName: TranslationLoader.t("opticoreServerTypeName", this.localLanguage),
         message: TranslationLoader.t("serverRunningAt", this.localLanguage, { server: msg5 })
       });
+      const dependenciesList = this.container.listDependencies();
+      if (dependenciesList.length > 0) {
+        this.serverLog.opticoreLog({
+          level: "OPTICORE",
+          message: TranslationLoader.t("DEPENDENCIES_STORED", this.localLanguage, { dependenciesList: dependenciesList.join(", ") }),
+          timestamp: parsingDateTimeUtils(getEnvironment.localFormatTime),
+          title: TranslationLoader.t("DEPENDENCIES_CONTAINER", this.localLanguage),
+          typeName: "DEPENDENCIES_CONTAINER"
+        });
+      } else {
+        this.serverLog.opticoreLog({
+          level: "OPTICORE",
+          message: TranslationLoader.t("NO_DEPENDENCIES_STORED", this.localLanguage),
+          timestamp: parsingDateTimeUtils(getEnvironment.localFormatTime),
+          title: TranslationLoader.t("DEPENDENCIES_CONTAINER", this.localLanguage),
+          typeName: "DEPENDENCIES_CONTAINER"
+        });
+      }
     } catch (err) {
       this.logger.error({
         message: err.message,
@@ -358,10 +391,284 @@ var SServerStartError = (err, environmentPath) => {
 };
 
 // src/core/webServer.core.ts
-import { SContainer as SContainer2 } from "opticore-dependency-inject";
+import { SContainer as SContainer3 } from "opticore-dependency-inject";
+
+// src/application/service/getEnvFileLoading.service.ts
+import path2 from "path";
+import process5 from "process";
+import fs2 from "fs";
+import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
+import { HttpStatusCode as status2 } from "opticore-http-response";
+var getEnvFileLoadingService = (filePath, localLanguage) => {
+  loaderTranslationFile(localLanguage);
+  const logger = dependenciesContainerProvider(localLanguage).resolve("LoggerCore");
+  try {
+    const fullPath = path2.resolve(process5.cwd(), filePath);
+    if (fs2.existsSync(fullPath)) {
+      const env = fs2.readFileSync(fullPath, "utf-8");
+      const lines = env.split("\n");
+      lines.forEach((line) => {
+        const match = line.match(/^([^#=]+)=([^#]+)$/);
+        if (match) {
+          const key = match[1].trim();
+          process5.env[key] = match[2].trim();
+        }
+      });
+    }
+  } catch (err) {
+    logger.error({
+      message: err.message,
+      title: TranslationLoader2.t("EnvFileLoading", localLanguage),
+      errorType: err.code,
+      stackTrace: err.stack,
+      httpCodeValue: status2.INTERNAL_SERVER_ERROR
+    });
+  }
+};
+
+// src/hotReload/hotReload.watcher.ts
+import { watch as fsWatch } from "fs";
+import { readdir, access } from "fs/promises";
+import { join as join2, resolve as resolve2, extname, relative, basename as basename2 } from "path";
+import { config as dotenvConfig } from "dotenv";
+import chalk2 from "chalk";
+import colors2 from "ansi-colors";
+import gradient from "gradient-string";
+var DEFAULT_WATCH_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs", ".json"];
+var DEFAULT_HOT_RELOAD_EXTENSIONS = [".json"];
+var DEFAULT_IGNORE = [
+  "node_modules",
+  "dist",
+  ".git",
+  "package.json",
+  "package-lock.json",
+  ".idea",
+  ".vscode",
+  "coverage",
+  "logs"
+];
+var DEFAULT_DEBOUNCE_MS = 300;
+var HotReloadWatcher = class {
+  cfg;
+  server = null;
+  watchers = [];
+  debounceTimer = null;
+  restarting = false;
+  constructor(config) {
+    const c = config ?? {};
+    this.cfg = {
+      rootDir: resolve2(c.rootDir ?? process.cwd()),
+      watchDirs: c.watchDirs ?? [],
+      watchExtensions: c.watchExtensions ?? DEFAULT_WATCH_EXTENSIONS,
+      ignore: [...DEFAULT_IGNORE, ...c.ignore ?? []],
+      envFile: c.envFile ?? ".env",
+      hotReloadExtensions: c.hotReloadExtensions ?? DEFAULT_HOT_RELOAD_EXTENSIONS,
+      debounceMs: c.debounceMs ?? DEFAULT_DEBOUNCE_MS
+    };
+  }
+  // ─── Called by WebServerCore once the HTTP server is listening ────────────
+  async attach(server) {
+    this.server = server;
+    this.printBanner();
+    await this.setupWatchers();
+    this.setupProcessSignals();
+  }
+  // ─── File watching ────────────────────────────────────────────────────────
+  async setupWatchers() {
+    const dirs = [
+      this.cfg.rootDir,
+      ...this.cfg.watchDirs.map((d) => resolve2(d))
+    ];
+    for (const dir of dirs) {
+      await this.watchRecursive(dir);
+    }
+  }
+  async watchRecursive(dir) {
+    if (this.shouldIgnoreDir(dir)) return;
+    try {
+      await access(dir);
+    } catch {
+      return;
+    }
+    try {
+      const w = fsWatch(dir, (_, filename) => {
+        if (filename) this.onFileChange(join2(dir, filename));
+      });
+      w.on("error", () => {
+      });
+      this.watchers.push(w);
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) await this.watchRecursive(join2(dir, entry.name));
+      }
+    } catch {
+    }
+  }
+  // ─── Change handling ──────────────────────────────────────────────────────
+  onFileChange(filePath) {
+    if (this.shouldIgnoreFile(filePath)) return;
+    if (!this.isWatched(filePath)) return;
+    if (this.restarting) return;
+    const rel = relative(this.cfg.rootDir, filePath);
+    if (this.isHotReloadable(filePath)) {
+      this.doHotReload(filePath, rel);
+    } else {
+      this.scheduleRestart(rel);
+    }
+  }
+  doHotReload(filePath, rel) {
+    if (this.isEnvFile(filePath)) {
+      dotenvConfig({ path: filePath, override: true });
+      this.printHot(rel, "env variables reloaded");
+    } else {
+      this.printHot(rel, "json config reloaded");
+    }
+  }
+  scheduleRestart(rel) {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.restarting = true;
+      this.printReloading(rel);
+      this.closeAndExit();
+    }, this.cfg.debounceMs);
+  }
+  /**
+   * Gracefully close the HTTP server so in-flight requests can finish,
+   * then exit with code 0 — the external runner restarts the process.
+   */
+  closeAndExit() {
+    if (!this.server) {
+      process.exit(0);
+      return;
+    }
+    this.server.close(() => {
+      process.exit(0);
+    });
+    setTimeout(() => {
+      process.exit(0);
+    }, 3e3).unref();
+  }
+  // ─── Filters ──────────────────────────────────────────────────────────────
+  shouldIgnoreDir(dir) {
+    return this.cfg.ignore.some(
+      (p) => dir.includes(`/${p}`) || dir.endsWith(`/${p}`) || dir.endsWith(p)
+    );
+  }
+  shouldIgnoreFile(filePath) {
+    const name = basename2(filePath);
+    const rel = relative(this.cfg.rootDir, filePath);
+    return this.cfg.ignore.some(
+      (p) => name === p || rel.includes(p) || filePath.includes(`/${p}/`)
+    );
+  }
+  isWatched(filePath) {
+    if (this.isEnvFile(filePath)) return true;
+    return this.cfg.watchExtensions.includes(extname(filePath));
+  }
+  isHotReloadable(filePath) {
+    if (this.isEnvFile(filePath)) return true;
+    return this.cfg.hotReloadExtensions.includes(extname(filePath));
+  }
+  isEnvFile(filePath) {
+    const name = basename2(filePath);
+    return name === this.cfg.envFile || name.startsWith(".env");
+  }
+  // ─── ANSI strip (box width calculation) ───────────────────────────────────
+  strip(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+  }
+  // ─── Timestamp ────────────────────────────────────────────────────────────
+  ts() {
+    const n = /* @__PURE__ */ new Date();
+    return [n.getHours(), n.getMinutes(), n.getSeconds()].map((v) => String(v).padStart(2, "0")).join(":");
+  }
+  // ─── Console output ───────────────────────────────────────────────────────
+  /**
+   * Startup banner — same bgGreen box style as CoreService.infoServer().
+   *
+   *        OPTICORE  HOT  RELOAD       ← gradient
+   *   ████████████████████████████████  ← bgGreen border
+   *    root      ./src
+   *    watching  .ts  .js  .json  .env
+   *    debounce  300ms
+   *   ████████████████████████████████  ← bgGreen border
+   *    watching for changes...
+   */
+  printBanner() {
+    const rootRel = relative(process.cwd(), this.cfg.rootDir) || ".";
+    const extStr = [...this.cfg.watchExtensions, ".env"].join("  ");
+    const ignoreParts = this.cfg.ignore.slice(0, 4);
+    const ignoreMore = this.cfg.ignore.length > 4 ? `  ${chalk2.blackBright(`+${this.cfg.ignore.length - 4} more`)}` : "";
+    const ignoreStr = chalk2.blackBright(ignoreParts.join("  ")) + ignoreMore;
+    const TITLE = "OPTICORE  HOT  RELOAD";
+    const rows = [
+      ` root      ${chalk2.white(rootRel)}`,
+      ` watching  ${chalk2.cyan(extStr)}`,
+      ` ignoring  ${ignoreStr}`,
+      ` debounce  ${chalk2.white(`${this.cfg.debounceMs}ms`)}`
+    ];
+    const maxLen = Math.max(
+      TITLE.length + 4,
+      ...rows.map((r) => this.strip(r).length)
+    ) + 4;
+    const border = chalk2.bgGreen.white(" ".repeat(maxLen));
+    const titlePad = " ".repeat(Math.max(0, Math.floor((maxLen - TITLE.length) / 2)));
+    console.log("\n" + titlePad + gradient(["#43e97b", "#38f9d7", "#00c6fb"])(TITLE));
+    console.log(border);
+    for (const row of rows) {
+      const pad = Math.max(0, maxLen - this.strip(row).length - 2);
+      console.log(chalk2.bgGreen.white(` ${row}${" ".repeat(pad)} `));
+    }
+    console.log(border);
+    console.log(chalk2.blackBright(`  watching for changes...
+`));
+  }
+  /**
+   *   ✔  [ HOT ]  14:23:45  |  .env                    →  env variables reloaded
+   */
+  printHot(file, action) {
+    const badge = colors2.bgCyan(colors2.white.bold("  HOT  "));
+    const filePart = chalk2.cyan.bold(file.padEnd(32));
+    console.log(
+      `  ${chalk2.green("\u2714")}  ${badge}  ${chalk2.blackBright(this.ts())}  ${chalk2.blackBright("|")}  ${filePart} ${chalk2.green("\u2192")}  ${chalk2.green(action)}`
+    );
+  }
+  /**
+   *   ⚡  [ RELOAD ]  14:24:03  |  src/routes/user.ts   →  restarting server...
+   */
+  printReloading(file) {
+    const badge = colors2.bgYellow(colors2.white.bold(" RELOAD "));
+    const filePart = chalk2.yellow.bold(file.padEnd(32));
+    console.log(
+      `
+  ${chalk2.yellow("\u26A1")}  ${badge}  ${chalk2.blackBright(this.ts())}  ${chalk2.blackBright("|")}  ${filePart} ${chalk2.yellow("\u2192")}  ${chalk2.yellow("restarting server...")}
+`
+    );
+  }
+  // ─── Graceful shutdown on CTRL+C ──────────────────────────────────────────
+  setupProcessSignals() {
+    const shutdown = () => {
+      const badge = colors2.bgBlackBright(colors2.white.bold(" STOPPED"));
+      console.log(
+        `
+  ${chalk2.gray("\u25A0")}  ${badge}  ${chalk2.blackBright(this.ts())}  ${chalk2.blackBright("|")}  ${chalk2.gray("watcher stopped")}
+`
+      );
+      this.watchers.forEach((w) => {
+        w.close();
+      });
+      process.exit(0);
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  }
+};
+
+// src/core/webServer.core.ts
 var WebServerCore = class {
   serverUtility;
   expressApp = express2();
+  container;
   localLanguage;
   loggerConfig;
   routerExpressApp;
@@ -369,6 +676,7 @@ var WebServerCore = class {
   environmentPath;
   serverListenEvent;
   dependenciesRegistered = false;
+  hotReloadCfg;
   constructor(paramsConstructor) {
     this.loadTranslationFiles();
     this.stackTraceErrorHandling();
@@ -377,6 +685,7 @@ var WebServerCore = class {
     this.loggerConfig = paramsConstructor.loggerConfig;
     this.localLanguage = paramsConstructor.localLanguage;
     this.environmentPath = paramsConstructor.environmentPath;
+    this.container = new SContainer3(paramsConstructor.localLanguage);
     this.expressApp.use(express2.json());
     this.expressApp.use(express2.raw());
     this.expressApp.use(express2.text());
@@ -384,17 +693,20 @@ var WebServerCore = class {
     this.expressApp.use(corsOrigin(paramsConstructor.corsOriginOptions));
     this.serverListenEvent = new ServerListenEventError2(paramsConstructor.localLanguage);
     this.serverUtility = new CoreService(paramsConstructor.localLanguage, paramsConstructor.environmentPath);
+    const hr = paramsConstructor.hotReload;
+    this.hotReloadCfg = !hr ? null : hr === true ? {} : hr;
   }
+  /**
+   *
+   * @param dependencies
+   */
   registerDependencies(dependencies2) {
+    this.loadTranslationFiles();
     try {
+      getEnvFileLoadingService(".env", this.localLanguage);
       if (dependencies2 && dependencies2.length > 0) {
         dependencies2.forEach((dependency) => {
-          return new SContainer2(this.localLanguage).register(dependency.key, dependency.factory, dependency.scope);
-        });
-      } else {
-        SLogger(this.environmentPath).logger.info({
-          message: TranslationLoader2.t("NO_REGISTER_DEPENDENCIES", this.localLanguage),
-          title: TranslationLoader2.t("REGISTER_DEPENDENCIES", this.localLanguage)
+          this.container.register(dependency.key, dependency.factory, dependency.scope);
         });
       }
     } catch (err) {
@@ -407,8 +719,15 @@ var WebServerCore = class {
       });
     }
   }
+  /**
+   *
+   * @param routers
+   * @param databaseCallback
+   * @param dependenciesProvider
+   */
   onStartServer(routers, databaseCallback, dependenciesProvider) {
     this.loadTranslationFiles();
+    getEnvFileLoadingService(".env", this.localLanguage);
     if (this.getEnvironmentValue.appPort === "" && Number(this.getEnvironmentValue.appPort) === 0) {
       this.serverListenEvent.hostPortUndefined(Number(this.getEnvironmentValue.appPort));
     } else if (this.getEnvironmentValue.appHost === "") {
@@ -417,29 +736,41 @@ var WebServerCore = class {
       this.serverListenEvent.portUndefined();
     } else if (this.localLanguage === "") {
       SLogger(this.environmentPath).logger.error({
-        message: TranslationLoader2.t("noDefaultLocalLang", this.localLanguage),
-        title: TranslationLoader2.t("noLocalLang", this.localLanguage),
-        errorType: TranslationLoader2.t("localLangMissing", this.localLanguage),
+        message: TranslationLoader3.t("noDefaultLocalLang", this.localLanguage),
+        title: TranslationLoader3.t("noLocalLang", this.localLanguage),
+        errorType: TranslationLoader3.t("localLangMissing", this.localLanguage),
         stackTrace: void 0,
         httpCodeValue: HttpStatusCode3.NOT_FOUND
       });
     } else {
-      return this.expressApp.listen(
+      const server = this.expressApp.listen(
         Number(this.getEnvironmentValue.appPort),
         () => {
           this.loadTranslationFiles();
           try {
             databaseCallback(this.getEnvironmentValue);
-            new SContainer2(this.localLanguage, dependenciesProvider);
-            this.expressApp.use(express2.static(path2.join(process4.cwd(), "public/template")));
+            if (dependenciesProvider) {
+              this.registerDependencies(dependenciesProvider);
+            }
+            this.container.loadServices();
+            this.expressApp.use(express2.static(path3.join(process6.cwd(), "public/template")));
             this.registerRoutes(routers);
+            const resolvedHmr = this.resolveHotReloadConfig();
+            if (resolvedHmr !== null) {
+              new HotReloadWatcher(resolvedHmr).attach(server);
+            }
           } catch (err) {
             SServerStartError(err, this.environmentPath);
           }
         }
       );
+      return server;
     }
   }
+  /**
+   *
+   * @param serverWeb
+   */
   onListeningOnServerEvent(serverWeb) {
     this.loadTranslationFiles();
     serverWeb.on(eventName2.error, (err) => {
@@ -452,6 +783,10 @@ var WebServerCore = class {
       this.infoWebApp();
     });
   }
+  /**
+   *
+   * @param serverWeb
+   */
   onRequestOnServerEvent(serverWeb) {
     this.loadTranslationFiles();
     serverWeb.on(eventName2.request, (req, res) => {
@@ -473,6 +808,62 @@ var WebServerCore = class {
   loadTranslationFiles() {
     loaderTranslationFile(this.localLanguage);
   }
+  /**
+   * Resolve the final HotReloadConfig by merging constructor config with
+   * HMR environment variables.
+   *
+   * Priority (highest → lowest):
+   *   1. Constructor hotReload properties  (explicit code-level config)
+   *   2. HMR_* env variables               (runtime / per-environment config)
+   *   3. HotReloadWatcher internal defaults (built-in fallbacks)
+   *
+   * The watcher starts when:
+   *   - constructor passed hotReload: true | HotReloadConfig
+   *   - OR HMR_ENABLED=true in the .env file
+   */
+  resolveHotReloadConfig() {
+    const env = this.getEnvironmentValue;
+    if (this.hotReloadCfg === null && !env.hmrEnabled) {
+      return null;
+    }
+    const base = this.hotReloadCfg ?? {};
+    const envExtensions = this.hmrExtractExtensions(env.hmrWatchPatterns);
+    const envIgnore = this.hmrExtractIgnore(env.hmrIgnorePatterns);
+    return {
+      rootDir: base.rootDir,
+      watchDirs: base.watchDirs,
+      watchExtensions: base.watchExtensions ?? (envExtensions.length ? envExtensions : void 0),
+      ignore: base.ignore ?? (envIgnore.length ? envIgnore : void 0),
+      hotReloadExtensions: base.hotReloadExtensions,
+      debounceMs: base.debounceMs ?? (env.hmrDebounceMs > 0 ? env.hmrDebounceMs : void 0),
+      envFile: base.envFile
+    };
+  }
+  /**
+   * Extract file extensions from glob patterns such as "src/** /*.ts".
+   * "src/** /*.ts"
+   * ".env"     skipped, handled natively by the watcher
+   */
+  hmrExtractExtensions(patterns) {
+    const exts = /* @__PURE__ */ new Set();
+    for (const p of patterns) {
+      const m = p.match(/\*(\.[a-zA-Z0-9]+)$/);
+      if (m) {
+        exts.add(m[1]);
+      }
+    }
+    return [...exts];
+  }
+  /**
+   * Extract ignore names from glob patterns such as "node_modules/**".
+   * "node_modules/**" → "node_modules"
+   * "dist/**"         → "dist"
+   */
+  hmrExtractIgnore(patterns) {
+    return [...new Set(
+      patterns.map((p) => p.split("/")[0]).filter(Boolean)
+    )];
+  }
   /**
    *
    * @param allFeatureRoutes
@@ -505,6 +896,7 @@ var WebServerCore = class {
   }
 };
 export {
+  HotReloadWatcher,
   WebServerCore as WebServer,
   envPath
 };