@navios/openapi-bun 0.8.0 → 0.9.0

package/lib/index.cjs

@@ -1,4 +1,3 @@
-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,2616 +5,6 @@ let zod = require("zod");
 let yaml = require("yaml");
 let _scalar_core_libs_html_rendering = require("@scalar/core/libs/html-rendering");
 
-//#region ../di/lib/container-DAKOvAgr.mjs
-let InjectableScope = /* @__PURE__ */ function(InjectableScope$1) {
-	/**
-	* Singleton scope: The instance is created once and shared across the application.
-	*/ InjectableScope$1["Singleton"] = "Singleton";
-	/**
-	* Instance scope: A new instance is created for each injection.
-	*/ InjectableScope$1["Transient"] = "Transient";
-	/**
-	* Request scope: The instance is created once per request and shared within that request context.
-	*/ InjectableScope$1["Request"] = "Request";
-	return InjectableScope$1;
-}({});
-let InjectableType = /* @__PURE__ */ function(InjectableType$1) {
-	InjectableType$1["Class"] = "Class";
-	InjectableType$1["Factory"] = "Factory";
-	return InjectableType$1;
-}({});
-var InjectionToken$2 = class InjectionToken$3 {
-	name;
-	schema;
-	id = globalThis.crypto.randomUUID();
-	formattedName = null;
-	constructor(name, schema) {
-		this.name = name;
-		this.schema = schema;
-	}
-	static create(name, schema) {
-		return new InjectionToken$3(name, schema);
-	}
-	static bound(token, value) {
-		return new BoundInjectionToken(token, value);
-	}
-	static factory(token, factory) {
-		return new FactoryInjectionToken(token, factory);
-	}
-	static refineType(token) {
-		return token;
-	}
-	toString() {
-		if (this.formattedName) return this.formattedName;
-		const { name } = this;
-		if (typeof name === "function") this.formattedName = `${name.name}(${this.id})`;
-		else if (typeof name === "symbol") this.formattedName = `${name.toString()}(${this.id})`;
-		else this.formattedName = `${name}(${this.id})`;
-		return this.formattedName;
-	}
-};
-var BoundInjectionToken = class {
-	token;
-	value;
-	id;
-	name;
-	schema;
-	constructor(token, value) {
-		this.token = token;
-		this.value = value;
-		this.name = token.name;
-		this.id = token.id;
-		this.schema = token.schema;
-	}
-	toString() {
-		return this.token.toString();
-	}
-};
-var FactoryInjectionToken = class {
-	token;
-	factory;
-	value;
-	resolved = false;
-	id;
-	name;
-	schema;
-	constructor(token, factory) {
-		this.token = token;
-		this.factory = factory;
-		this.name = token.name;
-		this.id = token.id;
-		this.schema = token.schema;
-	}
-	async resolve(ctx) {
-		if (!this.value) {
-			this.value = await this.factory(ctx);
-			this.resolved = true;
-		}
-		return this.value;
-	}
-	toString() {
-		return this.token.toString();
-	}
-};
-var Registry = class {
-	parent;
-	factories = /* @__PURE__ */ new Map();
-	constructor(parent) {
-		this.parent = parent;
-	}
-	has(token) {
-		if (this.factories.has(token.id)) return true;
-		if (this.parent) return this.parent.has(token);
-		return false;
-	}
-	get(token) {
-		const factory = this.factories.get(token.id);
-		if (!factory) {
-			if (this.parent) return this.parent.get(token);
-			throw new Error(`[Registry] No factory found for ${token.toString()}`);
-		}
-		return factory;
-	}
-	set(token, scope, target, type) {
-		this.factories.set(token.id, {
-			scope,
-			originalToken: token,
-			target,
-			type
-		});
-	}
-	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");
-function Injectable$1({ scope = InjectableScope.Singleton, token, schema, registry = globalRegistry } = {}) {
-	return (target, context) => {
-		if (context && context.kind !== "class" || target instanceof Function && !context) throw new Error("[ServiceLocator] @Injectable decorator can only be used on classes.");
-		if (schema && token) throw new Error("[ServiceLocator] @Injectable decorator cannot have both a token and a schema");
-		let injectableToken = token ?? InjectionToken$2.create(target, schema);
-		registry.set(injectableToken, scope, target, InjectableType.Class);
-		target[InjectableTokenMeta] = injectableToken;
-		return target;
-	};
-}
-let DIErrorCode = /* @__PURE__ */ function(DIErrorCode$1) {
-	DIErrorCode$1["FactoryNotFound"] = "FactoryNotFound";
-	DIErrorCode$1["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
-	DIErrorCode$1["InstanceNotFound"] = "InstanceNotFound";
-	DIErrorCode$1["InstanceDestroying"] = "InstanceDestroying";
-	DIErrorCode$1["CircularDependency"] = "CircularDependency";
-	DIErrorCode$1["UnknownError"] = "UnknownError";
-	return DIErrorCode$1;
-}({});
-var DIError = class DIError$1 extends Error {
-	context;
-	constructor(code, message, context) {
-		super(message);
-		this.code = code;
-		this.message = message;
-		this.context = context;
-	}
-	static factoryNotFound(name) {
-		return new DIError$1(DIErrorCode.FactoryNotFound, `Factory ${name} not found`, { name });
-	}
-	static factoryTokenNotResolved(token) {
-		return new DIError$1(DIErrorCode.FactoryTokenNotResolved, `Factory token not resolved: ${token?.toString() ?? "unknown"}`, { token });
-	}
-	static instanceNotFound(name) {
-		return new DIError$1(DIErrorCode.InstanceNotFound, `Instance ${name} not found`, { name });
-	}
-	static instanceDestroying(name) {
-		return new DIError$1(DIErrorCode.InstanceDestroying, `Instance ${name} destroying`, { name });
-	}
-	static unknown(message, context) {
-		if (message instanceof Error) return new DIError$1(DIErrorCode.UnknownError, message.message, {
-			...context,
-			parent: message
-		});
-		return new DIError$1(DIErrorCode.UnknownError, message, context);
-	}
-	static circularDependency(cycle) {
-		const cycleStr = cycle.join(" -> ");
-		return new DIError$1(DIErrorCode.CircularDependency, `Circular dependency detected: ${cycleStr}`, { cycle });
-	}
-};
-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() {}
-		}
-		loadedModule = {
-			createAsyncLocalStorage: () => new NoopLocalStorage(),
-			isUsingNativeAsyncLocalStorage: () => false
-		};
-	} else loadedModule = {
-		createAsyncLocalStorage: () => new node_async_hooks.AsyncLocalStorage(),
-		isUsingNativeAsyncLocalStorage: () => true
-	};
-	return loadedModule;
-}
-function createAsyncLocalStorage() {
-	return getModule().createAsyncLocalStorage();
-}
-/**
-* AsyncLocalStorage for tracking the current resolution context.
-*
-* 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.
-*
-* 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.
-*
-* The context tracks which holder is currently being instantiated,
-* allowing circular dependency detection to work correctly.
-*
-* @param waiterHolder The holder being instantiated
-* @param getHolder Function to retrieve holders by name
-* @param fn The function to run within the context
-*/ function withResolutionContext(waiterHolder, getHolder, fn) {
-	return getResolutionContext().run({
-		waiterHolder,
-		getHolder
-	}, fn);
-}
-/**
-* Gets the current resolution context, if any.
-*
-* 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 getResolutionContext().getStore();
-}
-/**
-* Runs a function outside any resolution context.
-*
-* This is useful for async injections that should not participate
-* in circular dependency detection since they don't block.
-*
-* @param fn The function to run without resolution context
-*/ function withoutResolutionContext(fn) {
-	return getResolutionContext().run(void 0, fn);
-}
-function getInjectors() {
-	let currentFactoryContext = null;
-	function provideFactoryContext$1(context) {
-		const original = currentFactoryContext;
-		currentFactoryContext = context;
-		return original;
-	}
-	function getFactoryContext() {
-		if (!currentFactoryContext) throw new Error("[Injector] Trying to access injection context outside of a injectable context");
-		return currentFactoryContext;
-	}
-	let promiseCollector = null;
-	let injectState = null;
-	function getRequest(token, args, skipCycleTracking = false) {
-		if (!injectState) throw new Error("[Injector] Trying to make a request outside of a injectable context");
-		if (injectState.isFrozen) {
-			const idx = injectState.currentIndex++;
-			const request$1 = injectState.requests[idx];
-			if (request$1.token !== token) throw new Error(`[Injector] Wrong token order. Expected ${request$1.token.toString()} but got ${token.toString()}`);
-			return request$1;
-		}
-		let result = null;
-		let error = null;
-		const doInject = () => getFactoryContext().inject(token, args).then((r) => {
-			result = r;
-			return r;
-		}).catch((e) => {
-			error = e;
-		});
-		const request = {
-			token,
-			promise: skipCycleTracking ? withoutResolutionContext(doInject) : doInject(),
-			get result() {
-				return result;
-			},
-			get error() {
-				return error;
-			}
-		};
-		injectState.requests.push(request);
-		injectState.currentIndex++;
-		return request;
-	}
-	function asyncInject$1(token, args) {
-		if (!injectState) throw new Error("[Injector] Trying to access inject outside of a injectable context");
-		const request = getRequest(token[InjectableTokenMeta] ?? token, args, true);
-		return request.promise.then((result) => {
-			if (request.error) throw request.error;
-			return result;
-		});
-	}
-	function wrapSyncInit$1(cb) {
-		return (previousState) => {
-			const promises = [];
-			const originalPromiseCollector = promiseCollector;
-			const originalInjectState = injectState;
-			injectState = previousState ? {
-				...previousState,
-				currentIndex: 0
-			} : {
-				currentIndex: 0,
-				isFrozen: false,
-				requests: []
-			};
-			promiseCollector = (promise) => {
-				promises.push(promise);
-			};
-			const result = cb();
-			promiseCollector = originalPromiseCollector;
-			const newInjectState = {
-				...injectState,
-				isFrozen: true
-			};
-			injectState = originalInjectState;
-			return [
-				result,
-				promises,
-				newInjectState
-			];
-		};
-	}
-	function inject$1$1(token, args) {
-		const realToken = token[InjectableTokenMeta] ?? token;
-		if (!injectState) throw new Error("[Injector] Trying to access inject outside of a injectable context");
-		const instance = getFactoryContext().container.tryGetSync(realToken, args);
-		if (!instance) {
-			const request = getRequest(realToken, args);
-			if (request.error) throw request.error;
-			else if (request.result) return request.result;
-			if (promiseCollector) promiseCollector(request.promise);
-			return new Proxy({}, { get() {
-				throw new Error(`[Injector] Trying to access ${realToken.toString()} before it's initialized, please move the code to a onServiceInit method`);
-			} });
-		}
-		return instance;
-	}
-	function optional$1(token, args) {
-		try {
-			return inject$1$1(token, args);
-		} catch {
-			return null;
-		}
-	}
-	return {
-		asyncInject: asyncInject$1,
-		inject: inject$1$1,
-		optional: optional$1,
-		wrapSyncInit: wrapSyncInit$1,
-		provideFactoryContext: provideFactoryContext$1
-	};
-}
-function getInjectableToken(target) {
-	const token = target[InjectableTokenMeta];
-	if (!token) throw new Error(`[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`);
-	return token;
-}
-const defaultInjectors = getInjectors();
-const asyncInject = defaultInjectors.asyncInject;
-const inject$4 = defaultInjectors.inject;
-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.
-	*
-	* 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,
-			path: [waiterName, targetName]
-		}];
-		while (queue.length > 0) {
-			const { name: currentName, path } = queue.shift();
-			if (currentName === waiterName) return path;
-			if (visited.has(currentName)) continue;
-			visited.add(currentName);
-			const holder = getHolder(currentName);
-			if (!holder) continue;
-			for (const waitingForName of holder.waitingFor) if (!visited.has(waitingForName)) queue.push({
-				name: waitingForName,
-				path: [...path, waitingForName]
-			});
-		}
-		return null;
-	}
-	/**
-	* Formats a cycle path into a human-readable string.
-	*
-	* @param cycle The cycle path (array of service names)
-	* @returns Formatted string like "ServiceA -> ServiceB -> ServiceA"
-	*/ static formatCycle(cycle) {
-		return cycle.join(" -> ");
-	}
-};
-/**
-* Represents the lifecycle status of an instance holder.
-*/ let InstanceStatus = /* @__PURE__ */ function(InstanceStatus$1) {
-	/** Instance has been successfully created and is ready for use */ InstanceStatus$1["Created"] = "created";
-	/** Instance is currently being created (async initialization in progress) */ InstanceStatus$1["Creating"] = "creating";
-	/** Instance is being destroyed (cleanup in progress) */ InstanceStatus$1["Destroying"] = "destroying";
-	/** Instance creation failed with an error */ InstanceStatus$1["Error"] = "error";
-	return InstanceStatus$1;
-}({});
-/**
-* Abstract base class providing common functionality for managing InstanceHolder objects.
-*
-* Provides shared patterns for holder storage, creation, and lifecycle management
-* used by both singleton (HolderManager) and request-scoped (RequestContext) managers.
-*/ 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.
-	*/ get holders() {
-		return this._holders;
-	}
-	/**
-	* 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) {
-		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);
-	}
-	/**
-	* 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.
-	*/ size() {
-		return this._holders.size;
-	}
-	/**
-	* Creates a new holder with Creating status and a deferred creation promise.
-	* This is useful for creating placeholder holders that can be fulfilled later.
-	* @param name The name of the instance
-	* @param type The injectable type
-	* @param scope The injectable scope
-	* @param deps Optional set of dependencies
-	* @returns A tuple containing the deferred promise and the holder
-	*/ createCreatingHolder(name, type, scope, deps = /* @__PURE__ */ new Set()) {
-		const deferred = Promise.withResolvers();
-		return [deferred, {
-			status: InstanceStatus.Creating,
-			name,
-			instance: null,
-			creationPromise: deferred.promise,
-			destroyPromise: null,
-			type,
-			scope,
-			deps,
-			destroyListeners: [],
-			createdAt: Date.now(),
-			waitingFor: /* @__PURE__ */ new Set()
-		}];
-	}
-	/**
-	* Creates a new holder with Created status and an actual instance.
-	* This is useful for creating holders that already have their instance ready.
-	* @param name The name of the instance
-	* @param instance The actual instance to store
-	* @param type The injectable type
-	* @param scope The injectable scope
-	* @param deps Optional set of dependencies
-	* @returns The created holder
-	*/ createCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set()) {
-		return {
-			status: InstanceStatus.Created,
-			name,
-			instance,
-			creationPromise: null,
-			destroyPromise: null,
-			type,
-			scope,
-			deps,
-			destroyListeners: [],
-			createdAt: Date.now(),
-			waitingFor: /* @__PURE__ */ new Set()
-		};
-	}
-	/**
-	* Gets all holder names currently managed.
-	*/ getAllNames() {
-		return Array.from(this._holders.keys());
-	}
-	/**
-	* Gets all holders currently managed.
-	*/ getAllHolders() {
-		return Array.from(this._holders.values());
-	}
-	/**
-	* Checks if this manager has any holders.
-	*/ isEmpty() {
-		return this._holders.size === 0;
-	}
-	/**
-	* Waits for a holder to be ready and returns the appropriate result.
-	* This is a shared utility used by both singleton and request-scoped resolution.
-	*
-	* @param holder The holder to wait for
-	* @param waiterHolder Optional holder that is doing the waiting (for circular dependency detection)
-	* @param getHolder Optional function to retrieve holders by name (required if waiterHolder is provided)
-	* @returns A promise that resolves with [undefined, holder] on success or [DIError] on failure
-	*/ static async waitForHolderReady(holder, waiterHolder, getHolder) {
-		switch (holder.status) {
-			case InstanceStatus.Creating:
-				if (waiterHolder && getHolder) {
-					const cycle = CircularDetector.detectCycle(waiterHolder.name, holder.name, getHolder);
-					if (cycle) return [DIError.circularDependency(cycle)];
-					if (process.env.NODE_ENV !== "production") waiterHolder.waitingFor.add(holder.name);
-				}
-				try {
-					await holder.creationPromise;
-				} finally {
-					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)];
-			case InstanceStatus.Error: return [holder.instance];
-			case InstanceStatus.Created: return [void 0, holder];
-			default: return [DIError.instanceNotFound("unknown")];
-		}
-	}
-};
-/**
-* Default implementation of RequestContext.
-*
-* Extends BaseHolderManager to provide holder management functionality
-* with request-specific metadata and lifecycle support.
-*/ var DefaultRequestContext = class extends BaseHolderManager {
-	requestId;
-	priority;
-	metadata = /* @__PURE__ */ new Map();
-	createdAt = Date.now();
-	constructor(requestId, priority = 100, initialMetadata) {
-		super(null), this.requestId = requestId, this.priority = priority;
-		if (initialMetadata) Object.entries(initialMetadata).forEach(([key, value]) => {
-			this.metadata.set(key, value);
-		});
-	}
-	/**
-	* Public getter for holders to maintain interface compatibility.
-	*/ get holders() {
-		return this._holders;
-	}
-	/**
-	* Gets a holder by name. For RequestContext, this is a simple lookup.
-	*/ get(name) {
-		return this._holders.get(name);
-	}
-	/**
-	* Sets a holder by name.
-	*/ set(name, holder) {
-		this._holders.set(name, holder);
-	}
-	/**
-	* Checks if a holder exists by name.
-	*/ has(name) {
-		return this._holders.has(name);
-	}
-	addInstance(instanceName, instance, holder) {
-		if (instanceName instanceof InjectionToken$2) {
-			const name = instanceName.toString();
-			const createdHolder = this.createCreatedHolder(name, instance, InjectableType.Class, InjectableScope.Singleton, /* @__PURE__ */ new Set());
-			this._holders.set(name, createdHolder);
-		} else {
-			if (!holder) throw new Error("Holder is required when adding an instance by name");
-			this._holders.set(instanceName, holder);
-		}
-	}
-	clear() {
-		super.clear();
-		this.metadata.clear();
-	}
-	getMetadata(key) {
-		return this.metadata.get(key);
-	}
-	setMetadata(key, value) {
-		this.metadata.set(key, value);
-	}
-};
-/**
-* Storage implementation for Request-scoped services.
-*
-* Wraps a RequestContext instance from a ScopedContainer and provides
-* the IHolderStorage interface. This allows the InstanceResolver to work
-* with request-scoped storage using the same interface as singleton storage.
-*/ var RequestStorage = class {
-	scope = InjectableScope.Request;
-	constructor(contextHolder, holderManager) {
-		this.contextHolder = contextHolder;
-		this.holderManager = holderManager;
-	}
-	get(instanceName) {
-		const holder = this.contextHolder.get(instanceName);
-		if (!holder) return null;
-		switch (holder.status) {
-			case InstanceStatus.Destroying: return [DIError.instanceDestroying(instanceName), holder];
-			case InstanceStatus.Error: return [holder.instance, holder];
-			case InstanceStatus.Creating:
-			case InstanceStatus.Created: return [void 0, holder];
-			default: return null;
-		}
-	}
-	set(instanceName, holder) {
-		this.contextHolder.set(instanceName, holder);
-	}
-	delete(instanceName) {
-		return this.contextHolder.delete(instanceName);
-	}
-	createHolder(instanceName, type, deps) {
-		return this.holderManager.createCreatingHolder(instanceName, type, this.scope, deps);
-	}
-	handles(scope) {
-		return scope === InjectableScope.Request;
-	}
-	getAllNames() {
-		const names = [];
-		for (const [name] of this.contextHolder.holders) names.push(name);
-		return names;
-	}
-	forEach(callback) {
-		for (const [name, holder] of this.contextHolder.holders) callback(name, holder);
-	}
-	findByInstance(instance) {
-		for (const holder of this.contextHolder.holders.values()) if (holder.instance === instance) return holder;
-		return null;
-	}
-	findDependents(instanceName) {
-		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];
-	}
-};
-/**
-* Request-scoped dependency injection container.
-*
-* Wraps a parent Container and provides isolated request-scoped instances
-* while delegating singleton and transient resolution to the parent.
-* This design eliminates race conditions that can occur with async operations
-* when multiple requests are processed concurrently.
-*/ var ScopedContainer = class {
-	parent;
-	registry;
-	requestId;
-	requestContextHolder;
-	holderStorage;
-	disposed = false;
-	constructor(parent, registry, requestId, metadata, priority = 100) {
-		this.parent = parent;
-		this.registry = registry;
-		this.requestId = requestId;
-		this.requestContextHolder = new DefaultRequestContext(requestId, priority, metadata);
-		this.holderStorage = new RequestStorage(this.requestContextHolder, this.parent.getServiceLocator().getManager());
-	}
-	/**
-	* Gets the request context holder for this scoped container.
-	*/ getRequestContextHolder() {
-		return this.requestContextHolder;
-	}
-	/**
-	* Gets the holder storage for this scoped container.
-	* Used by InstanceResolver for request-scoped resolution.
-	*/ getHolderStorage() {
-		return this.holderStorage;
-	}
-	/**
-	* Gets the request ID for this scoped container.
-	*/ getRequestId() {
-		return this.requestId;
-	}
-	/**
-	* Gets the parent container.
-	*/ getParent() {
-		return this.parent;
-	}
-	/**
-	* Gets metadata from the request context.
-	*/ getMetadata(key) {
-		return this.requestContextHolder.getMetadata(key);
-	}
-	/**
-	* Sets metadata on the request context.
-	*/ setMetadata(key, value) {
-		this.requestContextHolder.setMetadata(key, value);
-	}
-	/**
-	* Adds a pre-prepared instance to the request context.
-	*/ addInstance(token, instance) {
-		this.requestContextHolder.addInstance(token, instance);
-	}
-	async get(token, args) {
-		if (this.disposed) throw DIError.unknown(`ScopedContainer for request ${this.requestId} has been disposed`);
-		const actualToken = this.parent.getServiceLocator().getTokenProcessor().normalizeToken(token);
-		if (this.isRequestScoped(actualToken)) return this.resolveRequestScoped(actualToken, args);
-		return this.parent.getWithContext(token, args, this);
-	}
-	/**
-	* Invalidates a service and its dependencies.
-	* For request-scoped services, invalidation is handled within this context.
-	*/ async invalidate(service) {
-		const holder = this.holderStorage.findByInstance(service);
-		if (holder) {
-			await this.parent.getServiceLocator().getInvalidator().invalidateWithStorage(holder.name, this.holderStorage, 1, { emitEvents: false });
-			return;
-		}
-		await this.parent.invalidate(service);
-	}
-	/**
-	* Checks if a service is registered.
-	*/ isRegistered(token) {
-		return this.parent.isRegistered(token);
-	}
-	/**
-	* Disposes this scoped container and cleans up all request-scoped instances.
-	* This is an alias for endRequest() for IContainer compatibility.
-	*/ async dispose() {
-		await this.endRequest();
-	}
-	/**
-	* Ends the request and cleans up all request-scoped instances.
-	* Uses the invalidation system to properly cascade to dependent singletons.
-	*/ async endRequest() {
-		if (this.disposed) return;
-		this.disposed = true;
-		await this.parent.getServiceLocator().getInvalidator().clearAllWithStorage(this.holderStorage, {
-			waitForSettlement: true,
-			maxRounds: 10
-		});
-		this.requestContextHolder.clear();
-		this.parent.removeActiveRequest(this.requestId);
-	}
-	/**
-	* Waits for all pending operations to complete.
-	*/ async ready() {
-		await this.parent.ready();
-	}
-	/**
-	* @internal
-	* Attempts to get an instance synchronously if it already exists and is ready.
-	* For request-scoped services, checks this container's context first.
-	* For other services, delegates to the parent container.
-	*
-	* Returns null if the instance doesn't exist or is not yet ready (still creating).
-	*/ tryGetSync(token, args) {
-		const actualToken = this.parent.getServiceLocator().getTokenProcessor().normalizeToken(token);
-		if (this.isRequestScoped(actualToken)) {
-			const instanceName = this.parent.getServiceLocator().getInstanceIdentifier(token, args);
-			const holder = this.requestContextHolder.get(instanceName);
-			if (holder && holder.status === InstanceStatus.Created) return holder.instance;
-			return null;
-		}
-		return this.parent.tryGetSync(token, args);
-	}
-	/**
-	* Checks if a token is for a request-scoped service.
-	*/ isRequestScoped(token) {
-		const realToken = this.parent.getServiceLocator().getTokenProcessor().getRealToken(token);
-		if (!this.registry.has(realToken)) return false;
-		return this.registry.get(realToken).scope === InjectableScope.Request;
-	}
-	/**
-	* Resolves a request-scoped service from this container's context.
-	* Uses locking to prevent duplicate initialization during concurrent resolution.
-	*/ async resolveRequestScoped(token, args) {
-		const instanceName = this.parent.getServiceLocator().getInstanceIdentifier(token, args);
-		const existingHolder = this.requestContextHolder.get(instanceName);
-		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;
-		}
-		return this.parent.resolveForRequest(token, args, this);
-	}
-	/**
-	* Stores an instance in the request context.
-	* Called by Container during request-scoped service resolution.
-	*/ storeRequestInstance(instanceName, instance, holder) {
-		this.requestContextHolder.addInstance(instanceName, instance, holder);
-	}
-	/**
-	* Gets an existing instance from the request context.
-	* Called by Container during resolution to check for existing instances.
-	*/ getRequestInstance(instanceName) {
-		return this.requestContextHolder.get(instanceName);
-	}
-	/**
-	* Generates a prefixed event name for request-scoped services.
-	* Format: {requestId}:{instanceName}
-	*/ getPrefixedEventName(instanceName) {
-		return `${this.requestId}:${instanceName}`;
-	}
-};
-/**
-* Storage implementation for Singleton-scoped services.
-*
-* Wraps a HolderManager instance and provides the IHolderStorage interface.
-* This allows the InstanceResolver to work with singleton storage
-* using the same interface as request-scoped storage.
-*/ var SingletonStorage = class {
-	scope = InjectableScope.Singleton;
-	constructor(manager) {
-		this.manager = manager;
-	}
-	get(instanceName) {
-		const [error, holder] = this.manager.get(instanceName);
-		if (!error) return [void 0, holder];
-		switch (error.code) {
-			case DIErrorCode.InstanceNotFound: return null;
-			case DIErrorCode.InstanceDestroying: return [error, holder];
-			default: return [error];
-		}
-	}
-	set(instanceName, holder) {
-		this.manager.set(instanceName, holder);
-	}
-	delete(instanceName) {
-		return this.manager.delete(instanceName);
-	}
-	createHolder(instanceName, type, deps) {
-		return this.manager.createCreatingHolder(instanceName, type, this.scope, deps);
-	}
-	handles(scope) {
-		return scope === InjectableScope.Singleton;
-	}
-	getAllNames() {
-		return this.manager.getAllNames();
-	}
-	forEach(callback) {
-		this.manager.forEachHolder((holder, name) => callback(name, holder));
-	}
-	findByInstance(instance) {
-		return this.manager.findHolder((h) => h.instance === instance) ?? null;
-	}
-	findDependents(instanceName) {
-		return this.manager.getDependents(instanceName);
-	}
-};
-/**
-* Resolves instances from tokens, handling caching, creation, and scope rules.
-*
-* Uses the Storage Strategy pattern for unified singleton/request-scoped handling.
-* Coordinates with Instantiator for actual service creation.
-*/ var InstanceResolver = class {
-	registry;
-	manager;
-	instantiator;
-	tokenProcessor;
-	logger;
-	serviceLocator;
-	singletonStorage;
-	constructor(registry, manager, instantiator, tokenProcessor, logger = null, serviceLocator) {
-		this.registry = registry;
-		this.manager = manager;
-		this.instantiator = instantiator;
-		this.tokenProcessor = tokenProcessor;
-		this.logger = logger;
-		this.serviceLocator = serviceLocator;
-		this.singletonStorage = new SingletonStorage(manager);
-	}
-	/**
-	* Resolves an instance for the given token and arguments.
-	* This method is used for singleton and transient services.
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param contextContainer The container to use for creating FactoryContext
-	*/ async resolveInstance(token, args, contextContainer) {
-		return this.resolveWithStorage(token, args, contextContainer, this.singletonStorage);
-	}
-	/**
-	* Resolves a request-scoped instance for a ScopedContainer.
-	* The service will be stored in the ScopedContainer's request context.
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param scopedContainer The ScopedContainer that owns the request context
-	*/ async resolveRequestScopedInstance(token, args, scopedContainer) {
-		return this.resolveWithStorage(token, args, scopedContainer, scopedContainer.getHolderStorage(), scopedContainer);
-	}
-	/**
-	* Unified resolution method that works with any IHolderStorage.
-	* This eliminates duplication between singleton and request-scoped resolution.
-	*
-	* IMPORTANT: The check-and-store logic is carefully designed to avoid race conditions.
-	* The storage check and holder creation must happen synchronously (no awaits between).
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param contextContainer The container for FactoryContext
-	* @param storage The storage strategy to use
-	* @param scopedContainer Optional scoped container for request-scoped services
-	*/ async resolveWithStorage(token, args, contextContainer, storage, scopedContainer) {
-		const [err, data] = await this.resolveTokenAndPrepareInstanceName(token, args, contextContainer);
-		if (err) return [err];
-		const { instanceName, validatedArgs, realToken } = data;
-		const getResult = storage.get(instanceName);
-		if (getResult !== null) {
-			const [error, holder$1] = getResult;
-			if (!error && holder$1) {
-				const readyResult = await this.waitForInstanceReady(holder$1);
-				if (readyResult[0]) return [readyResult[0]];
-				return [void 0, readyResult[1].instance];
-			}
-			if (error) {
-				const handledResult = await this.handleStorageError(instanceName, error, holder$1, storage);
-				if (handledResult) return handledResult;
-			}
-		}
-		const [createError, holder] = await this.createAndStoreInstance(instanceName, realToken, validatedArgs, contextContainer, storage, scopedContainer);
-		if (createError) return [createError];
-		return [void 0, holder.instance];
-	}
-	/**
-	* Handles storage error states (destroying, error, etc.).
-	* Returns a result if handled, null if should proceed with creation.
-	*/ async handleStorageError(instanceName, error, holder, storage) {
-		switch (error.code) {
-			case DIErrorCode.InstanceDestroying:
-				this.logger?.log(`[InstanceResolver] Instance ${instanceName} is being destroyed, waiting...`);
-				if (holder?.destroyPromise) await holder.destroyPromise;
-				const newResult = storage.get(instanceName);
-				if (newResult !== null && !newResult[0]) {
-					const readyResult = await this.waitForInstanceReady(newResult[1]);
-					if (readyResult[0]) return [readyResult[0]];
-					return [void 0, readyResult[1].instance];
-				}
-				return null;
-			default:
-				if (holder) {
-					this.logger?.log(`[InstanceResolver] Removing failed instance ${instanceName} from storage to allow retry`);
-					storage.delete(instanceName);
-				}
-				return null;
-		}
-	}
-	/**
-	* Creates a new instance and stores it using the provided storage strategy.
-	* This unified method replaces instantiateServiceFromRegistry and createRequestScopedInstance.
-	*
-	* For transient services, the instance is created but not stored (no caching).
-	*/ async createAndStoreInstance(instanceName, realToken, args, contextContainer, storage, scopedContainer) {
-		this.logger?.log(`[InstanceResolver]#createAndStoreInstance() Creating instance for ${instanceName}`);
-		if (!this.registry.has(realToken)) return [DIError.factoryNotFound(realToken.name.toString())];
-		const ctx = this.createFactoryContext(contextContainer);
-		const record = this.registry.get(realToken);
-		const { scope, type } = record;
-		if (scope === InjectableScope.Transient) return this.createTransientInstance(instanceName, record, args, ctx);
-		const [deferred, holder] = this.manager.createCreatingHolder(instanceName, type, scope, ctx.deps);
-		storage.set(instanceName, holder);
-		const getHolder = (name) => {
-			const storageResult = storage.get(name);
-			if (storageResult !== null) {
-				const [, storageHolder] = storageResult;
-				if (storageHolder) return storageHolder;
-			}
-			const [, managerHolder] = this.manager.get(name);
-			return managerHolder;
-		};
-		withResolutionContext(holder, getHolder, () => {
-			this.instantiator.instantiateService(ctx, record, args).then(async (result) => {
-				const [error, instance] = result.length === 2 ? result : [result[0], void 0];
-				await this.handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance, scopedContainer);
-			}).catch(async (error) => {
-				await this.handleInstantiationError(instanceName, holder, deferred, scope, error);
-			}).catch(() => {});
-		});
-		return this.waitForInstanceReady(holder);
-	}
-	/**
-	* Creates a transient instance without storage or locking.
-	* Each call creates a new instance.
-	*/ async createTransientInstance(instanceName, record, args, ctx) {
-		this.logger?.log(`[InstanceResolver]#createTransientInstance() Creating transient instance for ${instanceName}`);
-		const tempHolder = {
-			status: InstanceStatus.Creating,
-			name: instanceName,
-			instance: null,
-			creationPromise: null,
-			destroyPromise: null,
-			type: record.type,
-			scope: InjectableScope.Transient,
-			deps: ctx.deps,
-			destroyListeners: [],
-			createdAt: Date.now(),
-			waitingFor: /* @__PURE__ */ new Set()
-		};
-		const getHolder = (name) => {
-			const [, managerHolder] = this.manager.get(name);
-			return managerHolder;
-		};
-		const [error, instance] = await withResolutionContext(tempHolder, getHolder, () => this.instantiator.instantiateService(ctx, record, args));
-		if (error) return [error];
-		return [void 0, {
-			status: InstanceStatus.Created,
-			name: instanceName,
-			instance,
-			creationPromise: null,
-			destroyPromise: null,
-			type: record.type,
-			scope: InjectableScope.Transient,
-			deps: ctx.deps,
-			destroyListeners: ctx.getDestroyListeners(),
-			createdAt: Date.now(),
-			waitingFor: /* @__PURE__ */ new Set()
-		}];
-	}
-	/**
-	* Gets a synchronous instance (for sync operations).
-	*/ getSyncInstance(token, args, contextContainer) {
-		const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
-		if (err) return null;
-		const instanceName = this.tokenProcessor.generateInstanceName(actualToken, validatedArgs);
-		if ("getRequestInstance" in contextContainer) {
-			const requestHolder = contextContainer.getRequestInstance(instanceName);
-			if (requestHolder) return requestHolder.instance;
-		}
-		const [error, holder] = this.manager.get(instanceName);
-		if (error) return null;
-		return holder.instance;
-	}
-	/**
-	* Internal method to resolve token args and create instance name.
-	* Handles factory token resolution and validation.
-	*/ async resolveTokenAndPrepareInstanceName(token, args, contextContainer) {
-		const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
-		if (err instanceof DIError && err.code === DIErrorCode.UnknownError) return [err];
-		else if (err instanceof DIError && err.code === DIErrorCode.FactoryTokenNotResolved && actualToken instanceof FactoryInjectionToken) {
-			this.logger?.log(`[InstanceResolver]#resolveTokenAndPrepareInstanceName() Factory token not resolved, resolving it`);
-			await actualToken.resolve(this.createFactoryContext(contextContainer));
-			return this.resolveTokenAndPrepareInstanceName(token, void 0, contextContainer);
-		}
-		return [void 0, {
-			instanceName: this.tokenProcessor.generateInstanceName(actualToken, validatedArgs),
-			validatedArgs,
-			actualToken,
-			realToken: actualToken instanceof BoundInjectionToken || actualToken instanceof FactoryInjectionToken ? actualToken.token : actualToken
-		}];
-	}
-	/**
-	* Waits for an instance holder to be ready and returns the appropriate result.
-	* Uses the shared utility from BaseHolderManager.
-	* Passes the current resolution context for circular dependency detection.
-	*/ waitForInstanceReady(holder) {
-		const ctx = getCurrentResolutionContext();
-		return BaseHolderManager.waitForHolderReady(holder, ctx?.waiterHolder, ctx?.getHolder);
-	}
-	/**
-	* Handles the result of service instantiation.
-	*/ async handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance, scopedContainer) {
-		holder.destroyListeners = ctx.getDestroyListeners();
-		holder.creationPromise = null;
-		if (error) await this.handleInstantiationError(instanceName, holder, deferred, scope, error);
-		else await this.handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, scopedContainer);
-	}
-	/**
-	* Handles successful service instantiation.
-	*/ 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}`);
-				this.serviceLocator.getInvalidator().invalidate(instanceName);
-			}));
-			if (scopedContainer) {
-				const prefixedDependency = scopedContainer.getPrefixedEventName(dependency);
-				holder.destroyListeners.push(this.serviceLocator.getEventBus().on(prefixedDependency, "destroy", () => {
-					this.logger?.log(`[InstanceResolver] Request-scoped dependency ${dependency} destroyed, invalidating ${instanceName}`);
-					scopedContainer.invalidate(instance);
-				}));
-			}
-		});
-		this.logger?.log(`[InstanceResolver] Instance ${instanceName} created successfully`);
-		deferred.resolve([void 0, instance]);
-	}
-	/**
-	* Handles service instantiation errors.
-	*/ async handleInstantiationError(instanceName, holder, deferred, scope, error) {
-		this.logger?.error(`[InstanceResolver] Error creating instance for ${instanceName}`, error);
-		holder.status = InstanceStatus.Error;
-		holder.instance = error;
-		holder.creationPromise = null;
-		if (scope === InjectableScope.Singleton) {
-			this.logger?.log(`[InstanceResolver] Singleton ${instanceName} failed, will be invalidated`);
-			this.serviceLocator.getInvalidator().invalidate(instanceName).catch(() => {});
-		}
-		deferred.reject(error);
-	}
-	/**
-	* Creates a factory context for dependency injection during service instantiation.
-	*/ createFactoryContext(contextContainer) {
-		return this.tokenProcessor.createFactoryContext(contextContainer);
-	}
-};
-/**
-* Creates service instances from registry records.
-*
-* Handles both class-based (@Injectable) and factory-based (@Factory) services,
-* managing the instantiation lifecycle including sync initialization retries
-* and lifecycle hook invocation (onServiceInit, onServiceDestroy).
-*/ var Instantiator = class {
-	injectors;
-	constructor(injectors) {
-		this.injectors = injectors;
-	}
-	/**
-	* Instantiates a service based on its registry record.
-	* @param ctx The factory context for dependency injection
-	* @param record The factory record from the registry
-	* @param args Optional arguments for the service
-	* @returns Promise resolving to [undefined, instance] or [error]
-	*/ async instantiateService(ctx, record, args = void 0) {
-		try {
-			switch (record.type) {
-				case InjectableType.Class: return this.instantiateClass(ctx, record, args);
-				case InjectableType.Factory: return this.instantiateFactory(ctx, record, args);
-				default: throw DIError.unknown(`[Instantiator] Unknown service type: ${record.type}`);
-			}
-		} catch (error) {
-			return [error instanceof DIError ? error : DIError.unknown(String(error))];
-		}
-	}
-	/**
-	* Instantiates a class-based service (Injectable decorator).
-	* @param ctx The factory context for dependency injection
-	* @param record The factory record from the registry
-	* @param args Optional arguments for the service constructor
-	* @returns Promise resolving to [undefined, instance] or [error]
-	*/ async instantiateClass(ctx, record, args) {
-		try {
-			const tryLoad = this.injectors.wrapSyncInit(() => {
-				const original = this.injectors.provideFactoryContext(ctx);
-				let result = new record.target(...args ? [args] : []);
-				this.injectors.provideFactoryContext(original);
-				return result;
-			});
-			let [instance, promises, injectState] = tryLoad();
-			if (promises.length > 0) {
-				if ((await Promise.allSettled(promises)).some((result) => result.status === "rejected")) throw DIError.unknown(`[Instantiator] Service ${record.target.name} cannot be instantiated.`);
-				const newRes = tryLoad(injectState);
-				instance = newRes[0];
-				promises = newRes[1];
-			}
-			if (promises.length > 0) {
-				console.error(`[Instantiator] ${record.target.name} has problem with it's definition.
-
-       One or more of the dependencies are registered as a InjectableScope.Instance and are used with inject.
-
-       Please use inject asyncInject of inject to load those dependencies.`);
-				throw DIError.unknown(`[Instantiator] Service ${record.target.name} cannot be instantiated.`);
-			}
-			if ("onServiceInit" in instance) await instance.onServiceInit();
-			if ("onServiceDestroy" in instance) ctx.addDestroyListener(async () => {
-				await instance.onServiceDestroy();
-			});
-			return [void 0, instance];
-		} catch (error) {
-			return [error instanceof DIError ? error : DIError.unknown(String(error))];
-		}
-	}
-	/**
-	* Instantiates a factory-based service (Factory decorator).
-	* @param ctx The factory context for dependency injection
-	* @param record The factory record from the registry
-	* @param args Optional arguments for the factory
-	* @returns Promise resolving to [undefined, instance] or [error]
-	*/ async instantiateFactory(ctx, record, args) {
-		try {
-			const tryLoad = this.injectors.wrapSyncInit(() => {
-				const original = this.injectors.provideFactoryContext(ctx);
-				let result = new record.target();
-				this.injectors.provideFactoryContext(original);
-				return result;
-			});
-			let [builder$3, promises, injectState] = tryLoad();
-			if (promises.length > 0) {
-				if ((await Promise.allSettled(promises)).some((result) => result.status === "rejected")) throw DIError.unknown(`[Instantiator] Service ${record.target.name} cannot be instantiated.`);
-				const newRes = tryLoad(injectState);
-				builder$3 = newRes[0];
-				promises = newRes[1];
-			}
-			if (promises.length > 0) {
-				console.error(`[Instantiator] ${record.target.name} has problem with it's definition.
-
-       One or more of the dependencies are registered as a InjectableScope.Instance and are used with inject.
-
-       Please use asyncInject instead of inject to load those dependencies.`);
-				throw DIError.unknown(`[Instantiator] Service ${record.target.name} cannot be instantiated.`);
-			}
-			if (typeof builder$3.create !== "function") throw DIError.unknown(`[Instantiator] Factory ${record.target.name} does not implement the create method.`);
-			return [void 0, await builder$3.create(ctx, args)];
-		} catch (error) {
-			return [error instanceof DIError ? error : DIError.unknown(String(error))];
-		}
-	}
-};
-/**
-* Manages graceful service cleanup with dependency-aware invalidation.
-*
-* Ensures services are destroyed in the correct order based on their dependencies.
-* Works with any IHolderStorage implementation, enabling unified invalidation
-* for both singleton and request-scoped services.
-*/ var Invalidator = class {
-	eventBus;
-	logger;
-	storage;
-	constructor(manager, eventBus, logger = null) {
-		this.eventBus = eventBus;
-		this.logger = logger;
-		this.storage = new SingletonStorage(manager);
-	}
-	/**
-	* Invalidates a service and all its dependencies.
-	* Works with the configured storage (singleton by default).
-	*/ invalidate(service, round = 1) {
-		return this.invalidateWithStorage(service, this.storage, round);
-	}
-	/**
-	* Invalidates a service using a specific storage.
-	* This allows request-scoped invalidation using a RequestStorage.
-	*
-	* @param service The instance name to invalidate
-	* @param storage The storage to use for this invalidation
-	* @param round Current invalidation round (for recursion limiting)
-	* @param options Additional options for invalidation behavior
-	*/ async invalidateWithStorage(service, storage, round = 1, options = {}) {
-		const { cascade = true, _invalidating = /* @__PURE__ */ new Set() } = options;
-		if (_invalidating.has(service)) {
-			this.logger?.log(`[Invalidator] Skipping ${service} - already being invalidated in this chain`);
-			return;
-		}
-		this.logger?.log(`[Invalidator] Starting invalidation process for ${service}`);
-		const result = storage.get(service);
-		if (result === null) return;
-		_invalidating.add(service);
-		const optionsWithTracking = {
-			...options,
-			_invalidating
-		};
-		if (cascade) {
-			const dependents = storage.findDependents(service);
-			for (const dependentName of dependents) await this.invalidateWithStorage(dependentName, storage, round, optionsWithTracking);
-		}
-		const [, holder] = result;
-		if (holder) await this.invalidateHolderWithStorage(service, holder, storage, round, optionsWithTracking);
-	}
-	/**
-	* Gracefully clears all services using invalidation logic.
-	* This method respects service dependencies and ensures proper cleanup order.
-	* Services that depend on others will be invalidated first, then their dependencies.
-	*/ async clearAll(options = {}) {
-		return this.clearAllWithStorage(this.storage, options);
-	}
-	/**
-	* Gracefully clears all services in a specific storage.
-	* This allows clearing request-scoped services using a RequestStorage.
-	*/ async clearAllWithStorage(storage, options = {}) {
-		const { maxRounds = 10, waitForSettlement = true } = options;
-		this.logger?.log("[Invalidator] Starting graceful clearing of all services");
-		if (waitForSettlement) {
-			this.logger?.log("[Invalidator] Waiting for all services to settle...");
-			await this.readyWithStorage(storage);
-		}
-		const allServiceNames = storage.getAllNames();
-		if (allServiceNames.length === 0) this.logger?.log("[Invalidator] No services to clear");
-		else {
-			this.logger?.log(`[Invalidator] Found ${allServiceNames.length} services to clear: ${allServiceNames.join(", ")}`);
-			await this.clearServicesWithDependencyAwarenessForStorage(allServiceNames, maxRounds, storage);
-		}
-		this.logger?.log("[Invalidator] Graceful clearing completed");
-	}
-	/**
-	* Waits for all services to settle (either created, destroyed, or error state).
-	*/ async ready() {
-		return this.readyWithStorage(this.storage);
-	}
-	/**
-	* Waits for all services in a specific storage to settle.
-	*/ async readyWithStorage(storage) {
-		const holders = [];
-		storage.forEach((_, holder) => holders.push(holder));
-		await Promise.all(holders.map((holder) => this.waitForHolderToSettle(holder)));
-	}
-	/**
-	* Invalidates a single holder using a specific storage.
-	*/ async invalidateHolderWithStorage(key, holder, storage, round, options = {}) {
-		const { emitEvents = true, onInvalidated } = options;
-		await this.invalidateHolderByStatus(holder, round, {
-			context: key,
-			onCreationError: () => this.logger?.error(`[Invalidator] ${key} creation triggered too many invalidation rounds`),
-			onRecursiveInvalidate: () => this.invalidateWithStorage(key, storage, round + 1, options),
-			onDestroy: () => this.destroyHolderWithStorage(key, holder, storage, emitEvents, onInvalidated)
-		});
-	}
-	/**
-	* Common invalidation logic for holders based on their status.
-	*/ async invalidateHolderByStatus(holder, round, options) {
-		switch (holder.status) {
-			case InstanceStatus.Destroying:
-				await holder.destroyPromise;
-				break;
-			case InstanceStatus.Creating:
-				await holder.creationPromise;
-				if (round > 3) {
-					options.onCreationError();
-					return;
-				}
-				await options.onRecursiveInvalidate();
-				break;
-			default:
-				await options.onDestroy();
-				break;
-		}
-	}
-	/**
-	* Destroys a holder using a specific storage.
-	*/ async destroyHolderWithStorage(key, holder, storage, emitEvents, onInvalidated) {
-		holder.status = InstanceStatus.Destroying;
-		this.logger?.log(`[Invalidator] Invalidating ${key} and notifying listeners`);
-		holder.destroyPromise = Promise.all(holder.destroyListeners.map((listener) => listener())).then(async () => {
-			holder.destroyListeners = [];
-			holder.deps.clear();
-			storage.delete(key);
-			if (emitEvents && this.eventBus) await this.emitInstanceEvent(key, "destroy");
-			if (onInvalidated) await onInvalidated(key);
-		});
-		await holder.destroyPromise;
-	}
-	/**
-	* Waits for a holder to settle (either created, destroyed, or error state).
-	*/ async waitForHolderToSettle(holder) {
-		switch (holder.status) {
-			case InstanceStatus.Creating:
-				await holder.creationPromise;
-				break;
-			case InstanceStatus.Destroying:
-				await holder.destroyPromise;
-				break;
-			case InstanceStatus.Created:
-			case InstanceStatus.Error: break;
-		}
-	}
-	/**
-	* Clears services with dependency awareness for a specific storage.
-	*/ async clearServicesWithDependencyAwarenessForStorage(serviceNames, maxRounds, storage) {
-		const clearedServices = /* @__PURE__ */ new Set();
-		let round = 1;
-		while (clearedServices.size < serviceNames.length && round <= maxRounds) {
-			this.logger?.log(`[Invalidator] Clearing round ${round}/${maxRounds}, ${clearedServices.size}/${serviceNames.length} services cleared`);
-			const servicesToClearThisRound = this.findServicesReadyForClearingInStorage(serviceNames, clearedServices, storage);
-			if (servicesToClearThisRound.length === 0) {
-				const remainingServices = serviceNames.filter((name) => !clearedServices.has(name));
-				if (remainingServices.length > 0) {
-					this.logger?.warn(`[Invalidator] No services ready for clearing, forcing cleanup of remaining: ${remainingServices.join(", ")}`);
-					await this.forceClearServicesInStorage(remainingServices, storage);
-					remainingServices.forEach((name) => clearedServices.add(name));
-				}
-				break;
-			}
-			const clearPromises = servicesToClearThisRound.map(async (serviceName) => {
-				try {
-					await this.invalidateWithStorage(serviceName, storage, round);
-					clearedServices.add(serviceName);
-					this.logger?.log(`[Invalidator] Successfully cleared service: ${serviceName}`);
-				} catch (error) {
-					this.logger?.error(`[Invalidator] Error clearing service ${serviceName}:`, error);
-					clearedServices.add(serviceName);
-				}
-			});
-			await Promise.all(clearPromises);
-			round++;
-		}
-		if (clearedServices.size < serviceNames.length) this.logger?.warn(`[Invalidator] Clearing completed after ${maxRounds} rounds, but ${serviceNames.length - clearedServices.size} services may not have been properly cleared`);
-	}
-	/**
-	* Finds services that are ready to be cleared in the current round.
-	* A service is ready if all its dependencies have already been cleared.
-	*/ findServicesReadyForClearingInStorage(allServiceNames, clearedServices, storage) {
-		return allServiceNames.filter((serviceName) => {
-			if (clearedServices.has(serviceName)) return false;
-			const result = storage.get(serviceName);
-			if (result === null || result[0]) return true;
-			const [, holder] = result;
-			return !Array.from(holder.deps).some((dep) => !clearedServices.has(dep));
-		});
-	}
-	/**
-	* Force clears services that couldn't be cleared through normal dependency resolution.
-	* This handles edge cases like circular dependencies.
-	*/ async forceClearServicesInStorage(serviceNames, storage) {
-		const promises = serviceNames.map(async (serviceName) => {
-			try {
-				const result = storage.get(serviceName);
-				if (result !== null && !result[0]) {
-					const [, holder] = result;
-					await this.destroyHolderWithStorage(serviceName, holder, storage, true);
-				}
-			} catch (error) {
-				this.logger?.error(`[Invalidator] Error force clearing service ${serviceName}:`, error);
-			}
-		});
-		await Promise.all(promises);
-	}
-	/**
-	* Emits events to listeners for instance lifecycle events.
-	*/ emitInstanceEvent(name, event = "create") {
-		if (!this.eventBus) return Promise.resolve();
-		this.logger?.log(`[Invalidator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`);
-		return this.eventBus.emit(name, event);
-	}
-};
-/**
-* Event bus for service lifecycle events (create, destroy, etc.).
-*
-* Enables loose coupling between services by allowing them to subscribe
-* to lifecycle events of their dependencies without direct references.
-* Used primarily for invalidation cascading.
-*/ var LifecycleEventBus = class {
-	logger;
-	listeners = /* @__PURE__ */ new Map();
-	constructor(logger = null) {
-		this.logger = logger;
-	}
-	on(ns, event, listener) {
-		this.logger?.debug(`[LifecycleEventBus]#on(): ns:${ns} event:${event}`);
-		if (!this.listeners.has(ns)) this.listeners.set(ns, /* @__PURE__ */ new Map());
-		const nsEvents = this.listeners.get(ns);
-		if (!nsEvents.has(event)) nsEvents.set(event, /* @__PURE__ */ new Set());
-		nsEvents.get(event).add(listener);
-		return () => {
-			nsEvents.get(event)?.delete(listener);
-			if (nsEvents.get(event)?.size === 0) nsEvents.delete(event);
-			if (nsEvents.size === 0) this.listeners.delete(ns);
-		};
-	}
-	async emit(key, event) {
-		if (!this.listeners.has(key)) return;
-		const events = this.listeners.get(key);
-		this.logger?.debug(`[LifecycleEventBus]#emit(): ${key}:${event}`);
-		return await Promise.allSettled([...events.get(event) ?? []].map((listener) => listener(event))).then((results) => {
-			const res = results.filter((result) => result.status === "rejected").map((result) => {
-				this.logger?.warn(`[LifecycleEventBus]#emit(): ${key}:${event} rejected with`, result.reason);
-				return result;
-			});
-			if (res.length > 0) return Promise.reject(res);
-			return results;
-		});
-	}
-};
-/**
-* Manages the storage and retrieval of singleton instance holders.
-*
-* Provides CRUD operations and filtering for the holder map.
-* Handles holder state validation (destroying, error states) on retrieval.
-*/ var HolderManager = class extends BaseHolderManager {
-	constructor(logger = null) {
-		super(logger);
-	}
-	get(name) {
-		const holder = this._holders.get(name);
-		if (holder) {
-			if (holder.status === InstanceStatus.Destroying) {
-				this.logger?.log(`[HolderManager]#get() Instance ${holder.name} is destroying`);
-				return [DIError.instanceDestroying(holder.name), holder];
-			} else if (holder.status === InstanceStatus.Error) {
-				this.logger?.log(`[HolderManager]#get() Instance ${holder.name} is in error state`);
-				return [holder.instance, holder];
-			}
-			return [void 0, holder];
-		} else {
-			this.logger?.log(`[HolderManager]#get() Instance ${name} not found`);
-			return [DIError.instanceNotFound(name)];
-		}
-	}
-	set(name, holder) {
-		this._holders.set(name, holder);
-	}
-	has(name) {
-		const [error, holder] = this.get(name);
-		if (!error) return [void 0, true];
-		if (error.code === DIErrorCode.InstanceDestroying) return [error];
-		return [void 0, !!holder];
-	}
-	/**
-	* Creates a new holder with Created status and stores it.
-	* This is useful for creating holders that already have their instance ready.
-	* @param name The name of the instance
-	* @param instance The actual instance to store
-	* @param type The injectable type
-	* @param scope The injectable scope
-	* @param deps Optional set of dependencies
-	* @returns The created holder
-	*/ storeCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set()) {
-		const holder = this.createCreatedHolder(name, instance, type, scope, deps);
-		this._holders.set(name, holder);
-		return holder;
-	}
-};
-/**
-* 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;
-	}
-	/**
-	* Normalizes a token to an InjectionToken.
-	* Handles class constructors by getting their injectable token.
-	*
-	* @param token A class constructor, InjectionToken, BoundInjectionToken, or FactoryInjectionToken
-	* @returns The normalized InjectionTokenType
-	*/ normalizeToken(token) {
-		if (typeof token === "function") return getInjectableToken(token);
-		return token;
-	}
-	/**
-	* Gets the underlying "real" token from wrapped tokens.
-	* For BoundInjectionToken and FactoryInjectionToken, returns the wrapped token.
-	* For other tokens, returns the token itself.
-	*
-	* @param token The token to unwrap
-	* @returns The underlying InjectionToken
-	*/ getRealToken(token) {
-		if (token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken) return token.token;
-		return token;
-	}
-	/**
-	* Convenience method that normalizes a token and then gets the real token.
-	* Useful for checking registry entries where you need the actual registered token.
-	*
-	* @param token Any injectable type
-	* @returns The underlying InjectionToken
-	*/ getRegistryToken(token) {
-		return this.getRealToken(this.normalizeToken(token));
-	}
-	/**
-	* Validates and resolves token arguments, handling factory token resolution and validation.
-	*/ validateAndResolveTokenArgs(token, args) {
-		let actualToken = token;
-		if (typeof token === "function") actualToken = getInjectableToken(token);
-		let realArgs = args;
-		if (actualToken instanceof BoundInjectionToken) realArgs = actualToken.value;
-		else if (actualToken instanceof FactoryInjectionToken) if (actualToken.resolved) realArgs = actualToken.value;
-		else return [DIError.factoryTokenNotResolved(token.name), { actualToken }];
-		if (!actualToken.schema) return [void 0, {
-			actualToken,
-			validatedArgs: realArgs
-		}];
-		const validatedArgs = actualToken.schema?.safeParse(realArgs);
-		if (validatedArgs && !validatedArgs.success) {
-			this.logger?.error(`[TokenProcessor]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`, validatedArgs.error);
-			return [DIError.unknown(validatedArgs.error), { actualToken }];
-		}
-		return [void 0, {
-			actualToken,
-			validatedArgs: validatedArgs?.data
-		}];
-	}
-	/**
-	* 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 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.
-	*/ formatArgValue(value) {
-		if (typeof value === "function") return `fn_${value.name}(${value.length})`;
-		if (typeof value === "symbol") return value.toString();
-		return JSON.stringify(value).slice(0, 40);
-	}
-	/**
-	* Creates a factory context for dependency injection during service instantiation.
-	* @param container The container instance (Container or ScopedContainer) for dependency resolution
-	* @param onDependencyResolved Callback when a dependency is resolved, receives the instance name
-	*/ createFactoryContext(container, onDependencyResolved) {
-		const destroyListeners = /* @__PURE__ */ new Set();
-		const deps = /* @__PURE__ */ new Set();
-		function addDestroyListener(listener) {
-			destroyListeners.add(listener);
-		}
-		function getDestroyListeners() {
-			return Array.from(destroyListeners);
-		}
-		const self = this;
-		return {
-			async inject(token, args) {
-				const actualToken = typeof token === "function" ? getInjectableToken(token) : token;
-				const instanceName = self.generateInstanceName(actualToken, args);
-				deps.add(instanceName);
-				if (onDependencyResolved) onDependencyResolved(instanceName);
-				return container.get(token, args);
-			},
-			addDestroyListener,
-			getDestroyListeners,
-			container,
-			deps
-		};
-	}
-};
-/**
-* Core DI engine that coordinates service instantiation, resolution, and lifecycle.
-*
-* Acts as the central orchestrator for dependency injection operations,
-* delegating to specialized components (InstanceResolver, Instantiator, Invalidator)
-* for specific tasks.
-*/ var ServiceLocator = class {
-	registry;
-	logger;
-	injectors;
-	eventBus;
-	manager;
-	instantiator;
-	tokenProcessor;
-	invalidator;
-	instanceResolver;
-	constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
-		this.registry = registry;
-		this.logger = logger;
-		this.injectors = injectors;
-		this.eventBus = new LifecycleEventBus(logger);
-		this.manager = new HolderManager(logger);
-		this.instantiator = new Instantiator(injectors);
-		this.tokenProcessor = new TokenProcessor(logger);
-		this.invalidator = new Invalidator(this.manager, this.eventBus, logger);
-		this.instanceResolver = new InstanceResolver(this.registry, this.manager, this.instantiator, this.tokenProcessor, logger, this);
-	}
-	getEventBus() {
-		return this.eventBus;
-	}
-	getManager() {
-		return this.manager;
-	}
-	getInvalidator() {
-		return this.invalidator;
-	}
-	getTokenProcessor() {
-		return this.tokenProcessor;
-	}
-	getInstanceIdentifier(token, args) {
-		const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
-		if (err) throw err;
-		return this.tokenProcessor.generateInstanceName(actualToken, validatedArgs);
-	}
-	/**
-	* Gets or creates an instance for the given token.
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param contextContainer The container to use for creating FactoryContext
-	*/ async getInstance(token, args, contextContainer) {
-		const [err, data] = await this.instanceResolver.resolveInstance(token, args, contextContainer);
-		if (err) return [err];
-		return [void 0, data];
-	}
-	/**
-	* Gets or throws an instance for the given token.
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param contextContainer The container to use for creating FactoryContext
-	*/ async getOrThrowInstance(token, args, contextContainer) {
-		const [error, instance] = await this.getInstance(token, args, contextContainer);
-		if (error) throw error;
-		return instance;
-	}
-	/**
-	* Resolves a request-scoped service for a ScopedContainer.
-	* The service will be stored in the ScopedContainer's request context.
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param scopedContainer The ScopedContainer that owns the request context
-	*/ async resolveRequestScoped(token, args, scopedContainer) {
-		const [err, data] = await this.instanceResolver.resolveRequestScopedInstance(token, args, scopedContainer);
-		if (err) throw err;
-		return data;
-	}
-	getSyncInstance(token, args, contextContainer) {
-		return this.instanceResolver.getSyncInstance(token, args, contextContainer);
-	}
-	invalidate(service, round = 1) {
-		return this.invalidator.invalidate(service, round);
-	}
-	/**
-	* Gracefully clears all services in the ServiceLocator using invalidation logic.
-	* This method respects service dependencies and ensures proper cleanup order.
-	* Services that depend on others will be invalidated first, then their dependencies.
-	*
-	* @param options Optional configuration for the clearing process
-	* @returns Promise that resolves when all services have been cleared
-	*/ async clearAll(options = {}) {
-		return this.invalidator.clearAll(options);
-	}
-	/**
-	* Waits for all services to settle (either created, destroyed, or error state).
-	*/ async ready() {
-		return this.invalidator.ready();
-	}
-	/**
-	* Helper method for InstanceResolver to generate instance names.
-	* This is needed for the factory context creation.
-	*/ generateInstanceName(token, args) {
-		return this.tokenProcessor.generateInstanceName(token, args);
-	}
-};
-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;
-let _Container;
-_dec$2 = Injectable$1();
-(class {
-	registry;
-	logger;
-	injectors;
-	static {
-		({c: [_Container, _initClass$2]} = _apply_decs_2203_r$5(this, [], [_dec$2]));
-	}
-	constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
-		this.registry = registry;
-		this.logger = logger;
-		this.injectors = injectors;
-		this.serviceLocator = new ServiceLocator(registry, logger, injectors);
-		this.registerSelf();
-	}
-	serviceLocator;
-	activeRequestIds = /* @__PURE__ */ new Set();
-	registerSelf() {
-		const token = getInjectableToken(_Container);
-		const instanceName = this.serviceLocator.getInstanceIdentifier(token);
-		this.serviceLocator.getManager().storeCreatedHolder(instanceName, this, InjectableType.Class, InjectableScope.Singleton);
-	}
-	async get(token, args) {
-		const realToken = this.serviceLocator.getTokenProcessor().getRegistryToken(token);
-		if (this.registry.has(realToken)) {
-			if (this.registry.get(realToken).scope === InjectableScope.Request) throw DIError.unknown(`Cannot resolve request-scoped service "${String(realToken.name)}" from Container. Use beginRequest() to create a ScopedContainer for request-scoped services.`);
-		}
-		return this.serviceLocator.getOrThrowInstance(token, args, this);
-	}
-	/**
-	* Gets an instance with a specific container context.
-	* Used by ScopedContainer to delegate singleton/transient resolution
-	* while maintaining the correct container context for nested inject() calls.
-	*
-	* @internal
-	*/ async getWithContext(token, args, contextContainer) {
-		return this.serviceLocator.getOrThrowInstance(token, args, contextContainer);
-	}
-	/**
-	* Resolves a request-scoped service for a ScopedContainer.
-	* The service will be stored in the ScopedContainer's request context.
-	*
-	* @internal
-	*/ async resolveForRequest(token, args, scopedContainer) {
-		return this.serviceLocator.resolveRequestScoped(token, args, scopedContainer);
-	}
-	/**
-	* Gets the underlying ServiceLocator instance for advanced usage
-	*/ getServiceLocator() {
-		return this.serviceLocator;
-	}
-	/**
-	* Gets the registry
-	*/ getRegistry() {
-		return this.registry;
-	}
-	/**
-	* Invalidates a service and its dependencies
-	*/ async invalidate(service) {
-		const holder = this.getHolderByInstance(service);
-		if (holder) await this.serviceLocator.invalidate(holder.name);
-	}
-	/**
-	* Gets a service holder by instance (reverse lookup)
-	*/ getHolderByInstance(instance) {
-		const holderMap = Array.from(this.serviceLocator.getManager().filter((holder) => holder.instance === instance).values());
-		return holderMap.length > 0 ? holderMap[0] : null;
-	}
-	/**
-	* Checks if a service is registered in the container
-	*/ isRegistered(token) {
-		try {
-			return this.serviceLocator.getInstanceIdentifier(token) !== null;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Disposes the container and cleans up all resources
-	*/ async dispose() {
-		await this.serviceLocator.clearAll();
-	}
-	/**
-	* Waits for all pending operations to complete
-	*/ async ready() {
-		await this.serviceLocator.ready();
-	}
-	/**
-	* @internal
-	* Attempts to get an instance synchronously if it already exists.
-	* Returns null if the instance doesn't exist or is not ready.
-	*/ tryGetSync(token, args) {
-		return this.serviceLocator.getSyncInstance(token, args, this);
-	}
-	/**
-	* Begins a new request context and returns a ScopedContainer.
-	*
-	* The ScopedContainer provides isolated request-scoped service resolution
-	* while delegating singleton and transient services to this Container.
-	*
-	* @param requestId Unique identifier for this request
-	* @param metadata Optional metadata for the request
-	* @param priority Priority for resolution (higher = more priority)
-	* @returns A ScopedContainer for this request
-	*/ beginRequest(requestId, metadata, priority = 100) {
-		if (this.activeRequestIds.has(requestId)) throw DIError.unknown(`Request context "${requestId}" already exists. Use a unique request ID.`);
-		this.activeRequestIds.add(requestId);
-		this.logger?.log(`[Container] Started request context: ${requestId}`);
-		return new ScopedContainer(this, this.registry, requestId, metadata, priority);
-	}
-	/**
-	* Removes a request ID from the active set.
-	* Called by ScopedContainer when the request ends.
-	*
-	* @internal
-	*/ removeActiveRequest(requestId) {
-		this.activeRequestIds.delete(requestId);
-		this.logger?.log(`[Container] Ended request context: ${requestId}`);
-	}
-	/**
-	* Gets the set of active request IDs.
-	*/ getActiveRequestIds() {
-		return this.activeRequestIds;
-	}
-	/**
-	* Checks if a request ID is currently active.
-	*/ hasActiveRequest(requestId) {
-		return this.activeRequestIds.has(requestId);
-	}
-	/**
-	* Clears all instances and bindings from the container.
-	* This is useful for testing or resetting the container state.
-	*/ clear() {
-		return this.serviceLocator.clearAll();
-	}
-	static {
-		_initClass$2();
-	}
-});
-
-//#endregion
-//#region ../di/lib/index.mjs
-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$1, _initClass$1;
-let _EventEmitter;
-_dec$1 = Injectable$1({ scope: InjectableScope.Transient });
-(class {
-	static {
-		({c: [_EventEmitter, _initClass$1]} = _apply_decs_2203_r$4(this, [], [_dec$1]));
-	}
-	listeners = /* @__PURE__ */ new Map();
-	on(event, listener) {
-		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
-		this.listeners.get(event).add(listener);
-		return () => {
-			this.off(event, listener);
-		};
-	}
-	off(event, listener) {
-		if (!this.listeners.has(event)) return;
-		this.listeners.get(event).delete(listener);
-		if (this.listeners.get(event).size === 0) this.listeners.delete(event);
-	}
-	once(event, listener) {
-		const off = this.on(event, (...args) => {
-			off();
-			listener(...args);
-		});
-		return off;
-	}
-	async emit(event, ...args) {
-		if (!this.listeners.has(event)) return;
-		return Promise.all(Array.from(this.listeners.get(event)).map((listener) => listener(...args)));
-	}
-	static {
-		_initClass$1();
-	}
-});
-
-//#endregion
 //#region src/tokens/openapi-options.token.mts
 /**
 * Injection token for OpenAPI plugin options.
@@ -3243,28 +632,28 @@ function _apply_decs_2203_r$2(targetClass, memberDecs, classDecs, parentClass) {
 * @param jsonPath - The path to serve the OpenAPI JSON (e.g., '/openapi.json')
 * @returns A controller class that serves the OpenAPI document as JSON
 */ function createOpenApiJsonController(jsonPath) {
-	var _dec$3, _dec1, _initClass$3, _dec2, _initProto;
+	var _dec$1, _dec1, _initClass$1, _dec2, _initProto;
 	const endpoint = (0, _navios_builder.builder)().declareEndpoint({
 		method: "GET",
 		url: jsonPath,
 		responseSchema: openApiDocumentSchema
 	});
 	let _OpenApiJsonController;
-	_dec$3 = (0, _navios_openapi.ApiExclude)(), _dec1 = (0, _navios_core.Controller)(), _dec2 = (0, _navios_core.Endpoint)(endpoint);
+	_dec$1 = (0, _navios_openapi.ApiExclude)(), _dec1 = (0, _navios_core.Controller)(), _dec2 = (0, _navios_core.Endpoint)(endpoint);
 	class OpenApiJsonController {
 		static {
-			({e: [_initProto], c: [_OpenApiJsonController, _initClass$3]} = _apply_decs_2203_r$2(this, [[
+			({e: [_initProto], c: [_OpenApiJsonController, _initClass$1]} = _apply_decs_2203_r$2(this, [[
 				_dec2,
 				2,
 				"getJson"
-			]], [_dec$3, _dec1]));
+			]], [_dec$1, _dec1]));
 		}
 		documentService = (_initProto(this), (0, _navios_core.inject)(OpenApiDocumentServiceToken));
-		async getJson(_params) {
+		async getJson() {
 			return this.documentService.getDocument();
 		}
 		static {
-			_initClass$3();
+			_initClass$1();
 		}
 	}
 	return _OpenApiJsonController;
@@ -3556,24 +945,24 @@ function _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass) {
 * @param jsonPath - The path to the OpenAPI JSON spec (used by Scalar to load the spec)
 * @returns A controller class that serves the Scalar API Reference UI
 */ function createOpenApiUiController(docsPath, jsonPath) {
-	var _dec$3, _dec1, _initClass$3, _dec2, _dec3, _initProto;
+	var _dec$1, _dec1, _initClass$1, _dec2, _dec3, _initProto;
 	const endpoint = (0, _navios_builder.builder)().declareStream({
 		method: "GET",
 		url: docsPath
 	});
 	let _OpenApiUiController;
-	_dec$3 = (0, _navios_openapi.ApiExclude)(), _dec1 = (0, _navios_core.Controller)(), _dec2 = (0, _navios_core.Stream)(endpoint), _dec3 = (0, _navios_openapi.ApiStream)({ contentType: "text/html" });
+	_dec$1 = (0, _navios_openapi.ApiExclude)(), _dec1 = (0, _navios_core.Controller)(), _dec2 = (0, _navios_core.Stream)(endpoint), _dec3 = (0, _navios_openapi.ApiStream)({ contentType: "text/html" });
 	class OpenApiUiController {
 		static {
-			({e: [_initProto], c: [_OpenApiUiController, _initClass$3]} = _apply_decs_2203_r$1(this, [[
+			({e: [_initProto], c: [_OpenApiUiController, _initClass$1]} = _apply_decs_2203_r$1(this, [[
 				[_dec2, _dec3],
 				2,
 				"getUi"
-			]], [_dec$3, _dec1]));
+			]], [_dec$1, _dec1]));
 		}
 		options = (_initProto(this), (0, _navios_core.inject)(OpenApiOptionsToken));
 		html = null;
-		async getUi(_params) {
+		async getUi() {
 			if (!this.html) this.html = this.generateHtml();
 			return new Response(this.html, { headers: { "Content-Type": "text/html; charset=utf-8" } });
 		}
@@ -3592,7 +981,7 @@ function _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass) {
 			});
 		}
 		static {
-			_initClass$3();
+			_initClass$1();
 		}
 	}
 	return _OpenApiUiController;
@@ -3884,28 +1273,28 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 * @param yamlPath - The path to serve the OpenAPI YAML (e.g., '/openapi.yaml')
 * @returns A controller class that serves the OpenAPI document as YAML
 */ function createOpenApiYamlController(yamlPath) {
-	var _dec$3, _dec1, _initClass$3, _dec2, _dec3, _initProto;
+	var _dec$1, _dec1, _initClass$1, _dec2, _dec3, _initProto;
 	const endpoint = (0, _navios_builder.builder)().declareStream({
 		method: "GET",
 		url: yamlPath
 	});
 	let _OpenApiYamlController;
-	_dec$3 = (0, _navios_openapi.ApiExclude)(), _dec1 = (0, _navios_core.Controller)(), _dec2 = (0, _navios_core.Stream)(endpoint), _dec3 = (0, _navios_openapi.ApiStream)({ contentType: "text/yaml" });
+	_dec$1 = (0, _navios_openapi.ApiExclude)(), _dec1 = (0, _navios_core.Controller)(), _dec2 = (0, _navios_core.Stream)(endpoint), _dec3 = (0, _navios_openapi.ApiStream)({ contentType: "text/yaml" });
 	class OpenApiYamlController {
 		static {
-			({e: [_initProto], c: [_OpenApiYamlController, _initClass$3]} = _apply_decs_2203_r(this, [[
+			({e: [_initProto], c: [_OpenApiYamlController, _initClass$1]} = _apply_decs_2203_r(this, [[
 				[_dec2, _dec3],
 				2,
 				"getYaml"
-			]], [_dec$3, _dec1]));
+			]], [_dec$1, _dec1]));
 		}
 		documentService = (_initProto(this), (0, _navios_core.inject)(OpenApiDocumentServiceToken));
-		async getYaml(_params) {
+		async getYaml() {
 			const yaml$1 = this.documentService.getYamlDocument();
 			return new Response(yaml$1, { headers: { "Content-Type": "text/yaml; charset=utf-8" } });
 		}
 		static {
-			_initClass$3();
+			_initClass$1();
 		}
 	}
 	return _OpenApiYamlController;
@@ -3997,9 +1386,7 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 	/**
 	* Registers the plugin options in the DI container.
 	*/ registerOptions(context, options) {
-		const locator = context.container.getServiceLocator();
-		const instanceName = locator.getInstanceIdentifier(OpenApiOptionsToken);
-		locator.getManager().storeCreatedHolder(instanceName, options, InjectableType.Class, InjectableScope.Singleton);
+		context.container.addInstance(OpenApiOptionsToken, options);
 	}
 	/**
 	* Registers and initializes the document service.