@navios/core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/lib/navios.factory-BanZIvtR.cjs

@@ -0,0 +1,4134 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_tokens = require('./tokens-BuXXB01L.cjs');
+let _navios_di = require("@navios/di");
+let zod_v4 = require("zod/v4");
+zod_v4 = __toESM(zod_v4);
+let util = require("util");
+let node_async_hooks = require("node:async_hooks");
+
+//#region src/logger/utils/cli-colors.util.mts
+const isColorAllowed = () => !process.env.NO_COLOR;
+const colorIfAllowed = (colorFn) => (text) => isColorAllowed() ? colorFn(text) : text;
+const 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`)
+};
+const yellow = colorIfAllowed((text) => `\x1B[38;5;3m${text}\x1B[39m`);
+
+//#endregion
+//#region src/logger/log-levels.mts
+/**
+* Available log levels in order of severity (lowest to highest).
+*/ const LOG_LEVELS = [
+	"verbose",
+	"debug",
+	"log",
+	"warn",
+	"error",
+	"fatal"
+];
+
+//#endregion
+//#region src/logger/utils/is-log-level.util.mts
+/**
+* @publicApi
+*/ function isLogLevel(maybeLogLevel) {
+	return LOG_LEVELS.includes(maybeLogLevel);
+}
+
+//#endregion
+//#region src/logger/utils/filter-log-levelts.util.mts
+/**
+* @publicApi
+*/ 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;
+}
+
+//#endregion
+//#region src/logger/utils/is-log-level-enabled.mts
+const LOG_LEVEL_VALUES = {
+	verbose: 0,
+	debug: 1,
+	log: 2,
+	warn: 3,
+	error: 4,
+	fatal: 5
+};
+/**
+* Checks if target level is enabled.
+* @param targetLevel target level
+* @param logLevels array of enabled log levels
+*/ function isLogLevelEnabled(targetLevel, logLevels) {
+	if (!logLevels || Array.isArray(logLevels) && logLevels?.length === 0) return false;
+	if (logLevels.includes(targetLevel)) return true;
+	const highestLogLevelValue = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)?.[0];
+	return LOG_LEVEL_VALUES[targetLevel] >= highestLogLevelValue;
+}
+
+//#endregion
+//#region src/logger/utils/shared.utils.mts
+const isUndefined = (obj) => typeof obj === "undefined";
+const isObject = (fn) => !isNil(fn) && typeof fn === "object";
+const 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);
+};
+const addLeadingSlash = (path) => path && typeof path === "string" ? path.charAt(0) !== "/" && path.substring(0, 2) !== "{/" ? "/" + path : path : "";
+const normalizePath = (path) => path ? path.startsWith("/") ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/") : "/" + path.replace(/\/+$/, "") : "/";
+const stripEndSlash = (path) => path[path.length - 1] === "/" ? path.slice(0, path.length - 1) : path;
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isNumber = (val) => typeof val === "number";
+const isConstructor = (val) => val === "constructor";
+const isNil = (val) => isUndefined(val) || val === null;
+const isEmpty = (array) => !(array && array.length > 0);
+const isSymbol = (val) => typeof val === "symbol";
+
+//#endregion
+//#region src/stores/request-id.store.mts
+let requestCounter = 0;
+/**
+* Generates a simple incremental request ID.
+* Much faster than crypto.randomUUID() and sufficient for request tracking.
+*
+* @returns A unique request ID string (e.g., "req-1", "req-2", ...)
+*/ function generateRequestId() {
+	return `req-${++requestCounter}`;
+}
+/**
+* AsyncLocalStorage store for the current request ID.
+*
+* This allows logging and other services to access the current request ID
+* without explicitly passing it through the call stack.
+*
+* @example
+* ```typescript
+* import { requestIdStore, runWithRequestId, getRequestId } from '@navios/core'
+*
+* // Run code with a request ID in context
+* runWithRequestId('req-123', () => {
+*   // Inside this callback, getRequestId() returns 'req-123'
+*   logger.log('Processing request') // Will include request ID if logger is configured
+* })
+*
+* // Get current request ID (returns undefined if not in a request context)
+* const currentId = getRequestId()
+* ```
+*/ let requestIdStore = null;
+function getRequestIdStore() {
+	if (!requestIdStore) requestIdStore = new node_async_hooks.AsyncLocalStorage();
+	return requestIdStore;
+}
+/**
+* Whether request ID propagation is enabled.
+* When disabled, runWithRequestId is a pass-through for better performance.
+*/ let requestIdEnabled = false;
+/**
+* Enables or disables request ID propagation.
+* Called by NaviosFactory based on the enableRequestId option.
+*
+* @param enabled - Whether to enable request ID propagation
+*/ function setRequestIdEnabled(enabled) {
+	requestIdEnabled = enabled;
+}
+/**
+* Runs a function with a request ID in the async local storage context.
+* If request ID propagation is disabled, the function is called directly
+* without AsyncLocalStorage overhead.
+*
+* @param requestId - The request ID to set for this context
+* @param fn - The function to run within this context
+* @returns The return value of the function
+*/ function runWithRequestId(requestId, fn) {
+	if (!requestIdEnabled) return fn();
+	return getRequestIdStore().run(requestId, fn);
+}
+/**
+* Gets the current request ID from the async local storage context.
+*
+* @returns The current request ID, or undefined if not in a request context
+*/ function getRequestId() {
+	if (!requestIdEnabled) return;
+	return getRequestIdStore().getStore();
+}
+
+//#endregion
+//#region src/logger/logger.tokens.mts
+/**
+* Injection token for the logger output service.
+* 
+* This token is used to provide a custom logger implementation.
+* By default, it's bound to ConsoleLogger.
+*/ const LoggerOutput = _navios_di.InjectionToken.create("LoggerOutput");
+/**
+* Schema for logger options.
+*/ const loggerOptionsSchema = zod_v4.default.object({ context: zod_v4.default.string().optional() }).optional();
+/**
+* Injection token for the Logger service.
+* 
+* Use this token to inject a contextualized logger instance.
+* 
+* @example
+* ```typescript
+* const logger = inject(Logger, { context: 'MyService' })
+* logger.log('Hello world') // Logs with context: [MyService]
+* ```
+*/ const Logger = _navios_di.InjectionToken.create("Logger", loggerOptionsSchema);
+
+//#endregion
+//#region src/logger/console-logger.service.mts
+function applyDecs2203RFactory$7() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$7(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$7 = applyDecs2203RFactory$7())(targetClass, memberDecs, classDecs, parentClass);
+}
+function _identity(x) {
+	return x;
+}
+var _dec$7, _initClass$7;
+const DEFAULT_DEPTH = 5;
+const DEFAULT_LOG_LEVELS = [
+	"log",
+	"error",
+	"warn",
+	"debug",
+	"verbose",
+	"fatal"
+];
+const dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
+	year: "numeric",
+	hour: "numeric",
+	minute: "numeric",
+	second: "numeric",
+	day: "2-digit",
+	month: "2-digit"
+});
+let _ConsoleLogger;
+_dec$7 = (0, _navios_di.Injectable)({ token: LoggerOutput });
+new class extends _identity {
+	constructor() {
+		super(_ConsoleLogger), _initClass$7();
+	}
+	static {
+		class ConsoleLogger {
+			static {
+				({c: [_ConsoleLogger, _initClass$7]} = _apply_decs_2203_r$7(this, [], [_dec$7]));
+			}
+			static create(contextOrOptions, options) {
+				const logger = new ConsoleLogger();
+				if (contextOrOptions !== void 0) if (typeof contextOrOptions === "string") logger.setup(contextOrOptions, options ?? {});
+				else logger.setup(contextOrOptions);
+				else logger.setup();
+				return logger;
+			}
+			/**
+			* 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 = this.getInspectOptions();
+			/**
+			* The last timestamp at which the log message was printed.
+			*/ lastTimestampAt;
+			setup(contextOrOptions, options) {
+				let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [void 0, options] : [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;
+				}
+			}
+			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", void 0, "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
+			* @param context context
+			*/ setContext(context) {
+				this.context = context;
+			}
+			/**
+			* Resets the logger context to the value that was passed in the constructor.
+			*/ resetContext() {
+				this.context = this.originalContext;
+			}
+			isLevelEnabled(level) {
+				const logLevels = this.options?.logLevels;
+				return isLogLevelEnabled(level, logLevels);
+			}
+			/**
+			* Gets the current request ID from the AsyncLocalStorage store.
+			* Only returns a value if the requestId option is enabled.
+			*/ getCurrentRequestId() {
+				if (!this.options.requestId) return;
+				return getRequestId();
+			}
+			getTimestamp() {
+				return dateTimeFormatter.format(Date.now());
+			}
+			printMessages(messages, context = "", logLevel = "log", requestId, writeStreamType, errorStack) {
+				const resolvedRequestId = requestId ?? this.getCurrentRequestId();
+				messages.forEach((message) => {
+					if (this.options.json) {
+						this.printAsJson(message, {
+							context,
+							logLevel,
+							writeStreamType,
+							errorStack,
+							requestId: resolvedRequestId
+						});
+						return;
+					}
+					const pidMessage = this.formatPid(process.pid);
+					const contextMessage = this.formatContext(context);
+					const timestampDiff = this.updateAndGetTimestampDiff();
+					const formattedLogLevel = logLevel.toUpperCase().padStart(7, " ");
+					const formattedMessage = this.formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff, resolvedRequestId);
+					process[writeStreamType ?? "stdout"].write(formattedMessage);
+				});
+			}
+			printAsJson(message, options) {
+				const logObject = {
+					level: options.logLevel,
+					pid: process.pid,
+					timestamp: Date.now(),
+					message
+				};
+				if (options.context) logObject.context = options.context;
+				if (options.errorStack) logObject.stack = options.errorStack;
+				if (this.options.requestId && options.requestId) logObject.requestId = options.requestId;
+				const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : (0, util.inspect)(logObject, this.inspectOptions);
+				process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}\n`);
+			}
+			formatPid(pid) {
+				const showPrefix = this.options.showPrefix ?? true;
+				const showPid = this.options.showPid ?? true;
+				if (!showPrefix && !showPid) return "";
+				const prefix = showPrefix ? `[${this.options.prefix}]` : "";
+				const pidPart = showPid ? `${pid}` : "";
+				return `${prefix}${showPrefix && showPid ? " " : ""}${pidPart}${showPrefix || showPid ? " - " : ""}`;
+			}
+			formatContext(context) {
+				const showContext = this.options.showContext ?? true;
+				if (!context || !showContext) return "";
+				context = `[${context}] `;
+				return this.options.colors ? yellow(context) : context;
+			}
+			formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff, requestId) {
+				const output = this.stringifyMessage(message, logLevel);
+				const showLogLevel = this.options.showLogLevel ?? true;
+				const showTimestamp = this.options.showTimestamp ?? true;
+				pidMessage = this.colorize(pidMessage, logLevel);
+				formattedLogLevel = showLogLevel ? this.colorize(formattedLogLevel, logLevel) : "";
+				const timestamp = showTimestamp ? this.getTimestamp() : "";
+				const requestIdPart = this.getRequestId(requestId);
+				const parts = [];
+				if (pidMessage) parts.push(pidMessage.trimEnd());
+				if (requestIdPart) parts.push(requestIdPart.trimEnd());
+				if (timestamp) parts.push(timestamp);
+				if (formattedLogLevel) parts.push(formattedLogLevel);
+				if (contextMessage) parts.push(contextMessage.trimEnd());
+				return `${parts.length > 0 ? parts.join(" ") + " " : ""}${output}${timestampDiff}\n`;
+			}
+			getRequestId(requestId) {
+				if (this.options.requestId && requestId) return `(${this.colorize(requestId, "log")}) `;
+				return "";
+			}
+			stringifyMessage(message, logLevel) {
+				if (isFunction(message)) {
+					if (Function.prototype.toString.call(message).startsWith("class ")) return this.stringifyMessage(message.name, logLevel);
+					return this.stringifyMessage(message(), logLevel);
+				}
+				if (typeof message === "string") return this.colorize(message, logLevel);
+				const outputText = (0, util.inspect)(message, this.inspectOptions);
+				if (isPlainObject(message)) return `Object(${Object.keys(message).length}) ${outputText}`;
+				if (Array.isArray(message)) return `Array(${message.length}) ${outputText}`;
+				return outputText;
+			}
+			colorize(message, logLevel) {
+				if (!this.options.colors || this.options.json) return message;
+				return this.getColorByLogLevel(logLevel)(message);
+			}
+			printStackTrace(stack) {
+				if (!stack || this.options.json) return;
+				process.stderr.write(`${stack}\n`);
+			}
+			updateAndGetTimestampDiff() {
+				const showTimeDiff = this.options?.showTimeDiff ?? false;
+				const result = this.lastTimestampAt && showTimeDiff ? this.formatTimestampDiff(Date.now() - this.lastTimestampAt) : "";
+				this.lastTimestampAt = Date.now();
+				return result;
+			}
+			formatTimestampDiff(timestampDiff) {
+				const formattedDiff = ` +${timestampDiff}ms`;
+				return this.options.colors ? yellow(formattedDiff) : formattedDiff;
+			}
+			getInspectOptions() {
+				let breakLength = this.options.breakLength;
+				if (typeof breakLength === "undefined") breakLength = this.options.colors ? this.options.compact ? Infinity : void 0 : this.options.compact === false ? void 0 : Infinity;
+				const inspectOptions = {
+					depth: this.options.depth ?? DEFAULT_DEPTH,
+					sorted: this.options.sorted,
+					showHidden: this.options.showHidden,
+					compact: this.options.compact ?? (this.options.json ? true : false),
+					colors: this.options.colors,
+					breakLength
+				};
+				if (this.options.maxArrayLength) inspectOptions.maxArrayLength = this.options.maxArrayLength;
+				if (this.options.maxStringLength) inspectOptions.maxStringLength = this.options.maxStringLength;
+				return inspectOptions;
+			}
+			stringifyReplacer(key, value) {
+				if (typeof value === "bigint") return value.toString();
+				if (typeof value === "symbol") return value.toString();
+				if (value instanceof Map || value instanceof Set || value instanceof Error) return `${(0, util.inspect)(value, this.inspectOptions)}`;
+				return value;
+			}
+			getContextAndMessagesToPrint(args) {
+				if (args?.length <= 1) return {
+					messages: args,
+					context: this.context
+				};
+				const lastElement = args[args.length - 1];
+				if (!isString(lastElement)) return {
+					messages: args,
+					context: this.context
+				};
+				return {
+					context: lastElement,
+					messages: args.slice(0, args.length - 1)
+				};
+			}
+			getContextAndStackAndMessagesToPrint(args) {
+				if (args.length === 2) return this.isStackFormat(args[1]) ? {
+					messages: [args[0]],
+					stack: args[1],
+					context: this.context
+				} : {
+					messages: [args[0]],
+					context: args[1]
+				};
+				const { messages, context } = this.getContextAndMessagesToPrint(args);
+				if (messages?.length <= 1) return {
+					messages,
+					context
+				};
+				const lastElement = messages[messages.length - 1];
+				if (!isString(lastElement) && !isUndefined(lastElement)) return {
+					messages,
+					context
+				};
+				return {
+					stack: lastElement,
+					messages: messages.slice(0, messages.length - 1),
+					context
+				};
+			}
+			isStackFormat(stack) {
+				if (!isString(stack) && !isUndefined(stack)) return false;
+				return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
+			}
+			getColorByLogLevel(level) {
+				switch (level) {
+					case "debug": return clc.magentaBright;
+					case "warn": return clc.yellow;
+					case "error": return clc.red;
+					case "verbose": return clc.cyanBright;
+					case "fatal": return clc.bold;
+					default: return clc.green;
+				}
+			}
+		}
+	}
+}();
+
+//#endregion
+//#region src/logger/logger.service.mts
+function applyDecs2203RFactory$6() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$6(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$6 = applyDecs2203RFactory$6())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$6, _initClass$6;
+let _LoggerInstance;
+_dec$6 = (0, _navios_di.Injectable)({ token: Logger });
+var LoggerInstance = class {
+	static {
+		({c: [_LoggerInstance, _initClass$6]} = _apply_decs_2203_r$6(this, [], [_dec$6]));
+	}
+	constructor(config = {}) {
+		this.context = config.context;
+	}
+	localInstance = (0, _navios_di.inject)(LoggerOutput);
+	context;
+	error(message, ...optionalParams) {
+		optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(this.context) : optionalParams;
+		this.localInstance?.error(message, ...optionalParams);
+	}
+	log(message, ...optionalParams) {
+		optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+		this.localInstance?.log(message, ...optionalParams);
+	}
+	warn(message, ...optionalParams) {
+		optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+		this.localInstance?.warn(message, ...optionalParams);
+	}
+	debug(message, ...optionalParams) {
+		optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+		this.localInstance?.debug?.(message, ...optionalParams);
+	}
+	verbose(message, ...optionalParams) {
+		optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+		this.localInstance?.verbose?.(message, ...optionalParams);
+	}
+	fatal(message, ...optionalParams) {
+		optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+		this.localInstance?.fatal?.(message, ...optionalParams);
+	}
+	static {
+		_initClass$6();
+	}
+};
+
+//#endregion
+//#region src/exceptions/http.exception.mts
+/**
+* Base exception class for all HTTP exceptions in Navios.
+* 
+* All HTTP exception classes extend this base class. When thrown from an endpoint handler,
+* Navios will automatically convert it to an appropriate HTTP response with the specified
+* status code and response body.
+* 
+* @example
+* ```typescript
+* @Endpoint(getUserEndpoint)
+* async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+*   const user = await this.userService.findById(request.urlParams.userId)
+*   if (!user) {
+*     throw new HttpException(404, 'User not found')
+*   }
+*   return user
+* }
+* ```
+*/ var HttpException = class {
+	statusCode;
+	response;
+	error;
+	/**
+	* Creates a new HttpException instance.
+	* 
+	* @param statusCode - HTTP status code (e.g., 400, 404, 500)
+	* @param response - Response body (string or object)
+	* @param error - Optional underlying error for logging/debugging
+	*/ constructor(statusCode, response, error) {
+		this.statusCode = statusCode;
+		this.response = response;
+		this.error = error;
+	}
+};
+
+//#endregion
+//#region src/responders/enums/framework-error.enum.mts
+/**
+* Enumeration of framework-level error types.
+* Used to explicitly specify which error responder should handle an error.
+*
+* @example
+* ```typescript
+* // In adapter error handling
+* if (error instanceof ZodError) {
+*   return errorProducer.respond(FrameworkError.ValidationError, error)
+* }
+* return errorProducer.handleUnknown(error)
+* ```
+*/ var FrameworkError = /* @__PURE__ */ function(FrameworkError$1) {
+	/**
+	* Resource not found (HTTP 404).
+	* Use when a requested resource does not exist.
+	*/ FrameworkError$1["NotFound"] = "NotFound";
+	/**
+	* Forbidden (HTTP 403).
+	* Use when access to a resource is denied (e.g., guard rejection).
+	*/ FrameworkError$1["Forbidden"] = "Forbidden";
+	/**
+	* Internal server error (HTTP 500).
+	* Use for unexpected errors that don't fit other categories.
+	*/ FrameworkError$1["InternalServerError"] = "InternalServerError";
+	/**
+	* Validation error (HTTP 400).
+	* Use when request data fails validation (e.g., Zod errors).
+	*/ FrameworkError$1["ValidationError"] = "ValidationError";
+	return FrameworkError$1;
+}({});
+
+//#endregion
+//#region src/responders/tokens/responder.tokens.mts
+/**
+* Injection token for the Internal Server Error responder.
+* Default implementation returns HTTP 500 with RFC 7807 Problem Details.
+*
+* @example Override with custom implementation:
+* ```typescript
+* @Injectable({
+*   token: InternalServerErrorResponderToken,
+*   priority: 0, // Higher than default -10
+* })
+* export class CustomInternalErrorResponder implements ErrorResponder {
+*   getResponse(error: unknown, description?: string): ErrorResponse {
+*     // Custom implementation
+*   }
+* }
+* ```
+*/ const InternalServerErrorResponderToken = _navios_di.InjectionToken.create("InternalServerErrorResponder");
+/**
+* Injection token for the Not Found responder.
+* Default implementation returns HTTP 404 with RFC 7807 Problem Details.
+*
+* @example Override with custom implementation:
+* ```typescript
+* @Injectable({
+*   token: NotFoundResponderToken,
+*   priority: 0, // Higher than default -10
+* })
+* export class CustomNotFoundResponder implements ErrorResponder {
+*   getResponse(error: unknown, description?: string): ErrorResponse {
+*     // Custom implementation
+*   }
+* }
+* ```
+*/ const NotFoundResponderToken = _navios_di.InjectionToken.create("NotFoundResponder");
+/**
+* Injection token for the Validation Error responder.
+* Default implementation returns HTTP 400 with RFC 7807 Problem Details
+* and includes validation errors from ZodError.
+*
+* @example Override with custom implementation:
+* ```typescript
+* @Injectable({
+*   token: ValidationErrorResponderToken,
+*   priority: 0, // Higher than default -10
+* })
+* export class CustomValidationResponder implements ErrorResponder {
+*   getResponse(error: unknown, description?: string): ErrorResponse {
+*     // Custom implementation
+*   }
+* }
+* ```
+*/ const ValidationErrorResponderToken = _navios_di.InjectionToken.create("ValidationErrorResponder");
+/**
+* Injection token for the Forbidden responder.
+* Default implementation returns HTTP 403 with RFC 7807 Problem Details.
+*
+* @example Override with custom implementation:
+* ```typescript
+* @Injectable({
+*   token: ForbiddenResponderToken,
+*   priority: 0, // Higher than default -10
+* })
+* export class CustomForbiddenResponder implements ErrorResponder {
+*   getResponse(error: unknown, description?: string): ErrorResponse {
+*     // Custom implementation
+*   }
+* }
+* ```
+*/ const ForbiddenResponderToken = _navios_di.InjectionToken.create("ForbiddenResponder");
+
+//#endregion
+//#region src/responders/services/error-response-producer.service.mts
+function applyDecs2203RFactory$5() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$5(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$5 = applyDecs2203RFactory$5())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$5, _initClass$5;
+let _ErrorResponseProducerService;
+_dec$5 = (0, _navios_di.Injectable)();
+var ErrorResponseProducerService = class {
+	static {
+		({c: [_ErrorResponseProducerService, _initClass$5]} = _apply_decs_2203_r$5(this, [], [_dec$5]));
+	}
+	forbiddenResponder = (0, _navios_di.inject)(ForbiddenResponderToken);
+	internalServerErrorResponder = (0, _navios_di.inject)(InternalServerErrorResponderToken);
+	notFoundResponder = (0, _navios_di.inject)(NotFoundResponderToken);
+	validationErrorResponder = (0, _navios_di.inject)(ValidationErrorResponderToken);
+	/**
+	* Produces an error response for a specific framework error type.
+	*
+	* @param type - The type of framework error (from FrameworkError enum)
+	* @param error - The original error that was thrown
+	* @param description - Optional custom description to include in the response
+	* @returns ErrorResponse with status code, RFC 7807 payload, and headers
+	*/ respond(type, error, description) {
+		switch (type) {
+			case FrameworkError.NotFound: return this.notFoundResponder.getResponse(error, description);
+			case FrameworkError.Forbidden: return this.forbiddenResponder.getResponse(error, description);
+			case FrameworkError.InternalServerError: return this.internalServerErrorResponder.getResponse(error, description);
+			case FrameworkError.ValidationError: return this.validationErrorResponder.getResponse(error, description);
+		}
+	}
+	/**
+	* Handles unknown errors by producing an Internal Server Error response.
+	*
+	* Use this as a fallback when the error type is not known or doesn't
+	* match any specific framework error type.
+	*
+	* @param error - The original error that was thrown
+	* @param description - Optional custom description to include in the response
+	* @returns ErrorResponse with 500 status code
+	*/ handleUnknown(error, description) {
+		return this.internalServerErrorResponder.getResponse(error, description);
+	}
+	/**
+	* Convenience method to produce a Not Found error response.
+	*
+	* @param error - The original error that was thrown
+	* @param description - Optional custom description
+	* @returns ErrorResponse with 404 status code
+	*/ notFound(error, description) {
+		return this.notFoundResponder.getResponse(error, description);
+	}
+	/**
+	* Convenience method to produce a Validation Error response.
+	*
+	* @param error - The original error (typically a ZodError)
+	* @param description - Optional custom description
+	* @returns ErrorResponse with 400 status code
+	*/ validationError(error, description) {
+		return this.validationErrorResponder.getResponse(error, description);
+	}
+	/**
+	* Convenience method to produce an Internal Server Error response.
+	*
+	* @param error - The original error
+	* @param description - Optional custom description
+	* @returns ErrorResponse with 500 status code
+	*/ internalServerError(error, description) {
+		return this.internalServerErrorResponder.getResponse(error, description);
+	}
+	/**
+	* Convenience method to produce a Forbidden error response.
+	*
+	* @param error - The original error
+	* @param description - Optional custom description
+	* @returns ErrorResponse with 403 status code
+	*/ forbidden(error, description) {
+		return this.forbiddenResponder.getResponse(error, description);
+	}
+	static {
+		_initClass$5();
+	}
+};
+
+//#endregion
+//#region src/services/instance-resolver.service.mts
+function applyDecs2203RFactory$4() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$4(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$4 = applyDecs2203RFactory$4())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$4, _initClass$4;
+let _InstanceResolverService;
+_dec$4 = (0, _navios_di.Injectable)();
+var InstanceResolverService = class {
+	static {
+		({c: [_InstanceResolverService, _initClass$4]} = _apply_decs_2203_r$4(this, [], [_dec$4]));
+	}
+	container = (0, _navios_di.inject)(_navios_di.Container);
+	/**
+	* Attempts to resolve a class instance, automatically detecting if it needs
+	* request scope based on its dependencies.
+	*
+	* @param classType - The class to resolve
+	* @returns A resolution result containing either a cached instance or resolver function
+	*/ async resolve(classType) {
+		let cachedInstance = null;
+		try {
+			cachedInstance = await this.container.get(classType);
+		} catch {
+			const token = (0, _navios_di.getInjectableToken)(classType);
+			this.container.getRegistry().updateScope(token, _navios_di.InjectableScope.Request);
+		}
+		return {
+			cached: cachedInstance !== null,
+			instance: cachedInstance,
+			resolve: (scoped) => scoped.get(classType)
+		};
+	}
+	/**
+	* Attempts to resolve multiple class instances, automatically detecting if any need
+	* request scope based on their dependencies.
+	*
+	* Returns `cached: true` only if ALL classes can be resolved as singletons.
+	* If any class has request-scoped dependencies, returns `cached: false`.
+	*
+	* @param classTypes - The classes to resolve
+	* @returns A resolution result containing either all cached instances or resolver function
+	*/ async resolveMany(classTypes) {
+		if (classTypes.length === 0) return {
+			cached: true,
+			instances: [],
+			classTypes: [],
+			resolve: async () => []
+		};
+		const results = await Promise.all(classTypes.map(async (classType) => {
+			try {
+				return {
+					success: true,
+					instance: await this.container.get(classType)
+				};
+			} catch {
+				const token = (0, _navios_di.getInjectableToken)(classType);
+				this.container.getRegistry().updateScope(token, _navios_di.InjectableScope.Request);
+				return {
+					success: false,
+					instance: null
+				};
+			}
+		}));
+		const allCached = results.every((r) => r.success);
+		return {
+			cached: allCached,
+			instances: allCached ? results.map((r) => r.instance) : null,
+			classTypes,
+			resolve: (scoped) => Promise.all(classTypes.map((classType) => scoped.get(classType)))
+		};
+	}
+	static {
+		_initClass$4();
+	}
+};
+/**
+* @deprecated Use InstanceResolverService instead
+*/ const ControllerResolverService = _InstanceResolverService;
+
+//#endregion
+//#region src/services/abstract-handler-adapter.service.mts
+const defaultOptions = {
+	adapter: [],
+	validateResponses: true,
+	enableRequestId: false
+};
+/**
+* Abstract base class for HTTP handler adapter services.
+*
+* Provides shared logic for:
+* - Controller resolution (singleton vs request-scoped)
+* - Argument formatting (sync/async detection)
+* - Handler generation with static/dynamic branching
+* - Standardized error handling
+*
+* Adapters implement abstract methods for framework-specific behavior:
+* - Request parsing (query, body, URL params)
+* - Response creation
+* - Schema provision
+*
+* Supports all adapter types:
+* - Endpoint adapters: JSON request/response with validation
+* - Stream adapters: Streaming responses with extra context
+* - Multipart adapters: Form data parsing (extends endpoint)
+*
+* @typeParam TRequest - Framework request type (BunRequest, FastifyRequest)
+* @typeParam TReply - Framework reply type (void for Bun, FastifyReply)
+* @typeParam TConfig - Endpoint configuration type
+*/ var AbstractHandlerAdapterService = class {
+	instanceResolver = (0, _navios_di.inject)(_InstanceResolverService);
+	options = (0, _navios_di.optional)(require_tokens.NaviosOptionsToken) ?? defaultOptions;
+	/**
+	* Prepares argument getters for parsing request data.
+	*
+	* Public alias for createArgumentGetters to satisfy interface contracts.
+	* Subclasses should override createArgumentGetters instead.
+	*
+	* @param handlerMetadata - Handler metadata with schemas and configuration
+	* @returns Array of getter functions
+	*/ prepareArguments(handlerMetadata) {
+		return this.createArgumentGetters(handlerMetadata);
+	}
+	/**
+	* Checks if the handler has any validation schemas defined.
+	*
+	* Override in subclasses to add additional schema checks
+	* (e.g., response schema validation for endpoint adapters).
+	*
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns true if handler has schemas
+	*/ hasSchema(handlerMetadata) {
+		const config = handlerMetadata.config;
+		return !!config.requestSchema || !!config.querySchema;
+	}
+	/**
+	* Provides schema information for the framework's validation system.
+	*
+	* Override in subclasses for frameworks that support schema registration
+	* (e.g., Fastify). Default returns empty object (suitable for Bun).
+	*
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns Schema object for framework registration
+	*/ provideSchema(_handlerMetadata) {
+		return {};
+	}
+	/**
+	* Creates a request handler function for the endpoint.
+	*
+	* This method orchestrates the entire handler creation:
+	* 1. Prepares argument getters for request parsing
+	* 2. Builds optimized formatArguments function (sync/async)
+	* 3. Resolves the controller (singleton vs request-scoped)
+	* 4. Creates appropriate handler (static or dynamic)
+	*
+	* @param controller - Controller class containing the handler method
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns Handler result (static or dynamic)
+	*/ async provideHandler(controller, handlerMetadata) {
+		const getters = this.createArgumentGetters(handlerMetadata);
+		const formatArguments = this.buildFormatArguments(getters);
+		const hasArguments = getters.length > 0;
+		const context = {
+			methodName: handlerMetadata.classMethod,
+			statusCode: handlerMetadata.successStatusCode,
+			headers: handlerMetadata.headers,
+			handlerMetadata,
+			hasArguments
+		};
+		const resolution = await this.instanceResolver.resolve(controller);
+		if (resolution.cached) {
+			const cachedController = resolution.instance;
+			const boundMethod = cachedController[context.methodName].bind(cachedController);
+			return this.createStaticHandler(boundMethod, formatArguments, context);
+		}
+		return this.createDynamicHandler(resolution, formatArguments, context);
+	}
+	/**
+	* Builds a formatArguments function from argument getters.
+	*
+	* Automatically detects sync vs async getters and optimizes accordingly:
+	* - If all getters are sync: returns sync function (no Promise overhead)
+	* - If any getter is async: returns async function with Promise.all
+	* - If no getters: returns frozen empty object (zero allocation)
+	*
+	* This method is public to allow composition-based adapters (like XML adapter)
+	* to reuse the optimized formatArguments logic without inheritance.
+	*
+	* @param getters - Array of argument getter functions
+	* @returns Function to format arguments from request
+	*/ buildFormatArguments(getters) {
+		if (getters.length === 0) {
+			const emptyArgs = Object.freeze({});
+			return () => emptyArgs;
+		}
+		if (getters.some((g) => g.constructor.name === "AsyncFunction")) return 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 (request) => {
+			const argument = {};
+			for (const getter of getters) getter(argument, request);
+			return argument;
+		};
+	}
+	/**
+	* Checks if the URL pattern contains URL parameters.
+	*
+	* @param config - Endpoint configuration
+	* @returns true if URL contains '$' parameter markers
+	*/ hasUrlParams(config) {
+		return config.url.includes("$");
+	}
+	/**
+	* Wraps handler execution with standardized error handling.
+	*
+	* Re-throws HttpExceptions as-is for framework error handlers.
+	* Other errors are re-thrown for global error handling.
+	*
+	* @param fn - Handler function to wrap
+	* @returns Wrapped function with error handling
+	*/ wrapWithErrorHandling(fn) {
+		return async (...args) => {
+			try {
+				return await fn(...args);
+			} catch (error) {
+				if (error && typeof error === "object" && "statusCode" in error) throw error;
+				throw error;
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/services/guard-runner.service.mts
+function applyDecs2203RFactory$3() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$3(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$3 = applyDecs2203RFactory$3())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$3, _initClass$3;
+let _GuardRunnerService;
+_dec$3 = (0, _navios_di.Injectable)();
+var GuardRunnerService = class {
+	static {
+		({c: [_GuardRunnerService, _initClass$3]} = _apply_decs_2203_r$3(this, [], [_dec$3]));
+	}
+	errorProducer = (0, _navios_di.inject)(_ErrorResponseProducerService);
+	logger = (0, _navios_di.inject)(Logger, { context: _GuardRunnerService.name });
+	/**
+	* Runs guards that need to be resolved from a scoped container.
+	* Use this when guards have request-scoped dependencies.
+	*/ async runGuards(allGuards, executionContext, context) {
+		const guardsArray = Array.from(allGuards).reverse();
+		const guardInstances = await Promise.all(guardsArray.map(async (guard) => {
+			const guardInstance = await context.get(guard);
+			if (!guardInstance.canActivate) throw new Error(`[Navios] Guard ${guard.name} does not implement canActivate()`);
+			return guardInstance;
+		}));
+		return this.executeGuards(guardInstances, executionContext);
+	}
+	/**
+	* Runs pre-resolved guard instances.
+	* Use this when all guards are singletons and have been pre-resolved at startup.
+	*/ async runGuardsStatic(guardInstances, executionContext) {
+		return this.executeGuards(guardInstances, executionContext);
+	}
+	/**
+	* Shared guard execution logic.
+	* Iterates through guard instances and calls canActivate on each.
+	*/ async executeGuards(guardInstances, executionContext) {
+		let canActivate = true;
+		for (const guardInstance of guardInstances) 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 {
+				this.logger.error("Error running guard", error);
+				const errorResponse = this.errorProducer.respond(FrameworkError.InternalServerError, error);
+				executionContext.getReply().status(errorResponse.statusCode).send(errorResponse.payload);
+				return false;
+			}
+		}
+		if (!canActivate) {
+			const errorResponse = this.errorProducer.respond(FrameworkError.Forbidden, null);
+			executionContext.getReply().status(errorResponse.statusCode).send(errorResponse.payload);
+			return false;
+		}
+		return canActivate;
+	}
+	makeContext(moduleMetadata, controllerMetadata, endpoint) {
+		const guards = /* @__PURE__ */ new Set();
+		const endpointGuards = endpoint.guards;
+		const controllerGuards = controllerMetadata.guards;
+		const moduleGuards = moduleMetadata.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;
+	}
+	static {
+		_initClass$3();
+	}
+};
+
+//#endregion
+//#region src/services/module-loader.service.mts
+function applyDecs2203RFactory$2() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$2(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$2 = applyDecs2203RFactory$2())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$2, _initClass$2;
+let _ModuleLoaderService;
+_dec$2 = (0, _navios_di.Injectable)();
+var ModuleLoaderService = class {
+	static {
+		({c: [_ModuleLoaderService, _initClass$2]} = _apply_decs_2203_r$2(this, [], [_dec$2]));
+	}
+	logger = (0, _navios_di.inject)(Logger, { context: _ModuleLoaderService.name });
+	container = (0, _navios_di.inject)(_navios_di.Container);
+	modulesMetadata = /* @__PURE__ */ new Map();
+	loadedModules = /* @__PURE__ */ new Map();
+	initialized = false;
+	async loadModules(appModule) {
+		if (this.initialized) return;
+		await this.traverseModules(appModule);
+		this.initialized = true;
+	}
+	/**
+	* Extends the module tree with additional modules or controllers.
+	*
+	* This method is designed to be called by plugins during registration,
+	* which happens after initial module loading but before route registration.
+	*
+	* @param extensions - Array of module extensions to add
+	* @throws Error if not initialized (loadModules must be called first)
+	*
+	* @example
+	* ```typescript
+	* // In plugin registration
+	* const moduleLoader = await context.container.get(ModuleLoaderService)
+	* await moduleLoader.extendModules([{
+	*   controllers: [OpenApiJsonController, OpenApiYamlController],
+	*   moduleName: 'OpenApiBunModule',
+	* }])
+	* ```
+	*/ async extendModules(extensions) {
+		if (!this.initialized) throw new Error("ModuleLoaderService must be initialized before extending. Call loadModules() first.");
+		for (const extension of extensions) if (extension.module) await this.traverseModules(extension.module);
+		else if (extension.controllers && extension.moduleName) await this.registerControllers(extension.controllers, extension.moduleName);
+		else if (extension.controllers) throw new Error("moduleName is required when providing controllers without a module");
+	}
+	/**
+	* Registers controllers under a synthetic module.
+	* Used when plugins want to add controllers without a full module class.
+	*/ async registerControllers(controllers, moduleName) {
+		if (this.modulesMetadata.has(moduleName)) {
+			const existing = this.modulesMetadata.get(moduleName);
+			for (const controller of controllers) existing.controllers.add(controller);
+			this.logger.debug(`Extended module ${moduleName} with ${controllers.length} controllers`);
+		} else {
+			const metadata = {
+				controllers: new Set(controllers),
+				imports: /* @__PURE__ */ new Set(),
+				guards: /* @__PURE__ */ new Set(),
+				overrides: /* @__PURE__ */ new Set(),
+				customAttributes: /* @__PURE__ */ new Map(),
+				customEntries: /* @__PURE__ */ new Map()
+			};
+			this.modulesMetadata.set(moduleName, metadata);
+			this.logger.debug(`Created module ${moduleName} with ${controllers.length} controllers`);
+		}
+	}
+	async traverseModules(module$1, parentMetadata) {
+		const metadata = require_tokens.extractModuleMetadata(module$1);
+		if (parentMetadata) this.mergeMetadata(metadata, parentMetadata);
+		const moduleName = (0, _navios_di.getInjectableToken)(module$1).id;
+		if (this.modulesMetadata.has(moduleName)) return;
+		try {
+			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);
+			this.validateOverrides(metadata, moduleName);
+			const instance = await this.container.get(module$1);
+			if (instance.onModuleInit) await instance.onModuleInit();
+			this.logger.debug(`Module ${moduleName} loaded`);
+			this.loadedModules.set(moduleName, instance);
+		} catch (error) {
+			this.logger.error(`Error loading module ${moduleName}`, error);
+			throw error;
+		}
+	}
+	validateOverrides(metadata, moduleName) {
+		if (!metadata.overrides || metadata.overrides.size === 0) return;
+		const registry = this.container.getRegistry();
+		for (const overrideClass of metadata.overrides) try {
+			const overrideToken = (0, _navios_di.getInjectableToken)(overrideClass);
+			const allRegistrations = registry.getAll(overrideToken);
+			if (allRegistrations.length === 0) {
+				this.logger.warn(`[Navios] Override ${overrideClass.name} in module ${moduleName} is not registered. Make sure it has @Injectable decorator.`);
+				continue;
+			}
+			const highestPriorityRegistration = allRegistrations[0];
+			if (highestPriorityRegistration.target !== overrideClass) {
+				const overrideRegistration = allRegistrations.find((r) => r.target === overrideClass);
+				if (!overrideRegistration) this.logger.warn(`[Navios] Override ${overrideClass.name} in module ${moduleName} is registered but not found in registry for token ${overrideToken.toString()}.`);
+				else this.logger.warn(`[Navios] Override ${overrideClass.name} in module ${moduleName} is not active. Current active service: ${highestPriorityRegistration.target.name} (priority: ${highestPriorityRegistration.priority}). Override priority: ${overrideRegistration.priority}. Override needs higher priority to take effect.`);
+			} else this.logger.debug(`[Navios] Override ${overrideClass.name} in module ${moduleName} is active (priority: ${highestPriorityRegistration.priority})`);
+		} catch (error) {
+			this.logger.warn(`[Navios] Failed to validate override ${overrideClass.name} in module ${moduleName}: ${error}`);
+		}
+	}
+	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;
+	}
+	static {
+		_initClass$2();
+	}
+};
+
+//#endregion
+//#region src/utils/adapter-supports.util.mts
+/**
+* Type guard to check if adapter implements a specific method.
+* Narrows the adapter type to include the method.
+*
+* @example
+* ```typescript
+* if (adapterSupports(adapter, 'getServer')) {
+*   const server = adapter.getServer() // TypeScript knows this exists
+* }
+* ```
+*/ function adapterSupports(adapter, method) {
+	return adapter !== null && typeof adapter[method] === "function";
+}
+/**
+* Asserts adapter supports a method, throws if not.
+* Narrows type after assertion.
+*
+* @example
+* ```typescript
+* assertAdapterSupports(adapter, 'enableCors')
+* adapter.enableCors(options) // TypeScript knows this exists
+* ```
+*/ function assertAdapterSupports(adapter, method) {
+	if (!adapterSupports(adapter, method)) throw new Error(`Current adapter does not implement '${method}()'`);
+}
+
+//#endregion
+//#region src/navios.environment.mts
+function applyDecs2203RFactory$1() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$1 = applyDecs2203RFactory$1())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$1, _initClass$1;
+let _NaviosEnvironment;
+_dec$1 = (0, _navios_di.Injectable)();
+var NaviosEnvironment = class {
+	static {
+		({c: [_NaviosEnvironment, _initClass$1]} = _apply_decs_2203_r$1(this, [], [_dec$1]));
+	}
+	adapterConfigured = false;
+	tokens = /* @__PURE__ */ new Map();
+	setupEnvironment(tokens) {
+		const hasAdapterToken = tokens.has(require_tokens.AdapterToken);
+		if (hasAdapterToken && this.adapterConfigured) throw new Error("Adapter already configured. Only one adapter per application.");
+		for (const [token, value] of tokens) this.tokens.set(token, value);
+		if (hasAdapterToken) this.adapterConfigured = true;
+	}
+	getToken(token) {
+		return this.tokens.get(token);
+	}
+	hasAdapterSetup() {
+		return this.adapterConfigured;
+	}
+	static {
+		_initClass$1();
+	}
+};
+
+//#endregion
+//#region src/navios.application.mts
+function applyDecs2203RFactory() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass;
+let _NaviosApplication;
+_dec = (0, _navios_di.Injectable)();
+var NaviosApplication = class {
+	static {
+		({c: [_NaviosApplication, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	environment = (0, _navios_di.inject)(_NaviosEnvironment);
+	moduleLoader = (0, _navios_di.inject)(_ModuleLoaderService);
+	adapter = null;
+	logger = (0, _navios_di.inject)(Logger, { context: _NaviosApplication.name });
+	container = (0, _navios_di.inject)(_navios_di.Container);
+	appModule = null;
+	options = { adapter: [] };
+	plugins = [];
+	/**
+	* Indicates whether the application has been initialized.
+	* Set to `true` after `init()` completes successfully.
+	*/ isInitialized = false;
+	/**
+	* Sets up the application with the provided module and options.
+	* This is called automatically by NaviosFactory.create().
+	*
+	* @param appModule - The root application module
+	* @param options - Application configuration options
+	* @internal
+	*/ async setup(appModule, options = { adapter: [] }) {
+		this.appModule = appModule;
+		this.options = options;
+		if (this.environment.hasAdapterSetup()) this.adapter = await this.container.get(require_tokens.AdapterToken);
+	}
+	/**
+	* Gets the dependency injection container used by this application.
+	*
+	* @returns The Container instance
+	*/ getContainer() {
+		return this.container;
+	}
+	/**
+	* Returns the current adapter instance.
+	*
+	* @returns The adapter instance
+	* @throws Error if adapter is not initialized
+	*/ getAdapter() {
+		if (!this.adapter) throw new Error("Adapter not initialized");
+		return this.adapter;
+	}
+	/**
+	* Registers a plugin to be initialized after modules are loaded.
+	*
+	* Plugins are initialized in the order they are registered,
+	* after all modules are loaded but before the server starts listening.
+	*
+	* @param definition - Plugin definition with options
+	* @returns this for method chaining
+	*
+	* @example
+	* ```typescript
+	* import { defineOpenApiPlugin } from '@navios/openapi-fastify'
+	*
+	* app.usePlugin(defineOpenApiPlugin({
+	*   info: { title: 'My API', version: '1.0.0' },
+	* }))
+	* ```
+	*/ usePlugin(definition) {
+		this.plugins.push(definition);
+		return this;
+	}
+	/**
+	* Initializes the application.
+	*
+	* This method:
+	* - Loads all modules and their dependencies
+	* - Sets up the adapter if one is configured
+	* - Calls onModuleInit hooks on all modules
+	* - Initializes registered plugins
+	* - Marks the application as initialized
+	*
+	* Must be called before `listen()`.
+	*
+	* @throws Error if app module is not set
+	*
+	* @example
+	* ```typescript
+	* const app = await NaviosFactory.create(AppModule, {
+	*   adapter: defineFastifyEnvironment(),
+	* })
+	* await app.init()
+	* await app.listen({ port: 3000 })
+	* ```
+	*/ async init() {
+		if (!this.appModule) throw new Error("App module is not set. Call setAppModule() first.");
+		await this.moduleLoader.loadModules(this.appModule);
+		if (this.environment.hasAdapterSetup() && this.adapter) await this.adapter.setupAdapter(this.options);
+		await this.initPlugins();
+		await this.initModules();
+		if (this.adapter) await this.adapter.ready();
+		this.isInitialized = true;
+		this.logger.debug("Navios application initialized");
+	}
+	async initModules() {
+		const modules = this.moduleLoader.getAllModules();
+		if (this.adapter) await this.adapter.onModulesInit(modules);
+	}
+	async initPlugins() {
+		if (this.plugins.length === 0) return;
+		if (!this.adapter) throw new Error("Cannot initialize plugins without an adapter");
+		const context = {
+			modules: this.moduleLoader.getAllModules(),
+			adapter: this.adapter,
+			container: this.container,
+			moduleLoader: this.moduleLoader
+		};
+		for (const { plugin, options } of this.plugins) {
+			this.logger.debug(`Initializing plugin: ${plugin.name}`);
+			await plugin.register(context, options);
+		}
+	}
+	async get(token, args) {
+		return this.container.get(token, args);
+	}
+	/**
+	* Configures the adapter with additional options before initialization.
+	*
+	* This method allows setting adapter-specific configuration options
+	* before the adapter is initialized. Must be called before `init()`.
+	*
+	* @param options - Adapter-specific configuration options
+	* @returns this for method chaining
+	* @throws Error if called after init() or if adapter doesn't support configure
+	*
+	* @example
+	* ```typescript
+	* // With Fastify adapter
+	* app.configure({ trustProxy: true, logger: true })
+	*
+	* // With Bun adapter
+	* app.configure({ development: true })
+	* ```
+	*/ configure(options) {
+		if (this.isInitialized) throw new Error("configure() must be called before init()");
+		assertAdapterSupports(this.adapter, "configure");
+		this.adapter.configure(options);
+		return this;
+	}
+	/**
+	* Enables CORS (Cross-Origin Resource Sharing) for the application.
+	*
+	* @param options - CORS configuration options (adapter-specific)
+	* @throws Error if adapter doesn't support enableCors
+	*
+	* @example
+	* ```typescript
+	* app.enableCors({
+	*   origin: ['http://localhost:3000', 'https://example.com'],
+	*   methods: ['GET', 'POST', 'PUT', 'DELETE'],
+	*   credentials: true,
+	* })
+	* ```
+	*/ enableCors(options) {
+		assertAdapterSupports(this.adapter, "enableCors");
+		this.adapter.enableCors(options);
+	}
+	/**
+	* Enables multipart/form-data support for file uploads.
+	*
+	* @param options - Multipart configuration options (adapter-specific)
+	* @throws Error if adapter doesn't support enableMultipart
+	*
+	* @example
+	* ```typescript
+	* app.enableMultipart({
+	*   limits: {
+	*     fileSize: 1024 * 1024 * 10, // 10MB
+	*   },
+	* })
+	* ```
+	*/ enableMultipart(options) {
+		assertAdapterSupports(this.adapter, "enableMultipart");
+		this.adapter.enableMultipart(options);
+	}
+	/**
+	* Sets a global prefix for all routes.
+	*
+	* @param prefix - The prefix to prepend to all route URLs (e.g., '/api')
+	* @throws Error if adapter doesn't support setGlobalPrefix
+	*
+	* @example
+	* ```typescript
+	* app.setGlobalPrefix('/api/v1')
+	* // All routes will be prefixed with /api/v1
+	* ```
+	*/ setGlobalPrefix(prefix) {
+		assertAdapterSupports(this.adapter, "setGlobalPrefix");
+		this.adapter.setGlobalPrefix(prefix);
+	}
+	/**
+	* Gets the underlying HTTP server instance.
+	*
+	* The type of the returned server depends on the adapter used:
+	* - Fastify adapter: Returns FastifyInstance
+	* - Bun adapter: Returns Bun.Server
+	*
+	* @returns The HTTP server instance
+	* @throws Error if adapter doesn't support getServer
+	*
+	* @example
+	* ```typescript
+	* const server = app.getServer()
+	* // Use adapter-specific server methods
+	* ```
+	*/ getServer() {
+		assertAdapterSupports(this.adapter, "getServer");
+		return this.adapter.getServer();
+	}
+	/**
+	* Starts the HTTP server and begins listening for requests.
+	*
+	* @param options - Listen options (port, host, etc.)
+	* @throws Error if adapter doesn't support listen
+	*
+	* @example
+	* ```typescript
+	* await app.listen({ port: 3000, host: '0.0.0.0' })
+	* ```
+	*/ async listen(options) {
+		assertAdapterSupports(this.adapter, "listen");
+		return this.adapter.listen(options);
+	}
+	/**
+	* Disposes of application resources.
+	*
+	* Cleans up the adapter and module loader.
+	* This method is called automatically by `close()`.
+	*/ async dispose() {
+		if (this.adapter) await this.adapter.dispose();
+		if (this.moduleLoader) this.moduleLoader.dispose();
+	}
+	/**
+	* Closes the application and cleans up all resources.
+	*
+	* This is an alias for `dispose()`.
+	*
+	* @example
+	* ```typescript
+	* // Graceful shutdown
+	* process.on('SIGTERM', async () => {
+	*   await app.close()
+	*   process.exit(0)
+	* })
+	* ```
+	*/ async close() {
+		await this.dispose();
+	}
+	static {
+		_initClass();
+	}
+};
+
+//#endregion
+//#region src/navios.factory.mts
+/**
+* Factory class for creating and configuring Navios applications.
+*
+* This is the main entry point for bootstrapping a Navios application.
+* It handles dependency injection container setup, adapter registration,
+* and logger configuration.
+*
+* @example
+* ```typescript
+* import { NaviosFactory } from '@navios/core'
+* import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+*
+* const app = await NaviosFactory.create(AppModule, {
+*   adapter: defineFastifyEnvironment(),
+*   logger: ['log', 'error', 'warn'],
+* })
+*
+* await app.init()
+* await app.listen({ port: 3000 })
+* ```
+*/ var NaviosFactory = class {
+	/**
+	* Creates a new Navios application instance.
+	*
+	* This method sets up the dependency injection container, registers the adapter,
+	* configures logging, and initializes the application with the provided module.
+	*
+	* @typeParam Environment - Adapter environment interface for type-safe access
+	*   to adapter-specific features. When specified, methods like `getServer()`,
+	*   `enableCors()`, `listen()`, and `configure()` will have proper types.
+	*
+	* @param appModule - The root application module class decorated with @Module()
+	* @param options - Configuration options for the application
+	* @param options.adapter - Adapter environment (required for server functionality)
+	* @param options.logger - Logger configuration. Can be:
+	*   - A LoggerService instance for custom logging
+	*   - An array of LogLevel strings to enable specific log levels
+	*   - `false` to disable logging
+	* @param options.container - Optional custom dependency injection container (useful for testing)
+	* @returns A configured NaviosApplication instance ready to be initialized
+	*
+	* @example
+	* ```typescript
+	* // Basic setup with Fastify adapter
+	* const app = await NaviosFactory.create(AppModule, {
+	*   adapter: defineFastifyEnvironment(),
+	* })
+	*
+	* // Type-safe setup with Fastify environment
+	* import { FastifyEnvironment } from '@navios/adapter-fastify'
+	*
+	* const app = await NaviosFactory.create<FastifyEnvironment>(AppModule, {
+	*   adapter: defineFastifyEnvironment(),
+	* })
+	* app.configure({ trustProxy: true })
+	* const server = app.getServer() // FastifyInstance
+	*
+	* // With custom logger configuration
+	* const app = await NaviosFactory.create(AppModule, {
+	*   adapter: defineFastifyEnvironment(),
+	*   logger: ['error', 'warn', 'log'],
+	* })
+	*
+	* // With custom container for testing
+	* const container = new Container()
+	* const app = await NaviosFactory.create(AppModule, {
+	*   adapter: defineFastifyEnvironment(),
+	*   container,
+	* })
+	* ```
+	*/ static async create(appModule, options = { adapter: [] }) {
+		const container = options.container ?? new _navios_di.Container(options.registry);
+		if (options.enableRequestId === true) setRequestIdEnabled(true);
+		container.addInstance(require_tokens.NaviosOptionsToken, options);
+		await this.registerLoggerConfiguration(container, options);
+		const adapters = Array.isArray(options.adapter) ? options.adapter : [options.adapter];
+		for (const adapter of adapters) await this.registerEnvironment(container, adapter);
+		const app = await container.get(_NaviosApplication);
+		await app.setup(appModule, options);
+		return app;
+	}
+	static async registerEnvironment(container, environment = {}) {
+		const naviosEnvironment = await container.get(_NaviosEnvironment);
+		const { tokens } = environment;
+		if (tokens) naviosEnvironment.setupEnvironment(tokens);
+	}
+	static async registerLoggerConfiguration(container, options) {
+		const { logger } = options;
+		if (Array.isArray(logger) || isNil(logger) || options.enableRequestId) {
+			(await container.get(LoggerOutput))?.setup({
+				logLevels: Array.isArray(logger) ? logger : void 0,
+				requestId: options.enableRequestId ?? false
+			});
+			return;
+		}
+		if (logger !== true && !isNil(logger)) container.addInstance(LoggerOutput, logger);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'AbstractHandlerAdapterService', {
+  enumerable: true,
+  get: function () {
+    return AbstractHandlerAdapterService;
+  }
+});
+Object.defineProperty(exports, 'ControllerResolverService', {
+  enumerable: true,
+  get: function () {
+    return ControllerResolverService;
+  }
+});
+Object.defineProperty(exports, 'ForbiddenResponderToken', {
+  enumerable: true,
+  get: function () {
+    return ForbiddenResponderToken;
+  }
+});
+Object.defineProperty(exports, 'FrameworkError', {
+  enumerable: true,
+  get: function () {
+    return FrameworkError;
+  }
+});
+Object.defineProperty(exports, 'HttpException', {
+  enumerable: true,
+  get: function () {
+    return HttpException;
+  }
+});
+Object.defineProperty(exports, 'InternalServerErrorResponderToken', {
+  enumerable: true,
+  get: function () {
+    return InternalServerErrorResponderToken;
+  }
+});
+Object.defineProperty(exports, 'LOG_LEVELS', {
+  enumerable: true,
+  get: function () {
+    return LOG_LEVELS;
+  }
+});
+Object.defineProperty(exports, 'Logger', {
+  enumerable: true,
+  get: function () {
+    return Logger;
+  }
+});
+Object.defineProperty(exports, 'LoggerOutput', {
+  enumerable: true,
+  get: function () {
+    return LoggerOutput;
+  }
+});
+Object.defineProperty(exports, 'NaviosFactory', {
+  enumerable: true,
+  get: function () {
+    return NaviosFactory;
+  }
+});
+Object.defineProperty(exports, 'NotFoundResponderToken', {
+  enumerable: true,
+  get: function () {
+    return NotFoundResponderToken;
+  }
+});
+Object.defineProperty(exports, 'ValidationErrorResponderToken', {
+  enumerable: true,
+  get: function () {
+    return ValidationErrorResponderToken;
+  }
+});
+Object.defineProperty(exports, '_ConsoleLogger', {
+  enumerable: true,
+  get: function () {
+    return _ConsoleLogger;
+  }
+});
+Object.defineProperty(exports, '_ErrorResponseProducerService', {
+  enumerable: true,
+  get: function () {
+    return _ErrorResponseProducerService;
+  }
+});
+Object.defineProperty(exports, '_GuardRunnerService', {
+  enumerable: true,
+  get: function () {
+    return _GuardRunnerService;
+  }
+});
+Object.defineProperty(exports, '_InstanceResolverService', {
+  enumerable: true,
+  get: function () {
+    return _InstanceResolverService;
+  }
+});
+Object.defineProperty(exports, '_LoggerInstance', {
+  enumerable: true,
+  get: function () {
+    return _LoggerInstance;
+  }
+});
+Object.defineProperty(exports, '_ModuleLoaderService', {
+  enumerable: true,
+  get: function () {
+    return _ModuleLoaderService;
+  }
+});
+Object.defineProperty(exports, '_NaviosApplication', {
+  enumerable: true,
+  get: function () {
+    return _NaviosApplication;
+  }
+});
+Object.defineProperty(exports, '_NaviosEnvironment', {
+  enumerable: true,
+  get: function () {
+    return _NaviosEnvironment;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'adapterSupports', {
+  enumerable: true,
+  get: function () {
+    return adapterSupports;
+  }
+});
+Object.defineProperty(exports, 'addLeadingSlash', {
+  enumerable: true,
+  get: function () {
+    return addLeadingSlash;
+  }
+});
+Object.defineProperty(exports, 'assertAdapterSupports', {
+  enumerable: true,
+  get: function () {
+    return assertAdapterSupports;
+  }
+});
+Object.defineProperty(exports, 'clc', {
+  enumerable: true,
+  get: function () {
+    return clc;
+  }
+});
+Object.defineProperty(exports, 'filterLogLevels', {
+  enumerable: true,
+  get: function () {
+    return filterLogLevels;
+  }
+});
+Object.defineProperty(exports, 'generateRequestId', {
+  enumerable: true,
+  get: function () {
+    return generateRequestId;
+  }
+});
+Object.defineProperty(exports, 'getRequestId', {
+  enumerable: true,
+  get: function () {
+    return getRequestId;
+  }
+});
+Object.defineProperty(exports, 'isConstructor', {
+  enumerable: true,
+  get: function () {
+    return isConstructor;
+  }
+});
+Object.defineProperty(exports, 'isEmpty', {
+  enumerable: true,
+  get: function () {
+    return isEmpty;
+  }
+});
+Object.defineProperty(exports, 'isFunction', {
+  enumerable: true,
+  get: function () {
+    return isFunction;
+  }
+});
+Object.defineProperty(exports, 'isLogLevel', {
+  enumerable: true,
+  get: function () {
+    return isLogLevel;
+  }
+});
+Object.defineProperty(exports, 'isLogLevelEnabled', {
+  enumerable: true,
+  get: function () {
+    return isLogLevelEnabled;
+  }
+});
+Object.defineProperty(exports, 'isNil', {
+  enumerable: true,
+  get: function () {
+    return isNil;
+  }
+});
+Object.defineProperty(exports, 'isNumber', {
+  enumerable: true,
+  get: function () {
+    return isNumber;
+  }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () {
+    return isObject;
+  }
+});
+Object.defineProperty(exports, 'isPlainObject', {
+  enumerable: true,
+  get: function () {
+    return isPlainObject;
+  }
+});
+Object.defineProperty(exports, 'isString', {
+  enumerable: true,
+  get: function () {
+    return isString;
+  }
+});
+Object.defineProperty(exports, 'isSymbol', {
+  enumerable: true,
+  get: function () {
+    return isSymbol;
+  }
+});
+Object.defineProperty(exports, 'isUndefined', {
+  enumerable: true,
+  get: function () {
+    return isUndefined;
+  }
+});
+Object.defineProperty(exports, 'loggerOptionsSchema', {
+  enumerable: true,
+  get: function () {
+    return loggerOptionsSchema;
+  }
+});
+Object.defineProperty(exports, 'normalizePath', {
+  enumerable: true,
+  get: function () {
+    return normalizePath;
+  }
+});
+Object.defineProperty(exports, 'runWithRequestId', {
+  enumerable: true,
+  get: function () {
+    return runWithRequestId;
+  }
+});
+Object.defineProperty(exports, 'setRequestIdEnabled', {
+  enumerable: true,
+  get: function () {
+    return setRequestIdEnabled;
+  }
+});
+Object.defineProperty(exports, 'stripEndSlash', {
+  enumerable: true,
+  get: function () {
+    return stripEndSlash;
+  }
+});
+Object.defineProperty(exports, 'yellow', {
+  enumerable: true,
+  get: function () {
+    return yellow;
+  }
+});
+//# sourceMappingURL=navios.factory-BanZIvtR.cjs.map