@navios/di 0.8.0 → 0.9.0

package/lib/{container-DENMeJ87.cjs → container-CaY2fDuk.cjs}

@@ -25,19 +25,45 @@ let InjectableType = /* @__PURE__ */ function(InjectableType$1) {
 	return InjectableType$1;
 }({});
 
+//#endregion
+//#region src/symbols/injectable-token.mts
+const InjectableTokenMeta = /* @__PURE__ */ Symbol.for("InjectableTokenMeta");
+
 //#endregion
 //#region src/token/injection-token.mts
+/**
+* Simple hash function for deterministic ID generation
+*/ function simpleHash(str) {
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return Math.abs(hash).toString(36);
+}
+/**
+* Generate deterministic ID from token name
+*/ function generateTokenId(name, customId) {
+	if (customId) return customId;
+	let base;
+	if (typeof name === "function") base = `${name.name}_${name.toString()}`;
+	else if (typeof name === "symbol") base = `symbol_${name.toString()}`;
+	else base = `token_${name}`;
+	return `${base.split("_")[0]}_${simpleHash(base)}`;
+}
 var InjectionToken = class InjectionToken {
 	name;
 	schema;
-	id = globalThis.crypto.randomUUID();
+	id;
 	formattedName = null;
-	constructor(name, schema) {
+	constructor(name, schema, customId) {
 		this.name = name;
 		this.schema = schema;
+		this.id = generateTokenId(name, customId);
 	}
-	static create(name, schema) {
-		return new InjectionToken(name, schema);
+	static create(name, schema, customId) {
+		return new InjectionToken(name, schema, customId);
 	}
 	static bound(token, value) {
 		return new BoundInjectionToken(token, value);
@@ -106,6 +132,7 @@ var FactoryInjectionToken = class {
 var Registry = class {
 	parent;
 	factories = /* @__PURE__ */ new Map();
+	highestPriority = /* @__PURE__ */ new Map();
 	constructor(parent) {
 		this.parent = parent;
 	}
@@ -115,23 +142,50 @@ var Registry = class {
 		return false;
 	}
 	get(token) {
-		const factory = this.factories.get(token.id);
+		const factory = this.highestPriority.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, {
+	getAll(token) {
+		const records = this.factories.get(token.id);
+		if (!records || records.length === 0) {
+			if (this.parent) return this.parent.getAll(token);
+			return [];
+		}
+		return [...records].sort((a, b) => b.priority - a.priority);
+	}
+	set(token, scope, target, type, priority = 0) {
+		const record = {
 			scope,
 			originalToken: token,
 			target,
-			type
-		});
+			type,
+			priority
+		};
+		const existing = this.factories.get(token.id) || [];
+		existing.push(record);
+		this.factories.set(token.id, existing);
+		const currentHighest = this.highestPriority.get(token.id);
+		if (!currentHighest || priority > currentHighest.priority) this.highestPriority.set(token.id, record);
 	}
 	delete(token) {
-		this.factories.delete(token.id);
+		const records = this.factories.get(token.id);
+		if (records) {
+			const deletedHighest = this.highestPriority.get(token.id);
+			this.factories.delete(token.id);
+			this.highestPriority.delete(token.id);
+			if (deletedHighest && records.length > 1) {
+				const remaining = records.filter((r) => r.originalToken.id !== deletedHighest.originalToken.id || r.priority !== deletedHighest.priority);
+				if (remaining.length > 0) {
+					const newHighest = remaining.reduce((max, current) => current.priority > max.priority ? current : max);
+					this.highestPriority.set(token.id, newHighest);
+					this.factories.set(token.id, remaining);
+				}
+			}
+		}
 	}
 	/**
 	* Updates the scope of an already registered factory.
@@ -142,29 +196,29 @@ var Registry = class {
 	* @param scope The new scope to set
 	* @returns true if the scope was updated, false if the token was not found
 	*/ updateScope(token, scope) {
-		const factory = this.factories.get(token.id);
-		if (factory) {
-			factory.scope = scope;
+		const records = this.factories.get(token.id);
+		if (records && records.length > 0) {
+			records.forEach((record) => {
+				record.scope = scope;
+			});
+			const highest = this.highestPriority.get(token.id);
+			if (highest) highest.scope = scope;
 			return true;
 		}
 		if (this.parent) return this.parent.updateScope(token, scope);
 		return false;
 	}
 };
-const globalRegistry = new Registry();
-
-//#endregion
-//#region src/symbols/injectable-token.mts
-const InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+const globalRegistry = /* @__PURE__ */ new Registry();
 
 //#endregion
 //#region src/decorators/injectable.decorator.mts
-function Injectable({ scope = InjectableScope.Singleton, token, schema, registry = globalRegistry } = {}) {
+function Injectable({ scope = InjectableScope.Singleton, token, schema, registry = globalRegistry, priority = 0 } = {}) {
 	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");
+		if (context && context.kind !== "class" || target instanceof Function && !context) throw new Error("[DI] @Injectable decorator can only be used on classes.");
+		if (schema && token) throw new Error("[DI] @Injectable decorator cannot have both a token and a schema");
 		let injectableToken = token ?? InjectionToken.create(target, schema);
-		registry.set(injectableToken, scope, target, InjectableType.Class);
+		registry.set(injectableToken, scope, target, InjectableType.Class, priority);
 		target[InjectableTokenMeta] = injectableToken;
 		return target;
 	};
@@ -172,45 +226,97 @@ function Injectable({ scope = InjectableScope.Singleton, token, schema, registry
 
 //#endregion
 //#region src/errors/di-error.mts
-let DIErrorCode = /* @__PURE__ */ function(DIErrorCode$1) {
+var 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["TokenValidationError"] = "TokenValidationError";
+	DIErrorCode$1["TokenSchemaRequiredError"] = "TokenSchemaRequiredError";
+	DIErrorCode$1["ClassNotInjectable"] = "ClassNotInjectable";
+	DIErrorCode$1["ScopeMismatchError"] = "ScopeMismatchError";
+	DIErrorCode$1["PriorityConflictError"] = "PriorityConflictError";
+	DIErrorCode$1["StorageError"] = "StorageError";
+	DIErrorCode$1["InitializationError"] = "InitializationError";
+	DIErrorCode$1["DependencyResolutionError"] = "DependencyResolutionError";
 	DIErrorCode$1["UnknownError"] = "UnknownError";
 	return DIErrorCode$1;
 }({});
 var DIError = class DIError extends Error {
+	code;
+	message;
 	context;
 	constructor(code, message, context) {
-		super(message);
-		this.code = code;
-		this.message = message;
+		super(message), this.code = code, this.message = message;
 		this.context = context;
+		this.name = "DIError";
 	}
 	static factoryNotFound(name) {
-		return new DIError(DIErrorCode.FactoryNotFound, `Factory ${name} not found`, { name });
+		return new DIError("FactoryNotFound", `Factory ${name} not found`, { name });
 	}
 	static factoryTokenNotResolved(token) {
-		return new DIError(DIErrorCode.FactoryTokenNotResolved, `Factory token not resolved: ${token?.toString() ?? "unknown"}`, { token });
+		return new DIError("FactoryTokenNotResolved", `Factory token not resolved: ${token?.toString() ?? "unknown"}`, { token });
 	}
 	static instanceNotFound(name) {
-		return new DIError(DIErrorCode.InstanceNotFound, `Instance ${name} not found`, { name });
+		return new DIError("InstanceNotFound", `Instance ${name} not found`, { name });
 	}
 	static instanceDestroying(name) {
-		return new DIError(DIErrorCode.InstanceDestroying, `Instance ${name} destroying`, { name });
+		return new DIError("InstanceDestroying", `Instance ${name} destroying`, { name });
 	}
 	static unknown(message, context) {
-		if (message instanceof Error) return new DIError(DIErrorCode.UnknownError, message.message, {
+		if (message instanceof Error) return new DIError("UnknownError", message.message, {
 			...context,
 			parent: message
 		});
-		return new DIError(DIErrorCode.UnknownError, message, context);
+		return new DIError("UnknownError", message, context);
 	}
 	static circularDependency(cycle) {
-		const cycleStr = cycle.join(" -> ");
-		return new DIError(DIErrorCode.CircularDependency, `Circular dependency detected: ${cycleStr}`, { cycle });
+		return new DIError("CircularDependency", `Circular dependency detected: ${cycle.join(" -> ")}`, { cycle });
+	}
+	static tokenValidationError(message, schema, value) {
+		return new DIError("TokenValidationError", message, {
+			schema,
+			value
+		});
+	}
+	static tokenSchemaRequiredError(token) {
+		return new DIError("TokenSchemaRequiredError", `Token ${token?.toString() ?? "unknown"} requires schema arguments and cannot be used with addInstance. Use BoundInjectionToken or provide arguments when resolving.`, { token });
+	}
+	static classNotInjectable(className) {
+		return new DIError("ClassNotInjectable", `Class ${className} is not decorated with @Injectable.`, { className });
+	}
+	static scopeMismatchError(token, expectedScope, actualScope) {
+		return new DIError("ScopeMismatchError", `Scope mismatch for ${token?.toString() ?? "unknown"}: expected ${expectedScope}, got ${actualScope}`, {
+			token,
+			expectedScope,
+			actualScope
+		});
+	}
+	static priorityConflictError(token, records) {
+		return new DIError("PriorityConflictError", `Priority conflict for ${token?.toString() ?? "unknown"}: multiple bindings with same priority`, {
+			token,
+			records
+		});
+	}
+	static storageError(message, operation, instanceName) {
+		return new DIError("StorageError", `Storage error: ${message}`, {
+			operation,
+			instanceName
+		});
+	}
+	static initializationError(serviceName, error) {
+		return new DIError("InitializationError", `Service ${serviceName} initialization failed: ${error instanceof Error ? error.message : error}`, {
+			serviceName,
+			error
+		});
+	}
+	static dependencyResolutionError(serviceName, dependencyName, error) {
+		return new DIError("DependencyResolutionError", `Failed to resolve dependency ${dependencyName} for service ${serviceName}: ${error instanceof Error ? error.message : error}`, {
+			serviceName,
+			dependencyName,
+			error
+		});
 	}
 };
 
@@ -240,6 +346,9 @@ function getModule() {
 function createAsyncLocalStorage() {
 	return getModule().createAsyncLocalStorage();
 }
+function isUsingNativeAsyncLocalStorage() {
+	return getModule().isUsingNativeAsyncLocalStorage();
+}
 
 //#endregion
 //#region src/internal/context/resolution-context.mts
@@ -294,135 +403,21 @@ function getResolutionContext() {
 }
 
 //#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;
+//#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/lifecycle/circular-detector.mts
@@ -483,200 +478,249 @@ const provideFactoryContext = defaultInjectors.provideFactoryContext;
 };
 
 //#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
+//#region src/internal/core/instance-resolver.mts
 /**
-* Abstract base class providing common functionality for managing InstanceHolder objects.
+* Resolves instances from tokens, handling caching, creation, and scope rules.
 *
-* Provides shared patterns for holder storage, creation, and lifecycle management
-* used by both singleton (HolderManager) and request-scoped (RequestContext) managers.
-*/ var BaseHolderManager = class BaseHolderManager {
+* Uses unified storage for both singleton and request-scoped services.
+* Coordinates with ServiceInitializer for actual service creation.
+* Integrates ScopeTracker for automatic scope upgrades.
+*/ var InstanceResolver = class {
+	registry;
+	storage;
+	serviceInitializer;
+	tokenResolver;
+	nameResolver;
+	scopeTracker;
+	serviceInvalidator;
+	eventBus;
 	logger;
-	_holders;
-	/**
-	* Reverse dependency index: maps a dependency name to the set of holder names that depend on it.
-	* This allows O(1) lookup of dependents instead of O(n) iteration.
-	*/ _dependents;
-	constructor(logger = null) {
+	constructor(registry, storage, serviceInitializer, tokenResolver, nameResolver, scopeTracker, serviceInvalidator, eventBus, logger = null) {
+		this.registry = registry;
+		this.storage = storage;
+		this.serviceInitializer = serviceInitializer;
+		this.tokenResolver = tokenResolver;
+		this.nameResolver = nameResolver;
+		this.scopeTracker = scopeTracker;
+		this.serviceInvalidator = serviceInvalidator;
+		this.eventBus = eventBus;
 		this.logger = logger;
-		this._holders = /* @__PURE__ */ new Map();
-		this._dependents = /* @__PURE__ */ new Map();
 	}
 	/**
-	* Protected getter for accessing the holders map from subclasses.
-	*/ get holders() {
-		return this._holders;
+	* 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 context
+	* @param requestStorage Optional request storage (for scope upgrades)
+	* @param requestId Optional request ID (for scope upgrades)
+	*/ async resolveInstance(token, args, contextContainer, requestStorage, requestId) {
+		return this.resolveWithStorage(token, args, contextContainer, this.storage, void 0, requestStorage, requestId);
 	}
 	/**
-	* Deletes a holder by name and cleans up the reverse dependency index.
-	* @param name The name of the holder to delete
-	* @returns true if the holder was deleted, false if it didn't exist
-	*/ delete(name) {
-		const holder = this._holders.get(name);
-		if (holder) this.removeFromDependentsIndex(name, holder.deps);
-		return this._holders.delete(name);
+	* Resolves a request-scoped instance for a ScopedContainer.
+	* The service will be stored in the ScopedContainer's request storage.
+	*
+	* @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.getParent(), scopedContainer.getParent().getStorage(), scopedContainer, scopedContainer.getStorage(), scopedContainer.getRequestId());
 	}
 	/**
-	* Registers a holder's dependencies in the reverse index.
-	* Call this after creating a holder with dependencies.
-	* @param holderName The name of the holder that has dependencies
-	* @param deps The set of dependency names
-	*/ registerDependencies(holderName, deps) {
-		for (const dep of deps) {
-			let dependents = this._dependents.get(dep);
-			if (!dependents) {
-				dependents = /* @__PURE__ */ new Set();
-				this._dependents.set(dep, dependents);
+	* 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 context
+	* @param storage The storage strategy to use
+	* @param scopedContainer Optional scoped container for request-scoped services
+	* @param requestStorage Optional request storage (for scope upgrades)
+	* @param requestId Optional request ID (for scope upgrades)
+	*/ async resolveWithStorage(token, args, contextContainer, storage, scopedContainer, requestStorage, requestId) {
+		const [err, data] = await this.resolveTokenAndPrepareInstanceName(token, args, contextContainer, requestId, scopedContainer);
+		if (err) return [err];
+		const { instanceName, validatedArgs, realToken, scope } = data;
+		const getResult = storage.get(instanceName) ?? requestStorage?.get(instanceName) ?? null;
+		const getHolder = (name) => {
+			const result = storage.get(name);
+			if (result && result[0] === void 0 && result[1]) return result[1];
+			if (requestStorage) {
+				const reqResult = requestStorage.get(name);
+				if (reqResult && reqResult[0] === void 0 && reqResult[1]) return reqResult[1];
 			}
-			dependents.add(holderName);
-		}
-	}
-	/**
-	* Removes a holder from the reverse dependency index.
-	* @param holderName The name of the holder to remove
-	* @param deps The set of dependency names to clean up
-	*/ removeFromDependentsIndex(holderName, deps) {
-		for (const dep of deps) {
-			const dependents = this._dependents.get(dep);
-			if (dependents) {
-				dependents.delete(holderName);
-				if (dependents.size === 0) this._dependents.delete(dep);
+		};
+		if (getResult !== null) {
+			const [error, holder$1] = getResult;
+			if (!error && holder$1) {
+				const waiterHolder = getCurrentResolutionContext()?.waiterHolder;
+				const readyResult = await this.waitForInstanceReady(holder$1, waiterHolder, getHolder);
+				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, requestStorage, requestId, scope);
+		if (createError) return [createError];
+		return [void 0, holder.instance];
 	}
 	/**
-	* Gets all holder names that depend on the given instance name.
-	* O(1) lookup using the reverse dependency index.
-	* @param instanceName The instance name to find dependents for
-	* @returns Array of holder names that depend on this instance
-	*/ getDependents(instanceName) {
-		const dependents = this._dependents.get(instanceName);
-		return dependents ? Array.from(dependents) : [];
-	}
-	/**
-	* Filters holders based on a predicate function.
-	* @param predicate Function to test each holder
-	* @returns A new Map containing only the holders that match the predicate
-	* @deprecated Use forEachHolder() for iteration to avoid allocations
-	*/ filter(predicate) {
-		const result = /* @__PURE__ */ new Map();
-		for (const [key, value] of this._holders) if (predicate(value, key)) result.set(key, value);
-		return result;
-	}
-	/**
-	* Iterates over holders with a callback. More efficient than filter() as it
-	* avoids creating intermediate arrays and Maps.
-	* @param callback Function called for each holder with (holder, name)
-	*/ forEachHolder(callback) {
-		for (const [name, holder] of this._holders) callback(holder, name);
-	}
-	/**
-	* Finds the first holder matching a predicate. More efficient than filter()
-	* when only one result is needed.
-	* @param predicate Function to test each holder
-	* @returns The first matching holder or undefined
-	*/ findHolder(predicate) {
-		for (const [name, holder] of this._holders) if (predicate(holder, name)) return holder;
-	}
-	/**
-	* Clears all holders from this manager and the reverse dependency index.
-	*/ clear() {
-		this._holders.clear();
-		this._dependents.clear();
+	* Internal method to resolve token args and create instance name.
+	* Handles factory token resolution and validation.
+	*/ async resolveTokenAndPrepareInstanceName(token, args, contextContainer, requestId, scopedContainer) {
+		const [err, { actualToken, validatedArgs }] = this.tokenResolver.validateAndResolveTokenArgs(token, args);
+		if (err instanceof DIError && err.code === DIErrorCode.TokenValidationError) 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`);
+			const factoryCtx = {
+				inject: async (t, a) => (scopedContainer ?? contextContainer).get(t, a),
+				container: scopedContainer ?? contextContainer,
+				addDestroyListener: () => {}
+			};
+			await actualToken.resolve(factoryCtx);
+			return this.resolveTokenAndPrepareInstanceName(token, void 0, contextContainer, requestId, scopedContainer);
+		}
+		const realToken = this.tokenResolver.getRealToken(actualToken);
+		const scope = this.registry.get(realToken).scope;
+		return [void 0, {
+			instanceName: this.nameResolver.generateInstanceName(actualToken, validatedArgs, requestId, scope),
+			validatedArgs,
+			actualToken,
+			realToken,
+			scope
+		}];
 	}
 	/**
-	* Gets the number of holders currently managed.
-	*/ size() {
-		return this._holders.size;
+	* 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 getHolder = (name) => {
+						const result = storage.get(name);
+						return result && result[0] === void 0 && result[1] ? result[1] : void 0;
+					};
+					const readyResult = await this.waitForInstanceReady(newResult[1], void 0, getHolder);
+					if (readyResult[0]) return [readyResult[0]];
+					return [void 0, readyResult[1].instance];
+				}
+				return null;
+			default:
+				if (holder) {
+					this.logger?.log(`[InstanceResolver] Removing failed instance ${instanceName} from storage to allow retry`);
+					storage.delete(instanceName);
+				}
+				return null;
+		}
 	}
 	/**
-	* Creates a new 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 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, requestStorage, requestId, scope) {
+		this.logger?.log(`[InstanceResolver]#createAndStoreInstance() Creating instance for ${instanceName}`);
+		if (!this.registry.has(realToken)) return [DIError.factoryNotFound(realToken.name.toString())];
+		const record = this.registry.get(realToken);
+		const { type, scope: recordScope } = record;
+		const serviceScope = scope || recordScope;
+		if (serviceScope === InjectableScope.Transient) return this.createTransientInstance(instanceName, record, args, contextContainer, scopedContainer, requestStorage, requestId);
+		if (serviceScope === InjectableScope.Request && !requestStorage) return [DIError.initializationError(`Request storage is required for request-scoped services`, instanceName)];
+		let storageToUse;
+		if (serviceScope === InjectableScope.Request) storageToUse = requestStorage;
+		else storageToUse = storage;
+		const [deferred, holder] = storageToUse.createHolder(instanceName, type, /* @__PURE__ */ new Set());
+		storageToUse.set(instanceName, holder);
+		const ctx = this.createServiceInitializationContext(scopedContainer ?? contextContainer, instanceName, serviceScope, holder.deps, realToken, requestStorage, requestId);
+		holder.destroyListeners = ctx.getDestroyListeners();
+		const getHolder = (name) => {
+			const result = storage.get(name);
+			if (result && result[0] === void 0 && result[1]) return result[1];
+			if (requestStorage) {
+				const reqResult = requestStorage.get(name);
+				if (reqResult && reqResult[0] === void 0 && reqResult[1]) return reqResult[1];
+			}
+		};
+		withResolutionContext(holder, getHolder, () => {
+			this.serviceInitializer.instantiateService(ctx, record, args).then(async (result) => {
+				const [error, instance] = result.length === 2 ? result : [result[0], void 0];
+				const newScope = record.scope;
+				const newName = this.nameResolver.generateInstanceName(realToken, args, requestId, newScope);
+				await this.handleInstantiationResult(newName, holder, ctx, deferred, newScope, error, instance, scopedContainer, requestStorage, requestId);
+			}).catch(async (error) => {
+				const newScope = record.scope;
+				const newName = this.nameResolver.generateInstanceName(realToken, args, requestId, newScope);
+				await this.handleInstantiationError(newName, holder, deferred, newScope, error);
+			}).catch(() => {});
+		});
+		const waiterHolder = getCurrentResolutionContext()?.waiterHolder;
+		return this.waitForInstanceReady(holder, waiterHolder, getHolder);
 	}
 	/**
-	* 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 {
+	* Creates a transient instance without storage or locking.
+	* Each call creates a new instance.
+	*/ async createTransientInstance(instanceName, record, args, contextContainer, scopedContainer, requestStorage, requestId) {
+		this.logger?.log(`[InstanceResolver]#createTransientInstance() Creating transient instance for ${instanceName}`);
+		const ctx = this.createServiceInitializationContext(scopedContainer ?? contextContainer, instanceName, InjectableScope.Transient, /* @__PURE__ */ new Set(), record.originalToken, requestStorage, requestId);
+		const [error, instance] = await this.serviceInitializer.instantiateService(ctx, record, args);
+		if (error) return [error];
+		return [void 0, {
 			status: InstanceStatus.Created,
-			name,
+			name: instanceName,
 			instance,
 			creationPromise: null,
 			destroyPromise: null,
-			type,
-			scope,
-			deps,
-			destroyListeners: [],
+			type: record.type,
+			scope: InjectableScope.Transient,
+			deps: ctx.dependencies,
+			destroyListeners: ctx.getDestroyListeners(),
 			createdAt: Date.now(),
 			waitingFor: /* @__PURE__ */ new Set()
-		};
+		}];
 	}
 	/**
-	* Gets all holder names currently managed.
-	*/ getAllNames() {
-		return Array.from(this._holders.keys());
+	* Handles successful service instantiation.
+	*/ async handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, _scopedContainer, requestStorage, _requestId) {
+		holder.instance = instance;
+		holder.status = InstanceStatus.Created;
+		const storageForSubscriptions = requestStorage || this.storage;
+		if (ctx.dependencies.size > 0) this.serviceInvalidator.setupDependencySubscriptions(instanceName, ctx.dependencies, storageForSubscriptions, holder);
+		this.logger?.log(`[InstanceResolver] Instance ${instanceName} created successfully`);
+		deferred.resolve([void 0, instance]);
 	}
 	/**
-	* Gets all holders currently managed.
-	*/ getAllHolders() {
-		return Array.from(this._holders.values());
+	* Handles service instantiation errors.
+	*/ async handleInstantiationError(instanceName, holder, deferred, scope, error) {
+		holder.status = InstanceStatus.Error;
+		holder.instance = error instanceof DIError ? error : DIError.unknown(error);
+		this.logger?.error(`[InstanceResolver] Instance ${instanceName} creation failed:`, error);
+		deferred.reject(error instanceof DIError ? error : DIError.unknown(error));
 	}
 	/**
-	* Checks if this manager has any holders.
-	*/ isEmpty() {
-		return this._holders.size === 0;
+	* Handles instantiation result (success or error).
+	*/ async handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance, scopedContainer, requestStorage, requestId) {
+		if (error) await this.handleInstantiationError(instanceName, holder, deferred, scope, error);
+		else await this.handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, scopedContainer, requestStorage, requestId);
 	}
 	/**
-	* 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.
+	* Waits for an instance holder to be ready and returns the appropriate result.
 	*
 	* @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) {
+	*/ async waitForInstanceReady(holder, waiterHolder, getHolder) {
 		switch (holder.status) {
 			case InstanceStatus.Creating:
 				if (waiterHolder && getHolder) {
@@ -691,642 +735,303 @@ let InstanceStatus = /* @__PURE__ */ function(InstanceStatus$1) {
 						if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
 					}
 				}
-				return BaseHolderManager.waitForHolderReady(holder, waiterHolder, getHolder);
+				return this.waitForInstanceReady(holder, waiterHolder, getHolder);
 			case InstanceStatus.Destroying: return [DIError.instanceDestroying(holder.name)];
 			case InstanceStatus.Error: return [holder.instance];
 			case InstanceStatus.Created: return [void 0, holder];
-			default: return [DIError.instanceNotFound("unknown")];
+			default: return [DIError.instanceNotFound(holder?.name ?? "unknown")];
 		}
 	}
+	/**
+	* Creates a ServiceInitializationContext for service instantiation.
+	*/ createServiceInitializationContext(container, serviceName, scope, deps, serviceToken, requestStorage, requestId) {
+		const destroyListeners = [];
+		return {
+			inject: async (token, args) => {
+				const actualToken = typeof token === "function" ? this.tokenResolver.normalizeToken(token) : token;
+				const realToken = this.tokenResolver.getRealToken(actualToken);
+				const depScope = this.registry.get(realToken).scope;
+				const dependencyRequestId = depScope === InjectableScope.Request ? requestId : void 0;
+				const finalDepName = this.nameResolver.generateInstanceName(actualToken, args, dependencyRequestId, depScope);
+				if (scope === InjectableScope.Singleton && depScope === InjectableScope.Request && requestStorage && requestId) {
+					const [needsUpgrade, newServiceName] = this.scopeTracker.checkAndUpgradeScope(serviceName, scope, finalDepName, depScope, serviceToken, this.storage, requestStorage, requestId);
+					if (needsUpgrade && newServiceName) {}
+				}
+				deps.add(finalDepName);
+				return container.get(token, args);
+			},
+			container,
+			addDestroyListener: (listener) => {
+				destroyListeners.push(listener);
+			},
+			getDestroyListeners: () => destroyListeners,
+			serviceName,
+			dependencies: deps,
+			scope,
+			trackDependency: (name, depScope) => {
+				deps.add(name);
+				if (scope === InjectableScope.Singleton && depScope === InjectableScope.Request && requestStorage && requestId) this.scopeTracker.checkAndUpgradeScope(serviceName, scope, name, depScope, serviceToken, this.storage, requestStorage, requestId);
+			}
+		};
+	}
 };
 
 //#endregion
-//#region src/internal/context/request-context.mts
+//#region src/internal/core/name-resolver.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);
+* Simple LRU cache for instance name generation.
+* Uses a Map which maintains insertion order for efficient LRU eviction.
+*/ var InstanceNameCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	constructor(maxSize = 1e3) {
+		this.maxSize = maxSize;
 	}
-	/**
-	* Checks if a holder exists by name.
-	*/ has(name) {
-		return this._holders.has(name);
+	get(key) {
+		const value = this.cache.get(key);
+		if (value !== void 0) {
+			this.cache.delete(key);
+			this.cache.set(key, value);
+		}
+		return value;
 	}
-	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);
+	set(key, value) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		else if (this.cache.size >= this.maxSize) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey !== void 0) this.cache.delete(firstKey);
 		}
+		this.cache.set(key, value);
 	}
 	clear() {
-		super.clear();
-		this.metadata.clear();
-	}
-	getMetadata(key) {
-		return this.metadata.get(key);
-	}
-	setMetadata(key, value) {
-		this.metadata.set(key, value);
+		this.cache.clear();
 	}
 };
 /**
-* Creates a new request context with the given parameters.
-*/ function createRequestContext(requestId, priority = 100, initialMetadata) {
-	return new DefaultRequestContext(requestId, priority, initialMetadata);
+* Simple hash function for deterministic hashing of arguments
+*/ function hashArgs(args) {
+	const str = JSON.stringify(args, Object.keys(args || {}).sort());
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return Math.abs(hash).toString(36);
 }
-
-//#endregion
-//#region src/internal/holder/request-storage.mts
 /**
-* Storage implementation for Request-scoped services.
+* Handles instance name generation with support for requestId and scope.
 *
-* 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;
+* Generates unique instance identifiers based on token, arguments, and scope.
+* Request-scoped services MUST include requestId in their name for proper isolation.
+*/ var NameResolver = class {
+	logger;
+	instanceNameCache = new InstanceNameCache();
+	constructor(logger = null) {
+		this.logger = logger;
 	}
-	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;
+	/**
+	* Generates a unique instance name based on token, arguments, requestId, and scope.
+	*
+	* Name formats:
+	* - Singleton/Transient without args: `${tokenId}`
+	* - Singleton/Transient with args: `${tokenId}:${argsHash}`
+	* - Request without args: `${tokenId}:requestId=${requestId}`
+	* - Request with args: `${tokenId}:requestId=${requestId}:${argsHash}`
+	*
+	* @param token The injection token
+	* @param args Optional arguments
+	* @param requestId Optional request ID (required for request-scoped services)
+	* @param scope Optional scope (used to determine if requestId should be included)
+	* @returns The generated instance name
+	*/ generateInstanceName(token, args, requestId, scope) {
+		const tokenStr = token.toString();
+		const isRequest = scope === InjectableScope.Request;
+		if (isRequest && !requestId) throw new Error(`[NameResolver] requestId is required for request-scoped services`);
+		const cacheKey = `${tokenStr}:${scope}:${requestId || ""}:${args ? JSON.stringify(args) : ""}`;
+		const cached = this.instanceNameCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		let result = tokenStr;
+		if (isRequest && requestId) result = `${result}:requestId=${requestId}`;
+		if (args) {
+			const argsHash = hashArgs(args);
+			result = `${result}:${argsHash}`;
 		}
+		this.instanceNameCache.set(cacheKey, result);
+		return result;
 	}
-	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;
+	/**
+	* Upgrades an existing instance name to include requestId.
+	* Preserves any args hash that might already be in the name.
+	*
+	* Examples:
+	* - `TokenName` → `TokenName:requestId=req-123`
+	* - `TokenName:abc123` → `TokenName:requestId=req-123:abc123`
+	*
+	* @param existingName The existing instance name (without requestId)
+	* @param requestId The request ID to add
+	* @returns The upgraded instance name with requestId
+	*/ upgradeInstanceNameToRequest(existingName, requestId) {
+		if (existingName.includes(`:requestId=${requestId}`)) return existingName;
+		if (/:requestId=/.test(existingName)) return existingName;
+		const colonIndex = existingName.indexOf(":");
+		if (colonIndex === -1) return `${existingName}:requestId=${requestId}`;
+		const tokenPart = existingName.substring(0, colonIndex);
+		const argsPart = existingName.substring(colonIndex + 1);
+		if (argsPart.startsWith("requestId=")) return existingName;
+		return `${tokenPart}:requestId=${requestId}:${argsPart}`;
 	}
-	findDependents(instanceName) {
-		const requestDependents = this.contextHolder.getDependents(instanceName);
-		const singletonDependents = this.holderManager.getDependents(instanceName);
-		if (requestDependents.length === 0) return singletonDependents;
-		if (singletonDependents.length === 0) return requestDependents;
-		return [...requestDependents, ...singletonDependents];
+	/**
+	* 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);
 	}
 };
 
 //#endregion
-//#region src/container/scoped-container.mts
+//#region src/internal/core/scope-tracker.mts
 /**
-* Request-scoped dependency injection container.
+* Component for tracking and handling scope upgrades.
 *
-* 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;
+* Detects when a Singleton service needs to be upgraded to Request scope
+* and coordinates the scope upgrade process atomically.
+*/ var ScopeTracker = class {
 	registry;
-	requestId;
-	requestContextHolder;
-	holderStorage;
-	disposed = false;
-	constructor(parent, registry, requestId, metadata, priority = 100) {
-		this.parent = parent;
+	nameResolver;
+	logger;
+	constructor(registry, nameResolver, logger = null) {
 		this.registry = registry;
-		this.requestId = requestId;
-		this.requestContextHolder = new DefaultRequestContext(requestId, priority, metadata);
-		this.holderStorage = new RequestStorage(this.requestContextHolder, this.parent.getServiceLocator().getManager());
+		this.nameResolver = nameResolver;
+		this.logger = logger;
 	}
 	/**
-	* Gets the request context holder for this scoped container.
-	*/ getRequestContextHolder() {
-		return this.requestContextHolder;
+	* Checks if a dependency requires scope upgrade and performs it if needed.
+	* Called during service resolution when a dependency is resolved.
+	*
+	* @param currentServiceName - Name of the service being created
+	* @param currentServiceScope - Current scope of the service being created
+	* @param dependencyName - Name of the dependency being resolved
+	* @param dependencyScope - Scope of the dependency
+	* @param dependencyToken - Token of the dependency
+	* @param singletonStorage - Singleton storage instance
+	* @param requestStorage - Request storage instance (if in request context)
+	* @param requestId - Request ID (if in request context)
+	* @returns [needsUpgrade: boolean, newName?: string] - whether upgrade occurred and new name
+	*/ checkAndUpgradeScope(currentServiceName, currentServiceScope, dependencyName, dependencyScope, dependencyToken, singletonStorage, requestStorage, requestId) {
+		if (currentServiceScope !== InjectableScope.Singleton || dependencyScope !== InjectableScope.Request) return [false];
+		if (!requestStorage || !requestId) {
+			this.logger?.warn(`[ScopeTracker] Cannot upgrade scope for ${currentServiceName}: missing requestStorage or requestId`);
+			return [false];
+		}
+		this.logger?.log(`[ScopeTracker] Upgrading ${currentServiceName} from Singleton to Request scope`);
+		try {
+			const [success, newName] = this.upgradeScopeToRequestSync(currentServiceName, dependencyToken, singletonStorage, requestStorage, requestId);
+			if (success && newName) return [true, newName];
+		} catch (error) {
+			this.logger?.error(`[ScopeTracker] Error upgrading scope for ${currentServiceName}:`, error);
+		}
+		return [false];
 	}
 	/**
-	* Gets the holder storage for this scoped container.
-	* Used by InstanceResolver for request-scoped resolution.
-	*/ getHolderStorage() {
-		return this.holderStorage;
+	* Performs the actual scope upgrade from Singleton to Request.
+	* This is the core migration logic.
+	*
+	* @param serviceName - Current service name (without requestId)
+	* @param token - Service injection token
+	* @param singletonStorage - Source storage
+	* @param requestStorage - Target storage
+	* @param requestId - Request ID to include in new name
+	* @returns [success: boolean, newName?: string, error?: DIError]
+	*/ async upgradeScopeToRequest(serviceName, token, singletonStorage, requestStorage, requestId) {
+		try {
+			const [success, newName] = this.upgradeScopeToRequestSync(serviceName, token, singletonStorage, requestStorage, requestId);
+			if (success && newName) return [true, newName];
+			return [
+				false,
+				void 0,
+				DIError.storageError("Scope upgrade failed", "upgradeScopeToRequest", serviceName)
+			];
+		} catch (error) {
+			return [
+				false,
+				void 0,
+				error instanceof DIError ? error : DIError.unknown(error)
+			];
+		}
 	}
 	/**
-	* Gets the request ID for this scoped container.
-	*/ getRequestId() {
-		return this.requestId;
+	* Synchronous part of scope upgrade - handles immediate updates.
+	* Async operations (like waiting for holder creation) should be done separately.
+	*/ upgradeScopeToRequestSync(serviceName, token, singletonStorage, requestStorage, requestId) {
+		const newName = this.nameResolver.upgradeInstanceNameToRequest(serviceName, requestId);
+		if (!this.registry.updateScope(token, InjectableScope.Request)) {
+			this.logger?.warn(`[ScopeTracker] Could not update scope in registry for ${serviceName}`);
+			return [false];
+		}
+		const holderResult = singletonStorage.get(serviceName);
+		if (holderResult === null) return [true, newName];
+		const [error, holder] = holderResult;
+		if (error) {
+			this.logger?.warn(`[ScopeTracker] Holder for ${serviceName} is in error state: ${error.message}`);
+			return [false];
+		}
+		if (!holder) return [false];
+		if (holder.status === InstanceStatus.Creating) {
+			holder.name = newName;
+			requestStorage.set(newName, holder);
+			singletonStorage.delete(serviceName);
+			this.updateParentDependencies(serviceName, newName, singletonStorage, requestStorage);
+			return [true, newName];
+		}
+		holder.name = newName;
+		requestStorage.set(newName, holder);
+		singletonStorage.delete(serviceName);
+		this.updateParentDependencies(serviceName, newName, singletonStorage, requestStorage);
+		return [true, newName];
 	}
 	/**
-	* Gets the parent container.
-	*/ getParent() {
-		return this.parent;
+	* Updates all parent dependencies to reference the new service name.
+	*
+	* @param oldName - Original service name
+	* @param newName - New service name with requestId
+	* @param singletonStorage - Singleton storage to check
+	* @param requestStorage - Request storage to check
+	*/ updateParentDependencies(oldName, newName, singletonStorage, requestStorage) {
+		singletonStorage.updateDependencyReference(oldName, newName);
+		if (requestStorage) requestStorage.updateDependencyReference(oldName, newName);
 	}
-	/**
-	* Gets metadata from the request context.
-	*/ getMetadata(key) {
-		return this.requestContextHolder.getMetadata(key);
+};
+
+//#endregion
+//#region src/internal/core/service-initializer.mts
+/**
+* Creates service instances from registry records.
+*
+* Handles both class-based (@Injectable) and factory-based (@Factory) services,
+* managing the instantiation lifecycle including lifecycle hook invocation.
+*/ var ServiceInitializer = class {
+	injectors;
+	constructor(injectors) {
+		this.injectors = injectors;
 	}
 	/**
-	* Sets metadata on the request context.
-	*/ setMetadata(key, value) {
-		this.requestContextHolder.setMetadata(key, value);
-	}
-	/**
-	* Adds a pre-prepared instance to the request context.
-	*/ addInstance(token, instance) {
-		this.requestContextHolder.addInstance(token, instance);
-	}
-	async get(token, args) {
-		if (this.disposed) throw DIError.unknown(`ScopedContainer for request ${this.requestId} has been disposed`);
-		const actualToken = this.parent.getServiceLocator().getTokenProcessor().normalizeToken(token);
-		if (this.isRequestScoped(actualToken)) return this.resolveRequestScoped(actualToken, args);
-		return this.parent.getWithContext(token, args, this);
-	}
-	/**
-	* Invalidates a service and its dependencies.
-	* For request-scoped services, invalidation is handled within this context.
-	*/ async invalidate(service) {
-		const holder = this.holderStorage.findByInstance(service);
-		if (holder) {
-			await this.parent.getServiceLocator().getInvalidator().invalidateWithStorage(holder.name, this.holderStorage, 1, { emitEvents: false });
-			return;
-		}
-		await this.parent.invalidate(service);
-	}
-	/**
-	* Checks if a service is registered.
-	*/ isRegistered(token) {
-		return this.parent.isRegistered(token);
-	}
-	/**
-	* Disposes this scoped container and cleans up all request-scoped instances.
-	* This is an alias for endRequest() for IContainer compatibility.
-	*/ async dispose() {
-		await this.endRequest();
-	}
-	/**
-	* Ends the request and cleans up all request-scoped instances.
-	* Uses the invalidation system to properly cascade to dependent singletons.
-	*/ async endRequest() {
-		if (this.disposed) return;
-		this.disposed = true;
-		await this.parent.getServiceLocator().getInvalidator().clearAllWithStorage(this.holderStorage, {
-			waitForSettlement: true,
-			maxRounds: 10
-		});
-		this.requestContextHolder.clear();
-		this.parent.removeActiveRequest(this.requestId);
-	}
-	/**
-	* Waits for all pending operations to complete.
-	*/ async ready() {
-		await this.parent.ready();
-	}
-	/**
-	* @internal
-	* Attempts to get an instance synchronously if it already exists and is ready.
-	* For request-scoped services, checks this container's context first.
-	* For other services, delegates to the parent container.
-	*
-	* Returns null if the instance doesn't exist or is not yet ready (still creating).
-	*/ tryGetSync(token, args) {
-		const actualToken = this.parent.getServiceLocator().getTokenProcessor().normalizeToken(token);
-		if (this.isRequestScoped(actualToken)) {
-			const instanceName = this.parent.getServiceLocator().getInstanceIdentifier(token, args);
-			const holder = this.requestContextHolder.get(instanceName);
-			if (holder && holder.status === InstanceStatus.Created) return holder.instance;
-			return null;
-		}
-		return this.parent.tryGetSync(token, args);
-	}
-	/**
-	* Checks if a token is for a request-scoped service.
-	*/ isRequestScoped(token) {
-		const realToken = this.parent.getServiceLocator().getTokenProcessor().getRealToken(token);
-		if (!this.registry.has(realToken)) return false;
-		return this.registry.get(realToken).scope === InjectableScope.Request;
-	}
-	/**
-	* Resolves a request-scoped service from this container's context.
-	* Uses locking to prevent duplicate initialization during concurrent resolution.
-	*/ async resolveRequestScoped(token, args) {
-		const instanceName = this.parent.getServiceLocator().getInstanceIdentifier(token, args);
-		const existingHolder = this.requestContextHolder.get(instanceName);
-		if (existingHolder) if (existingHolder.status === InstanceStatus.Error) this.requestContextHolder.delete(instanceName);
-		else {
-			const [error, readyHolder] = await BaseHolderManager.waitForHolderReady(existingHolder);
-			if (error) throw error;
-			return readyHolder.instance;
-		}
-		return this.parent.resolveForRequest(token, args, this);
-	}
-	/**
-	* Stores an instance in the request context.
-	* Called by Container during request-scoped service resolution.
-	*/ storeRequestInstance(instanceName, instance, holder) {
-		this.requestContextHolder.addInstance(instanceName, instance, holder);
-	}
-	/**
-	* Gets an existing instance from the request context.
-	* Called by Container during resolution to check for existing instances.
-	*/ getRequestInstance(instanceName) {
-		return this.requestContextHolder.get(instanceName);
-	}
-	/**
-	* Generates a prefixed event name for request-scoped services.
-	* Format: {requestId}:{instanceName}
-	*/ getPrefixedEventName(instanceName) {
-		return `${this.requestId}:${instanceName}`;
-	}
-};
-
-//#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) {
-		this.manager.forEachHolder((holder, name) => callback(name, holder));
-	}
-	findByInstance(instance) {
-		return this.manager.findHolder((h) => h.instance === instance) ?? null;
-	}
-	findDependents(instanceName) {
-		return this.manager.getDependents(instanceName);
-	}
-};
-
-//#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:
-				if (holder) {
-					this.logger?.log(`[InstanceResolver] Removing failed instance ${instanceName} from storage to allow retry`);
-					storage.delete(instanceName);
-				}
-				return null;
-		}
-	}
-	/**
-	* Creates a new instance and stores it using the provided storage strategy.
-	* This unified method replaces instantiateServiceFromRegistry and createRequestScopedInstance.
-	*
-	* For transient services, the instance is created but not stored (no caching).
-	*/ async createAndStoreInstance(instanceName, realToken, args, contextContainer, storage, scopedContainer) {
-		this.logger?.log(`[InstanceResolver]#createAndStoreInstance() Creating instance for ${instanceName}`);
-		if (!this.registry.has(realToken)) return [DIError.factoryNotFound(realToken.name.toString())];
-		const ctx = this.createFactoryContext(contextContainer);
-		const record = this.registry.get(realToken);
-		const { scope, type } = record;
-		if (scope === InjectableScope.Transient) return this.createTransientInstance(instanceName, record, args, ctx);
-		const [deferred, holder] = this.manager.createCreatingHolder(instanceName, type, scope, ctx.deps);
-		storage.set(instanceName, holder);
-		const getHolder = (name) => {
-			const storageResult = storage.get(name);
-			if (storageResult !== null) {
-				const [, storageHolder] = storageResult;
-				if (storageHolder) return storageHolder;
-			}
-			const [, managerHolder] = this.manager.get(name);
-			return managerHolder;
-		};
-		withResolutionContext(holder, getHolder, () => {
-			this.instantiator.instantiateService(ctx, record, args).then(async (result) => {
-				const [error, instance] = result.length === 2 ? result : [result[0], void 0];
-				await this.handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance, scopedContainer);
-			}).catch(async (error) => {
-				await this.handleInstantiationError(instanceName, holder, deferred, scope, error);
-			}).catch(() => {});
-		});
-		return this.waitForInstanceReady(holder);
-	}
-	/**
-	* Creates a transient instance without storage or locking.
-	* Each call creates a new instance.
-	*/ async createTransientInstance(instanceName, record, args, ctx) {
-		this.logger?.log(`[InstanceResolver]#createTransientInstance() Creating transient instance for ${instanceName}`);
-		const tempHolder = {
-			status: InstanceStatus.Creating,
-			name: instanceName,
-			instance: null,
-			creationPromise: null,
-			destroyPromise: null,
-			type: record.type,
-			scope: InjectableScope.Transient,
-			deps: ctx.deps,
-			destroyListeners: [],
-			createdAt: Date.now(),
-			waitingFor: /* @__PURE__ */ new Set()
-		};
-		const getHolder = (name) => {
-			const [, managerHolder] = this.manager.get(name);
-			return managerHolder;
-		};
-		const [error, instance] = await withResolutionContext(tempHolder, getHolder, () => this.instantiator.instantiateService(ctx, record, args));
-		if (error) return [error];
-		return [void 0, {
-			status: InstanceStatus.Created,
-			name: instanceName,
-			instance,
-			creationPromise: null,
-			destroyPromise: null,
-			type: record.type,
-			scope: InjectableScope.Transient,
-			deps: ctx.deps,
-			destroyListeners: ctx.getDestroyListeners(),
-			createdAt: Date.now(),
-			waitingFor: /* @__PURE__ */ new Set()
-		}];
-	}
-	/**
-	* Gets a synchronous instance (for sync operations).
-	*/ getSyncInstance(token, args, contextContainer) {
-		const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
-		if (err) return null;
-		const instanceName = this.tokenProcessor.generateInstanceName(actualToken, validatedArgs);
-		if ("getRequestInstance" in contextContainer) {
-			const requestHolder = contextContainer.getRequestInstance(instanceName);
-			if (requestHolder) return requestHolder.instance;
-		}
-		const [error, holder] = this.manager.get(instanceName);
-		if (error) return null;
-		return holder.instance;
-	}
-	/**
-	* Internal method to resolve token args and create instance name.
-	* Handles factory token resolution and validation.
-	*/ async resolveTokenAndPrepareInstanceName(token, args, contextContainer) {
-		const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
-		if (err instanceof DIError && err.code === DIErrorCode.UnknownError) return [err];
-		else if (err instanceof DIError && err.code === DIErrorCode.FactoryTokenNotResolved && actualToken instanceof FactoryInjectionToken) {
-			this.logger?.log(`[InstanceResolver]#resolveTokenAndPrepareInstanceName() Factory token not resolved, resolving it`);
-			await actualToken.resolve(this.createFactoryContext(contextContainer));
-			return this.resolveTokenAndPrepareInstanceName(token, void 0, contextContainer);
-		}
-		return [void 0, {
-			instanceName: this.tokenProcessor.generateInstanceName(actualToken, validatedArgs),
-			validatedArgs,
-			actualToken,
-			realToken: actualToken instanceof BoundInjectionToken || actualToken instanceof FactoryInjectionToken ? actualToken.token : actualToken
-		}];
-	}
-	/**
-	* Waits for an instance holder to be ready and returns the appropriate result.
-	* Uses the shared utility from BaseHolderManager.
-	* Passes the current resolution context for circular dependency detection.
-	*/ waitForInstanceReady(holder) {
-		const ctx = getCurrentResolutionContext();
-		return BaseHolderManager.waitForHolderReady(holder, ctx?.waiterHolder, ctx?.getHolder);
-	}
-	/**
-	* Handles the result of service instantiation.
-	*/ async handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance, scopedContainer) {
-		holder.destroyListeners = ctx.getDestroyListeners();
-		holder.creationPromise = null;
-		if (error) await this.handleInstantiationError(instanceName, holder, deferred, scope, error);
-		else await this.handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, scopedContainer);
-	}
-	/**
-	* Handles successful service instantiation.
-	*/ async handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance, scopedContainer) {
-		holder.instance = instance;
-		holder.status = InstanceStatus.Created;
-		if (ctx.deps.size > 0) if (scopedContainer) scopedContainer.getRequestContextHolder().registerDependencies(instanceName, ctx.deps);
-		else this.manager.registerDependencies(instanceName, ctx.deps);
-		if (ctx.deps.size > 0) ctx.deps.forEach((dependency) => {
-			holder.destroyListeners.push(this.serviceLocator.getEventBus().on(dependency, "destroy", () => {
-				this.logger?.log(`[InstanceResolver] Dependency ${dependency} destroyed, invalidating ${instanceName}`);
-				this.serviceLocator.getInvalidator().invalidate(instanceName);
-			}));
-			if (scopedContainer) {
-				const prefixedDependency = scopedContainer.getPrefixedEventName(dependency);
-				holder.destroyListeners.push(this.serviceLocator.getEventBus().on(prefixedDependency, "destroy", () => {
-					this.logger?.log(`[InstanceResolver] Request-scoped dependency ${dependency} destroyed, invalidating ${instanceName}`);
-					scopedContainer.invalidate(instance);
-				}));
-			}
-		});
-		this.logger?.log(`[InstanceResolver] Instance ${instanceName} created successfully`);
-		deferred.resolve([void 0, instance]);
-	}
-	/**
-	* Handles service instantiation errors.
-	*/ async handleInstantiationError(instanceName, holder, deferred, scope, error) {
-		this.logger?.error(`[InstanceResolver] Error creating instance for ${instanceName}`, error);
-		holder.status = InstanceStatus.Error;
-		holder.instance = error;
-		holder.creationPromise = null;
-		if (scope === InjectableScope.Singleton) {
-			this.logger?.log(`[InstanceResolver] Singleton ${instanceName} failed, will be invalidated`);
-			this.serviceLocator.getInvalidator().invalidate(instanceName).catch(() => {});
-		}
-		deferred.reject(error);
-	}
-	/**
-	* Creates a factory context for dependency injection during service instantiation.
-	*/ createFactoryContext(contextContainer) {
-		return this.tokenProcessor.createFactoryContext(contextContainer);
-	}
-};
-
-//#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 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(`[ServiceInitializer] Unknown service type: ${record.type}`);
+			}
+		} catch (error) {
+			return [error instanceof DIError ? error : DIError.initializationError(record.target.name, error)];
+		}
 	}
 	/**
 	* Instantiates a class-based service (Injectable decorator).
@@ -1344,18 +1049,18 @@ var SingletonStorage = class {
 			});
 			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.`);
+				if ((await Promise.allSettled(promises)).some((result) => result.status === "rejected")) throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service 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.
+				console.error(`[ServiceInitializer] ${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.
+       One or more of the dependencies are registered as a InjectableScope.Transient 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.`);
+       Please use asyncInject instead of inject to load those dependencies.`);
+				throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service cannot be instantiated"));
 			}
 			if ("onServiceInit" in instance) await instance.onServiceInit();
 			if ("onServiceDestroy" in instance) ctx.addDestroyListener(async () => {
@@ -1363,7 +1068,7 @@ var SingletonStorage = class {
 			});
 			return [void 0, instance];
 		} catch (error) {
-			return [error instanceof DIError ? error : DIError.unknown(String(error))];
+			return [error instanceof DIError ? error : DIError.initializationError(record.target.name, error)];
 		}
 	}
 	/**
@@ -1382,242 +1087,503 @@ var SingletonStorage = class {
 			});
 			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.`);
+				if ((await Promise.allSettled(promises)).some((result) => result.status === "rejected")) throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service 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.
+				console.error(`[ServiceInitializer] ${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.
+       One or more of the dependencies are registered as a InjectableScope.Transient 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.`);
+				throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service cannot be instantiated"));
 			}
-			if (typeof builder.create !== "function") throw DIError.unknown(`[Instantiator] Factory ${record.target.name} does not implement the create method.`);
+			if (typeof builder.create !== "function") throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Factory 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))];
+			return [error instanceof DIError ? error : DIError.initializationError(record.target.name, error)];
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/core/service-invalidator.mts
+/**
+* Manages graceful service cleanup with event-based invalidation.
+*
+* Uses event subscriptions instead of manual dependent finding.
+* When a service is created, it subscribes to destroy events of its dependencies.
+* When a dependency is destroyed, the event automatically invalidates dependents.
+*/ var ServiceInvalidator = class {
+	eventBus;
+	logger;
+	constructor(eventBus, logger = null) {
+		this.eventBus = eventBus;
+		this.logger = logger;
+	}
+	/**
+	* Invalidates a service using a specific storage.
+	* Event-based invalidation means dependents are automatically invalidated
+	* via destroy event subscriptions - no need to manually find dependents.
+	*
+	* @param service The instance name to invalidate
+	* @param storage The storage to use for this invalidation
+	* @param options Additional options for invalidation behavior
+	*/ async invalidateWithStorage(service, storage, options = {}) {
+		const { emitEvents = true, onInvalidated } = options;
+		this.logger?.log(`[ServiceInvalidator] Starting invalidation process for ${service}`);
+		const result = storage.get(service);
+		if (result === null) return;
+		const [, holder] = result;
+		if (holder) await this.invalidateHolderWithStorage(service, holder, storage, emitEvents, onInvalidated);
+	}
+	/**
+	* Sets up destroy event subscriptions for a service's dependencies.
+	* Called when a service is successfully instantiated.
+	*
+	* @param serviceName The name of the service
+	* @param dependencies The set of dependency names
+	* @param storage The storage to use for invalidation
+	* @param holder The holder for the service (to add unsubscribe to destroy listeners)
+	*/ setupDependencySubscriptions(serviceName, dependencies, storage, holder) {
+		if (!this.eventBus) return;
+		for (const dependencyName of dependencies) {
+			const unsubscribe = this.eventBus.on(dependencyName, "destroy", () => {
+				this.logger?.log(`[ServiceInvalidator] Dependency ${dependencyName} destroyed, invalidating ${serviceName}`);
+				this.invalidateWithStorage(serviceName, storage).catch((error) => {
+					this.logger?.error(`[ServiceInvalidator] Error invalidating ${serviceName} after dependency ${dependencyName} destroyed:`, error);
+				});
+			});
+			holder.destroyListeners.push(unsubscribe);
+		}
+	}
+	/**
+	* Gracefully clears all services in a specific storage.
+	* This allows clearing request-scoped services using a RequestStorage.
+	*/ async clearAllWithStorage(storage, options = {}) {
+		const { waitForSettlement = true } = options;
+		this.logger?.log("[ServiceInvalidator] Starting graceful clearing of all services");
+		if (waitForSettlement) {
+			this.logger?.log("[ServiceInvalidator] Waiting for all services to settle...");
+			await this.readyWithStorage(storage);
+		}
+		const allServiceNames = storage.getAllNames();
+		if (allServiceNames.length === 0) this.logger?.log("[ServiceInvalidator] No services to clear");
+		else {
+			this.logger?.log(`[ServiceInvalidator] Found ${allServiceNames.length} services to clear: ${allServiceNames.join(", ")}`);
+			const clearPromises = allServiceNames.map((serviceName) => this.invalidateWithStorage(serviceName, storage));
+			await Promise.all(clearPromises);
+		}
+		this.logger?.log("[ServiceInvalidator] Graceful clearing completed");
+	}
+	/**
+	* 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, emitEvents, onInvalidated) {
+		await this.invalidateHolderByStatus(holder, {
+			context: key,
+			onDestroy: () => this.destroyHolderWithStorage(key, holder, storage, emitEvents, onInvalidated)
+		});
+	}
+	/**
+	* Common invalidation logic for holders based on their status.
+	*/ async invalidateHolderByStatus(holder, options) {
+		switch (holder.status) {
+			case InstanceStatus.Destroying:
+				await holder.destroyPromise;
+				break;
+			case InstanceStatus.Creating:
+				await holder.creationPromise;
+				await options.onDestroy();
+				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(`[ServiceInvalidator] 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;
 		}
 	}
+	/**
+	* Emits events to listeners for instance lifecycle events.
+	*/ emitInstanceEvent(name, event = "create") {
+		if (!this.eventBus) return Promise.resolve();
+		this.logger?.log(`[ServiceInvalidator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`);
+		return this.eventBus.emit(name, event);
+	}
 };
 
 //#endregion
-//#region src/internal/core/invalidator.mts
+//#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 ctx = getFactoryContext();
+		const instance = ctx.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`);
+			} });
+		}
+		ctx.inject(realToken, args).catch(() => {});
+		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/default-injectors.mts
+const defaultInjectors = /* @__PURE__ */ getInjectors();
+const inject = defaultInjectors.inject;
+const optional = defaultInjectors.optional;
+const asyncInject = defaultInjectors.asyncInject;
+const wrapSyncInit = defaultInjectors.wrapSyncInit;
+const provideFactoryContext = defaultInjectors.provideFactoryContext;
+
+//#endregion
+//#region src/utils/get-injectable-token.mts
+function getInjectableToken(target) {
+	const token = target[InjectableTokenMeta];
+	if (!token) throw DIError.classNotInjectable(target.name);
+	return token;
+}
+
+//#endregion
+//#region src/internal/core/token-resolver.mts
 /**
-* Manages graceful service cleanup with dependency-aware invalidation.
+* Handles token validation and resolution.
 *
-* 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;
+* Focuses on token validation, normalization, and argument validation.
+* Name generation is handled by NameResolver.
+*/ var TokenResolver = class {
 	logger;
-	storage;
-	constructor(manager, eventBus, logger = null) {
-		this.eventBus = eventBus;
+	constructor(logger = null) {
 		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);
+	* 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;
 	}
 	/**
-	* Invalidates a service using a specific storage.
-	* This allows request-scoped invalidation using a RequestStorage.
+	* Gets the underlying "real" token from wrapped tokens.
+	* For BoundInjectionToken and FactoryInjectionToken, returns the wrapped token.
+	* For other tokens, returns the token itself.
 	*
-	* @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);
+	* @param token The token to unwrap
+	* @returns The underlying InjectionToken
+	*/ getRealToken(token) {
+		if (token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken) return token.token;
+		return token;
 	}
 	/**
-	* 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);
+	* 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));
 	}
 	/**
-	* 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);
+	* Validates and resolves token arguments, handling factory token resolution and validation.
+	*
+	* @param token The token to validate
+	* @param args Optional arguments
+	* @returns [error, { actualToken, validatedArgs }]
+	*/ 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(`[TokenResolver]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`, validatedArgs.error);
+			return [DIError.tokenValidationError(`Validation failed for ${actualToken.name.toString()}`, actualToken.schema, realArgs), { actualToken }];
 		}
-		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)));
+		return [void 0, {
+			actualToken,
+			validatedArgs: validatedArgs?.data
+		}];
 	}
+};
+
+//#endregion
+//#region src/internal/holder/unified-storage.mts
+/**
+* Unified storage implementation that works the same way regardless of scope.
+* Replaces RequestContext, HolderManager, SingletonStorage, RequestStorage.
+*
+* Scope is just metadata - storage operations are identical for all scopes.
+* Different storage instances are just isolated storage spaces.
+*/ var UnifiedStorage = class {
+	scope;
+	holders = /* @__PURE__ */ new Map();
 	/**
-	* 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)
-		});
+	* Reverse dependency index: maps a dependency name to the set of holder names that depend on it.
+	* This allows O(1) lookup of dependents instead of O(n) iteration.
+	*/ dependents = /* @__PURE__ */ new Map();
+	constructor(scope = InjectableScope.Singleton) {
+		this.scope = scope;
 	}
-	/**
-	* Common invalidation logic for holders based on their status.
-	*/ async invalidateHolderByStatus(holder, round, options) {
+	get(instanceName) {
+		const holder = this.holders.get(instanceName);
+		if (!holder) return null;
 		switch (holder.status) {
-			case InstanceStatus.Destroying:
-				await holder.destroyPromise;
-				break;
+			case InstanceStatus.Destroying: return [DIError.instanceDestroying(instanceName), holder];
+			case InstanceStatus.Error: return [holder.instance, holder];
 			case InstanceStatus.Creating:
-				await holder.creationPromise;
-				if (round > 3) {
-					options.onCreationError();
-					return;
-				}
-				await options.onRecursiveInvalidate();
-				break;
-			default:
-				await options.onDestroy();
-				break;
+			case InstanceStatus.Created: return [void 0, holder];
+			default: return null;
 		}
 	}
-	/**
-	* 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);
+	set(instanceName, holder) {
+		this.holders.set(instanceName, holder);
+		if (holder.deps.size > 0) this.registerDependencies(instanceName, holder.deps);
+	}
+	delete(instanceName) {
+		const holder = this.holders.get(instanceName);
+		if (holder) this.removeFromDependentsIndex(instanceName, holder.deps);
+		return this.holders.delete(instanceName);
+	}
+	createHolder(instanceName, type, deps) {
+		const deferred = Promise.withResolvers();
+		return [deferred, {
+			status: InstanceStatus.Creating,
+			name: instanceName,
+			instance: null,
+			creationPromise: deferred.promise,
+			destroyPromise: null,
+			type,
+			scope: this.scope,
+			deps,
+			destroyListeners: [],
+			createdAt: Date.now(),
+			waitingFor: /* @__PURE__ */ new Set()
+		}];
+	}
+	storeInstance(instanceName, instance) {
+		if (this.holders.get(instanceName)) throw DIError.storageError("Instance already stored", "storeInstance", instanceName);
+		this.set(instanceName, {
+			status: InstanceStatus.Created,
+			name: instanceName,
+			instance,
+			creationPromise: null,
+			destroyPromise: null,
+			type: InjectableType.Class,
+			scope: this.scope,
+			deps: /* @__PURE__ */ new Set(),
+			destroyListeners: typeof instance === "object" && instance !== null && "onServiceDestroy" in instance ? [instance.onServiceDestroy] : [],
+			createdAt: Date.now(),
+			waitingFor: /* @__PURE__ */ new Set()
 		});
-		await holder.destroyPromise;
+	}
+	handles(scope) {
+		return scope === this.scope;
+	}
+	getAllNames() {
+		return Array.from(this.holders.keys());
+	}
+	forEach(callback) {
+		for (const [name, holder] of this.holders) callback(name, holder);
+	}
+	findByInstance(instance) {
+		for (const holder of this.holders.values()) if (holder.instance === instance) return holder;
+		return null;
+	}
+	findDependents(instanceName) {
+		const dependents = this.dependents.get(instanceName);
+		return dependents ? Array.from(dependents) : [];
 	}
 	/**
-	* 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;
+	* Updates dependency references when instance names change.
+	* Used during scope upgrades when instance names are regenerated with requestId.
+	*
+	* @param oldName The old instance name
+	* @param newName The new instance name
+	*/ updateDependencyReference(oldName, newName) {
+		for (const holder of this.holders.values()) if (holder.deps.has(oldName)) {
+			holder.deps.delete(oldName);
+			holder.deps.add(newName);
+		}
+		const oldDependents = this.dependents.get(oldName);
+		if (oldDependents) {
+			const newDependents = this.dependents.get(newName) || /* @__PURE__ */ new Set();
+			for (const dependent of oldDependents) newDependents.add(dependent);
+			this.dependents.set(newName, newDependents);
+			this.dependents.delete(oldName);
+		}
+		for (const [depName, dependents] of this.dependents.entries()) if (depName === oldName) {
+			const newDependents = this.dependents.get(newName) || /* @__PURE__ */ new Set();
+			for (const dependent of dependents) newDependents.add(dependent);
+			this.dependents.set(newName, newDependents);
+			this.dependents.delete(oldName);
 		}
 	}
 	/**
-	* 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;
+	* Registers a holder's dependencies in the reverse index.
+	*/ registerDependencies(holderName, deps) {
+		for (const dep of deps) {
+			let dependents = this.dependents.get(dep);
+			if (!dependents) {
+				dependents = /* @__PURE__ */ new Set();
+				this.dependents.set(dep, dependents);
 			}
-			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++;
+			dependents.add(holderName);
 		}
-		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);
+	* Removes a holder from the reverse dependency index.
+	*/ removeFromDependentsIndex(holderName, deps) {
+		for (const dep of deps) {
+			const dependents = this.dependents.get(dep);
+			if (dependents) {
+				dependents.delete(holderName);
+				if (dependents.size === 0) this.dependents.delete(dep);
 			}
-		});
-		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);
+		}
 	}
 };
 
@@ -1641,328 +1607,242 @@ var SingletonStorage = class {
 		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
-/**
-* Simple LRU cache for instance name generation.
-* Uses a Map which maintains insertion order for efficient LRU eviction.
-*/ var InstanceNameCache = class {
-	cache = /* @__PURE__ */ new Map();
-	maxSize;
-	constructor(maxSize = 1e3) {
-		this.maxSize = maxSize;
-	}
-	get(key) {
-		const value = this.cache.get(key);
-		if (value !== void 0) {
-			this.cache.delete(key);
-			this.cache.set(key, value);
-		}
-		return value;
-	}
-	set(key, value) {
-		if (this.cache.has(key)) this.cache.delete(key);
-		else if (this.cache.size >= this.maxSize) {
-			const firstKey = this.cache.keys().next().value;
-			if (firstKey !== void 0) this.cache.delete(firstKey);
-		}
-		this.cache.set(key, value);
+		return () => {
+			nsEvents.get(event)?.delete(listener);
+			if (nsEvents.get(event)?.size === 0) nsEvents.delete(event);
+			if (nsEvents.size === 0) this.listeners.delete(ns);
+		};
 	}
-	clear() {
-		this.cache.clear();
+	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/stub-factory-class.mts
 /**
-* Handles token validation, normalization, and instance name generation.
+* Stub factory class used when registering InjectionTokens without a real class implementation.
+* This is used in ScopedContainer.addInstance() to allow registering tokens that don't have
+* a corresponding class, while preventing accidental instantiation.
 *
-* Provides utilities for resolving tokens to their underlying InjectionToken,
-* validating arguments against schemas, and generating unique instance identifiers.
-*/ var TokenProcessor = class {
-	logger;
-	instanceNameCache = new InstanceNameCache();
-	constructor(logger = null) {
-		this.logger = logger;
+* @internal
+*/ var StubFactoryClass = class {
+	constructor() {
+		throw DIError.factoryNotFound("Trying to get instance of factory without real implementation");
 	}
+};
+
+//#endregion
+//#region src/container/abstract-container.mts
+/**
+* Abstract base class for dependency injection containers.
+*
+* Provides shared implementation for common container operations.
+* Both Container and ScopedContainer extend this class.
+*/ var AbstractContainer = class {
 	/**
-	* Normalizes a token to an InjectionToken.
-	* Handles class constructors by getting their injectable token.
+	* Calculates the instance name for a given token and optional arguments.
 	*
-	* @param token A class constructor, InjectionToken, BoundInjectionToken, or FactoryInjectionToken
-	* @returns The normalized InjectionTokenType
-	*/ normalizeToken(token) {
-		if (typeof token === "function") return getInjectableToken(token);
-		return token;
+	* @internal
+	* @param token The class type, InjectionToken, BoundInjectionToken, or FactoryInjectionToken
+	* @param args Optional arguments (ignored for BoundInjectionToken which uses its bound value)
+	* @returns The calculated instance name string, or null if the token is a FactoryInjectionToken that is not yet resolved
+	*/ calculateInstanceName(token, args) {
+		const [err, { actualToken, validatedArgs }] = this.getTokenResolver().validateAndResolveTokenArgs(token, args);
+		if (err) {
+			if (err instanceof DIError && err.code === DIErrorCode.FactoryTokenNotResolved) return null;
+			if (err instanceof DIError && err.code === DIErrorCode.TokenValidationError) return null;
+		}
+		const realToken = this.getTokenResolver().getRealToken(actualToken);
+		const registry = this.getRegistry();
+		const scope = registry.has(realToken) ? registry.get(realToken).scope : this.defaultScope;
+		return this.getNameResolver().generateInstanceName(actualToken, validatedArgs, scope === InjectableScope.Request ? this.requestId : void 0, scope);
 	}
 	/**
-	* 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;
+	* Checks if a service is registered in the container.
+	*/ isRegistered(token) {
+		const realToken = this.getTokenResolver().getRegistryToken(token);
+		return this.getRegistry().has(realToken);
 	}
 	/**
-	* 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));
+	* Waits for all pending operations to complete.
+	*/ async ready() {
+		await this.getServiceInvalidator().readyWithStorage(this.getStorage());
 	}
 	/**
-	* 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
-		}];
+	* @internal
+	* Attempts to get an instance synchronously if it already exists.
+	*/ tryGetSync(token, args) {
+		return this.tryGetSyncFromStorage(token, args, this.getStorage(), this.requestId);
 	}
 	/**
-	* Generates a unique instance name based on token and arguments.
-	* Results are cached using an LRU cache for performance.
-	*/ generateInstanceName(token, args) {
-		if (!args) return token.toString();
-		const tokenStr = token.toString();
-		const cacheKey = `${tokenStr}:${JSON.stringify(args)}`;
-		const cached = this.instanceNameCache.get(cacheKey);
-		if (cached !== void 0) return cached;
-		const result = `${tokenStr}:${Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",").replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
-		this.instanceNameCache.set(cacheKey, result);
-		return result;
+	* @internal
+	* Internal method for getting instances synchronously with configurable storage.
+	*/ tryGetSyncFromStorage(token, args, storage, requestId) {
+		const tokenResolver = this.getTokenResolver();
+		const realToken = tokenResolver.getRegistryToken(token);
+		const registry = this.getRegistry();
+		const scope = registry.has(realToken) ? registry.get(realToken).scope : InjectableScope.Singleton;
+		try {
+			const instanceName = this.getNameResolver().generateInstanceName(tokenResolver.normalizeToken(token), args, requestId, scope);
+			const result = storage.get(instanceName);
+			if (result && result[0] === void 0 && result[1]) {
+				const holder = result[1];
+				if (holder.status === InstanceStatus.Created) return holder.instance;
+			}
+		} catch {}
+		return null;
 	}
 	/**
-	* 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);
+	* Adds an instance to the container.
+	* Accepts class types, InjectionTokens, and BoundInjectionTokens.
+	* Rejects InjectionTokens with required schemas (use BoundInjectionToken instead).
+	*
+	* @param token The class type, InjectionToken, or BoundInjectionToken to register the instance for
+	* @param instance The instance to store
+	*/ addInstance(token, instance) {
+		this.addInstanceToStorage(token, instance, this.getStorage(), this.defaultScope, this.requestId);
 	}
 	/**
-	* 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);
+	* @internal
+	* Internal method for adding instances with configurable scope and storage.
+	*/ addInstanceToStorage(token, instance, storage, scope, requestId) {
+		if (token instanceof InjectionToken) {
+			if (token.schema) {
+				if (token.schema?.def?.type !== "optional") throw DIError.tokenSchemaRequiredError(token.name);
+			}
 		}
-		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
-		};
+		const tokenResolver = this.getTokenResolver();
+		const registry = this.getRegistry();
+		const normalizedToken = tokenResolver.normalizeToken(token);
+		const realToken = tokenResolver.getRegistryToken(token);
+		if (typeof token === "function" && !registry.has(realToken)) registry.set(realToken, scope, token, InjectableType.Class);
+		else if (!registry.has(realToken)) registry.set(realToken, scope, StubFactoryClass, InjectableType.Class, -1);
+		const instanceName = this.getNameResolver().generateInstanceName(normalizedToken, normalizedToken instanceof BoundInjectionToken ? normalizedToken.value : void 0, requestId, scope);
+		storage.storeInstance(instanceName, instance);
 	}
 };
 
 //#endregion
-//#region src/internal/core/service-locator.mts
+//#region src/container/scoped-container.mts
 /**
-* Core DI engine that coordinates service instantiation, resolution, and lifecycle.
+* Request-scoped dependency injection container.
 *
-* Acts as the central orchestrator for dependency injection operations,
-* delegating to specialized components (InstanceResolver, Instantiator, Invalidator)
-* for specific tasks.
-*/ var ServiceLocator = class {
+* 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 extends AbstractContainer {
+	parent;
 	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);
+	requestId;
+	defaultScope = InjectableScope.Request;
+	storage;
+	disposed = false;
+	metadata;
+	constructor(parent, registry, requestId, metadata) {
+		super(), this.parent = parent, this.registry = registry, this.requestId = requestId;
+		this.storage = new UnifiedStorage(InjectableScope.Request);
+		this.metadata = metadata || {};
 	}
-	getEventBus() {
-		return this.eventBus;
+	getStorage() {
+		return this.storage;
 	}
-	getManager() {
-		return this.manager;
+	getRegistry() {
+		return this.registry;
 	}
-	getInvalidator() {
-		return this.invalidator;
+	getTokenResolver() {
+		return this.parent.getTokenResolver();
 	}
-	getTokenProcessor() {
-		return this.tokenProcessor;
+	getNameResolver() {
+		return this.parent.getNameResolver();
 	}
-	getInstanceIdentifier(token, args) {
-		const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
-		if (err) throw err;
-		return this.tokenProcessor.generateInstanceName(actualToken, validatedArgs);
+	getServiceInvalidator() {
+		return this.parent.getServiceInvalidator();
 	}
 	/**
-	* 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 the request ID for this scoped container.
+	*/ getRequestId() {
+		return this.requestId;
 	}
 	/**
-	* 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);
+	* Gets the parent container.
+	*/ getParent() {
+		return this.parent;
+	}
+	/**
+	* Gets metadata from the request context.
+	*/ getMetadata(key) {
+		return this.metadata[key];
+	}
+	/**
+	* Sets metadata on the request context.
+	*/ setMetadata(key, value) {
+		this.metadata[key] = value;
+	}
+	async get(token, args) {
+		if (this.disposed) throw new Error("ScopedContainer has been disposed");
+		const realToken = this.getTokenResolver().getRegistryToken(token);
+		if (this.registry.has(realToken)) {
+			if (this.registry.get(realToken).scope === InjectableScope.Request) {
+				const [error$1, instance$1] = await this.parent.getInstanceResolver().resolveRequestScopedInstance(token, args, this);
+				if (error$1) throw error$1;
+				return instance$1;
+			}
+		}
+		const [error, instance] = await this.parent.getInstanceResolver().resolveInstance(token, args, this, this.storage, this.requestId);
 		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);
+	* Invalidates a service and its dependencies.
+	*/ async invalidate(service) {
+		const holder = this.storage.findByInstance(service);
+		if (!holder) return this.parent.invalidate(service);
+		await this.getServiceInvalidator().invalidateWithStorage(holder.name, this.storage);
 	}
-	invalidate(service, round = 1) {
-		return this.invalidator.invalidate(service, round);
+	/**
+	* Disposes the container and cleans up all resources.
+	* Alias for endRequest().
+	*/ async dispose() {
+		return this.endRequest();
 	}
 	/**
-	* 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);
+	* @internal
+	* Attempts to get an instance synchronously if it already exists.
+	* Checks request storage first, then delegates to parent.
+	*/ tryGetSync(token, args) {
+		const realToken = this.getTokenResolver().getRegistryToken(token);
+		if ((this.registry.has(realToken) ? this.registry.get(realToken).scope : InjectableScope.Singleton) === InjectableScope.Request) {
+			const result = this.tryGetSyncFromStorage(token, args, this.storage, this.requestId);
+			if (result !== null) return result;
+		}
+		return this.parent.tryGetSync(token, args, this.requestId);
 	}
 	/**
-	* Waits for all services to settle (either created, destroyed, or error state).
-	*/ async ready() {
-		return this.invalidator.ready();
+	* Adds an instance to the container.
+	* Overrides base class to check disposed state.
+	*/ addInstance(token, instance) {
+		if (this.disposed) throw new Error("ScopedContainer has been disposed");
+		super.addInstance(token, instance);
 	}
 	/**
-	* 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);
+	* Ends the request and cleans up all request-scoped services.
+	*/ async endRequest() {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.getServiceInvalidator().clearAllWithStorage(this.storage);
+		this.parent.removeRequestId(this.requestId);
 	}
 };
 
@@ -2245,142 +2125,125 @@ function applyDecs2203RFactory() {
 function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec, _initClass;
+var _dec, _initClass, _AbstractContainer;
 let _Container;
 _dec = Injectable();
-var Container = class {
+var Container = class extends (_AbstractContainer = AbstractContainer) {
 	registry;
 	logger;
 	injectors;
 	static {
-		({c: [_Container, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+		({c: [_Container, _initClass]} = _apply_decs_2203_r(this, [], [_dec], _AbstractContainer));
 	}
 	constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
-		this.registry = registry;
-		this.logger = logger;
-		this.injectors = injectors;
-		this.serviceLocator = new ServiceLocator(registry, logger, injectors);
+		super(), this.registry = registry, this.logger = logger, this.injectors = injectors;
+		this.storage = new UnifiedStorage(InjectableScope.Singleton);
+		this.eventBus = new LifecycleEventBus(logger);
+		this.nameResolver = new NameResolver(logger);
+		this.tokenResolver = new TokenResolver(logger);
+		this.scopeTracker = new ScopeTracker(registry, this.nameResolver, logger);
+		this.serviceInitializer = new ServiceInitializer(injectors);
+		this.serviceInvalidator = new ServiceInvalidator(this.eventBus, logger);
+		this.instanceResolver = new InstanceResolver(registry, this.storage, this.serviceInitializer, this.tokenResolver, this.nameResolver, this.scopeTracker, this.serviceInvalidator, this.eventBus, logger);
 		this.registerSelf();
 	}
-	serviceLocator;
+	defaultScope = InjectableScope.Singleton;
+	requestId = void 0;
+	storage;
+	serviceInitializer;
+	serviceInvalidator;
+	tokenResolver;
+	nameResolver;
+	scopeTracker;
+	eventBus;
+	instanceResolver;
 	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);
+		this.registry.set(token, InjectableScope.Singleton, _Container, InjectableType.Class);
+		const instanceName = this.nameResolver.generateInstanceName(token, void 0, void 0, InjectableScope.Singleton);
+		this.storage.storeInstance(instanceName, this);
 	}
 	async get(token, args) {
-		const realToken = this.serviceLocator.getTokenProcessor().getRegistryToken(token);
+		const realToken = this.tokenResolver.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.`);
+			if (this.registry.get(realToken).scope === InjectableScope.Request) throw DIError.scopeMismatchError(realToken.name, "ScopedContainer", "Container");
 		}
-		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;
+		const [error, instance] = await this.instanceResolver.resolveInstance(token, args, this);
+		if (error) throw error;
+		return instance;
 	}
 	/**
-	* Invalidates a service and its dependencies
+	* 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;
+		const holder = this.storage.findByInstance(service);
+		if (!holder) {
+			this.logger?.warn(`[Container] Service instance not found for invalidation`);
+			return;
 		}
+		await this.serviceInvalidator.invalidateWithStorage(holder.name, this.storage);
 	}
 	/**
-	* Disposes the container and cleans up all resources
+	* 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();
+		await this.serviceInvalidator.clearAllWithStorage(this.storage);
 	}
 	/**
 	* @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);
+	* Overrides base class to support requestId parameter for ScopedContainer compatibility.
+	*/ tryGetSync(token, args, requestId) {
+		return this.tryGetSyncFromStorage(token, args, this.storage, requestId ?? this.requestId);
 	}
 	/**
 	* 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.`);
+	*/ beginRequest(requestId, metadata) {
+		if (this.activeRequestIds.has(requestId)) throw new Error(`Request with ID ${requestId} already exists`);
 		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}`);
+		return new ScopedContainer(this, this.registry, requestId, metadata);
 	}
 	/**
-	* Gets the set of active request IDs.
+	* Gets all active request IDs.
 	*/ getActiveRequestIds() {
 		return this.activeRequestIds;
 	}
 	/**
-	* Checks if a request ID is currently active.
+	* Checks if a request is 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();
+	* Removes a request ID from active requests.
+	* Called by ScopedContainer when request ends.
+	*/ removeRequestId(requestId) {
+		this.activeRequestIds.delete(requestId);
+	}
+	getStorage() {
+		return this.storage;
+	}
+	getServiceInitializer() {
+		return this.serviceInitializer;
+	}
+	getServiceInvalidator() {
+		return this.serviceInvalidator;
+	}
+	getTokenResolver() {
+		return this.tokenResolver;
+	}
+	getNameResolver() {
+		return this.nameResolver;
+	}
+	getScopeTracker() {
+		return this.scopeTracker;
+	}
+	getEventBus() {
+		return this.eventBus;
+	}
+	getRegistry() {
+		return this.registry;
+	}
+	getInstanceResolver() {
+		return this.instanceResolver;
 	}
 	static {
 		_initClass();
@@ -2388,12 +2251,6 @@ var Container = class {
 };
 
 //#endregion
-Object.defineProperty(exports, 'BaseHolderManager', {
-  enumerable: true,
-  get: function () {
-    return BaseHolderManager;
-  }
-});
 Object.defineProperty(exports, 'BoundInjectionToken', {
   enumerable: true,
   get: function () {
@@ -2418,24 +2275,12 @@ Object.defineProperty(exports, 'DIErrorCode', {
     return DIErrorCode;
   }
 });
-Object.defineProperty(exports, 'DefaultRequestContext', {
-  enumerable: true,
-  get: function () {
-    return DefaultRequestContext;
-  }
-});
 Object.defineProperty(exports, 'FactoryInjectionToken', {
   enumerable: true,
   get: function () {
     return FactoryInjectionToken;
   }
 });
-Object.defineProperty(exports, 'HolderManager', {
-  enumerable: true,
-  get: function () {
-    return HolderManager;
-  }
-});
 Object.defineProperty(exports, 'Injectable', {
   enumerable: true,
   get: function () {
@@ -2478,22 +2323,16 @@ Object.defineProperty(exports, 'InstanceStatus', {
     return InstanceStatus;
   }
 });
-Object.defineProperty(exports, 'Instantiator', {
-  enumerable: true,
-  get: function () {
-    return Instantiator;
-  }
-});
-Object.defineProperty(exports, 'Invalidator', {
+Object.defineProperty(exports, 'LifecycleEventBus', {
   enumerable: true,
   get: function () {
-    return Invalidator;
+    return LifecycleEventBus;
   }
 });
-Object.defineProperty(exports, 'LifecycleEventBus', {
+Object.defineProperty(exports, 'NameResolver', {
   enumerable: true,
   get: function () {
-    return LifecycleEventBus;
+    return NameResolver;
   }
 });
 Object.defineProperty(exports, 'Registry', {
@@ -2502,10 +2341,10 @@ Object.defineProperty(exports, 'Registry', {
     return Registry;
   }
 });
-Object.defineProperty(exports, 'RequestStorage', {
+Object.defineProperty(exports, 'ScopeTracker', {
   enumerable: true,
   get: function () {
-    return RequestStorage;
+    return ScopeTracker;
   }
 });
 Object.defineProperty(exports, 'ScopedContainer', {
@@ -2514,22 +2353,34 @@ Object.defineProperty(exports, 'ScopedContainer', {
     return ScopedContainer;
   }
 });
-Object.defineProperty(exports, 'ServiceLocator', {
+Object.defineProperty(exports, 'ServiceInitializer', {
+  enumerable: true,
+  get: function () {
+    return ServiceInitializer;
+  }
+});
+Object.defineProperty(exports, 'ServiceInvalidator', {
   enumerable: true,
   get: function () {
-    return ServiceLocator;
+    return ServiceInvalidator;
   }
 });
-Object.defineProperty(exports, 'SingletonStorage', {
+Object.defineProperty(exports, 'StubFactoryClass', {
   enumerable: true,
   get: function () {
-    return SingletonStorage;
+    return StubFactoryClass;
   }
 });
-Object.defineProperty(exports, 'TokenProcessor', {
+Object.defineProperty(exports, 'TokenResolver', {
   enumerable: true,
   get: function () {
-    return TokenProcessor;
+    return TokenResolver;
+  }
+});
+Object.defineProperty(exports, 'UnifiedStorage', {
+  enumerable: true,
+  get: function () {
+    return UnifiedStorage;
   }
 });
 Object.defineProperty(exports, '_Container', {
@@ -2544,10 +2395,10 @@ Object.defineProperty(exports, 'asyncInject', {
     return asyncInject;
   }
 });
-Object.defineProperty(exports, 'createRequestContext', {
+Object.defineProperty(exports, 'createAsyncLocalStorage', {
   enumerable: true,
   get: function () {
-    return createRequestContext;
+    return createAsyncLocalStorage;
   }
 });
 Object.defineProperty(exports, 'defaultInjectors', {
@@ -2586,6 +2437,12 @@ Object.defineProperty(exports, 'inject', {
     return inject;
   }
 });
+Object.defineProperty(exports, 'isUsingNativeAsyncLocalStorage', {
+  enumerable: true,
+  get: function () {
+    return isUsingNativeAsyncLocalStorage;
+  }
+});
 Object.defineProperty(exports, 'optional', {
   enumerable: true,
   get: function () {
@@ -2616,4 +2473,4 @@ Object.defineProperty(exports, 'wrapSyncInit', {
     return wrapSyncInit;
   }
 });
-//# sourceMappingURL=container-DENMeJ87.cjs.map
+//# sourceMappingURL=container-CaY2fDuk.cjs.map