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

package/lib/navios.factory-C75yZCoD.mjs

@@ -0,0 +1,3831 @@
+import { a as NaviosOptionsToken, d as AdapterToken, p as extractModuleMetadata } from "./tokens-4J9sredA.mjs";
+import { Container, Injectable, InjectableScope, InjectionToken, getInjectableToken, inject, optional } from "@navios/di";
+import z from "zod/v4";
+import { inspect } from "util";
+import { AsyncLocalStorage } from "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 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 = InjectionToken.create("LoggerOutput");
+/**
+* Schema for logger options.
+*/ const loggerOptionsSchema = z.object({ context: z.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 = 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 = 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) : 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 = 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 `${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 = 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 = 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 = 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 = 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 = 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 = 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 = Injectable();
+var ErrorResponseProducerService = class {
+	static {
+		({c: [_ErrorResponseProducerService, _initClass$5]} = _apply_decs_2203_r$5(this, [], [_dec$5]));
+	}
+	forbiddenResponder = inject(ForbiddenResponderToken);
+	internalServerErrorResponder = inject(InternalServerErrorResponderToken);
+	notFoundResponder = inject(NotFoundResponderToken);
+	validationErrorResponder = 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 = Injectable();
+var InstanceResolverService = class {
+	static {
+		({c: [_InstanceResolverService, _initClass$4]} = _apply_decs_2203_r$4(this, [], [_dec$4]));
+	}
+	container = inject(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 = getInjectableToken(classType);
+			this.container.getRegistry().updateScope(token, 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 = getInjectableToken(classType);
+				this.container.getRegistry().updateScope(token, 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 = inject(_InstanceResolverService);
+	options = optional(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 = Injectable();
+var GuardRunnerService = class {
+	static {
+		({c: [_GuardRunnerService, _initClass$3]} = _apply_decs_2203_r$3(this, [], [_dec$3]));
+	}
+	errorProducer = inject(_ErrorResponseProducerService);
+	logger = 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 = Injectable();
+var ModuleLoaderService = class {
+	static {
+		({c: [_ModuleLoaderService, _initClass$2]} = _apply_decs_2203_r$2(this, [], [_dec$2]));
+	}
+	logger = inject(Logger, { context: _ModuleLoaderService.name });
+	container = inject(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, parentMetadata) {
+		const metadata = extractModuleMetadata(module);
+		if (parentMetadata) this.mergeMetadata(metadata, parentMetadata);
+		const moduleName = getInjectableToken(module).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);
+			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 = 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 = 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(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 = Injectable();
+var NaviosApplication = class {
+	static {
+		({c: [_NaviosApplication, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	environment = inject(_NaviosEnvironment);
+	moduleLoader = inject(_ModuleLoaderService);
+	adapter = null;
+	logger = inject(Logger, { context: _NaviosApplication.name });
+	container = inject(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(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 Container(options.registry);
+		if (options.enableRequestId === true) setRequestIdEnabled(true);
+		container.addInstance(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
+export { isFunction as A, isLogLevelEnabled as B, generateRequestId as C, addLeadingSlash as D, setRequestIdEnabled as E, isString as F, yellow as G, isLogLevel as H, isSymbol as I, isUndefined as L, isNumber as M, isObject as N, isConstructor as O, isPlainObject as P, normalizePath as R, loggerOptionsSchema as S, runWithRequestId as T, LOG_LEVELS as U, filterLogLevels as V, clc as W, HttpException as _, assertAdapterSupports as a, Logger as b, AbstractHandlerAdapterService as c, _ErrorResponseProducerService as d, ForbiddenResponderToken as f, FrameworkError as g, ValidationErrorResponderToken as h, adapterSupports as i, isNil as j, isEmpty as k, ControllerResolverService as l, NotFoundResponderToken as m, _NaviosApplication as n, _ModuleLoaderService as o, InternalServerErrorResponderToken as p, _NaviosEnvironment as r, _GuardRunnerService as s, NaviosFactory as t, _InstanceResolverService as u, _LoggerInstance as v, getRequestId as w, LoggerOutput as x, _ConsoleLogger as y, stripEndSlash as z };
+//# sourceMappingURL=navios.factory-C75yZCoD.mjs.map