@navios/di 0.7.1 → 0.9.0

package/lib/{container-Pb_Y4Z4x.mjs → container-8-z89TyQ.mjs}

@@ -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,784 +478,559 @@ 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;
-	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();
-	}
-	/**
-	* Protected getter for accessing the holders map from subclasses.
-	*/ get holders() {
-		return this._holders;
 	}
 	/**
-	* Deletes a holder by name.
-	* @param name The name of the holder to delete
-	* @returns true if the holder was deleted, false if it didn't exist
-	*/ delete(name) {
-		return this._holders.delete(name);
+	* 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);
 	}
 	/**
-	* Filters holders based on a predicate function.
-	* @param predicate Function to test each holder
-	* @returns A new Map containing only the holders that match the predicate
-	*/ filter(predicate) {
-		return new Map([...this._holders].filter(([key, value]) => predicate(value, key)));
+	* 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());
 	}
 	/**
-	* Clears all holders from this manager.
-	*/ clear() {
-		this._holders.clear();
+	* 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];
+			}
+		};
+		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 the number of holders currently managed.
-	*/ size() {
-		return this._holders.size;
+	* 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
+		}];
 	}
 	/**
-	* 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()
-		}];
+	* 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 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 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 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) {
 					const cycle = CircularDetector.detectCycle(waiterHolder.name, holder.name, getHolder);
 					if (cycle) return [DIError.circularDependency(cycle)];
-					waiterHolder.waitingFor.add(holder.name);
+					if (process.env.NODE_ENV !== "production") waiterHolder.waitingFor.add(holder.name);
 				}
 				try {
 					await holder.creationPromise;
 				} finally {
-					if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+					if (process.env.NODE_ENV !== "production") {
+						if (waiterHolder) waiterHolder.waitingFor.delete(holder.name);
+					}
 				}
-				return BaseHolderManager.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);
-	}
-	/**
-	* Checks if a holder exists by name.
-	*/ has(name) {
-		return this._holders.has(name);
+* 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;
 	}
-	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 dependents = [];
-		for (const [name, holder] of this.contextHolder.holders) if (holder.deps.has(instanceName)) dependents.push(name);
-		for (const [name, holder] of this.holderManager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
-		return dependents;
+	/**
+	* 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());
-	}
-	/**
-	* Gets the request context holder for this scoped container.
-	*/ getRequestContextHolder() {
-		return this.requestContextHolder;
-	}
-	/**
-	* Gets the holder storage for this scoped container.
-	* Used by InstanceResolver for request-scoped resolution.
-	*/ getHolderStorage() {
-		return this.holderStorage;
-	}
-	/**
-	* Gets the request ID for this scoped container.
-	*/ getRequestId() {
-		return this.requestId;
-	}
-	/**
-	* Gets the parent container.
-	*/ getParent() {
-		return this.parent;
-	}
-	/**
-	* Gets metadata from the request context.
-	*/ getMetadata(key) {
-		return this.requestContextHolder.getMetadata(key);
-	}
-	/**
-	* Sets metadata on the request context.
-	*/ setMetadata(key, value) {
-		this.requestContextHolder.setMetadata(key, value);
-	}
-	/**
-	* Adds a pre-prepared instance to the request context.
-	*/ addInstance(token, instance) {
-		this.requestContextHolder.addInstance(token, instance);
-	}
-	async get(token, args) {
-		if (this.disposed) throw DIError.unknown(`ScopedContainer for request ${this.requestId} has been disposed`);
-		const actualToken = this.parent.getServiceLocator().getTokenProcessor().normalizeToken(token);
-		if (this.isRequestScoped(actualToken)) return this.resolveRequestScoped(actualToken, args);
-		return this.parent.getWithContext(token, args, this);
+		this.nameResolver = nameResolver;
+		this.logger = logger;
 	}
 	/**
-	* 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;
+	* 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];
 		}
-		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();
+		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];
 	}
 	/**
-	* @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.
+	* Performs the actual scope upgrade from Singleton to Request.
+	* This is the core migration logic.
 	*
-	* 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;
+	* @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)
+			];
 		}
-		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;
+	* 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];
 		}
-		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);
+		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];
 	}
 	/**
-	* Generates a prefixed event name for request-scoped services.
-	* Format: {requestId}:{instanceName}
-	*/ getPrefixedEventName(instanceName) {
-		return `${this.requestId}:${instanceName}`;
+	* 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);
 	}
 };
 
 //#endregion
-//#region src/internal/holder/singleton-storage.mts
+//#region src/internal/core/service-initializer.mts
 /**
-* Storage implementation for Singleton-scoped services.
+* Creates service instances from registry records.
 *
-* 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;
+* 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;
 	}
-	get(instanceName) {
-		const [error, holder] = this.manager.get(instanceName);
-		if (!error) return [void 0, holder];
-		switch (error.code) {
-			case DIErrorCode.InstanceNotFound: return null;
-			case DIErrorCode.InstanceDestroying: return [error, holder];
-			default: return [error];
-		}
-	}
-	set(instanceName, holder) {
-		this.manager.set(instanceName, holder);
-	}
-	delete(instanceName) {
-		return this.manager.delete(instanceName);
-	}
-	createHolder(instanceName, type, deps) {
-		return this.manager.createCreatingHolder(instanceName, type, this.scope, deps);
-	}
-	handles(scope) {
-		return scope === InjectableScope.Singleton;
-	}
-	getAllNames() {
-		return this.manager.getAllNames();
-	}
-	forEach(callback) {
-		for (const [name, holder] of this.manager.filter(() => true)) callback(name, holder);
-	}
-	findByInstance(instance) {
-		for (const [, holder] of this.manager.filter((h) => h.instance === instance)) return holder;
-		return null;
-	}
-	findDependents(instanceName) {
-		const dependents = [];
-		for (const [name, holder] of this.manager.filter(() => true)) if (holder.deps.has(instanceName)) dependents.push(name);
-		return dependents;
-	}
-};
-
-//#endregion
-//#region src/internal/core/instance-resolver.mts
-/**
-* Resolves instances from tokens, handling caching, creation, and scope rules.
-*
-* Uses the Storage Strategy pattern for unified singleton/request-scoped handling.
-* Coordinates with Instantiator for actual service creation.
-*/ var InstanceResolver = class {
-	registry;
-	manager;
-	instantiator;
-	tokenProcessor;
-	logger;
-	serviceLocator;
-	singletonStorage;
-	constructor(registry, manager, instantiator, tokenProcessor, logger = null, serviceLocator) {
-		this.registry = registry;
-		this.manager = manager;
-		this.instantiator = instantiator;
-		this.tokenProcessor = tokenProcessor;
-		this.logger = logger;
-		this.serviceLocator = serviceLocator;
-		this.singletonStorage = new SingletonStorage(manager);
-	}
-	/**
-	* Resolves an instance for the given token and arguments.
-	* This method is used for singleton and transient services.
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param contextContainer The container to use for creating FactoryContext
-	*/ async resolveInstance(token, args, contextContainer) {
-		return this.resolveWithStorage(token, args, contextContainer, this.singletonStorage);
-	}
-	/**
-	* Resolves a request-scoped instance for a ScopedContainer.
-	* The service will be stored in the ScopedContainer's request context.
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param scopedContainer The ScopedContainer that owns the request context
-	*/ async resolveRequestScopedInstance(token, args, scopedContainer) {
-		return this.resolveWithStorage(token, args, scopedContainer, scopedContainer.getHolderStorage(), scopedContainer);
-	}
-	/**
-	* Unified resolution method that works with any IHolderStorage.
-	* This eliminates duplication between singleton and request-scoped resolution.
-	*
-	* IMPORTANT: The check-and-store logic is carefully designed to avoid race conditions.
-	* The storage check and holder creation must happen synchronously (no awaits between).
-	*
-	* @param token The injection token
-	* @param args Optional arguments
-	* @param contextContainer The container for FactoryContext
-	* @param storage The storage strategy to use
-	* @param scopedContainer Optional scoped container for request-scoped services
-	*/ async resolveWithStorage(token, args, contextContainer, storage, scopedContainer) {
-		const [err, data] = await this.resolveTokenAndPrepareInstanceName(token, args, contextContainer);
-		if (err) return [err];
-		const { instanceName, validatedArgs, realToken } = data;
-		const getResult = storage.get(instanceName);
-		if (getResult !== null) {
-			const [error, holder$1] = getResult;
-			if (!error && holder$1) {
-				const readyResult = await this.waitForInstanceReady(holder$1);
-				if (readyResult[0]) return [readyResult[0]];
-				return [void 0, readyResult[1].instance];
-			}
-			if (error) {
-				const handledResult = await this.handleStorageError(instanceName, error, holder$1, storage);
-				if (handledResult) return handledResult;
-			}
-		}
-		const [createError, holder] = await this.createAndStoreInstance(instanceName, realToken, validatedArgs, contextContainer, storage, scopedContainer);
-		if (createError) return [createError];
-		return [void 0, holder.instance];
-	}
-	/**
-	* Handles storage error states (destroying, error, etc.).
-	* Returns a result if handled, null if should proceed with creation.
-	*/ async handleStorageError(instanceName, error, holder, storage) {
-		switch (error.code) {
-			case DIErrorCode.InstanceDestroying:
-				this.logger?.log(`[InstanceResolver] Instance ${instanceName} is being destroyed, waiting...`);
-				if (holder?.destroyPromise) await holder.destroyPromise;
-				const newResult = storage.get(instanceName);
-				if (newResult !== null && !newResult[0]) {
-					const readyResult = await this.waitForInstanceReady(newResult[1]);
-					if (readyResult[0]) return [readyResult[0]];
-					return [void 0, readyResult[1].instance];
-				}
-				return null;
-			default:
-				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) 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)];
 		}
 	}
 	/**
@@ -1279,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 () => {
@@ -1298,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)];
 		}
 	}
 	/**
@@ -1317,108 +1087,96 @@ 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/invalidator.mts
+//#region src/internal/core/service-invalidator.mts
 /**
-* Manages graceful service cleanup with dependency-aware invalidation.
+* Manages graceful service cleanup with event-based invalidation.
 *
-* Ensures services are destroyed in the correct order based on their dependencies.
-* Works with any IHolderStorage implementation, enabling unified invalidation
-* for both singleton and request-scoped services.
-*/ var Invalidator = class {
+* 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;
-	storage;
-	constructor(manager, eventBus, logger = null) {
+	constructor(eventBus, logger = null) {
 		this.eventBus = eventBus;
 		this.logger = logger;
-		this.storage = new SingletonStorage(manager);
-	}
-	/**
-	* Invalidates a service and all its dependencies.
-	* Works with the configured storage (singleton by default).
-	*/ invalidate(service, round = 1) {
-		return this.invalidateWithStorage(service, this.storage, round);
 	}
 	/**
 	* Invalidates a service using a specific storage.
-	* This allows request-scoped invalidation using a RequestStorage.
+	* 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 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}`);
+	*/ 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;
-		_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);
+		if (holder) await this.invalidateHolderWithStorage(service, holder, storage, emitEvents, onInvalidated);
 	}
 	/**
-	* 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);
+	* 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 { maxRounds = 10, waitForSettlement = true } = options;
-		this.logger?.log("[Invalidator] Starting graceful clearing of all services");
+		const { waitForSettlement = true } = options;
+		this.logger?.log("[ServiceInvalidator] Starting graceful clearing of all services");
 		if (waitForSettlement) {
-			this.logger?.log("[Invalidator] Waiting for all services to settle...");
+			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("[Invalidator] No services to clear");
+		if (allServiceNames.length === 0) this.logger?.log("[ServiceInvalidator] No services to clear");
 		else {
-			this.logger?.log(`[Invalidator] Found ${allServiceNames.length} services to clear: ${allServiceNames.join(", ")}`);
-			await this.clearServicesWithDependencyAwarenessForStorage(allServiceNames, maxRounds, storage);
+			this.logger?.log(`[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("[Invalidator] Graceful clearing completed");
-	}
-	/**
-	* Waits for all services to settle (either created, destroyed, or error state).
-	*/ async ready() {
-		return this.readyWithStorage(this.storage);
+		this.logger?.log("[ServiceInvalidator] Graceful clearing completed");
 	}
 	/**
 	* Waits for all services in a specific storage to settle.
@@ -1429,29 +1187,22 @@ var SingletonStorage = class {
 	}
 	/**
 	* 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, {
+	*/ async invalidateHolderWithStorage(key, holder, storage, emitEvents, onInvalidated) {
+		await this.invalidateHolderByStatus(holder, {
 			context: key,
-			onCreationError: () => this.logger?.error(`[Invalidator] ${key} creation triggered too many invalidation rounds`),
-			onRecursiveInvalidate: () => this.invalidateWithStorage(key, storage, round + 1, options),
 			onDestroy: () => this.destroyHolderWithStorage(key, holder, storage, emitEvents, onInvalidated)
 		});
 	}
 	/**
 	* Common invalidation logic for holders based on their status.
-	*/ async invalidateHolderByStatus(holder, round, options) {
+	*/ async invalidateHolderByStatus(holder, options) {
 		switch (holder.status) {
 			case InstanceStatus.Destroying:
 				await holder.destroyPromise;
 				break;
 			case InstanceStatus.Creating:
 				await holder.creationPromise;
-				if (round > 3) {
-					options.onCreationError();
-					return;
-				}
-				await options.onRecursiveInvalidate();
+				await options.onDestroy();
 				break;
 			default:
 				await options.onDestroy();
@@ -1462,7 +1213,7 @@ var SingletonStorage = class {
 	* 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`);
+		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();
@@ -1470,89 +1221,369 @@ var SingletonStorage = class {
 			if (emitEvents && this.eventBus) await this.emitInstanceEvent(key, "destroy");
 			if (onInvalidated) await onInvalidated(key);
 		});
-		await holder.destroyPromise;
+		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/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
+/**
+* Handles token validation and resolution.
+*
+* Focuses on token validation, normalization, and argument validation.
+* Name generation is handled by NameResolver.
+*/ var TokenResolver = class {
+	logger;
+	constructor(logger = null) {
+		this.logger = logger;
+	}
+	/**
+	* Normalizes a token to an InjectionToken.
+	* Handles class constructors by getting their injectable token.
+	*
+	* @param token A class constructor, InjectionToken, BoundInjectionToken, or FactoryInjectionToken
+	* @returns The normalized InjectionTokenType
+	*/ normalizeToken(token) {
+		if (typeof token === "function") return getInjectableToken(token);
+		return token;
+	}
+	/**
+	* Gets the underlying "real" token from wrapped tokens.
+	* For BoundInjectionToken and FactoryInjectionToken, returns the wrapped token.
+	* For other tokens, returns the token itself.
+	*
+	* @param token The token to unwrap
+	* @returns The underlying InjectionToken
+	*/ getRealToken(token) {
+		if (token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken) return token.token;
+		return token;
+	}
+	/**
+	* Convenience method that normalizes a token and then gets the real token.
+	* Useful for checking registry entries where you need the actual registered token.
+	*
+	* @param token Any injectable type
+	* @returns The underlying InjectionToken
+	*/ getRegistryToken(token) {
+		return this.getRealToken(this.normalizeToken(token));
+	}
+	/**
+	* Validates and resolves token arguments, handling factory token resolution and validation.
+	*
+	* @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 }];
+		}
+		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();
+	/**
+	* 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;
+	}
+	get(instanceName) {
+		const holder = this.holders.get(instanceName);
+		if (!holder) return null;
+		switch (holder.status) {
+			case InstanceStatus.Destroying: return [DIError.instanceDestroying(instanceName), holder];
+			case InstanceStatus.Error: return [holder.instance, holder];
+			case InstanceStatus.Creating:
+			case InstanceStatus.Created: return [void 0, holder];
+			default: return null;
+		}
+	}
+	set(instanceName, holder) {
+		this.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()
+		});
+	}
+	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);
+		}
 	}
 };
 
@@ -1598,270 +1629,220 @@ var SingletonStorage = class {
 };
 
 //#endregion
-//#region src/internal/holder/holder-manager.mts
+//#region src/internal/stub-factory-class.mts
 /**
-* Manages the storage and retrieval of singleton instance holders.
+* 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 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;
+* @internal
+*/ var StubFactoryClass = class {
+	constructor() {
+		throw DIError.factoryNotFound("Trying to get instance of factory without real implementation");
 	}
 };
 
 //#endregion
-//#region src/internal/core/token-processor.mts
+//#region src/container/abstract-container.mts
 /**
-* Handles token validation, normalization, and instance name generation.
+* Abstract base class for dependency injection containers.
 *
-* Provides utilities for resolving tokens to their underlying InjectionToken,
-* validating arguments against schemas, and generating unique instance identifiers.
-*/ var TokenProcessor = class {
-	logger;
-	constructor(logger = null) {
-		this.logger = logger;
-	}
+* 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.
-	*/ generateInstanceName(token, args) {
-		if (!args) return token.toString();
-		const formattedArgs = Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",");
-		return `${token.toString()}:${formattedArgs.replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+	* @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);
 	}
 };
 
@@ -2144,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();
@@ -2287,5 +2251,5 @@ var Container = class {
 };
 
 //#endregion
-export { Injectable as A, getInjectableToken as C, withoutResolutionContext as D, withResolutionContext as E, FactoryInjectionToken as F, InjectionToken as I, InjectableType as L, Registry as M, globalRegistry as N, DIError as O, BoundInjectionToken as P, InjectableScope as R, wrapSyncInit as S, getCurrentResolutionContext as T, asyncInject as _, LifecycleEventBus as a, optional as b, InstanceResolver as c, RequestStorage as d, DefaultRequestContext as f, CircularDetector as g, InstanceStatus as h, HolderManager as i, InjectableTokenMeta as j, DIErrorCode as k, SingletonStorage as l, BaseHolderManager as m, ServiceLocator as n, Invalidator as o, createRequestContext as p, TokenProcessor as r, Instantiator as s, _Container as t, ScopedContainer as u, defaultInjectors as v, getInjectors as w, provideFactoryContext as x, inject as y };
-//# sourceMappingURL=container-Pb_Y4Z4x.mjs.map
+export { Registry as A, withResolutionContext as C, DIError as D, isUsingNativeAsyncLocalStorage as E, InjectableTokenMeta as F, InjectableType as I, InjectableScope as L, BoundInjectionToken as M, FactoryInjectionToken as N, DIErrorCode as O, InjectionToken as P, getCurrentResolutionContext as S, createAsyncLocalStorage as T, ScopeTracker as _, UnifiedStorage as a, CircularDetector as b, asyncInject as c, optional as d, provideFactoryContext as f, ServiceInitializer as g, ServiceInvalidator as h, LifecycleEventBus as i, globalRegistry as j, Injectable as k, defaultInjectors as l, getInjectors as m, ScopedContainer as n, TokenResolver as o, wrapSyncInit as p, StubFactoryClass as r, getInjectableToken as s, _Container as t, inject as u, NameResolver as v, withoutResolutionContext as w, InstanceStatus as x, InstanceResolver as y };
+//# sourceMappingURL=container-8-z89TyQ.mjs.map