@navios/openapi-bun 0.7.0 → 0.8.0

package/lib/index.cjs

@@ -1,4 +1,4 @@
-let node_module = require("node:module");
+let node_async_hooks = require("node:async_hooks");
 let _navios_builder = require("@navios/builder");
 let _navios_core = require("@navios/core");
 let _navios_openapi = require("@navios/openapi");
@@ -6,8 +6,7 @@ let zod = require("zod");
 let yaml = require("yaml");
 let _scalar_core_libs_html_rendering = require("@scalar/core/libs/html-rendering");
 
-//#region ../di/lib/testing-BG_fa9TJ.mjs
-var __require = /* @__PURE__ */ (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+//#region ../di/lib/container-DAKOvAgr.mjs
 let InjectableScope = /* @__PURE__ */ function(InjectableScope$1) {
 	/**
 	* Singleton scope: The instance is created once and shared across the application.
@@ -99,6 +98,7 @@ var FactoryInjectionToken = class {
 	}
 };
 var Registry = class {
+	parent;
 	factories = /* @__PURE__ */ new Map();
 	constructor(parent) {
 		this.parent = parent;
@@ -127,6 +127,23 @@ var Registry = class {
 	delete(token) {
 		this.factories.delete(token.id);
 	}
+	/**
+	* Updates the scope of an already registered factory.
+	* This is useful when you need to dynamically change a service's scope
+	* (e.g., when a singleton controller has request-scoped dependencies).
+	*
+	* @param token The injection token to update
+	* @param scope The new scope to set
+	* @returns true if the scope was updated, false if the token was not found
+	*/ updateScope(token, scope) {
+		const factory = this.factories.get(token.id);
+		if (factory) {
+			factory.scope = scope;
+			return true;
+		}
+		if (this.parent) return this.parent.updateScope(token, scope);
+		return false;
+	}
 };
 const globalRegistry = new Registry();
 const InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
@@ -181,86 +198,29 @@ var DIError = class DIError$1 extends Error {
 		return new DIError$1(DIErrorCode.CircularDependency, `Circular dependency detected: ${cycleStr}`, { cycle });
 	}
 };
-/**
-* A synchronous-only polyfill for AsyncLocalStorage.
-*
-* This provides the same API as Node's AsyncLocalStorage but only works
-* for synchronous code paths. It uses a simple stack-based approach.
-*
-* Limitations:
-* - Context does NOT propagate across async boundaries (setTimeout, promises, etc.)
-* - Only suitable for environments where DI resolution is synchronous
-*
-* This is acceptable for browser environments where:
-* 1. Constructors are typically synchronous
-* 2. Circular dependency detection mainly needs sync tracking
-*/ var SyncLocalStorage = class {
-	stack = [];
-	/**
-	* Runs a function within the given store context.
-	* The context is only available synchronously within the function.
-	*/ run(store, fn) {
-		this.stack.push(store);
-		try {
-			return fn();
-		} finally {
-			this.stack.pop();
-		}
-	}
-	/**
-	* Gets the current store value, or undefined if not in a context.
-	*/ getStore() {
-		return this.stack.length > 0 ? this.stack[this.stack.length - 1] : void 0;
-	}
-	/**
-	* Exits the current context and runs the function without any store.
-	* This matches AsyncLocalStorage.exit() behavior.
-	*/ exit(fn) {
-		const savedStack = this.stack;
-		this.stack = [];
-		try {
-			return fn();
-		} finally {
-			this.stack = savedStack;
+const isProduction$1 = process.env.NODE_ENV === "production";
+let loadedModule = null;
+function getModule() {
+	if (loadedModule) return loadedModule;
+	if (isProduction$1) {
+		class NoopLocalStorage {
+			run(_store, fn) {
+				return fn();
+			}
+			getStore() {}
 		}
-	}
-};
-/**
-* Cross-platform AsyncLocalStorage wrapper.
-*
-* Provides AsyncLocalStorage on Node.js/Bun and falls back to
-* a synchronous-only polyfill in browser environments.
-*/
-/**
-* Detects if we're running in a Node.js-like environment with async_hooks support.
-*/ function hasAsyncHooksSupport() {
-	if (typeof process !== "undefined" && process.versions && process.versions.node) return true;
-	if (typeof process !== "undefined" && process.versions && "bun" in process.versions) return true;
-	if (typeof globalThis.Deno !== "undefined") return true;
-	return false;
-}
-let AsyncLocalStorageClass = null;
-let initialized = false;
-/**
-* Gets the appropriate AsyncLocalStorage implementation for the current environment.
-*
-* - On Node.js/Bun/Deno: Returns the native AsyncLocalStorage
-* - On browsers: Returns SyncLocalStorage polyfill
-*/ function getAsyncLocalStorageClass() {
-	if (initialized) return AsyncLocalStorageClass;
-	initialized = true;
-	if (hasAsyncHooksSupport()) try {
-		AsyncLocalStorageClass = __require("node:async_hooks").AsyncLocalStorage;
-	} catch {
-		AsyncLocalStorageClass = SyncLocalStorage;
-	}
-	else AsyncLocalStorageClass = SyncLocalStorage;
-	return AsyncLocalStorageClass;
+		loadedModule = {
+			createAsyncLocalStorage: () => new NoopLocalStorage(),
+			isUsingNativeAsyncLocalStorage: () => false
+		};
+	} else loadedModule = {
+		createAsyncLocalStorage: () => new node_async_hooks.AsyncLocalStorage(),
+		isUsingNativeAsyncLocalStorage: () => true
+	};
+	return loadedModule;
 }
-/**
-* Creates a new AsyncLocalStorage instance appropriate for the current environment.
-*/ function createAsyncLocalStorage() {
-	return new (getAsyncLocalStorageClass())();
+function createAsyncLocalStorage() {
+	return getModule().createAsyncLocalStorage();
 }
 /**
 * AsyncLocalStorage for tracking the current resolution context.
@@ -268,7 +228,16 @@ let initialized = false;
 * This allows tracking which service is being instantiated even across
 * async boundaries (like when inject() is called inside a constructor).
 * Essential for circular dependency detection.
-*/ const resolutionContext = createAsyncLocalStorage();
+*
+* The actual implementation varies by environment:
+* - Production: No-op (returns undefined, run() just calls fn directly)
+* - Development: Real AsyncLocalStorage with full async tracking
+* - Browser: SyncLocalStorage for synchronous-only tracking
+*/ let resolutionContext = null;
+function getResolutionContext() {
+	if (!resolutionContext) resolutionContext = createAsyncLocalStorage();
+	return resolutionContext;
+}
 /**
 * Runs a function within a resolution context.
 *
@@ -279,7 +248,7 @@ let initialized = false;
 * @param getHolder Function to retrieve holders by name
 * @param fn The function to run within the context
 */ function withResolutionContext(waiterHolder, getHolder, fn) {
-	return resolutionContext.run({
+	return getResolutionContext().run({
 		waiterHolder,
 		getHolder
 	}, fn);
@@ -290,7 +259,7 @@ let initialized = false;
 * Returns undefined if we're not inside a resolution context
 * (e.g., when resolving a top-level service that has no parent).
 */ function getCurrentResolutionContext() {
-	return resolutionContext.getStore();
+	return getResolutionContext().getStore();
 }
 /**
 * Runs a function outside any resolution context.
@@ -300,7 +269,7 @@ let initialized = false;
 *
 * @param fn The function to run without resolution context
 */ function withoutResolutionContext(fn) {
-	return resolutionContext.run(void 0, fn);
+	return getResolutionContext().run(void 0, fn);
 }
 function getInjectors() {
 	let currentFactoryContext = null;
@@ -425,11 +394,17 @@ const optional = defaultInjectors.optional;
 const wrapSyncInit = defaultInjectors.wrapSyncInit;
 const provideFactoryContext = defaultInjectors.provideFactoryContext;
 /**
+* Whether we're running in production mode.
+* In production, circular dependency detection is skipped for performance.
+*/ const isProduction = process.env.NODE_ENV === "production";
+/**
 * Detects circular dependencies by analyzing the waitingFor relationships
 * between service holders.
 *
 * Uses BFS to traverse the waitingFor graph starting from a target holder
 * and checks if following the chain leads back to the waiter, indicating a circular dependency.
+*
+* Note: In production (NODE_ENV === 'production'), detection is skipped for performance.
 */ var CircularDetector = class {
 	/**
 	* Detects if waiting for `targetName` from `waiterName` would create a cycle.
@@ -437,11 +412,14 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 	* This works by checking if `targetName` (or any holder in its waitingFor chain)
 	* is currently waiting for `waiterName`. If so, waiting would create a deadlock.
 	*
+	* In production mode, this always returns null to skip the BFS traversal overhead.
+	*
 	* @param waiterName The name of the holder that wants to wait
 	* @param targetName The name of the holder being waited on
 	* @param getHolder Function to retrieve a holder by name
 	* @returns The cycle path if a cycle is detected, null otherwise
 	*/ static detectCycle(waiterName, targetName, getHolder) {
+		if (isProduction) return null;
 		const visited = /* @__PURE__ */ new Set();
 		const queue = [{
 			name: targetName,
@@ -487,9 +465,14 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 */ var BaseHolderManager = class BaseHolderManager$1 {
 	logger;
 	_holders;
+	/**
+	* Reverse dependency index: maps a dependency name to the set of holder names that depend on it.
+	* This allows O(1) lookup of dependents instead of O(n) iteration.
+	*/ _dependents;
 	constructor(logger = null) {
 		this.logger = logger;
 		this._holders = /* @__PURE__ */ new Map();
+		this._dependents = /* @__PURE__ */ new Map();
 	}
 	/**
 	* Protected getter for accessing the holders map from subclasses.
@@ -497,23 +480,81 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 		return this._holders;
 	}
 	/**
-	* Deletes a holder by name.
+	* Deletes a holder by name and cleans up the reverse dependency index.
 	* @param name The name of the holder to delete
 	* @returns true if the holder was deleted, false if it didn't exist
 	*/ delete(name) {
+		const holder = this._holders.get(name);
+		if (holder) this.removeFromDependentsIndex(name, holder.deps);
 		return this._holders.delete(name);
 	}
 	/**
+	* Registers a holder's dependencies in the reverse index.
+	* Call this after creating a holder with dependencies.
+	* @param holderName The name of the holder that has dependencies
+	* @param deps The set of dependency names
+	*/ registerDependencies(holderName, deps) {
+		for (const dep of deps) {
+			let dependents = this._dependents.get(dep);
+			if (!dependents) {
+				dependents = /* @__PURE__ */ new Set();
+				this._dependents.set(dep, dependents);
+			}
+			dependents.add(holderName);
+		}
+	}
+	/**
+	* Removes a holder from the reverse dependency index.
+	* @param holderName The name of the holder to remove
+	* @param deps The set of dependency names to clean up
+	*/ removeFromDependentsIndex(holderName, deps) {
+		for (const dep of deps) {
+			const dependents = this._dependents.get(dep);
+			if (dependents) {
+				dependents.delete(holderName);
+				if (dependents.size === 0) this._dependents.delete(dep);
+			}
+		}
+	}
+	/**
+	* Gets all holder names that depend on the given instance name.
+	* O(1) lookup using the reverse dependency index.
+	* @param instanceName The instance name to find dependents for
+	* @returns Array of holder names that depend on this instance
+	*/ getDependents(instanceName) {
+		const dependents = this._dependents.get(instanceName);
+		return dependents ? Array.from(dependents) : [];
+	}
+	/**
 	* Filters holders based on a predicate function.
 	* @param predicate Function to test each holder
 	* @returns A new Map containing only the holders that match the predicate
+	* @deprecated Use forEachHolder() for iteration to avoid allocations
 	*/ filter(predicate) {
-		return new Map([...this._holders].filter(([key, value]) => predicate(value, key)));
+		const result = /* @__PURE__ */ new Map();
+		for (const [key, value] of this._holders) if (predicate(value, key)) result.set(key, value);
+		return result;
+	}
+	/**
+	* Iterates over holders with a callback. More efficient than filter() as it
+	* avoids creating intermediate arrays and Maps.
+	* @param callback Function called for each holder with (holder, name)
+	*/ forEachHolder(callback) {
+		for (const [name, holder] of this._holders) callback(holder, name);
 	}
 	/**
-	* Clears all holders from this manager.
+	* Finds the first holder matching a predicate. More efficient than filter()
+	* when only one result is needed.
+	* @param predicate Function to test each holder
+	* @returns The first matching holder or undefined
+	*/ findHolder(predicate) {
+		for (const [name, holder] of this._holders) if (predicate(holder, name)) return holder;
+	}
+	/**
+	* Clears all holders from this manager and the reverse dependency index.
 	*/ clear() {
 		this._holders.clear();
+		this._dependents.clear();
 	}
 	/**
 	* Gets the number of holders currently managed.
@@ -597,12 +638,14 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 				if (waiterHolder && getHolder) {
 					const cycle = CircularDetector.detectCycle(waiterHolder.name, holder.name, getHolder);
 					if (cycle) return [DIError.circularDependency(cycle)];
-					waiterHolder.waitingFor.add(holder.name);
+					if (process.env.NODE_ENV !== "production") waiterHolder.waitingFor.add(holder.name);
 				}
 				try {
 					await holder.creationPromise;
 				} finally {
-					if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+					if (process.env.NODE_ENV !== "production") {
+						if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+					}
 				}
 				return BaseHolderManager$1.waitForHolderReady(holder, waiterHolder, getHolder);
 			case InstanceStatus.Destroying: return [DIError.instanceDestroying(holder.name)];
@@ -717,10 +760,11 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 		return null;
 	}
 	findDependents(instanceName) {
-		const dependents = [];
-		for (const [name, holder] of this.contextHolder.holders) if (holder.deps.has(instanceName)) dependents.push(name);
-		for (const [name, holder] of this.holderManager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
-		return dependents;
+		const requestDependents = this.contextHolder.getDependents(instanceName);
+		const singletonDependents = this.holderManager.getDependents(instanceName);
+		if (requestDependents.length === 0) return singletonDependents;
+		if (singletonDependents.length === 0) return requestDependents;
+		return [...requestDependents, ...singletonDependents];
 	}
 };
 /**
@@ -856,7 +900,8 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 	*/ async resolveRequestScoped(token, args) {
 		const instanceName = this.parent.getServiceLocator().getInstanceIdentifier(token, args);
 		const existingHolder = this.requestContextHolder.get(instanceName);
-		if (existingHolder) {
+		if (existingHolder) if (existingHolder.status === InstanceStatus.Error) this.requestContextHolder.delete(instanceName);
+		else {
 			const [error, readyHolder] = await BaseHolderManager.waitForHolderReady(existingHolder);
 			if (error) throw error;
 			return readyHolder.instance;
@@ -918,16 +963,13 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 		return this.manager.getAllNames();
 	}
 	forEach(callback) {
-		for (const [name, holder] of this.manager.filter(() => true)) callback(name, holder);
+		this.manager.forEachHolder((holder, name) => callback(name, holder));
 	}
 	findByInstance(instance) {
-		for (const [, holder] of this.manager.filter((h) => h.instance === instance)) return holder;
-		return null;
+		return this.manager.findHolder((h) => h.instance === instance) ?? null;
 	}
 	findDependents(instanceName) {
-		const dependents = [];
-		for (const [name, holder] of this.manager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
-		return dependents;
+		return this.manager.getDependents(instanceName);
 	}
 };
 /**
@@ -1020,7 +1062,12 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 					return [void 0, readyResult[1].instance];
 				}
 				return null;
-			default: return [error];
+			default:
+				if (holder) {
+					this.logger?.log(`[InstanceResolver] Removing failed instance ${instanceName} from storage to allow retry`);
+					storage.delete(instanceName);
+				}
+				return null;
 		}
 	}
 	/**
@@ -1147,6 +1194,8 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 	*/ async handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, scopedContainer) {
 		holder.instance = instance;
 		holder.status = InstanceStatus.Created;
+		if (ctx.deps.size > 0) if (scopedContainer) scopedContainer.getRequestContextHolder().registerDependencies(instanceName, ctx.deps);
+		else this.manager.registerDependencies(instanceName, ctx.deps);
 		if (ctx.deps.size > 0) ctx.deps.forEach((dependency) => {
 			holder.destroyListeners.push(this.serviceLocator.getEventBus().on(dependency, "destroy", () => {
 				this.logger?.log(`[InstanceResolver] Dependency ${dependency} destroyed, invalidating ${instanceName}`);
@@ -1587,12 +1636,42 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 	}
 };
 /**
+* Simple LRU cache for instance name generation.
+* Uses a Map which maintains insertion order for efficient LRU eviction.
+*/ var InstanceNameCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	constructor(maxSize = 1e3) {
+		this.maxSize = maxSize;
+	}
+	get(key) {
+		const value = this.cache.get(key);
+		if (value !== void 0) {
+			this.cache.delete(key);
+			this.cache.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		else if (this.cache.size >= this.maxSize) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey !== void 0) this.cache.delete(firstKey);
+		}
+		this.cache.set(key, value);
+	}
+	clear() {
+		this.cache.clear();
+	}
+};
+/**
 * Handles token validation, normalization, and instance name generation.
 *
 * Provides utilities for resolving tokens to their underlying InjectionToken,
 * validating arguments against schemas, and generating unique instance identifiers.
 */ var TokenProcessor = class {
 	logger;
+	instanceNameCache = new InstanceNameCache();
 	constructor(logger = null) {
 		this.logger = logger;
 	}
@@ -1651,10 +1730,16 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 	}
 	/**
 	* Generates a unique instance name based on token and arguments.
+	* Results are cached using an LRU cache for performance.
 	*/ generateInstanceName(token, args) {
 		if (!args) return token.toString();
-		const formattedArgs = Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",");
-		return `${token.toString()}:${formattedArgs.replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+		const tokenStr = token.toString();
+		const cacheKey = `${tokenStr}:${JSON.stringify(args)}`;
+		const cached = this.instanceNameCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const result = `${tokenStr}:${Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",").replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+		this.instanceNameCache.set(cacheKey, result);
+		return result;
 	}
 	/**
 	* Formats a single argument value for instance name generation.
@@ -1796,7 +1881,7 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 		return this.tokenProcessor.generateInstanceName(token, args);
 	}
 };
-function applyDecs2203RFactory$1$1() {
+function applyDecs2203RFactory$5() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -2070,18 +2155,18 @@ function applyDecs2203RFactory$1$1() {
 		};
 	};
 }
-function _apply_decs_2203_r$1$1(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$1$1 = applyDecs2203RFactory$1$1())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$5(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$5 = applyDecs2203RFactory$5())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$1$1, _initClass$1$1;
-let _Container$1;
-_dec$1$1 = Injectable$1();
+var _dec$2, _initClass$2;
+let _Container;
+_dec$2 = Injectable$1();
 (class {
 	registry;
 	logger;
 	injectors;
 	static {
-		({c: [_Container$1, _initClass$1$1]} = _apply_decs_2203_r$1$1(this, [], [_dec$1$1]));
+		({c: [_Container, _initClass$2]} = _apply_decs_2203_r$5(this, [], [_dec$2]));
 	}
 	constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
 		this.registry = registry;
@@ -2093,7 +2178,7 @@ _dec$1$1 = Injectable$1();
 	serviceLocator;
 	activeRequestIds = /* @__PURE__ */ new Set();
 	registerSelf() {
-		const token = getInjectableToken(_Container$1);
+		const token = getInjectableToken(_Container);
 		const instanceName = this.serviceLocator.getInstanceIdentifier(token);
 		this.serviceLocator.getManager().storeCreatedHolder(instanceName, this, InjectableType.Class, InjectableScope.Singleton);
 	}
@@ -2210,341 +2295,6 @@ _dec$1$1 = Injectable$1();
 	*/ clear() {
 		return this.serviceLocator.clearAll();
 	}
-	static {
-		_initClass$1$1();
-	}
-});
-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$2, _initClass$2, _Container;
-/**
-* A binding builder for the TestContainer that allows chaining binding operations.
-*/ var TestBindingBuilder = class {
-	container;
-	token;
-	constructor(container, token) {
-		this.container = container;
-		this.token = token;
-	}
-	/**
-	* Binds the token to a specific value.
-	* This is useful for testing with mock values or constants.
-	* @param value The value to bind to the token
-	*/ toValue(value) {
-		const instanceName = this.container.getServiceLocator().getInstanceIdentifier(this.token);
-		this.container.getServiceLocator().getManager().storeCreatedHolder(instanceName, value, InjectableType.Class, InjectableScope.Singleton);
-		return this.container;
-	}
-	/**
-	* Binds the token to a class constructor.
-	* @param target The class constructor to bind to
-	*/ toClass(target) {
-		this.container["registry"].set(this.token, InjectableScope.Singleton, target, InjectableType.Class);
-		return this.container;
-	}
-};
-let _TestContainer;
-_dec$2 = Injectable$1();
-(class extends (_Container = _Container$1) {
-	static {
-		({c: [_TestContainer, _initClass$2]} = _apply_decs_2203_r$5(this, [], [_dec$2], _Container));
-	}
-	constructor(registry = globalRegistry, logger = null, injectors = void 0) {
-		super(registry, logger, injectors);
-	}
-	bind(token) {
-		let realToken = token;
-		if (typeof token === "function") realToken = getInjectableToken(token);
-		return new TestBindingBuilder(this, realToken);
-	}
-	bindValue(token, value) {
-		return this.bind(token).toValue(value);
-	}
-	bindClass(token, target) {
-		return this.bind(token).toClass(target);
-	}
-	/**
-	* Creates a new TestContainer instance with the same configuration.
-	* This is useful for creating isolated test containers.
-	* @returns A new TestContainer instance
-	*/ createChild() {
-		return new _TestContainer(this.registry, this.logger, this.injectors);
-	}
 	static {
 		_initClass$2();
 	}