@navios/core 0.7.1 → 0.8.0

package/lib/{src-QnxR5b7c.cjs → src-B6eISODM.cjs}

@@ -25,7 +25,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_use_guards_decorator = require('./use-guards.decorator-B6q_N0sf.cjs');
+const require_use_guards_decorator = require('./use-guards.decorator-COR-9mZY.cjs');
 let _navios_di = require("@navios/di");
 let node_process = require("node:process");
 let zod_v4 = require("zod/v4");
@@ -138,6 +138,15 @@ 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.
 *
@@ -157,22 +166,42 @@ const isSymbol = (val) => typeof val === "symbol";
 * // Get current request ID (returns undefined if not in a request context)
 * const currentId = getRequestId()
 * ```
-*/ const requestIdStore = new node_async_hooks.AsyncLocalStorage();
+*/ let requestIdStore = null;
+function getRequestIdStore() {
+	if (!requestIdStore) requestIdStore = new node_async_hooks.AsyncLocalStorage();
+	return requestIdStore;
+}
+/**
+* Whether request ID propagation is enabled.
+* When disabled, runWithRequestId is a pass-through for better performance.
+*/ let requestIdEnabled = false;
+/**
+* Enables or disables request ID propagation.
+* Called by NaviosFactory based on the enableRequestId option.
+*
+* @param enabled - Whether to enable request ID propagation
+*/ function setRequestIdEnabled(enabled) {
+	requestIdEnabled = enabled;
+}
 /**
 * Runs a function with a request ID in the async local storage context.
+* If request ID propagation is disabled, the function is called directly
+* without AsyncLocalStorage overhead.
 *
 * @param requestId - The request ID to set for this context
 * @param fn - The function to run within this context
 * @returns The return value of the function
 */ function runWithRequestId(requestId, fn) {
-	return requestIdStore.run(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() {
-	return requestIdStore.getStore();
+	if (!requestIdEnabled) return;
+	return getRequestIdStore().getStore();
 }
 
 //#endregion
@@ -200,7 +229,7 @@ const isSymbol = (val) => typeof val === "symbol";
 
 //#endregion
 //#region src/logger/console-logger.service.mts
-function applyDecs2203RFactory$13() {
+function applyDecs2203RFactory$14() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -474,10 +503,10 @@ function applyDecs2203RFactory$13() {
 		};
 	};
 }
-function _apply_decs_2203_r$13(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$13 = applyDecs2203RFactory$13())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$14(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$14 = applyDecs2203RFactory$14())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$13, _initClass$13;
+var _dec$14, _initClass$14;
 const DEFAULT_DEPTH = 5;
 const DEFAULT_LOG_LEVELS = [
 	"log",
@@ -496,10 +525,10 @@ const dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
 	month: "2-digit"
 });
 let _ConsoleLogger;
-_dec$13 = (0, _navios_di.Injectable)({ token: LoggerOutput });
+_dec$14 = (0, _navios_di.Injectable)({ token: LoggerOutput });
 var ConsoleLogger = class {
 	static {
-		({c: [_ConsoleLogger, _initClass$13]} = _apply_decs_2203_r$13(this, [], [_dec$13]));
+		({c: [_ConsoleLogger, _initClass$14]} = _apply_decs_2203_r$14(this, [], [_dec$14]));
 	}
 	/**
 	* The options of the logger.
@@ -748,13 +777,13 @@ var ConsoleLogger = class {
 		}
 	}
 	static {
-		_initClass$13();
+		_initClass$14();
 	}
 };
 
 //#endregion
 //#region src/logger/logger.service.mts
-function applyDecs2203RFactory$12() {
+function applyDecs2203RFactory$13() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -1028,15 +1057,15 @@ function applyDecs2203RFactory$12() {
 		};
 	};
 }
-function _apply_decs_2203_r$12(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$12 = applyDecs2203RFactory$12())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$13(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$13 = applyDecs2203RFactory$13())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$12, _initClass$12;
+var _dec$13, _initClass$13;
 let _LoggerInstance;
-_dec$12 = (0, _navios_di.Injectable)({ token: Logger });
+_dec$13 = (0, _navios_di.Injectable)({ token: Logger });
 var LoggerInstance = class {
 	static {
-		({c: [_LoggerInstance, _initClass$12]} = _apply_decs_2203_r$12(this, [], [_dec$12]));
+		({c: [_LoggerInstance, _initClass$13]} = _apply_decs_2203_r$13(this, [], [_dec$13]));
 	}
 	constructor(config = {}) {
 		this.context = config.context;
@@ -1049,8 +1078,6 @@ var LoggerInstance = class {
 	}
 	log(message, ...optionalParams) {
 		optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-		console.log("log", message, optionalParams);
-		console.log("localInstance", this.localInstance);
 		this.localInstance?.log(message, ...optionalParams);
 	}
 	warn(message, ...optionalParams) {
@@ -1070,13 +1097,13 @@ var LoggerInstance = class {
 		this.localInstance?.fatal?.(message, ...optionalParams);
 	}
 	static {
-		_initClass$12();
+		_initClass$13();
 	}
 };
 
 //#endregion
 //#region src/config/config.service.mts
-function applyDecs2203RFactory$11() {
+function applyDecs2203RFactory$12() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -1350,10 +1377,10 @@ function applyDecs2203RFactory$11() {
 		};
 	};
 }
-function _apply_decs_2203_r$11(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$11 = applyDecs2203RFactory$11())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$12(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$12 = applyDecs2203RFactory$12())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$11, _initClass$11;
+var _dec$12, _initClass$12;
 /**
 * Schema for validating configuration service options.
 */ const ConfigServiceOptionsSchema = zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown());
@@ -1361,11 +1388,11 @@ var _dec$11, _initClass$11;
 * Injection token for ConfigService.
 */ const ConfigServiceToken = _navios_di.InjectionToken.create(Symbol.for("ConfigService"), ConfigServiceOptionsSchema);
 let _ConfigService;
-_dec$11 = (0, _navios_di.Injectable)({ token: ConfigServiceToken });
+_dec$12 = (0, _navios_di.Injectable)({ token: ConfigServiceToken });
 var ConfigService = class {
 	config;
 	static {
-		({c: [_ConfigService, _initClass$11]} = _apply_decs_2203_r$11(this, [], [_dec$11]));
+		({c: [_ConfigService, _initClass$12]} = _apply_decs_2203_r$12(this, [], [_dec$12]));
 	}
 	/**
 	* Creates a new ConfigService instance.
@@ -1447,7 +1474,7 @@ var ConfigService = class {
 		return value;
 	}
 	static {
-		_initClass$11();
+		_initClass$12();
 	}
 };
 
@@ -1707,6 +1734,360 @@ var ConfigService = class {
 	}
 };
 
+//#endregion
+//#region src/services/instance-resolver.service.mts
+function applyDecs2203RFactory$11() {
+	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$11(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$11 = applyDecs2203RFactory$11())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$11, _initClass$11;
+let _InstanceResolverService;
+_dec$11 = (0, _navios_di.Injectable)();
+var InstanceResolverService = class {
+	static {
+		({c: [_InstanceResolverService, _initClass$11]} = _apply_decs_2203_r$11(this, [], [_dec$11]));
+	}
+	container = (0, _navios_di.inject)(_navios_di.Container);
+	/**
+	* Attempts to resolve a class instance, automatically detecting if it needs
+	* request scope based on its dependencies.
+	*
+	* @param classType - The class to resolve
+	* @returns A resolution result containing either a cached instance or resolver function
+	*/ async resolve(classType) {
+		let cachedInstance = null;
+		try {
+			cachedInstance = await this.container.get(classType);
+		} catch {
+			const token = (0, _navios_di.getInjectableToken)(classType);
+			this.container.getRegistry().updateScope(token, _navios_di.InjectableScope.Request);
+		}
+		return {
+			cached: cachedInstance !== null,
+			instance: cachedInstance,
+			resolve: (scoped) => scoped.get(classType)
+		};
+	}
+	/**
+	* Attempts to resolve multiple class instances, automatically detecting if any need
+	* request scope based on their dependencies.
+	*
+	* Returns `cached: true` only if ALL classes can be resolved as singletons.
+	* If any class has request-scoped dependencies, returns `cached: false`.
+	*
+	* @param classTypes - The classes to resolve
+	* @returns A resolution result containing either all cached instances or resolver function
+	*/ async resolveMany(classTypes) {
+		if (classTypes.length === 0) return {
+			cached: true,
+			instances: [],
+			classTypes: [],
+			resolve: async () => []
+		};
+		const results = await Promise.all(classTypes.map(async (classType) => {
+			try {
+				return {
+					success: true,
+					instance: await this.container.get(classType)
+				};
+			} catch {
+				const token = (0, _navios_di.getInjectableToken)(classType);
+				this.container.getRegistry().updateScope(token, _navios_di.InjectableScope.Request);
+				return {
+					success: false,
+					instance: null
+				};
+			}
+		}));
+		const allCached = results.every((r) => r.success);
+		return {
+			cached: allCached,
+			instances: allCached ? results.map((r) => r.instance) : null,
+			classTypes,
+			resolve: (scoped) => Promise.all(classTypes.map((classType) => scoped.get(classType)))
+		};
+	}
+	static {
+		_initClass$11();
+	}
+};
+/**
+* @deprecated Use InstanceResolverService instead
+*/ const ControllerResolverService = _InstanceResolverService;
+
 //#endregion
 //#region src/services/guard-runner.service.mts
 function applyDecs2203RFactory$10() {
@@ -1994,23 +2375,40 @@ var GuardRunnerService = class {
 		({c: [_GuardRunnerService, _initClass$10]} = _apply_decs_2203_r$10(this, [], [_dec$10]));
 	}
 	logger = (0, _navios_di.inject)(Logger, { context: _GuardRunnerService.name });
-	async runGuards(allGuards, executionContext, context) {
-		let canActivate = true;
-		for (const guard of Array.from(allGuards).reverse()) {
+	/**
+	* 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()`);
-			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);
-					executionContext.getReply().status(500).send({ message: "Internal server error" });
-					return false;
-				}
+			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);
+				executionContext.getReply().status(500).send({ message: "Internal server error" });
+				return false;
 			}
 		}
 		if (!canActivate) {
@@ -5444,6 +5842,8 @@ var NaviosApplication = class {
 	* ```
 	*/ static async create(appModule, options = { adapter: [] }) {
 		const container = options.container ?? new _navios_di.Container();
+		if (options.enableRequestId === true) setRequestIdEnabled(true);
+		container.getServiceLocator().getManager().storeCreatedHolder(require_use_guards_decorator.NaviosOptionsToken.toString(), options, _navios_di.InjectableType.Class, _navios_di.InjectableScope.Singleton);
 		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);
@@ -5503,6 +5903,12 @@ Object.defineProperty(exports, 'ConflictException', {
     return ConflictException;
   }
 });
+Object.defineProperty(exports, 'ControllerResolverService', {
+  enumerable: true,
+  get: function () {
+    return ControllerResolverService;
+  }
+});
 Object.defineProperty(exports, 'EnvConfigProvider', {
   enumerable: true,
   get: function () {
@@ -5593,6 +5999,12 @@ Object.defineProperty(exports, '_HttpAdapterFactory', {
     return _HttpAdapterFactory;
   }
 });
+Object.defineProperty(exports, '_InstanceResolverService', {
+  enumerable: true,
+  get: function () {
+    return _InstanceResolverService;
+  }
+});
 Object.defineProperty(exports, '_LoggerInstance', {
   enumerable: true,
   get: function () {
@@ -5677,6 +6089,12 @@ Object.defineProperty(exports, 'filterLogLevels', {
     return filterLogLevels;
   }
 });
+Object.defineProperty(exports, 'generateRequestId', {
+  enumerable: true,
+  get: function () {
+    return generateRequestId;
+  }
+});
 Object.defineProperty(exports, 'getRequestId', {
   enumerable: true,
   get: function () {
@@ -5773,16 +6191,16 @@ Object.defineProperty(exports, 'provideConfig', {
     return provideConfig;
   }
 });
-Object.defineProperty(exports, 'requestIdStore', {
+Object.defineProperty(exports, 'runWithRequestId', {
   enumerable: true,
   get: function () {
-    return requestIdStore;
+    return runWithRequestId;
   }
 });
-Object.defineProperty(exports, 'runWithRequestId', {
+Object.defineProperty(exports, 'setRequestIdEnabled', {
   enumerable: true,
   get: function () {
-    return runWithRequestId;
+    return setRequestIdEnabled;
   }
 });
 Object.defineProperty(exports, 'stripEndSlash', {
@@ -5797,4 +6215,4 @@ Object.defineProperty(exports, 'yellow', {
     return yellow;
   }
 });
-//# sourceMappingURL=src-QnxR5b7c.cjs.map
+//# sourceMappingURL=src-B6eISODM.cjs.map