@navios/core 0.1.13 → 0.1.15

package/dist/index.mjs

@@ -46,117 +46,6 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// packages/core/src/config/utils/helpers.mts
-import { env } from "node:process";
-function envInt(key, defaultValue) {
-  const envKey = env[key] || process.env[key];
-  return envKey ? parseInt(envKey, 10) : defaultValue;
-}
-function envString(key, defaultValue) {
-  return env[key] || process.env[key] || defaultValue || void 0;
-}
-
-// packages/core/src/config/config.provider.mts
-import { z as z3 } from "zod";
-
-// packages/core/src/logger/utils/cli-colors.util.mts
-var isColorAllowed = () => !process.env.NO_COLOR;
-var colorIfAllowed = (colorFn) => (text) => isColorAllowed() ? colorFn(text) : text;
-var clc = {
-  bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-  green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-  yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-  red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-  magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-  cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-var yellow = colorIfAllowed(
-  (text) => `\x1B[38;5;3m${text}\x1B[39m`
-);
-
-// packages/core/src/logger/log-levels.mts
-var LOG_LEVELS = [
-  "verbose",
-  "debug",
-  "log",
-  "warn",
-  "error",
-  "fatal"
-];
-
-// packages/core/src/logger/utils/is-log-level.util.mts
-function isLogLevel(maybeLogLevel) {
-  return LOG_LEVELS.includes(maybeLogLevel);
-}
-
-// packages/core/src/logger/utils/filter-log-levelts.util.mts
-function filterLogLevels(parseableString = "") {
-  const sanitizedString = parseableString.replaceAll(" ", "").toLowerCase();
-  if (sanitizedString[0] === ">") {
-    const orEqual = sanitizedString[1] === "=";
-    const logLevelIndex = LOG_LEVELS.indexOf(
-      sanitizedString.substring(orEqual ? 2 : 1)
-    );
-    if (logLevelIndex === -1) {
-      throw new Error(`parse error (unknown log level): ${sanitizedString}`);
-    }
-    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
-  } else if (sanitizedString.includes(",")) {
-    return sanitizedString.split(",").filter(isLogLevel);
-  }
-  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS;
-}
-
-// packages/core/src/logger/utils/is-log-level-enabled.mts
-var LOG_LEVEL_VALUES = {
-  verbose: 0,
-  debug: 1,
-  log: 2,
-  warn: 3,
-  error: 4,
-  fatal: 5
-};
-function isLogLevelEnabled(targetLevel, logLevels) {
-  var _a;
-  if (!logLevels || Array.isArray(logLevels) && (logLevels == null ? void 0 : logLevels.length) === 0) {
-    return false;
-  }
-  if (logLevels.includes(targetLevel)) {
-    return true;
-  }
-  const highestLogLevelValue = (_a = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)) == null ? void 0 : _a[0];
-  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
-  return targetLevelValue >= highestLogLevelValue;
-}
-
-// packages/core/src/logger/utils/shared.utils.mts
-var isUndefined = (obj) => typeof obj === "undefined";
-var isObject = (fn) => !isNil(fn) && typeof fn === "object";
-var isPlainObject = (fn) => {
-  if (!isObject(fn)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(fn);
-  if (proto === null) {
-    return true;
-  }
-  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
-};
-var addLeadingSlash = (path) => path && typeof path === "string" ? path.charAt(0) !== "/" && path.substring(0, 2) !== "{/" ? "/" + path : path : "";
-var normalizePath = (path) => path ? path.startsWith("/") ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/") : "/" + path.replace(/\/+$/, "") : "/";
-var stripEndSlash = (path) => path[path.length - 1] === "/" ? path.slice(0, path.length - 1) : path;
-var isFunction = (val) => typeof val === "function";
-var isString = (val) => typeof val === "string";
-var isNumber = (val) => typeof val === "number";
-var isConstructor = (val) => val === "constructor";
-var isNil = (val) => isUndefined(val) || val === null;
-var isEmpty = (array) => !(array && array.length > 0);
-var isSymbol = (val) => typeof val === "symbol";
-
-// packages/core/src/logger/console-logger.service.mts
-import { inspect } from "util";
-
 // packages/core/src/service-locator/decorators/injectable.decorator.mts
 import { NaviosException as NaviosException2 } from "@navios/common";
 
@@ -290,8 +179,8 @@ var ServiceLocatorEventBus = class {
   }
   listeners = /* @__PURE__ */ new Map();
   on(ns, event, listener) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
+    var _a3;
+    (_a3 = this.logger) == null ? void 0 : _a3.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
     if (!this.listeners.has(ns)) {
       this.listeners.set(ns, /* @__PURE__ */ new Map());
     }
@@ -301,9 +190,9 @@ var ServiceLocatorEventBus = class {
     }
     nsEvents.get(event).add(listener);
     return () => {
-      var _a2;
+      var _a4;
       nsEvents.get(event).delete(listener);
-      if (((_a2 = nsEvents.get(event)) == null ? void 0 : _a2.size) === 0) {
+      if (((_a4 = nsEvents.get(event)) == null ? void 0 : _a4.size) === 0) {
         nsEvents.delete(event);
       }
       if (nsEvents.size === 0) {
@@ -312,20 +201,20 @@ var ServiceLocatorEventBus = class {
     };
   }
   async emit(key, event) {
-    var _a, _b, _c;
+    var _a3, _b, _c;
     if (!this.listeners.has(key)) {
       return;
     }
     const events = this.listeners.get(key);
     const preEvent = `pre:${event}`;
     const postEvent = `post:${event}`;
-    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
+    (_a3 = this.logger) == null ? void 0 : _a3.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
     await Promise.allSettled(
       [...events.get(preEvent) ?? []].map((listener) => listener(preEvent))
     ).then((results) => {
       results.filter((result) => result.status === "rejected").forEach((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
+        var _a4;
+        (_a4 = this.logger) == null ? void 0 : _a4.warn(
           `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
           result.reason
         );
@@ -336,8 +225,8 @@ var ServiceLocatorEventBus = class {
       [...events.get(event) ?? []].map((listener) => listener(event))
     ).then((results) => {
       const res2 = results.filter((result) => result.status === "rejected").map((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
+        var _a4;
+        (_a4 = this.logger) == null ? void 0 : _a4.warn(
           `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
           result.reason
         );
@@ -353,8 +242,8 @@ var ServiceLocatorEventBus = class {
       [...events.get(postEvent) ?? []].map((listener) => listener(postEvent))
     ).then((results) => {
       results.filter((result) => result.status === "rejected").forEach((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
+        var _a4;
+        (_a4 = this.logger) == null ? void 0 : _a4.warn(
           `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
           result.reason
         );
@@ -385,13 +274,13 @@ var ServiceLocatorManager = class {
   }
   instancesHolders = /* @__PURE__ */ new Map();
   get(name2) {
-    var _a, _b, _c;
+    var _a3, _b, _c;
     const holder = this.instancesHolders.get(name2);
     if (holder) {
       if (holder.ttl !== Infinity) {
         const now = Date.now();
         if (now - holder.createdAt > holder.ttl) {
-          (_a = this.logger) == null ? void 0 : _a.log(
+          (_a3 = this.logger) == null ? void 0 : _a3.log(
             `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`
           );
           return [new InstanceExpired(holder.name), holder];
@@ -466,14 +355,15 @@ var ServiceLocator = class {
       destroyPromise: null,
       creationPromise: null
     });
+    this.eventBus.emit(instanceName, "create");
   }
   removeInstance(token) {
     const instanceName = this.getInstanceIdentifier(token, void 0);
     return this.invalidate(instanceName);
   }
   registerAbstractFactory(token, factory, type = "Singleton" /* Singleton */) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
+    var _a3;
+    (_a3 = this.logger) == null ? void 0 : _a3.log(
       `[ServiceLocator]#registerAbstractFactory(): Registering abstract factory for ${name}`
     );
     if (type === "Instance" /* Instance */) {
@@ -485,7 +375,7 @@ var ServiceLocator = class {
     }
   }
   resolveTokenArgs(token, args) {
-    var _a, _b;
+    var _a3, _b;
     let realArgs = args;
     if (token instanceof BoundInjectionToken) {
       realArgs = token.value;
@@ -499,7 +389,7 @@ var ServiceLocator = class {
     if (!token.schema) {
       return [void 0, realArgs];
     }
-    const validatedArgs = (_a = token.schema) == null ? void 0 : _a.safeParse(realArgs);
+    const validatedArgs = (_a3 = token.schema) == null ? void 0 : _a3.safeParse(realArgs);
     if (validatedArgs && !validatedArgs.success) {
       (_b = this.logger) == null ? void 0 : _b.error(
         `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
@@ -517,7 +407,7 @@ var ServiceLocator = class {
     return this.makeInstanceName(token, realArgs);
   }
   async getInstance(token, args) {
-    var _a, _b;
+    var _a3, _b;
     const [err, realArgs] = this.resolveTokenArgs(token, args);
     if (err instanceof UnknownError) {
       throw err;
@@ -537,7 +427,7 @@ var ServiceLocator = class {
     }
     switch (error.code) {
       case "InstanceDestroying" /* InstanceDestroying */:
-        (_a = this.logger) == null ? void 0 : _a.log(
+        (_a3 = this.logger) == null ? void 0 : _a3.log(
           `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
         );
         await (holder == null ? void 0 : holder.destroyPromise);
@@ -563,15 +453,15 @@ var ServiceLocator = class {
     return instance;
   }
   notifyListeners(name2, event = "create") {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
+    var _a3;
+    (_a3 = this.logger) == null ? void 0 : _a3.log(
       `[ServiceLocator]#notifyListeners() Notifying listeners for ${name2} with event ${event}`
     );
     return this.eventBus.emit(name2, event);
   }
   async createInstance(instanceName, token, args) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
+    var _a3;
+    (_a3 = this.logger) == null ? void 0 : _a3.log(
       `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`
     );
     let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
@@ -586,8 +476,8 @@ var ServiceLocator = class {
     }
   }
   async createInstanceFromAbstractFactory(instanceName, token, args) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
+    var _a3;
+    (_a3 = this.logger) == null ? void 0 : _a3.log(
       `[ServiceLocator]#createInstanceFromAbstractFactory(): Creating instance for ${instanceName} from abstract factory`
     );
     const ctx = this.createContextForAbstractFactory(instanceName);
@@ -607,14 +497,14 @@ var ServiceLocator = class {
       kind: "abstractFactory" /* AbstractFactory */,
       // @ts-expect-error TS2322 This is correct type
       creationPromise: abstractFactory(ctx, args).then(async (instance) => {
-        var _a2;
+        var _a4;
         holder.instance = instance;
         holder.status = "created" /* Created */;
         holder.deps = ctx.getDependencies();
         holder.destroyListeners = ctx.getDestroyListeners();
         holder.ttl = ctx.getTtl();
         if (holder.deps.length > 0) {
-          (_a2 = this.logger) == null ? void 0 : _a2.log(
+          (_a4 = this.logger) == null ? void 0 : _a4.log(
             `[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(
               ", "
             )}`
@@ -635,8 +525,8 @@ var ServiceLocator = class {
         await this.notifyListeners(instanceName);
         return [void 0, instance];
       }).catch((error) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.error(
+        var _a4;
+        (_a4 = this.logger) == null ? void 0 : _a4.error(
           `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
           error
         );
@@ -713,8 +603,8 @@ var ServiceLocator = class {
     return holder.instance;
   }
   invalidate(service, round = 1) {
-    var _a, _b, _c, _d, _e;
-    (_a = this.logger) == null ? void 0 : _a.log(
+    var _a3, _b, _c, _d, _e;
+    (_a3 = this.logger) == null ? void 0 : _a3.log(
       `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`
     );
     const toInvalidate = this.manager.filter(
@@ -735,9 +625,9 @@ var ServiceLocator = class {
         );
         promises.push(
           (_d = holder.creationPromise) == null ? void 0 : _d.then(() => {
-            var _a2;
+            var _a4;
             if (round > 3) {
-              (_a2 = this.logger) == null ? void 0 : _a2.error(
+              (_a4 = this.logger) == null ? void 0 : _a4.error(
                 `[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`
               );
               return;
@@ -764,9 +654,9 @@ var ServiceLocator = class {
   async ready() {
     return Promise.all(
       Array.from(this.manager.filter(() => true)).map(([, holder]) => {
-        var _a;
+        var _a3;
         if (holder.status === "creating" /* Creating */) {
-          return (_a = holder.creationPromise) == null ? void 0 : _a.then(() => null);
+          return (_a3 = holder.creationPromise) == null ? void 0 : _a3.then(() => null);
         }
         if (holder.status === "destroying" /* Destroying */) {
           return holder.destroyPromise.then(() => null);
@@ -927,7 +817,7 @@ var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
   InjectableType2["Factory"] = "Factory";
   return InjectableType2;
 })(InjectableType || {});
-var InjectableTokenMeta = Symbol("InjectableTokenMeta");
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 function Injectable({
   scope = "Singleton" /* Singleton */,
   type = "Class" /* Class */,
@@ -1041,127 +931,937 @@ function override(token, target) {
   };
 }
 
-// packages/core/src/logger/console-logger.service.mts
-var DEFAULT_DEPTH = 5;
-var DEFAULT_LOG_LEVELS = [
-  "log",
-  "error",
-  "warn",
-  "debug",
-  "verbose",
-  "fatal"
-];
-var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
-  year: "numeric",
-  hour: "numeric",
-  minute: "numeric",
-  second: "numeric",
-  day: "2-digit",
-  month: "2-digit"
-});
-var _ConsoleLogger_decorators, _init;
-_ConsoleLogger_decorators = [Injectable()];
-var _ConsoleLogger = class _ConsoleLogger {
-  /**
-   * The options of the logger.
-   */
-  options;
-  /**
-   * The context of the logger (can be set manually or automatically inferred).
-   */
-  context;
-  /**
-   * The original context of the logger (set in the constructor).
-   */
-  originalContext;
-  /**
-   * The options used for the "inspect" method.
-   */
-  inspectOptions;
-  /**
-   * The last timestamp at which the log message was printed.
-   */
-  static lastTimestampAt;
-  constructor(contextOrOptions, options) {
-    let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [void 0, options] : [contextOrOptions == null ? void 0 : contextOrOptions.context, contextOrOptions];
-    opts = opts ?? {};
-    opts.logLevels ??= DEFAULT_LOG_LEVELS;
-    opts.colors ??= opts.colors ?? (opts.json ? false : true);
-    opts.prefix ??= "Navios";
-    this.options = opts;
-    this.inspectOptions = this.getInspectOptions();
-    if (context) {
-      this.context = context;
-      this.originalContext = context;
+// packages/core/src/adapters/stream-adapter.service.mts
+var StreamAdapterToken = InjectionToken.create(
+  Symbol.for("StreamAdapterService")
+);
+var _StreamAdapterService_decorators, _init;
+_StreamAdapterService_decorators = [Injectable({
+  token: StreamAdapterToken
+})];
+var StreamAdapterService = class {
+  hasSchema(handlerMetadata) {
+    const config = handlerMetadata.config;
+    return !!config.requestSchema || !!config.querySchema;
+  }
+  prepareArguments(handlerMetadata) {
+    const config = handlerMetadata.config;
+    const getters = [];
+    if (config.querySchema) {
+      getters.push((target, request) => {
+        target.params = request.query;
+      });
     }
-  }
-  log(message, ...optionalParams) {
-    if (!this.isLevelEnabled("log")) {
-      return;
+    if (config.requestSchema) {
+      getters.push((target, request) => {
+        target.data = request.body;
+      });
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "log");
-  }
-  error(message, ...optionalParams) {
-    if (!this.isLevelEnabled("error")) {
-      return;
+    if (config.url.includes("$")) {
+      getters.push((target, request) => {
+        target.urlParams = request.params;
+      });
     }
-    const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
-    this.printMessages(messages, context, "error", "stderr", stack);
-    this.printStackTrace(stack);
+    return getters;
+  }
+  provideHandler(controller, executionContext, handlerMetadata) {
+    const getters = this.prepareArguments(handlerMetadata);
+    const formatArguments = async (request) => {
+      const argument = {};
+      const promises = [];
+      for (const getter of getters) {
+        const res = getter(argument, request);
+        if (res instanceof Promise) {
+          promises.push(res);
+        }
+      }
+      await Promise.all(promises);
+      return argument;
+    };
+    return async function(request, reply) {
+      const controllerInstance = await inject(controller);
+      const argument = await formatArguments(request);
+      await controllerInstance[handlerMetadata.classMethod](argument, reply);
+    };
   }
-  warn(message, ...optionalParams) {
-    if (!this.isLevelEnabled("warn")) {
-      return;
+  provideSchema(handlerMetadata) {
+    const schema = {};
+    const { querySchema, requestSchema } = handlerMetadata.config;
+    if (querySchema) {
+      schema.querystring = querySchema;
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "warn");
-  }
-  debug(message, ...optionalParams) {
-    if (!this.isLevelEnabled("debug")) {
-      return;
+    if (requestSchema) {
+      schema.body = requestSchema;
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "debug");
+    return schema;
   }
-  verbose(message, ...optionalParams) {
-    if (!this.isLevelEnabled("verbose")) {
-      return;
+};
+_init = __decoratorStart(null);
+StreamAdapterService = __decorateElement(_init, 0, "StreamAdapterService", _StreamAdapterService_decorators, StreamAdapterService);
+__runInitializers(_init, 1, StreamAdapterService);
+
+// packages/core/src/adapters/endpoint-adapter.service.mts
+var EndpointAdapterToken = InjectionToken.create(
+  Symbol.for("EndpointAdapterService")
+);
+var _EndpointAdapterService_decorators, _init2, _a;
+_EndpointAdapterService_decorators = [Injectable({
+  token: EndpointAdapterToken
+})];
+var EndpointAdapterService = class extends (_a = StreamAdapterService) {
+  hasSchema(handlerMetadata) {
+    const config = handlerMetadata.config;
+    return super.hasSchema(handlerMetadata) || !!config.responseSchema;
+  }
+  provideSchema(handlerMetadata) {
+    const config = handlerMetadata.config;
+    const schema = super.provideSchema(handlerMetadata);
+    if (config.responseSchema) {
+      schema.response = {
+        200: config.responseSchema
+      };
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "verbose");
+    return schema;
   }
-  fatal(message, ...optionalParams) {
-    if (!this.isLevelEnabled("fatal")) {
-      return;
-    }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "fatal");
+  provideHandler(controller, executionContext, handlerMetadata) {
+    const getters = this.prepareArguments(handlerMetadata);
+    const formatArguments = async (request) => {
+      const argument = {};
+      const promises = [];
+      for (const getter of getters) {
+        const res = getter(argument, request);
+        if (res instanceof Promise) {
+          promises.push(res);
+        }
+      }
+      await Promise.all(promises);
+      return argument;
+    };
+    return async function(request, reply) {
+      const controllerInstance = await inject(controller);
+      const argument = await formatArguments(request);
+      const result = await controllerInstance[handlerMetadata.classMethod](argument);
+      reply.status(handlerMetadata.successStatusCode).headers(handlerMetadata.headers).send(result);
+    };
   }
-  /**
-   * Set log levels
-   * @param levels log levels
-   */
-  setLogLevels(levels) {
-    if (!this.options) {
-      this.options = {};
+};
+_init2 = __decoratorStart(_a);
+EndpointAdapterService = __decorateElement(_init2, 0, "EndpointAdapterService", _EndpointAdapterService_decorators, EndpointAdapterService);
+__runInitializers(_init2, 1, EndpointAdapterService);
+
+// packages/core/src/adapters/multipart-adapter.service.mts
+import { ZodArray, ZodObject, ZodOptional as ZodOptional2 } from "zod";
+var MultipartAdapterToken = InjectionToken.create(
+  Symbol.for("MultipartAdapterService")
+);
+var _MultipartAdapterService_decorators, _init3, _a2;
+_MultipartAdapterService_decorators = [Injectable({
+  token: MultipartAdapterToken
+})];
+var MultipartAdapterService = class extends (_a2 = EndpointAdapterService) {
+  prepareArguments(handlerMetadata) {
+    const config = handlerMetadata.config;
+    const getters = [];
+    if (config.querySchema) {
+      getters.push((target, request) => {
+        target.params = request.query;
+      });
     }
-    this.options.logLevels = levels;
+    if (config.url.includes("$")) {
+      getters.push((target, request) => {
+        target.urlParams = request.params;
+      });
+    }
+    const requestSchema = config.requestSchema;
+    const shape = requestSchema._def.shape();
+    const structure = this.analyzeSchema(shape);
+    getters.push(async (target, request) => {
+      const req = {};
+      for await (const part of request.parts()) {
+        await this.populateRequest(structure, part, req);
+      }
+      target.data = requestSchema.parse(req);
+    });
+    return getters;
+  }
+  async populateRequest(structure, part, req) {
+    const { isArray, isObject: isObject2 } = structure[part.fieldname] ?? {};
+    if (isArray && !req[part.fieldname]) {
+      req[part.fieldname] = [];
+    }
+    let value;
+    if (part.type === "file") {
+      value = new File([await part.toBuffer()], part.filename, {
+        type: part.mimetype
+      });
+    } else {
+      value = part.value;
+      if (isObject2 && typeof value === "string") {
+        value = JSON.parse(value);
+      }
+    }
+    if (isArray) {
+      req[part.fieldname].push(value);
+    } else {
+      req[part.fieldname] = value;
+    }
+  }
+  analyzeSchema(shape) {
+    return Object.keys(shape).reduce(
+      (target, key) => {
+        let schema = shape[key];
+        const isOptional = schema instanceof ZodOptional2;
+        if (isOptional) {
+          schema = schema.unwrap();
+        }
+        const isArray = schema instanceof ZodArray;
+        if (isArray) {
+          schema = schema.element;
+        }
+        const isObject2 = schema instanceof ZodObject;
+        return {
+          ...target,
+          [key]: {
+            isArray,
+            isOptional,
+            isObject: isObject2
+          }
+        };
+      },
+      {}
+    );
+  }
+  provideSchema(handlerMetadata) {
+    const schema = {};
+    const { querySchema, responseSchema } = handlerMetadata.config;
+    if (querySchema) {
+      schema.querystring = querySchema;
+    }
+    if (responseSchema) {
+      schema.response = {
+        200: responseSchema
+      };
+    }
+    return schema;
+  }
+};
+_init3 = __decoratorStart(_a2);
+MultipartAdapterService = __decorateElement(_init3, 0, "MultipartAdapterService", _MultipartAdapterService_decorators, MultipartAdapterService);
+__runInitializers(_init3, 1, MultipartAdapterService);
+
+// packages/core/src/config/utils/helpers.mts
+import { env } from "node:process";
+function envInt(key, defaultValue) {
+  const envKey = env[key] || process.env[key];
+  return envKey ? parseInt(envKey, 10) : defaultValue;
+}
+function envString(key, defaultValue) {
+  return env[key] || process.env[key] || defaultValue || void 0;
+}
+
+// packages/core/src/config/config.provider.mts
+import { z as z3 } from "zod";
+
+// packages/core/src/logger/utils/cli-colors.util.mts
+var isColorAllowed = () => !process.env.NO_COLOR;
+var colorIfAllowed = (colorFn) => (text) => isColorAllowed() ? colorFn(text) : text;
+var clc = {
+  bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+  green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+  yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+  red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+  magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+  cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
+};
+var yellow = colorIfAllowed(
+  (text) => `\x1B[38;5;3m${text}\x1B[39m`
+);
+
+// packages/core/src/logger/log-levels.mts
+var LOG_LEVELS = [
+  "verbose",
+  "debug",
+  "log",
+  "warn",
+  "error",
+  "fatal"
+];
+
+// packages/core/src/logger/utils/is-log-level.util.mts
+function isLogLevel(maybeLogLevel) {
+  return LOG_LEVELS.includes(maybeLogLevel);
+}
+
+// packages/core/src/logger/utils/filter-log-levelts.util.mts
+function filterLogLevels(parseableString = "") {
+  const sanitizedString = parseableString.replaceAll(" ", "").toLowerCase();
+  if (sanitizedString[0] === ">") {
+    const orEqual = sanitizedString[1] === "=";
+    const logLevelIndex = LOG_LEVELS.indexOf(
+      sanitizedString.substring(orEqual ? 2 : 1)
+    );
+    if (logLevelIndex === -1) {
+      throw new Error(`parse error (unknown log level): ${sanitizedString}`);
+    }
+    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
+  } else if (sanitizedString.includes(",")) {
+    return sanitizedString.split(",").filter(isLogLevel);
+  }
+  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS;
+}
+
+// packages/core/src/logger/utils/is-log-level-enabled.mts
+var LOG_LEVEL_VALUES = {
+  verbose: 0,
+  debug: 1,
+  log: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+function isLogLevelEnabled(targetLevel, logLevels) {
+  var _a3;
+  if (!logLevels || Array.isArray(logLevels) && (logLevels == null ? void 0 : logLevels.length) === 0) {
+    return false;
+  }
+  if (logLevels.includes(targetLevel)) {
+    return true;
+  }
+  const highestLogLevelValue = (_a3 = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)) == null ? void 0 : _a3[0];
+  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
+  return targetLevelValue >= highestLogLevelValue;
+}
+
+// packages/core/src/logger/utils/shared.utils.mts
+var isUndefined = (obj) => typeof obj === "undefined";
+var isObject = (fn) => !isNil(fn) && typeof fn === "object";
+var isPlainObject = (fn) => {
+  if (!isObject(fn)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(fn);
+  if (proto === null) {
+    return true;
+  }
+  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
+};
+var addLeadingSlash = (path) => path && typeof path === "string" ? path.charAt(0) !== "/" && path.substring(0, 2) !== "{/" ? "/" + path : path : "";
+var normalizePath = (path) => path ? path.startsWith("/") ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/") : "/" + path.replace(/\/+$/, "") : "/";
+var stripEndSlash = (path) => path[path.length - 1] === "/" ? path.slice(0, path.length - 1) : path;
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isNumber = (val) => typeof val === "number";
+var isConstructor = (val) => val === "constructor";
+var isNil = (val) => isUndefined(val) || val === null;
+var isEmpty = (array) => !(array && array.length > 0);
+var isSymbol = (val) => typeof val === "symbol";
+
+// packages/core/src/logger/console-logger.service.mts
+import { inspect } from "util";
+
+// packages/core/src/tokens/application.token.mts
+var ApplicationInjectionToken = "ApplicationInjectionToken";
+var Application = InjectionToken.create(
+  ApplicationInjectionToken
+);
+
+// packages/core/src/metadata/handler.metadata.mts
+var EndpointMetadataKey = Symbol("EndpointMetadataKey");
+function getAllEndpointMetadata(context) {
+  if (context.metadata) {
+    const metadata = context.metadata[EndpointMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
+      return context.metadata[EndpointMetadataKey];
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function getEndpointMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = getAllEndpointMetadata(context);
+    if (metadata) {
+      const endpointMetadata = Array.from(metadata).find(
+        (item) => item.classMethod === target.name
+      );
+      if (endpointMetadata) {
+        return endpointMetadata;
+      } else {
+        const newMetadata = {
+          classMethod: target.name,
+          url: "",
+          successStatusCode: 200,
+          adapterToken: null,
+          headers: {},
+          httpMethod: "GET",
+          // @ts-expect-error We are using a generic type here
+          config: null,
+          guards: /* @__PURE__ */ new Set(),
+          customAttributes: /* @__PURE__ */ new Map()
+        };
+        metadata.add(newMetadata);
+        return newMetadata;
+      }
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+
+// packages/core/src/metadata/controller.metadata.mts
+var ControllerMetadataKey = Symbol("ControllerMetadataKey");
+function getControllerMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = context.metadata[ControllerMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      const endpointsMetadata = getAllEndpointMetadata(context);
+      const newMetadata = {
+        endpoints: endpointsMetadata,
+        guards: /* @__PURE__ */ new Set(),
+        customAttributes: /* @__PURE__ */ new Map()
+      };
+      context.metadata[ControllerMetadataKey] = newMetadata;
+      target[ControllerMetadataKey] = newMetadata;
+      return newMetadata;
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function extractControllerMetadata(target) {
+  const metadata = target[ControllerMetadataKey];
+  if (!metadata) {
+    throw new Error(
+      "[Navios] Controller metadata not found. Make sure to use @Controller decorator."
+    );
+  }
+  return metadata;
+}
+function hasControllerMetadata(target) {
+  const metadata = target[ControllerMetadataKey];
+  return !!metadata;
+}
+
+// packages/core/src/metadata/module.metadata.mts
+var ModuleMetadataKey = Symbol("ControllerMetadataKey");
+function getModuleMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = context.metadata[ModuleMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      const newMetadata = {
+        controllers: /* @__PURE__ */ new Set(),
+        imports: /* @__PURE__ */ new Set(),
+        guards: /* @__PURE__ */ new Set(),
+        customAttributes: /* @__PURE__ */ new Map()
+      };
+      context.metadata[ModuleMetadataKey] = newMetadata;
+      target[ModuleMetadataKey] = newMetadata;
+      return newMetadata;
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function extractModuleMetadata(target) {
+  const metadata = target[ModuleMetadataKey];
+  if (!metadata) {
+    throw new Error(
+      `[Navios] Module metadata not found for ${target.name}. Make sure to use @Module decorator.`
+    );
+  }
+  return metadata;
+}
+function hasModuleMetadata(target) {
+  return !!target[ModuleMetadataKey];
+}
+
+// packages/core/src/services/execution-context.mts
+var ExecutionContext = class {
+  constructor(module, controller, handler) {
+    this.module = module;
+    this.controller = controller;
+    this.handler = handler;
+  }
+  request;
+  reply;
+  getModule() {
+    return this.module;
+  }
+  getController() {
+    return this.controller;
+  }
+  getHandler() {
+    return this.handler;
+  }
+  getRequest() {
+    if (!this.request) {
+      throw new Error(
+        "[Navios] Request is not set. Make sure to set it before using it."
+      );
+    }
+    return this.request;
+  }
+  getReply() {
+    if (!this.reply) {
+      throw new Error(
+        "[Navios] Reply is not set. Make sure to set it before using it."
+      );
+    }
+    return this.reply;
+  }
+  provideRequest(request) {
+    this.request = request;
+  }
+  provideReply(reply) {
+    this.reply = reply;
+  }
+};
+
+// packages/core/src/exceptions/http.exception.mts
+var HttpException = class {
+  constructor(statusCode, response, error) {
+    this.statusCode = statusCode;
+    this.response = response;
+    this.error = error;
+  }
+};
+
+// packages/core/src/exceptions/bad-request.exception.mts
+var BadRequestException = class extends HttpException {
+  constructor(message) {
+    super(400, message);
+  }
+};
+
+// packages/core/src/exceptions/forbidden.exception.mts
+var ForbiddenException = class extends HttpException {
+  constructor(message) {
+    super(403, message);
+  }
+};
+
+// packages/core/src/exceptions/internal-server-error.exception.mts
+var InternalServerErrorException = class extends HttpException {
+  constructor(message, error) {
+    super(500, message, error);
+  }
+};
+
+// packages/core/src/exceptions/not-found.exception.mts
+var NotFoundException = class extends HttpException {
+  constructor(response, error) {
+    super(404, response, error);
+    this.response = response;
+    this.error = error;
+  }
+};
+
+// packages/core/src/exceptions/unauthorized.exception.mts
+var UnauthorizedException = class extends HttpException {
+  constructor(message, error) {
+    super(401, message, error);
+  }
+};
+
+// packages/core/src/exceptions/conflict.exception.mts
+var ConflictException = class extends HttpException {
+  constructor(message, error) {
+    super(409, message, error);
+  }
+};
+
+// packages/core/src/services/guard-runner.service.mts
+var _GuardRunnerService_decorators, _init4;
+_GuardRunnerService_decorators = [Injectable()];
+var GuardRunnerService = class {
+  async runGuards(allGuards, executionContext) {
+    let canActivate = true;
+    for (const guard of Array.from(allGuards).reverse()) {
+      const guardInstance = await inject(
+        guard
+      );
+      if (!guardInstance.canActivate) {
+        throw new Error(
+          `[Navios] Guard ${guard.name} does not implement canActivate()`
+        );
+      }
+      try {
+        canActivate = await guardInstance.canActivate(executionContext);
+        if (!canActivate) {
+          break;
+        }
+      } catch (error) {
+        if (error instanceof HttpException) {
+          executionContext.getReply().status(error.statusCode).send(error.response);
+          return false;
+        } else {
+          executionContext.getReply().status(500).send({
+            message: "Internal server error",
+            error: error.message
+          });
+          return false;
+        }
+      }
+    }
+    if (!canActivate) {
+      executionContext.getReply().status(403).send({
+        message: "Forbidden"
+      });
+      return false;
+    }
+    return canActivate;
+  }
+  makeContext(executionContext) {
+    const guards = /* @__PURE__ */ new Set();
+    const endpointGuards = executionContext.getHandler().guards;
+    const controllerGuards = executionContext.getController().guards;
+    const moduleGuards = executionContext.getModule().guards;
+    if (endpointGuards.size > 0) {
+      for (const guard of endpointGuards) {
+        guards.add(guard);
+      }
+    }
+    if (controllerGuards.size > 0) {
+      for (const guard of controllerGuards) {
+        guards.add(guard);
+      }
+    }
+    if (moduleGuards.size > 0) {
+      for (const guard of moduleGuards) {
+        guards.add(guard);
+      }
+    }
+    return guards;
+  }
+};
+_init4 = __decoratorStart(null);
+GuardRunnerService = __decorateElement(_init4, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
+__runInitializers(_init4, 1, GuardRunnerService);
+
+// packages/core/src/services/controller-adapter.service.mts
+var _ControllerAdapterService_decorators, _init5;
+_ControllerAdapterService_decorators = [Injectable()];
+var _ControllerAdapterService = class _ControllerAdapterService {
+  guardRunner = syncInject(GuardRunnerService);
+  logger = syncInject(Logger, {
+    context: _ControllerAdapterService.name
+  });
+  async setupController(controller, instance, moduleMetadata) {
+    var _a3, _b;
+    const controllerMetadata = extractControllerMetadata(controller);
+    for (const endpoint of controllerMetadata.endpoints) {
+      const { classMethod, url, httpMethod, adapterToken } = endpoint;
+      if (!url || !adapterToken) {
+        throw new Error(
+          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
+        );
+      }
+      const adapter = await inject(
+        adapterToken
+      );
+      const executionContext = new ExecutionContext(
+        moduleMetadata,
+        controllerMetadata,
+        endpoint
+      );
+      const hasSchema = ((_a3 = adapter.hasSchema) == null ? void 0 : _a3.call(adapter, endpoint)) ?? false;
+      if (hasSchema) {
+        instance.withTypeProvider().route({
+          method: httpMethod,
+          url: url.replaceAll("$", ":"),
+          schema: ((_b = adapter.provideSchema) == null ? void 0 : _b.call(adapter, endpoint)) ?? {},
+          preHandler: this.providePreHandler(executionContext),
+          handler: this.wrapHandler(
+            executionContext,
+            adapter.provideHandler(controller, executionContext, endpoint)
+          )
+        });
+      } else {
+        instance.route({
+          method: httpMethod,
+          url: url.replaceAll("$", ":"),
+          preHandler: this.providePreHandler(executionContext),
+          handler: this.wrapHandler(
+            executionContext,
+            adapter.provideHandler(controller, executionContext, endpoint)
+          )
+        });
+      }
+      this.logger.debug(
+        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
+      );
+    }
+  }
+  providePreHandler(executionContext) {
+    const guards = this.guardRunner.makeContext(executionContext);
+    return guards.size > 0 ? this.wrapHandler(
+      executionContext,
+      async (request, reply) => {
+        let canActivate = true;
+        canActivate = await this.guardRunner.runGuards(
+          guards,
+          executionContext
+        );
+        if (!canActivate) {
+          return reply;
+        }
+      }
+    ) : void 0;
+  }
+  wrapHandler(executionContext, handler) {
+    const locator = getServiceLocator();
+    return async (request, reply) => {
+      locator.registerInstance(Request, request);
+      locator.registerInstance(Reply, reply);
+      locator.registerInstance(ExecutionContextToken, executionContext);
+      executionContext.provideRequest(request);
+      executionContext.provideReply(reply);
+      try {
+        return await handler(request, reply);
+      } finally {
+        Promise.all([
+          locator.removeInstance(Request),
+          locator.removeInstance(Reply),
+          locator.removeInstance(ExecutionContextToken)
+        ]).catch((err) => {
+          this.logger.warn(`Error removing instances: ${err}`);
+        });
+      }
+    };
+  }
+};
+_init5 = __decoratorStart(null);
+_ControllerAdapterService = __decorateElement(_init5, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
+__runInitializers(_init5, 1, _ControllerAdapterService);
+var ControllerAdapterService = _ControllerAdapterService;
+
+// packages/core/src/services/module-loader.service.mts
+var _ModuleLoaderService_decorators, _init6;
+_ModuleLoaderService_decorators = [Injectable()];
+var _ModuleLoaderService = class _ModuleLoaderService {
+  logger = syncInject(Logger, {
+    context: _ModuleLoaderService.name
+  });
+  modulesMetadata = /* @__PURE__ */ new Map();
+  loadedModules = /* @__PURE__ */ new Map();
+  initialized = false;
+  async loadModules(appModule) {
+    if (this.initialized) {
+      return;
+    }
+    await this.traverseModules(appModule);
+    this.initialized = true;
+  }
+  async traverseModules(module, parentMetadata) {
+    const metadata = extractModuleMetadata(module);
+    if (parentMetadata) {
+      this.mergeMetadata(metadata, parentMetadata);
+    }
+    const moduleName = module.name;
+    if (this.modulesMetadata.has(moduleName)) {
+      return;
+    }
+    this.modulesMetadata.set(moduleName, metadata);
+    const imports = metadata.imports ?? /* @__PURE__ */ new Set();
+    const loadingPromises = Array.from(imports).map(
+      async (importedModule) => this.traverseModules(importedModule, metadata)
+    );
+    await Promise.all(loadingPromises);
+    const instance = await inject(module);
+    if (instance.onModuleInit) {
+      await instance.onModuleInit();
+    }
+    this.logger.debug(`Module ${moduleName} loaded`);
+    this.loadedModules.set(moduleName, instance);
+  }
+  mergeMetadata(metadata, parentMetadata) {
+    if (parentMetadata.guards) {
+      for (const guard of parentMetadata.guards) {
+        metadata.guards.add(guard);
+      }
+    }
+    if (parentMetadata.customAttributes) {
+      for (const [key, value] of parentMetadata.customAttributes) {
+        if (metadata.customAttributes.has(key)) {
+          continue;
+        }
+        metadata.customAttributes.set(key, value);
+      }
+    }
+  }
+  getAllModules() {
+    return this.modulesMetadata;
+  }
+  dispose() {
+    this.modulesMetadata.clear();
+    this.loadedModules.clear();
+    this.initialized = false;
+  }
+};
+_init6 = __decoratorStart(null);
+_ModuleLoaderService = __decorateElement(_init6, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
+__runInitializers(_init6, 1, _ModuleLoaderService);
+var ModuleLoaderService = _ModuleLoaderService;
+
+// packages/core/src/tokens/execution-context.token.mts
+var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+var ExecutionContextToken = InjectionToken.create(
+  ExecutionContextInjectionToken
+);
+
+// packages/core/src/tokens/reply.token.mts
+var ReplyInjectionToken = "ReplyInjectionToken";
+var Reply = InjectionToken.create(ReplyInjectionToken);
+
+// packages/core/src/tokens/request.token.mts
+var RequestInjectionToken = "RequestInjectionToken";
+var Request = InjectionToken.create(
+  RequestInjectionToken
+);
+
+// packages/core/src/logger/console-logger.service.mts
+var DEFAULT_DEPTH = 5;
+var DEFAULT_LOG_LEVELS = [
+  "log",
+  "error",
+  "warn",
+  "debug",
+  "verbose",
+  "fatal"
+];
+var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  day: "2-digit",
+  month: "2-digit"
+});
+var _ConsoleLogger_decorators, _init7;
+_ConsoleLogger_decorators = [Injectable()];
+var _ConsoleLogger = class _ConsoleLogger {
+  /**
+   * The options of the logger.
+   */
+  options;
+  /**
+   * The context of the logger (can be set manually or automatically inferred).
+   */
+  context;
+  /**
+   * Request ID (if enabled).
+   */
+  requestId = null;
+  /**
+   * The original context of the logger (set in the constructor).
+   */
+  originalContext;
+  /**
+   * The options used for the "inspect" method.
+   */
+  inspectOptions;
+  /**
+   * The last timestamp at which the log message was printed.
+   */
+  static lastTimestampAt;
+  constructor(contextOrOptions, options) {
+    let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [void 0, options] : [contextOrOptions == null ? void 0 : contextOrOptions.context, contextOrOptions];
+    opts = opts ?? {};
+    opts.logLevels ??= DEFAULT_LOG_LEVELS;
+    opts.colors ??= opts.colors ?? (opts.json ? false : true);
+    opts.prefix ??= "Navios";
+    this.options = opts;
+    this.inspectOptions = this.getInspectOptions();
+    if (context) {
+      this.context = context;
+      this.originalContext = context;
+    }
+    if (opts == null ? void 0 : opts.requestId) {
+      const locator = getServiceLocator();
+      locator.getEventBus().on(locator.getInstanceIdentifier(Request, void 0), "create", () => {
+        const request = locator.getSyncInstance(Request, void 0);
+        this.requestId = (request == null ? void 0 : request.id) ?? null;
+      });
+      locator.getEventBus().on(
+        locator.getInstanceIdentifier(Request, void 0),
+        "destroy",
+        () => {
+          this.requestId = null;
+        }
+      );
+    }
+  }
+  log(message, ...optionalParams) {
+    if (!this.isLevelEnabled("log")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "log");
+  }
+  error(message, ...optionalParams) {
+    if (!this.isLevelEnabled("error")) {
+      return;
+    }
+    const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "error", "stderr", stack);
+    this.printStackTrace(stack);
+  }
+  warn(message, ...optionalParams) {
+    if (!this.isLevelEnabled("warn")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "warn");
+  }
+  debug(message, ...optionalParams) {
+    if (!this.isLevelEnabled("debug")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "debug");
+  }
+  verbose(message, ...optionalParams) {
+    if (!this.isLevelEnabled("verbose")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "verbose");
+  }
+  fatal(message, ...optionalParams) {
+    if (!this.isLevelEnabled("fatal")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "fatal");
+  }
+  /**
+   * Set log levels
+   * @param levels log levels
+   */
+  setLogLevels(levels) {
+    if (!this.options) {
+      this.options = {};
+    }
+    this.options.logLevels = levels;
   }
   /**
    * Set logger context
@@ -1177,8 +1877,8 @@ var _ConsoleLogger = class _ConsoleLogger {
     this.context = this.originalContext;
   }
   isLevelEnabled(level) {
-    var _a;
-    const logLevels = (_a = this.options) == null ? void 0 : _a.logLevels;
+    var _a3;
+    const logLevels = (_a3 = this.options) == null ? void 0 : _a3.logLevels;
     return isLogLevelEnabled(level, logLevels);
   }
   getTimestamp() {
@@ -1223,12 +1923,15 @@ var _ConsoleLogger = class _ConsoleLogger {
     if (options.errorStack) {
       logObject.stack = options.errorStack;
     }
+    if (this.options.requestId && this.requestId) {
+      logObject.requestId = this.requestId;
+    }
     const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : inspect(logObject, this.inspectOptions);
     process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
 `);
   }
   formatPid(pid) {
-    return `[${this.options.prefix}] ${pid}  - `;
+    return `[${this.options.prefix}] ${pid} - `;
   }
   formatContext(context) {
     if (!context) {
@@ -1241,9 +1944,15 @@ var _ConsoleLogger = class _ConsoleLogger {
     const output = this.stringifyMessage(message, logLevel);
     pidMessage = this.colorize(pidMessage, logLevel);
     formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
-    return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
+    return `${pidMessage}${this.getRequestId()}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
 `;
   }
+  getRequestId() {
+    if (this.options.requestId && this.requestId) {
+      return `(${this.colorize(this.requestId, "log")}) `;
+    }
+    return "";
+  }
   stringifyMessage(message, logLevel) {
     if (isFunction(message)) {
       const messageAsStr = Function.prototype.toString.call(message);
@@ -1280,8 +1989,8 @@ var _ConsoleLogger = class _ConsoleLogger {
 `);
   }
   updateAndGetTimestampDiff() {
-    var _a;
-    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a = this.options) == null ? void 0 : _a.timestamp);
+    var _a3;
+    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a3 = this.options) == null ? void 0 : _a3.timestamp);
     const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - _ConsoleLogger.lastTimestampAt) : "";
     _ConsoleLogger.lastTimestampAt = Date.now();
     return result;
@@ -1386,9 +2095,9 @@ var _ConsoleLogger = class _ConsoleLogger {
     }
   }
 };
-_init = __decoratorStart(null);
-_ConsoleLogger = __decorateElement(_init, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
-__runInitializers(_init, 1, _ConsoleLogger);
+_init7 = __decoratorStart(null);
+_ConsoleLogger = __decorateElement(_init7, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
+__runInitializers(_init7, 1, _ConsoleLogger);
 var ConsoleLogger = _ConsoleLogger;
 
 // packages/core/src/logger/logger.factory.mts
@@ -1404,7 +2113,7 @@ var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
   day: "2-digit",
   month: "2-digit"
 });
-var _LoggerInstance_decorators, _init2;
+var _LoggerInstance_decorators, _init8;
 _LoggerInstance_decorators = [Injectable()];
 var _LoggerInstance = class _LoggerInstance {
   constructor(context, options = {}) {
@@ -1426,69 +2135,69 @@ var _LoggerInstance = class _LoggerInstance {
     return _LoggerInstance.staticInstanceRef;
   }
   error(message, ...optionalParams) {
-    var _a;
+    var _a3;
     optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(
       this.context
     ) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.error(message, ...optionalParams);
+    (_a3 = this.localInstance) == null ? void 0 : _a3.error(message, ...optionalParams);
   }
   log(message, ...optionalParams) {
-    var _a;
+    var _a3;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.log(message, ...optionalParams);
+    (_a3 = this.localInstance) == null ? void 0 : _a3.log(message, ...optionalParams);
   }
   warn(message, ...optionalParams) {
-    var _a;
+    var _a3;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.warn(message, ...optionalParams);
+    (_a3 = this.localInstance) == null ? void 0 : _a3.warn(message, ...optionalParams);
   }
   debug(message, ...optionalParams) {
-    var _a, _b;
+    var _a3, _b;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    (_b = (_a3 = this.localInstance) == null ? void 0 : _a3.debug) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   verbose(message, ...optionalParams) {
-    var _a, _b;
+    var _a3, _b;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    (_b = (_a3 = this.localInstance) == null ? void 0 : _a3.verbose) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   fatal(message, ...optionalParams) {
-    var _a, _b;
+    var _a3, _b;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    (_b = (_a3 = this.localInstance) == null ? void 0 : _a3.fatal) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   static error(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(message, ...optionalParams);
+    var _a3;
+    (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.error(message, ...optionalParams);
   }
   static log(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
+    var _a3;
+    (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.log(message, ...optionalParams);
   }
   static warn(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
+    var _a3;
+    (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.warn(message, ...optionalParams);
   }
   static debug(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.debug) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   static verbose(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.verbose) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   static fatal(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.fatal) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   static getTimestamp() {
     return dateTimeFormatter2.format(Date.now());
   }
   static overrideLogger(logger) {
-    var _a, _b;
+    var _a3, _b;
     if (Array.isArray(logger)) {
       _LoggerInstance.logLevels = logger;
-      return (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.setLogLevels) == null ? void 0 : _b.call(_a, logger);
+      return (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.setLogLevels) == null ? void 0 : _b.call(_a3, logger);
     }
     if (isObject(logger)) {
       this.staticInstanceRef = logger;
@@ -1501,20 +2210,20 @@ var _LoggerInstance = class _LoggerInstance {
     return isLogLevelEnabled(level, logLevels);
   }
   registerLocalInstanceRef() {
-    var _a;
+    var _a3;
     if (this.localInstanceRef) {
       return this.localInstanceRef;
     }
     this.localInstanceRef = new ConsoleLogger(this.context, {
-      timestamp: (_a = this.options) == null ? void 0 : _a.timestamp,
+      timestamp: (_a3 = this.options) == null ? void 0 : _a3.timestamp,
       logLevels: _LoggerInstance.logLevels
     });
     return this.localInstanceRef;
   }
 };
-_init2 = __decoratorStart(null);
-_LoggerInstance = __decorateElement(_init2, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
-__runInitializers(_init2, 1, _LoggerInstance);
+_init8 = __decoratorStart(null);
+_LoggerInstance = __decorateElement(_init8, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
+__runInitializers(_init8, 1, _LoggerInstance);
 var LoggerInstance = _LoggerInstance;
 
 // packages/core/src/logger/logger.factory.mts
@@ -1526,7 +2235,7 @@ var LoggerOptions = z2.object({
   }).optional()
 }).optional();
 var Logger = InjectionToken.create(LoggerInjectionToken, LoggerOptions);
-var _LoggerFactory_decorators, _init3;
+var _LoggerFactory_decorators, _init9;
 _LoggerFactory_decorators = [Injectable({
   type: "Factory" /* Factory */,
   token: Logger
@@ -1536,9 +2245,9 @@ var LoggerFactory = class {
     return new LoggerInstance(args == null ? void 0 : args.context, args == null ? void 0 : args.options);
   }
 };
-_init3 = __decoratorStart(null);
-LoggerFactory = __decorateElement(_init3, 0, "LoggerFactory", _LoggerFactory_decorators, LoggerFactory);
-__runInitializers(_init3, 1, LoggerFactory);
+_init9 = __decoratorStart(null);
+LoggerFactory = __decorateElement(_init9, 0, "LoggerFactory", _LoggerFactory_decorators, LoggerFactory);
+__runInitializers(_init9, 1, LoggerFactory);
 
 // packages/core/src/logger/pino-wrapper.mts
 var PinoWrapper = class _PinoWrapper {
@@ -1560,12 +2269,12 @@ var PinoWrapper = class _PinoWrapper {
   info() {
   }
   debug(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.logger).debug) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   trace(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.logger).verbose) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   silent() {
   }
@@ -1603,7 +2312,7 @@ var ConfigServiceInstance = class {
     return this.config;
   }
   get(key) {
-    var _a, _b;
+    var _a3, _b;
     try {
       const parts = String(key).split(".");
       let value = this.config;
@@ -1615,8 +2324,8 @@ var ConfigServiceInstance = class {
       }
       return value ?? null;
     } catch (error) {
-      (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(
-        _a,
+      (_b = (_a3 = this.logger).debug) == null ? void 0 : _b.call(
+        _a3,
         `Failed to get config value for key ${String(key)}`,
         error
       );
@@ -1643,7 +2352,7 @@ var ConfigProviderOptions = z3.object({
   load: z3.function()
 });
 var ConfigProvider = InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
-var _ConfigProviderFactory_decorators, _init4;
+var _ConfigProviderFactory_decorators, _init10;
 _ConfigProviderFactory_decorators = [Injectable({
   token: ConfigProvider,
   type: "Factory" /* Factory */
@@ -1657,267 +2366,50 @@ var ConfigProviderFactory = class {
     const logger = this.logger;
     try {
       const config = await load();
-      return new ConfigServiceInstance(config, logger);
+      return new ConfigServiceInstance(
+        config,
+        logger
+      );
     } catch (error) {
       logger.error("Error loading config", error);
       throw error;
     }
-  }
-};
-_init4 = __decoratorStart(null);
-ConfigProviderFactory = __decorateElement(_init4, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
-__runInitializers(_init4, 1, ConfigProviderFactory);
-function provideConfig(options) {
-  return InjectionToken.bound(ConfigProvider, options);
-}
-
-// packages/core/src/metadata/endpoint.metadata.mts
-var EndpointMetadataKey = Symbol("EndpointMetadataKey");
-var EndpointType = /* @__PURE__ */ ((EndpointType2) => {
-  EndpointType2["Unknown"] = "unknown";
-  EndpointType2["Endpoint"] = "endpoint";
-  EndpointType2["Stream"] = "stream";
-  EndpointType2["Multipart"] = "multipart";
-  EndpointType2["Handler"] = "handler";
-  return EndpointType2;
-})(EndpointType || {});
-function getAllEndpointMetadata(context) {
-  if (context.metadata) {
-    const metadata = context.metadata[EndpointMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
-      return context.metadata[EndpointMetadataKey];
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
-}
-function getEndpointMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = getAllEndpointMetadata(context);
-    if (metadata) {
-      const endpointMetadata = Array.from(metadata).find(
-        (item) => item.classMethod === target.name
-      );
-      if (endpointMetadata) {
-        return endpointMetadata;
-      } else {
-        const newMetadata = {
-          classMethod: target.name,
-          url: "",
-          successStatusCode: 200,
-          headers: {},
-          type: "unknown" /* Unknown */,
-          httpMethod: "GET",
-          config: null,
-          guards: /* @__PURE__ */ new Set(),
-          customAttributes: /* @__PURE__ */ new Map()
-        };
-        metadata.add(newMetadata);
-        return newMetadata;
-      }
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
-}
-
-// packages/core/src/metadata/controller.metadata.mts
-var ControllerMetadataKey = Symbol("ControllerMetadataKey");
-function getControllerMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = context.metadata[ControllerMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      const endpointsMetadata = getAllEndpointMetadata(context);
-      const newMetadata = {
-        endpoints: endpointsMetadata,
-        guards: /* @__PURE__ */ new Set(),
-        customAttributes: /* @__PURE__ */ new Map()
-      };
-      context.metadata[ControllerMetadataKey] = newMetadata;
-      target[ControllerMetadataKey] = newMetadata;
-      return newMetadata;
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
-}
-function extractControllerMetadata(target) {
-  const metadata = target[ControllerMetadataKey];
-  if (!metadata) {
-    throw new Error(
-      "[Navios] Controller metadata not found. Make sure to use @Controller decorator."
-    );
-  }
-  return metadata;
-}
-function hasControllerMetadata(target) {
-  const metadata = target[ControllerMetadataKey];
-  return !!metadata;
-}
-
-// packages/core/src/metadata/module.metadata.mts
-var ModuleMetadataKey = Symbol("ControllerMetadataKey");
-function getModuleMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = context.metadata[ModuleMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      const newMetadata = {
-        controllers: /* @__PURE__ */ new Set(),
-        imports: /* @__PURE__ */ new Set(),
-        guards: /* @__PURE__ */ new Set(),
-        customAttributes: /* @__PURE__ */ new Map()
-      };
-      context.metadata[ModuleMetadataKey] = newMetadata;
-      target[ModuleMetadataKey] = newMetadata;
-      return newMetadata;
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
-}
-function extractModuleMetadata(target) {
-  const metadata = target[ModuleMetadataKey];
-  if (!metadata) {
-    throw new Error(
-      `[Navios] Module metadata not found for ${target.name}. Make sure to use @Module decorator.`
-    );
-  }
-  return metadata;
-}
-function hasModuleMetadata(target) {
-  return !!target[ModuleMetadataKey];
-}
-
-// packages/core/src/decorators/controller.decorator.mts
-function Controller({ guards } = {}) {
-  return function(target, context) {
-    if (context.kind !== "class") {
-      throw new Error(
-        "[Navios] @Controller decorator can only be used on classes."
-      );
-    }
-    const token = InjectionToken.create(target);
-    if (context.metadata) {
-      const controllerMetadata = getControllerMetadata(target, context);
-      if (guards) {
-        for (const guard of Array.from(guards).reverse()) {
-          controllerMetadata.guards.add(guard);
-        }
-      }
-    }
-    return Injectable({
-      token,
-      type: "Class" /* Class */,
-      scope: "Instance" /* Instance */
-    })(target, context);
-  };
-}
-
-// packages/core/src/decorators/endpoint.decorator.mts
-import "zod";
-function Endpoint(endpoint) {
-  return (target, context) => {
-    if (typeof target !== "function") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on functions."
-      );
-    }
-    if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on methods."
-      );
-    }
-    const config = endpoint.config;
-    if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
-      if (endpointMetadata.config && endpointMetadata.config.url) {
-        throw new Error(
-          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
-        );
-      }
-      endpointMetadata.config = config;
-      endpointMetadata.type = "endpoint" /* Endpoint */;
-      endpointMetadata.classMethod = target.name;
-      endpointMetadata.httpMethod = config.method;
-      endpointMetadata.url = config.url;
-    }
-    return target;
-  };
-}
-
-// packages/core/src/decorators/header.decorator.mts
-function Header(name2, value) {
-  return (target, context) => {
-    if (context.kind !== "method") {
-      throw new Error("[Navios] Header decorator can only be used on methods.");
-    }
-    const metadata = getEndpointMetadata(target, context);
-    if (metadata.type === "stream" /* Stream */) {
-      throw new Error(
-        "[Navios] HttpCode decorator cannot be used on stream endpoints."
-      );
-    }
-    metadata.headers[name2] = value;
-    return target;
-  };
-}
-
-// packages/core/src/decorators/http-code.decorator.mts
-function HttpCode(code) {
-  return (target, context) => {
-    if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] HttpCode decorator can only be used on methods."
-      );
-    }
-    const metadata = getEndpointMetadata(target, context);
-    if (metadata.type === "stream" /* Stream */) {
-      throw new Error(
-        "[Navios] HttpCode decorator cannot be used on stream endpoints."
-      );
-    }
-    metadata.successStatusCode = code;
-    return target;
-  };
+  }
+};
+_init10 = __decoratorStart(null);
+ConfigProviderFactory = __decorateElement(_init10, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
+__runInitializers(_init10, 1, ConfigProviderFactory);
+function provideConfig(options) {
+  return InjectionToken.bound(ConfigProvider, options);
 }
 
-// packages/core/src/decorators/module.decorator.mts
-function Module(metadata) {
-  return (target, context) => {
+// packages/core/src/decorators/controller.decorator.mts
+function Controller({ guards } = {}) {
+  return function(target, context) {
     if (context.kind !== "class") {
-      throw new Error("[Navios] @Module decorator can only be used on classes.");
+      throw new Error(
+        "[Navios] @Controller decorator can only be used on classes."
+      );
     }
     const token = InjectionToken.create(target);
-    const moduleMetadata = getModuleMetadata(target, context);
-    if (metadata.controllers) {
-      for (const controller of metadata.controllers) {
-        moduleMetadata.controllers.add(controller);
-      }
-    }
-    if (metadata.imports) {
-      for (const importedModule of metadata.imports) {
-        moduleMetadata.imports.add(importedModule);
-      }
-    }
-    if (metadata.guards) {
-      for (const guard of Array.from(metadata.guards).reverse()) {
-        moduleMetadata.guards.add(guard);
+    if (context.metadata) {
+      const controllerMetadata = getControllerMetadata(target, context);
+      if (guards) {
+        for (const guard of Array.from(guards).reverse()) {
+          controllerMetadata.guards.add(guard);
+        }
       }
     }
     return Injectable({
       token,
-      type: "Class" /* Class */,
-      scope: "Singleton" /* Singleton */
+      scope: "Instance" /* Instance */
     })(target, context);
   };
 }
 
-// packages/core/src/decorators/multipart.decorator.mts
+// packages/core/src/decorators/endpoint.decorator.mts
 import "zod";
-function Multipart(endpoint) {
+function Endpoint(endpoint) {
   return (target, context) => {
     if (typeof target !== "function") {
       throw new Error(
@@ -1931,14 +2423,17 @@ function Multipart(endpoint) {
     }
     const config = endpoint.config;
     if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
+      let endpointMetadata = getEndpointMetadata(
+        target,
+        context
+      );
       if (endpointMetadata.config && endpointMetadata.config.url) {
         throw new Error(
           `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
         );
       }
       endpointMetadata.config = config;
-      endpointMetadata.type = "multipart" /* Multipart */;
+      endpointMetadata.adapterToken = EndpointAdapterToken;
       endpointMetadata.classMethod = target.name;
       endpointMetadata.httpMethod = config.method;
       endpointMetadata.url = config.url;
@@ -1947,563 +2442,153 @@ function Multipart(endpoint) {
   };
 }
 
-// packages/core/src/decorators/stream.decorator.mts
-function Stream(endpoint) {
+// packages/core/src/decorators/header.decorator.mts
+function Header(name2, value) {
   return (target, context) => {
-    if (typeof target !== "function") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on functions."
-      );
-    }
     if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on methods."
-      );
-    }
-    const config = endpoint.config;
-    if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
-      if (endpointMetadata.config && endpointMetadata.config.url) {
-        throw new Error(
-          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
-        );
-      }
-      endpointMetadata.config = config;
-      endpointMetadata.type = "stream" /* Stream */;
-      endpointMetadata.classMethod = target.name;
-      endpointMetadata.httpMethod = config.method;
-      endpointMetadata.url = config.url;
+      throw new Error("[Navios] Header decorator can only be used on methods.");
     }
+    const metadata = getEndpointMetadata(target, context);
+    metadata.headers[name2] = value;
     return target;
   };
 }
 
-// packages/core/src/decorators/use-guards.decorator.mts
-function UseGuards(...guards) {
-  return function(target, context) {
-    if (context.kind === "class") {
-      const controllerMetadata = getControllerMetadata(
-        target,
-        context
-      );
-      for (const guard of guards.reverse()) {
-        controllerMetadata.guards.add(guard);
-      }
-    } else if (context.kind === "method") {
-      const endpointMetadata = getEndpointMetadata(target, context);
-      for (const guard of guards.reverse()) {
-        endpointMetadata.guards.add(guard);
-      }
-    } else {
+// packages/core/src/decorators/http-code.decorator.mts
+function HttpCode(code) {
+  return (target, context) => {
+    if (context.kind !== "method") {
       throw new Error(
-        "[Navios] @UseGuards decorator can only be used on classes or methods."
+        "[Navios] HttpCode decorator can only be used on methods."
       );
     }
+    const metadata = getEndpointMetadata(target, context);
+    metadata.successStatusCode = code;
     return target;
   };
 }
-
-// packages/core/src/exceptions/http.exception.mts
-var HttpException = class {
-  constructor(statusCode, response, error) {
-    this.statusCode = statusCode;
-    this.response = response;
-    this.error = error;
-  }
-};
-
-// packages/core/src/exceptions/bad-request.exception.mts
-var BadRequestException = class extends HttpException {
-  constructor(message) {
-    super(400, message);
-  }
-};
-
-// packages/core/src/exceptions/forbidden.exception.mts
-var ForbiddenException = class extends HttpException {
-  constructor(message) {
-    super(403, message);
-  }
-};
-
-// packages/core/src/exceptions/internal-server-error.exception.mts
-var InternalServerErrorException = class extends HttpException {
-  constructor(message, error) {
-    super(500, message, error);
-  }
-};
-
-// packages/core/src/exceptions/not-found.exception.mts
-var NotFoundException = class extends HttpException {
-  constructor(response, error) {
-    super(404, response, error);
-    this.response = response;
-    this.error = error;
-  }
-};
-
-// packages/core/src/exceptions/unauthorized.exception.mts
-var UnauthorizedException = class extends HttpException {
-  constructor(message, error) {
-    super(401, message, error);
-  }
-};
-
-// packages/core/src/exceptions/conflict.exception.mts
-var ConflictException = class extends HttpException {
-  constructor(message, error) {
-    super(409, message, error);
-  }
-};
-
-// packages/core/src/services/controller-adapter.service.mts
-import { NaviosException as NaviosException4 } from "@navios/common";
-import { ZodArray } from "zod";
-
-// packages/core/src/tokens/application.token.mts
-var ApplicationInjectionToken = "ApplicationInjectionToken";
-var Application = InjectionToken.create(
-  ApplicationInjectionToken
-);
-
-// packages/core/src/tokens/execution-context.token.mts
-var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
-var ExecutionContextToken = InjectionToken.create(
-  ExecutionContextInjectionToken
-);
-
-// packages/core/src/tokens/reply.token.mts
-var ReplyInjectionToken = "ReplyInjectionToken";
-var Reply = InjectionToken.create(ReplyInjectionToken);
-
-// packages/core/src/tokens/request.token.mts
-var RequestInjectionToken = "RequestInjectionToken";
-var Request = InjectionToken.create(
-  RequestInjectionToken
-);
-
-// packages/core/src/services/execution-context.mts
-var ExecutionContext2 = class {
-  constructor(module, controller, handler) {
-    this.module = module;
-    this.controller = controller;
-    this.handler = handler;
-  }
-  request;
-  reply;
-  getModule() {
-    return this.module;
-  }
-  getController() {
-    return this.controller;
-  }
-  getHandler() {
-    return this.handler;
-  }
-  getRequest() {
-    if (!this.request) {
-      throw new Error(
-        "[Navios] Request is not set. Make sure to set it before using it."
-      );
-    }
-    return this.request;
-  }
-  getReply() {
-    if (!this.reply) {
-      throw new Error(
-        "[Navios] Reply is not set. Make sure to set it before using it."
-      );
-    }
-    return this.reply;
-  }
-  provideRequest(request) {
-    this.request = request;
-  }
-  provideReply(reply) {
-    this.reply = reply;
-  }
-};
-
-// packages/core/src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init5;
-_GuardRunnerService_decorators = [Injectable()];
-var GuardRunnerService = class {
-  async runGuards(allGuards, executionContext) {
-    let canActivate = true;
-    for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await inject(
-        guard
-      );
-      if (!guardInstance.canActivate) {
-        throw new Error(
-          `[Navios] Guard ${guard.name} does not implement canActivate()`
-        );
-      }
-      try {
-        canActivate = await guardInstance.canActivate(executionContext);
-        if (!canActivate) {
-          break;
-        }
-      } catch (error) {
-        if (error instanceof HttpException) {
-          executionContext.getReply().status(error.statusCode).send(error.response);
-          return false;
-        } else {
-          executionContext.getReply().status(500).send({
-            message: "Internal server error",
-            error: error.message
-          });
-          return false;
-        }
-      }
-    }
-    if (!canActivate) {
-      executionContext.getReply().status(403).send({
-        message: "Forbidden"
-      });
-      return false;
-    }
-    return canActivate;
-  }
-  makeContext(executionContext) {
-    const guards = /* @__PURE__ */ new Set();
-    const endpointGuards = executionContext.getHandler().guards;
-    const controllerGuards = executionContext.getController().guards;
-    const moduleGuards = executionContext.getModule().guards;
-    if (endpointGuards.size > 0) {
-      for (const guard of endpointGuards) {
-        guards.add(guard);
-      }
+
+// packages/core/src/decorators/module.decorator.mts
+function Module({ controllers = [], imports = [], guards = [] } = {
+  controllers: [],
+  imports: [],
+  guards: []
+}) {
+  return (target, context) => {
+    if (context.kind !== "class") {
+      throw new Error("[Navios] @Module decorator can only be used on classes.");
     }
-    if (controllerGuards.size > 0) {
-      for (const guard of controllerGuards) {
-        guards.add(guard);
-      }
+    const token = InjectionToken.create(target);
+    const moduleMetadata = getModuleMetadata(target, context);
+    for (const controller of controllers) {
+      moduleMetadata.controllers.add(controller);
     }
-    if (moduleGuards.size > 0) {
-      for (const guard of moduleGuards) {
-        guards.add(guard);
-      }
+    for (const importedModule of imports) {
+      moduleMetadata.imports.add(importedModule);
     }
-    return guards;
-  }
-};
-_init5 = __decoratorStart(null);
-GuardRunnerService = __decorateElement(_init5, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
-__runInitializers(_init5, 1, GuardRunnerService);
+    for (const guard of Array.from(guards).reverse()) {
+      moduleMetadata.guards.add(guard);
+    }
+    return Injectable({
+      token,
+      scope: "Singleton" /* Singleton */
+    })(target, context);
+  };
+}
 
-// packages/core/src/services/controller-adapter.service.mts
-var _ControllerAdapterService_decorators, _init6;
-_ControllerAdapterService_decorators = [Injectable()];
-var _ControllerAdapterService = class _ControllerAdapterService {
-  guardRunner = syncInject(GuardRunnerService);
-  logger = syncInject(Logger, {
-    context: _ControllerAdapterService.name
-  });
-  setupController(controller, instance, moduleMetadata) {
-    const controllerMetadata = extractControllerMetadata(controller);
-    for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod } = endpoint;
-      if (!url) {
-        throw new Error(
-          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
-        );
-      }
-      const executionContext = new ExecutionContext2(
-        moduleMetadata,
-        controllerMetadata,
-        endpoint
+// packages/core/src/decorators/multipart.decorator.mts
+import "zod";
+function Multipart(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
       );
-      instance.withTypeProvider().route({
-        method: httpMethod,
-        url: url.replaceAll("$", ":"),
-        schema: this.provideSchemaForConfig(endpoint),
-        preHandler: this.providePreHandler(executionContext),
-        handler: this.provideHandler(controller, executionContext, endpoint)
-      });
-      this.logger.debug(
-        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
+    }
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on methods."
       );
     }
-  }
-  providePreHandler(executionContext) {
-    const guards = this.guardRunner.makeContext(executionContext);
-    return guards.size > 0 ? async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
+    const config = endpoint.config;
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(
+        target,
+        context
       );
-      executionContext.provideRequest(request);
-      executionContext.provideReply(reply);
-      let canActivate = true;
-      try {
-        canActivate = await this.guardRunner.runGuards(
-          guards,
-          executionContext
+      if (endpointMetadata.config && endpointMetadata.config.url) {
+        throw new Error(
+          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
         );
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
-      }
-      if (!canActivate) {
-        return reply;
       }
-    } : void 0;
-  }
-  provideSchemaForConfig(endpointMetadata) {
-    if (!endpointMetadata.config) {
-      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`);
-      return {};
-    }
-    const { querySchema, requestSchema, responseSchema } = endpointMetadata.config;
-    const schema = {};
-    if (querySchema) {
-      schema.querystring = querySchema;
+      endpointMetadata.config = config;
+      endpointMetadata.adapterToken = MultipartAdapterToken;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
     }
-    if (requestSchema && endpointMetadata.type !== "multipart" /* Multipart */) {
-      schema.body = requestSchema;
+    return target;
+  };
+}
+
+// packages/core/src/decorators/stream.decorator.mts
+function Stream(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
+      );
     }
-    if (responseSchema) {
-      schema.response = {
-        200: responseSchema
-      };
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on methods."
+      );
     }
-    return schema;
-  }
-  provideHandler(controller, executionContext, endpointMetadata) {
-    switch (endpointMetadata.type) {
-      case "unknown" /* Unknown */:
-        this.logger.error(
-          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`
-        );
-        throw new NaviosException4("Unknown endpoint type");
-      case "endpoint" /* Endpoint */:
-        return this.provideHandlerForConfig(
-          controller,
-          executionContext,
-          endpointMetadata
-        );
-      case "stream" /* Stream */:
-        return this.provideHandlerForStream(
-          controller,
-          executionContext,
-          endpointMetadata
-        );
-      case "multipart" /* Multipart */:
-        return this.provideHandlerForMultipart(
-          controller,
-          executionContext,
-          endpointMetadata
+    const config = endpoint.config;
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(
+        target,
+        context
+      );
+      if (endpointMetadata.config && endpointMetadata.config.url) {
+        throw new Error(
+          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
         );
-      case "handler" /* Handler */:
-        this.logger.error("Not implemented yet");
-        throw new NaviosException4("Not implemented yet");
+      }
+      endpointMetadata.config = config;
+      endpointMetadata.adapterToken = StreamAdapterToken;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
     }
-  }
-  provideHandlerForConfig(controller, executionContext, endpointMetadata) {
-    return async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
+    return target;
+  };
+}
+
+// packages/core/src/decorators/use-guards.decorator.mts
+function UseGuards(...guards) {
+  return function(target, context) {
+    if (context.kind === "class") {
+      const controllerMetadata = getControllerMetadata(
+        target,
+        context
       );
-      executionContext.provideRequest(request);
-      executionContext.provideReply(reply);
-      const controllerInstance = await inject(controller);
-      try {
-        const { query, params, body } = request;
-        const argument = {};
-        if (query && Object.keys(query).length > 0) {
-          argument.params = query;
-        }
-        if (params && Object.keys(params).length > 0) {
-          argument.urlParams = params;
-        }
-        if (body) {
-          argument.data = body;
-        }
-        const result = await controllerInstance[endpointMetadata.classMethod](argument);
-        reply.status(endpointMetadata.successStatusCode).headers(endpointMetadata.headers).send(result);
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
+      for (const guard of guards.reverse()) {
+        controllerMetadata.guards.add(guard);
       }
-    };
-  }
-  provideHandlerForStream(controller, executionContext, endpointMetadata) {
-    return async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
-      );
-      executionContext.provideRequest(request);
-      executionContext.provideReply(reply);
-      const controllerInstance = await inject(controller);
-      try {
-        const { query, params, body } = request;
-        const argument = {};
-        if (query && Object.keys(query).length > 0) {
-          argument.params = query;
-        }
-        if (params && Object.keys(params).length > 0) {
-          argument.urlParams = params;
-        }
-        if (body) {
-          argument.data = body;
-        }
-        await controllerInstance[endpointMetadata.classMethod](argument, reply);
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
+    } else if (context.kind === "method") {
+      const endpointMetadata = getEndpointMetadata(target, context);
+      for (const guard of guards.reverse()) {
+        endpointMetadata.guards.add(guard);
       }
-    };
-  }
-  provideHandlerForMultipart(controller, executionContext, endpointMetadata) {
-    const config = endpointMetadata.config;
-    const requestSchema = config.requestSchema;
-    const shape = requestSchema._def.shape();
-    return async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
+    } else {
+      throw new Error(
+        "[Navios] @UseGuards decorator can only be used on classes or methods."
       );
-      executionContext.provideRequest(request);
-      executionContext.provideReply(reply);
-      const controllerInstance = await inject(controller);
-      try {
-        const parts = request.parts();
-        const { query, params } = request;
-        const argument = {};
-        if (query && Object.keys(query).length > 0) {
-          argument.params = query;
-        }
-        if (params && Object.keys(params).length > 0) {
-          argument.urlParams = params;
-        }
-        const req = {};
-        for await (const part of parts) {
-          if (!shape[part.fieldname]) {
-            throw new NaviosException4(
-              `Invalid field name ${part.fieldname} for multipart request`
-            );
-          }
-          const schema = shape[part.fieldname];
-          if (part.type === "file") {
-            const file = new File([await part.toBuffer()], part.filename, {
-              type: part.mimetype
-            });
-            if (schema instanceof ZodArray) {
-              if (!req[part.fieldname]) {
-                req[part.fieldname] = [];
-              }
-              req[part.fieldname].push(file);
-            } else {
-              req[part.fieldname] = file;
-            }
-          } else {
-            if (schema instanceof ZodArray) {
-              if (!req[part.fieldname]) {
-                req[part.fieldname] = [];
-              }
-              req[part.fieldname].push(part.value);
-            } else {
-              req[part.fieldname] = part.value;
-            }
-          }
-        }
-        argument.data = requestSchema.parse(req);
-        const result = await controllerInstance[endpointMetadata.classMethod](argument);
-        reply.status(endpointMetadata.successStatusCode).headers(endpointMetadata.headers).send(result);
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
-      }
-    };
-  }
-};
-_init6 = __decoratorStart(null);
-_ControllerAdapterService = __decorateElement(_init6, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
-__runInitializers(_init6, 1, _ControllerAdapterService);
-var ControllerAdapterService = _ControllerAdapterService;
-
-// packages/core/src/services/module-loader.service.mts
-var _ModuleLoaderService_decorators, _init7;
-_ModuleLoaderService_decorators = [Injectable()];
-var _ModuleLoaderService = class _ModuleLoaderService {
-  logger = syncInject(Logger, {
-    context: _ModuleLoaderService.name
-  });
-  modulesMetadata = /* @__PURE__ */ new Map();
-  loadedModules = /* @__PURE__ */ new Map();
-  initialized = false;
-  async loadModules(appModule) {
-    if (this.initialized) {
-      return;
-    }
-    await this.traverseModules(appModule);
-    this.initialized = true;
-  }
-  async traverseModules(module, parentMetadata) {
-    const metadata = extractModuleMetadata(module);
-    if (parentMetadata) {
-      this.mergeMetadata(metadata, parentMetadata);
-    }
-    const moduleName = module.name;
-    if (this.modulesMetadata.has(moduleName)) {
-      return;
-    }
-    this.modulesMetadata.set(moduleName, metadata);
-    const imports = metadata.imports ?? /* @__PURE__ */ new Set();
-    const loadingPromises = Array.from(imports).map(
-      async (importedModule) => this.traverseModules(importedModule, metadata)
-    );
-    await Promise.all(loadingPromises);
-    const instance = await inject(module);
-    if (instance.onModuleInit) {
-      await instance.onModuleInit();
-    }
-    this.logger.debug(`Module ${moduleName} loaded`);
-    this.loadedModules.set(moduleName, instance);
-  }
-  mergeMetadata(metadata, parentMetadata) {
-    if (parentMetadata.guards) {
-      for (const guard of parentMetadata.guards) {
-        metadata.guards.add(guard);
-      }
-    }
-    if (parentMetadata.customAttributes) {
-      for (const [key, value] of parentMetadata.customAttributes) {
-        if (metadata.customAttributes.has(key)) {
-          continue;
-        }
-        metadata.customAttributes.set(key, value);
-      }
     }
-  }
-  getAllModules() {
-    return this.modulesMetadata;
-  }
-  dispose() {
-    this.modulesMetadata.clear();
-    this.loadedModules.clear();
-    this.initialized = false;
-  }
-};
-_init7 = __decoratorStart(null);
-_ModuleLoaderService = __decorateElement(_init7, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
-__runInitializers(_init7, 1, _ModuleLoaderService);
-var ModuleLoaderService = _ModuleLoaderService;
+    return target;
+  };
+}
 
 // packages/core/src/attribute.factory.mts
 var AttributeFactory = class {
@@ -2570,7 +2655,7 @@ import {
   serializerCompiler,
   validatorCompiler
 } from "fastify-type-provider-zod";
-var _NaviosApplication_decorators, _init8;
+var _NaviosApplication_decorators, _init11;
 _NaviosApplication_decorators = [Injectable()];
 var _NaviosApplication = class _NaviosApplication {
   moduleLoader = syncInject(ModuleLoaderService);
@@ -2662,7 +2747,7 @@ var _NaviosApplication = class _NaviosApplication {
         message: "Not Found",
         error: "NotFound"
       };
-      this.logger.error(`Route not found: ${req.url}`);
+      this.logger.error(`Route not found: [${req.method}] ${req.url}`);
       return reply.status(404).send(response);
     });
   }
@@ -2683,15 +2768,14 @@ var _NaviosApplication = class _NaviosApplication {
       }
       promises.push(
         this.server.register(
-          (instance, opts, done) => {
+          async (instance, opts) => {
             for (const controller of moduleMetadata.controllers) {
-              this.controllerAdapter.setupController(
+              await this.controllerAdapter.setupController(
                 controller,
                 instance,
                 moduleMetadata
               );
             }
-            done();
           },
           {
             prefix: this.globalPrefix ?? ""
@@ -2736,9 +2820,9 @@ var _NaviosApplication = class _NaviosApplication {
     await this.dispose();
   }
 };
-_init8 = __decoratorStart(null);
-_NaviosApplication = __decorateElement(_init8, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
-__runInitializers(_init8, 1, _NaviosApplication);
+_init11 = __decoratorStart(null);
+_NaviosApplication = __decorateElement(_init11, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
+__runInitializers(_init11, 1, _NaviosApplication);
 var NaviosApplication = _NaviosApplication;
 
 // packages/core/src/navios.factory.mts
@@ -2774,11 +2858,12 @@ export {
   ControllerAdapterService,
   ControllerMetadataKey,
   Endpoint,
+  EndpointAdapterService,
+  EndpointAdapterToken,
   EndpointMetadataKey,
-  EndpointType,
   ErrorsEnum,
   EventEmitter,
-  ExecutionContext2 as ExecutionContext,
+  ExecutionContext,
   ExecutionContextInjectionToken,
   ExecutionContextToken,
   FactoryInjectionToken,
@@ -2808,6 +2893,8 @@ export {
   ModuleLoaderService,
   ModuleMetadataKey,
   Multipart,
+  MultipartAdapterService,
+  MultipartAdapterToken,
   NaviosApplication,
   NaviosFactory,
   NotFoundException,
@@ -2820,6 +2907,8 @@ export {
   ServiceLocatorInstanceHolderStatus,
   ServiceLocatorManager,
   Stream,
+  StreamAdapterService,
+  StreamAdapterToken,
   UnauthorizedException,
   UnknownError,
   UseGuards,