@navios/di 0.5.0 → 0.6.0

package/lib/testing-DCXz8AJD.mjs

@@ -0,0 +1,2655 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#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 {
+	context;
+	constructor(code, message, context) {
+		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;
+_dec$1 = Injectable();
+var Container = class {
+	registry;
+	logger;
+	injectors;
+	static {
+		({c: [_Container, _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);
+		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$1;
+/**
+* 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$1 = _Container) {
+	static {
+		({c: [_TestContainer, _initClass]} = _apply_decs_2203_r(this, [], [_dec], _Container$1));
+	}
+	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
+export { withoutResolutionContext as A, InjectableType as B, provideFactoryContext as C, getCurrentResolutionContext as D, getInjectors as E, Registry as F, globalRegistry as I, BoundInjectionToken as L, DIErrorCode as M, Injectable as N, resolutionContext as O, InjectableTokenMeta as P, FactoryInjectionToken as R, optional as S, getInjectableToken as T, InjectableScope as V, InstanceStatus as _, TokenProcessor as a, defaultInjectors as b, Invalidator as c, SingletonStorage as d, ScopedContainer as f, BaseHolderManager as g, createRequestContext as h, ServiceLocator as i, DIError as j, withResolutionContext as k, Instantiator as l, DefaultRequestContext as m, _TestContainer as n, HolderManager as o, RequestStorage as p, _Container as r, LifecycleEventBus as s, TestBindingBuilder as t, InstanceResolver as u, CircularDetector as v, wrapSyncInit as w, inject as x, asyncInject as y, InjectionToken as z };
+//# sourceMappingURL=testing-DCXz8AJD.mjs.map