@navios/di 0.5.1 → 0.6.1

package/lib/testing-DIaIRiJz.cjs

@@ -0,0 +1,2896 @@
+
+//#region src/enums/injectable-scope.enum.mts
+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;
+}({});
+
+//#endregion
+//#region src/enums/injectable-type.enum.mts
+let InjectableType = /* @__PURE__ */ function(InjectableType$1) {
+	InjectableType$1["Class"] = "Class";
+	InjectableType$1["Factory"] = "Factory";
+	return InjectableType$1;
+}({});
+
+//#endregion
+//#region src/token/injection-token.mts
+var InjectionToken = class InjectionToken {
+	name;
+	schema;
+	id = globalThis.crypto.randomUUID();
+	formattedName = null;
+	constructor(name, schema) {
+		this.name = name;
+		this.schema = schema;
+	}
+	static create(name, schema) {
+		return new InjectionToken(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();
+	}
+};
+
+//#endregion
+//#region src/token/registry.mts
+var Registry = class {
+	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);
+	}
+};
+const globalRegistry = new Registry();
+
+//#endregion
+//#region src/symbols/injectable-token.mts
+const InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+
+//#endregion
+//#region src/decorators/injectable.decorator.mts
+function Injectable({ 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.create(target, schema);
+		registry.set(injectableToken, scope, target, InjectableType.Class);
+		target[InjectableTokenMeta] = injectableToken;
+		return target;
+	};
+}
+
+//#endregion
+//#region src/errors/di-error.mts
+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 extends Error {
+	context;
+	constructor(code, message, context) {
+		super(message);
+		this.code = code;
+		this.message = message;
+		this.context = context;
+	}
+	static factoryNotFound(name) {
+		return new DIError(DIErrorCode.FactoryNotFound, `Factory ${name} not found`, { name });
+	}
+	static factoryTokenNotResolved(token) {
+		return new DIError(DIErrorCode.FactoryTokenNotResolved, `Factory token not resolved: ${token?.toString() ?? "unknown"}`, { token });
+	}
+	static instanceNotFound(name) {
+		return new DIError(DIErrorCode.InstanceNotFound, `Instance ${name} not found`, { name });
+	}
+	static instanceDestroying(name) {
+		return new DIError(DIErrorCode.InstanceDestroying, `Instance ${name} destroying`, { name });
+	}
+	static unknown(message, context) {
+		if (message instanceof Error) return new DIError(DIErrorCode.UnknownError, message.message, {
+			...context,
+			parent: message
+		});
+		return new DIError(DIErrorCode.UnknownError, message, context);
+	}
+	static circularDependency(cycle) {
+		const cycleStr = cycle.join(" -> ");
+		return new DIError(DIErrorCode.CircularDependency, `Circular dependency detected: ${cycleStr}`, { cycle });
+	}
+};
+
+//#endregion
+//#region src/internal/context/sync-local-storage.mts
+/**
+* A synchronous-only polyfill for AsyncLocalStorage.
+*
+* This provides the same API as Node's AsyncLocalStorage but only works
+* for synchronous code paths. It uses a simple stack-based approach.
+*
+* Limitations:
+* - Context does NOT propagate across async boundaries (setTimeout, promises, etc.)
+* - Only suitable for environments where DI resolution is synchronous
+*
+* This is acceptable for browser environments where:
+* 1. Constructors are typically synchronous
+* 2. Circular dependency detection mainly needs sync tracking
+*/
+var SyncLocalStorage = class {
+	stack = [];
+	/**
+	* Runs a function within the given store context.
+	* The context is only available synchronously within the function.
+	*/
+	run(store, fn) {
+		this.stack.push(store);
+		try {
+			return fn();
+		} finally {
+			this.stack.pop();
+		}
+	}
+	/**
+	* Gets the current store value, or undefined if not in a context.
+	*/
+	getStore() {
+		return this.stack.length > 0 ? this.stack[this.stack.length - 1] : void 0;
+	}
+	/**
+	* Exits the current context and runs the function without any store.
+	* This matches AsyncLocalStorage.exit() behavior.
+	*/
+	exit(fn) {
+		const savedStack = this.stack;
+		this.stack = [];
+		try {
+			return fn();
+		} finally {
+			this.stack = savedStack;
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/context/async-local-storage.mts
+/**
+* Cross-platform AsyncLocalStorage wrapper.
+*
+* Provides AsyncLocalStorage on Node.js/Bun and falls back to
+* a synchronous-only polyfill in browser environments.
+*/
+ /**
+* Detects if we're running in a Node.js-like environment with async_hooks support.
+*/ function hasAsyncHooksSupport() {
+	if (typeof process !== "undefined" && process.versions && process.versions.node) return true;
+	if (typeof process !== "undefined" && process.versions && "bun" in process.versions) return true;
+	if (typeof globalThis.Deno !== "undefined") return true;
+	return false;
+}
+let AsyncLocalStorageClass = null;
+let initialized = false;
+let forceSyncMode = false;
+/**
+* Gets the appropriate AsyncLocalStorage implementation for the current environment.
+*
+* - On Node.js/Bun/Deno: Returns the native AsyncLocalStorage
+* - On browsers: Returns SyncLocalStorage polyfill
+*/ function getAsyncLocalStorageClass() {
+	if (initialized) return AsyncLocalStorageClass;
+	initialized = true;
+	if (!forceSyncMode && hasAsyncHooksSupport()) try {
+		AsyncLocalStorageClass = require("node:async_hooks").AsyncLocalStorage;
+	} catch {
+		AsyncLocalStorageClass = SyncLocalStorage;
+	}
+	else AsyncLocalStorageClass = SyncLocalStorage;
+	return AsyncLocalStorageClass;
+}
+/**
+* Creates a new AsyncLocalStorage instance appropriate for the current environment.
+*/ function createAsyncLocalStorage() {
+	return new (getAsyncLocalStorageClass())();
+}
+
+//#endregion
+//#region src/internal/context/resolution-context.mts
+/**
+* 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.
+*/ const resolutionContext = createAsyncLocalStorage();
+/**
+* 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 resolutionContext.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 resolutionContext.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 resolutionContext.run(void 0, fn);
+}
+
+//#endregion
+//#region src/utils/get-injectors.mts
+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(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(token, args);
+		} catch {
+			return null;
+		}
+	}
+	return {
+		asyncInject: asyncInject$1,
+		inject: inject$1,
+		optional: optional$1,
+		wrapSyncInit: wrapSyncInit$1,
+		provideFactoryContext: provideFactoryContext$1
+	};
+}
+
+//#endregion
+//#region src/utils/get-injectable-token.mts
+function getInjectableToken(target) {
+	const token = target[InjectableTokenMeta];
+	if (!token) throw new Error(`[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`);
+	return token;
+}
+
+//#endregion
+//#region src/injectors.mts
+const defaultInjectors = getInjectors();
+const asyncInject = defaultInjectors.asyncInject;
+const inject = defaultInjectors.inject;
+const optional = defaultInjectors.optional;
+const wrapSyncInit = defaultInjectors.wrapSyncInit;
+const provideFactoryContext = defaultInjectors.provideFactoryContext;
+
+//#endregion
+//#region src/internal/lifecycle/circular-detector.mts
+/**
+* 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.
+*/ 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.
+	*
+	* @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) {
+		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(" -> ");
+	}
+};
+
+//#endregion
+//#region src/internal/holder/instance-holder.mts
+/**
+* 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;
+}({});
+
+//#endregion
+//#region src/internal/holder/base-holder-manager.mts
+/**
+* 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 {
+	logger;
+	_holders;
+	constructor(logger = null) {
+		this.logger = logger;
+		this._holders = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Protected getter for accessing the holders map from subclasses.
+	*/ get holders() {
+		return this._holders;
+	}
+	/**
+	* Deletes a holder by name.
+	* @param name The name of the holder to delete
+	* @returns true if the holder was deleted, false if it didn't exist
+	*/ delete(name) {
+		return this._holders.delete(name);
+	}
+	/**
+	* 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
+	*/ filter(predicate) {
+		return new Map([...this._holders].filter(([key, value]) => predicate(value, key)));
+	}
+	/**
+	* Clears all holders from this manager.
+	*/ clear() {
+		this._holders.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)];
+					waiterHolder.waitingFor.add(holder.name);
+				}
+				try {
+					await holder.creationPromise;
+				} finally {
+					if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+				}
+				return BaseHolderManager.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")];
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/context/request-context.mts
+/**
+* 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) {
+			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);
+	}
+};
+/**
+* Creates a new request context with the given parameters.
+*/ function createRequestContext(requestId, priority = 100, initialMetadata) {
+	return new DefaultRequestContext(requestId, priority, initialMetadata);
+}
+
+//#endregion
+//#region src/internal/holder/request-storage.mts
+/**
+* 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 dependents = [];
+		for (const [name, holder] of this.contextHolder.holders) if (holder.deps.has(instanceName)) dependents.push(name);
+		for (const [name, holder] of this.holderManager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
+		return dependents;
+	}
+};
+
+//#endregion
+//#region src/container/scoped-container.mts
+/**
+* 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) {
+			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}`;
+	}
+};
+
+//#endregion
+//#region src/internal/holder/singleton-storage.mts
+/**
+* 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) {
+		for (const [name, holder] of this.manager.filter(() => true)) callback(name, holder);
+	}
+	findByInstance(instance) {
+		for (const [, holder] of this.manager.filter((h) => h.instance === instance)) return holder;
+		return null;
+	}
+	findDependents(instanceName) {
+		const dependents = [];
+		for (const [name, holder] of this.manager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
+		return dependents;
+	}
+};
+
+//#endregion
+//#region src/internal/core/instance-resolver.mts
+/**
+* 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: return [error];
+		}
+	}
+	/**
+	* 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) 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);
+	}
+};
+
+//#endregion
+//#region src/internal/core/instantiator.mts
+/**
+* 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, 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 = 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.create !== "function") throw DIError.unknown(`[Instantiator] Factory ${record.target.name} does not implement the create method.`);
+			return [void 0, await builder.create(ctx, args)];
+		} catch (error) {
+			return [error instanceof DIError ? error : DIError.unknown(String(error))];
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/core/invalidator.mts
+/**
+* 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);
+	}
+};
+
+//#endregion
+//#region src/internal/lifecycle/lifecycle-event-bus.mts
+/**
+* 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;
+		});
+	}
+};
+
+//#endregion
+//#region src/internal/holder/holder-manager.mts
+/**
+* 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;
+	}
+};
+
+//#endregion
+//#region src/internal/core/token-processor.mts
+/**
+* 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;
+	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.
+	*/ generateInstanceName(token, args) {
+		if (!args) return token.toString();
+		const formattedArgs = Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",");
+		return `${token.toString()}:${formattedArgs.replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+	}
+	/**
+	* 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
+		};
+	}
+};
+
+//#endregion
+//#region src/internal/core/service-locator.mts
+/**
+* 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);
+	}
+};
+
+//#endregion
+//#region src/container/container.mts
+function applyDecs2203RFactory$1() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$1 = applyDecs2203RFactory$1())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$1, _initClass$1;
+let _Container$1;
+_dec$1 = Injectable();
+var Container = class {
+	registry;
+	logger;
+	injectors;
+	static {
+		({c: [_Container$1, _initClass$1]} = _apply_decs_2203_r$1(this, [], [_dec$1]));
+	}
+	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$1);
+		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$1();
+	}
+};
+
+//#endregion
+//#region src/testing/test-container.mts
+function applyDecs2203RFactory() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass, _Container;
+/**
+* A binding builder for the TestContainer that allows chaining binding operations.
+*/ var TestBindingBuilder = class {
+	container;
+	token;
+	constructor(container, token) {
+		this.container = container;
+		this.token = token;
+	}
+	/**
+	* Binds the token to a specific value.
+	* This is useful for testing with mock values or constants.
+	* @param value The value to bind to the token
+	*/ toValue(value) {
+		const instanceName = this.container.getServiceLocator().getInstanceIdentifier(this.token);
+		this.container.getServiceLocator().getManager().storeCreatedHolder(instanceName, value, InjectableType.Class, InjectableScope.Singleton);
+		return this.container;
+	}
+	/**
+	* Binds the token to a class constructor.
+	* @param target The class constructor to bind to
+	*/ toClass(target) {
+		this.container["registry"].set(this.token, InjectableScope.Singleton, target, InjectableType.Class);
+		return this.container;
+	}
+};
+let _TestContainer;
+_dec = Injectable();
+var TestContainer = class extends (_Container = _Container$1) {
+	static {
+		({c: [_TestContainer, _initClass]} = _apply_decs_2203_r(this, [], [_dec], _Container));
+	}
+	constructor(registry = globalRegistry, logger = null, injectors = void 0) {
+		super(registry, logger, injectors);
+	}
+	bind(token) {
+		let realToken = token;
+		if (typeof token === "function") realToken = getInjectableToken(token);
+		return new TestBindingBuilder(this, realToken);
+	}
+	bindValue(token, value) {
+		return this.bind(token).toValue(value);
+	}
+	bindClass(token, target) {
+		return this.bind(token).toClass(target);
+	}
+	/**
+	* Creates a new TestContainer instance with the same configuration.
+	* This is useful for creating isolated test containers.
+	* @returns A new TestContainer instance
+	*/ createChild() {
+		return new _TestContainer(this.registry, this.logger, this.injectors);
+	}
+	static {
+		_initClass();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'BaseHolderManager', {
+  enumerable: true,
+  get: function () {
+    return BaseHolderManager;
+  }
+});
+Object.defineProperty(exports, 'BoundInjectionToken', {
+  enumerable: true,
+  get: function () {
+    return BoundInjectionToken;
+  }
+});
+Object.defineProperty(exports, 'CircularDetector', {
+  enumerable: true,
+  get: function () {
+    return CircularDetector;
+  }
+});
+Object.defineProperty(exports, 'DIError', {
+  enumerable: true,
+  get: function () {
+    return DIError;
+  }
+});
+Object.defineProperty(exports, 'DIErrorCode', {
+  enumerable: true,
+  get: function () {
+    return DIErrorCode;
+  }
+});
+Object.defineProperty(exports, 'DefaultRequestContext', {
+  enumerable: true,
+  get: function () {
+    return DefaultRequestContext;
+  }
+});
+Object.defineProperty(exports, 'FactoryInjectionToken', {
+  enumerable: true,
+  get: function () {
+    return FactoryInjectionToken;
+  }
+});
+Object.defineProperty(exports, 'HolderManager', {
+  enumerable: true,
+  get: function () {
+    return HolderManager;
+  }
+});
+Object.defineProperty(exports, 'Injectable', {
+  enumerable: true,
+  get: function () {
+    return Injectable;
+  }
+});
+Object.defineProperty(exports, 'InjectableScope', {
+  enumerable: true,
+  get: function () {
+    return InjectableScope;
+  }
+});
+Object.defineProperty(exports, 'InjectableTokenMeta', {
+  enumerable: true,
+  get: function () {
+    return InjectableTokenMeta;
+  }
+});
+Object.defineProperty(exports, 'InjectableType', {
+  enumerable: true,
+  get: function () {
+    return InjectableType;
+  }
+});
+Object.defineProperty(exports, 'InjectionToken', {
+  enumerable: true,
+  get: function () {
+    return InjectionToken;
+  }
+});
+Object.defineProperty(exports, 'InstanceResolver', {
+  enumerable: true,
+  get: function () {
+    return InstanceResolver;
+  }
+});
+Object.defineProperty(exports, 'InstanceStatus', {
+  enumerable: true,
+  get: function () {
+    return InstanceStatus;
+  }
+});
+Object.defineProperty(exports, 'Instantiator', {
+  enumerable: true,
+  get: function () {
+    return Instantiator;
+  }
+});
+Object.defineProperty(exports, 'Invalidator', {
+  enumerable: true,
+  get: function () {
+    return Invalidator;
+  }
+});
+Object.defineProperty(exports, 'LifecycleEventBus', {
+  enumerable: true,
+  get: function () {
+    return LifecycleEventBus;
+  }
+});
+Object.defineProperty(exports, 'Registry', {
+  enumerable: true,
+  get: function () {
+    return Registry;
+  }
+});
+Object.defineProperty(exports, 'RequestStorage', {
+  enumerable: true,
+  get: function () {
+    return RequestStorage;
+  }
+});
+Object.defineProperty(exports, 'ScopedContainer', {
+  enumerable: true,
+  get: function () {
+    return ScopedContainer;
+  }
+});
+Object.defineProperty(exports, 'ServiceLocator', {
+  enumerable: true,
+  get: function () {
+    return ServiceLocator;
+  }
+});
+Object.defineProperty(exports, 'SingletonStorage', {
+  enumerable: true,
+  get: function () {
+    return SingletonStorage;
+  }
+});
+Object.defineProperty(exports, 'TestBindingBuilder', {
+  enumerable: true,
+  get: function () {
+    return TestBindingBuilder;
+  }
+});
+Object.defineProperty(exports, 'TokenProcessor', {
+  enumerable: true,
+  get: function () {
+    return TokenProcessor;
+  }
+});
+Object.defineProperty(exports, '_Container', {
+  enumerable: true,
+  get: function () {
+    return _Container$1;
+  }
+});
+Object.defineProperty(exports, '_TestContainer', {
+  enumerable: true,
+  get: function () {
+    return _TestContainer;
+  }
+});
+Object.defineProperty(exports, 'asyncInject', {
+  enumerable: true,
+  get: function () {
+    return asyncInject;
+  }
+});
+Object.defineProperty(exports, 'createRequestContext', {
+  enumerable: true,
+  get: function () {
+    return createRequestContext;
+  }
+});
+Object.defineProperty(exports, 'defaultInjectors', {
+  enumerable: true,
+  get: function () {
+    return defaultInjectors;
+  }
+});
+Object.defineProperty(exports, 'getCurrentResolutionContext', {
+  enumerable: true,
+  get: function () {
+    return getCurrentResolutionContext;
+  }
+});
+Object.defineProperty(exports, 'getInjectableToken', {
+  enumerable: true,
+  get: function () {
+    return getInjectableToken;
+  }
+});
+Object.defineProperty(exports, 'getInjectors', {
+  enumerable: true,
+  get: function () {
+    return getInjectors;
+  }
+});
+Object.defineProperty(exports, 'globalRegistry', {
+  enumerable: true,
+  get: function () {
+    return globalRegistry;
+  }
+});
+Object.defineProperty(exports, 'inject', {
+  enumerable: true,
+  get: function () {
+    return inject;
+  }
+});
+Object.defineProperty(exports, 'optional', {
+  enumerable: true,
+  get: function () {
+    return optional;
+  }
+});
+Object.defineProperty(exports, 'provideFactoryContext', {
+  enumerable: true,
+  get: function () {
+    return provideFactoryContext;
+  }
+});
+Object.defineProperty(exports, 'resolutionContext', {
+  enumerable: true,
+  get: function () {
+    return resolutionContext;
+  }
+});
+Object.defineProperty(exports, 'withResolutionContext', {
+  enumerable: true,
+  get: function () {
+    return withResolutionContext;
+  }
+});
+Object.defineProperty(exports, 'withoutResolutionContext', {
+  enumerable: true,
+  get: function () {
+    return withoutResolutionContext;
+  }
+});
+Object.defineProperty(exports, 'wrapSyncInit', {
+  enumerable: true,
+  get: function () {
+    return wrapSyncInit;
+  }
+});
+//# sourceMappingURL=testing-DIaIRiJz.cjs.map