@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/resolver.mjs

@@ -1,457 +1,748 @@
-import { AsyncResolutionError, CircularDependencyError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError } from "./errors.mjs";
-import { filterMatchingBindings, registryKeyLabel, selectBindingForRegistry } from "./binding-select.mjs";
-import { isPromiseLike, runActivation, runActivationAsync, runPostConstruct, runPostConstructAsync } from "./lifecycle.mjs";
+import { AsyncResolutionError, CircularDependencyError, InternalError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, TokenNotBoundError } from "./errors.mjs";
+import { selectAllBindings, selectBinding } from "./binding-select.mjs";
+import { tokenName } from "./token.mjs";
+import { DefaultResolutionContext, buildMaterializationFrame, runWithContainer } from "./environment.mjs";
+import { injectableSlotToResolveOptions } from "./resolve-options.mjs";
 //#region src/resolver.ts
-/**
-* Converts a registry key + binding into a {@link MaterializationFrame} for the captive-dependency stack.
-*/
-function bindingToMaterializationFrame(registryKey, binding) {
-	return {
-		registryKey,
-		bindingId: binding.id,
-		bindingKind: binding.kind,
-		tags: binding.tags,
-		scope: binding.scope
-	};
-}
-/**
-* Stateless graph walker: selects a binding, checks for cycles and scope violations,
-* delegates instance caching to `ScopeManager`, and runs lifecycle hooks.
-*
-* Resolution algorithm (per token):
-* 1. Lookup all bindings for the registry key.
-* 2. Apply name/tag hint and `when()` constraint filtering.
-* 3. Circular-dependency check via a mutable `visiting` set (per call tree).
-* 4. Captive-dependency check via the `materializationStack`.
-* 5. Scope-cache hit → return cached instance.
-* 6. Scope-cache miss → `materialize` → `@postConstruct` → `onActivation` → cache.
-*
-* Used exclusively by `DefaultContainer`; not part of the public API.
-*/
+const RESOLUTION_SET_KEY = Symbol("di:resolution-set");
+const RESOLUTION_SET_THRESHOLD = 32;
+const EMPTY_STRING_LIST = [];
+const EMPTY_FRAME_LIST = [];
+const ROOT_CONSTRAINT_CONTEXT = {
+	resolutionPath: EMPTY_STRING_LIST,
+	materializationStack: EMPTY_FRAME_LIST,
+	parent: void 0,
+	ancestors: EMPTY_FRAME_LIST,
+	currentResolveHint: void 0
+};
 var DependencyResolver = class {
-	constructor(deps) {
-		this.deps = deps;
-	}
-	/**
-	* Entry point for synchronous single-binding resolution.
-	*
-	* @throws {@link TokenNotBoundError} — no binding registered for `key`, or a nested dependency is unbound.
-	* @throws {@link NoMatchingBindingError} — a name/tag `hint` was given for `key` but no binding matched it.
-	* @throws {@link InternalError} — multiple bindings matched for `key` after applying the hint (ambiguous).
-	* @throws {@link CircularDependencyError} — `key` or a nested token appears twice on the resolution stack.
-	* @throws {@link AsyncResolutionError} — an `async-dynamic` binding or async lifecycle/activation on the sync path.
-	* @throws {@link ScopeViolationError} — captive dependency (singleton → scoped/transient).
-	* @throws {@link MissingMetadataError} — `class` binding lacks injectable metadata when the reader requires it.
-	*/
-	resolveRoot(key, hint) {
-		return this.resolve(key, hint, [], /* @__PURE__ */ new Set(), []);
-	}
-	/**
-	* Entry point for async single-binding resolution. Awaits `async-dynamic` factories
-	* and async lifecycle hooks that would cause {@link AsyncResolutionError} on the sync path.
-	*
-	* @throws {@link TokenNotBoundError} — no binding registered for `key`, or a nested dependency is unbound.
-	* @throws {@link NoMatchingBindingError} — a name/tag `hint` was given for `key` but no binding matched it.
-	* @throws {@link InternalError} — multiple bindings matched for `key` after applying the hint (ambiguous).
-	* @throws {@link CircularDependencyError} — `key` or a nested token appears twice on the resolution stack.
-	* @throws {@link ScopeViolationError} — captive dependency (singleton → scoped/transient).
-	* @throws {@link MissingMetadataError} — `class` binding lacks injectable metadata when the reader requires it.
-	*/
-	resolveAsyncRoot(key, hint) {
-		return this.resolveAsync(key, hint, [], /* @__PURE__ */ new Set(), []);
-	}
-	/**
-	* Optional resolution for the **requested key only**: returns `undefined` when that key has no
-	* bindings or every candidate is filtered out **without** a name/tag hint — without throwing
-	* {@link TokenNotBoundError} for those cases. Instantiating the selected binding still runs the
-	* normal sync resolution path for nested dependencies; an unregistered transitive dependency
-	* throws {@link TokenNotBoundError} as usual.
-	*
-	* Behavioral rules:
-	* 1. If the registry key is completely unbound → returns `undefined`.
-	* 2. If no candidate survives constraint filtering (without a hint) → returns `undefined`.
-	* 3. If a name/tag hint was provided but no binding matches it → throws {@link NoMatchingBindingError}.
-	* 4. Still throws on: circular dependencies, async operations on the sync path,
-	*    scope violations, ambiguous multi-binding matches, and {@link TokenNotBoundError} when a
-	*    required nested dependency is unbound.
-	*/
-	resolveOptionalRoot(key, hint) {
-		const registryKey = key;
-		const label = registryKeyLabel(key);
-		const pathLabels = [label];
-		const bindings = this.deps.lookup(registryKey);
-		if (bindings === void 0 || bindings.length === 0) return;
-		const candidates = filterMatchingBindings(bindings, hint, this.buildConstraintContext(pathLabels, [], hint));
-		if (candidates.length === 0) {
-			if (hint !== void 0 && (hint.name !== void 0 || hint.tag !== void 0)) throw new NoMatchingBindingError(label, hint, pathLabels);
-			return;
-		}
-		if (candidates.length !== 1) throw new InternalError(`Ambiguous binding for "${label}": ${String(candidates.length)} candidates matched (resolution path: ${pathLabels.join(" -> ")})`);
-		const binding = candidates[0];
-		if (binding === void 0) throw new InternalError(`Internal: expected single binding candidate for "${label}" (resolution path: ${pathLabels.join(" -> ")})`);
-		this.assertDependencyScopeAllowed(binding, pathLabels, []);
-		if (binding.kind === "async-dynamic") throw new AsyncResolutionError(label, pathLabels, "encountered async-dynamic factory during synchronous resolution");
-		const visiting = /* @__PURE__ */ new Set();
-		visiting.add(registryKey);
+	_frameByBindingId = /* @__PURE__ */ new Map();
+	_syncResolutionContextPool = [];
+	_deepCycleMarks = /* @__PURE__ */ new Map();
+	_deepCycleGen = 0;
+	_deepActiveLevels = 0;
+	_deepSyncCtx;
+	_deepSyncCtxPath;
+	_deepAsyncCtx;
+	_deepAsyncCtxPath;
+	_deepAsyncActiveLevels = 0;
+	_classHasPostConstruct = /* @__PURE__ */ new WeakMap();
+	_classNeedsActiveContainer = /* @__PURE__ */ new WeakMap();
+	_classConstructorMetadata = /* @__PURE__ */ new WeakMap();
+	_activationNeedByBindingId = /* @__PURE__ */ new Map();
+	_activationCacheVersion = -1;
+	constructor(_registry, _scope, _lifecycle, _metadataReader, _container, _parent) {
+		this._registry = _registry;
+		this._scope = _scope;
+		this._lifecycle = _lifecycle;
+		this._metadataReader = _metadataReader;
+		this._container = _container;
+		this._parent = _parent;
+	}
+	_findBinding(token, hint, resolutionPath, materializationStack) {
+		if (hint === void 0) {
+			const fastDefaultBinding = this._registry.getFastDefault(token);
+			if (fastDefaultBinding !== void 0) return {
+				binding: fastDefaultBinding,
+				owner: this
+			};
+		}
+		if (hint?.name !== void 0 && hint.tag === void 0 && (hint.tags?.length ?? 0) === 0) {
+			const namedBinding = this._registry.getSimpleNamed(token, hint.name);
+			if (namedBinding !== void 0 && this._matchesBindingFast(namedBinding, hint, resolutionPath, materializationStack)) return {
+				binding: namedBinding,
+				owner: this
+			};
+		}
+		const bindings = this._registry.getAll(token);
+		if (bindings.length > 0) {
+			if (bindings.length === 1) {
+				const onlyBinding = bindings[0];
+				const isDefaultSlot = onlyBinding.slot.name === void 0 && onlyBinding.slot.tags.length === 0;
+				if (hint === void 0 && isDefaultSlot && onlyBinding.predicate === void 0) return {
+					binding: onlyBinding,
+					owner: this
+				};
+				if (this._matchesBindingFast(onlyBinding, hint, resolutionPath, materializationStack)) return {
+					binding: onlyBinding,
+					owner: this
+				};
+			}
+			const binding = selectBinding(bindings, hint, this._makeConstraintContext(resolutionPath, materializationStack, hint), this._getTokenName(token));
+			if (binding !== void 0) return {
+				binding,
+				owner: this
+			};
+		}
+		if (this._parent !== void 0) return this._parent._findBinding(token, hint, resolutionPath, materializationStack);
+	}
+	resolveFromContext(token, resolutionPath, materializationStack) {
+		const fastBinding = this._registry.getFastDefault(token);
+		if (fastBinding !== void 0) {
+			if (fastBinding.kind === "alias") return this.resolveFromContext(fastBinding.target, resolutionPath, materializationStack);
+			const scope = fastBinding.scope ?? "transient";
+			if (scope === "transient" && fastBinding.kind === "dynamic" && fastBinding.onActivation === void 0 && (this._lifecycle.activationVersion === 0 || !this._lifecycle.hasActivationHandlers(fastBinding.token))) return this._resolveTransientDynamicSyncFromContext(fastBinding, resolutionPath, materializationStack);
+			if (scope === "singleton" && this._scope.hasSingleton(fastBinding.id)) return this._scope.getSingleton(fastBinding.id);
+			if (scope === "scoped") {
+				if (!this._scope.isChild) throw new MissingScopeContextError(this._getTokenName(fastBinding.token));
+				if (this._scope.hasScoped(fastBinding.id)) return this._scope.getScoped(fastBinding.id);
+			}
+			return this._resolveBinding(fastBinding, void 0, resolutionPath, materializationStack);
+		}
+		return this.resolve(token, void 0, resolutionPath, materializationStack);
+	}
+	resolve(token, hint, resolutionPath, materializationStack) {
+		const found = this._findBinding(token, hint, resolutionPath, materializationStack);
+		if (found === void 0) {
+			if (this._registry.getAll(token).length > 0) throw new NoMatchingBindingError(this._getTokenName(token), hint ?? {}, this._getAvailableSlots(token));
+			throw new TokenNotBoundError(this._getTokenName(token));
+		}
+		const { binding, owner } = found;
+		if (binding.kind === "alias") return this.resolve(binding.target, hint, resolutionPath, materializationStack);
+		if ((binding.scope ?? "transient") === "singleton" && owner !== this) return owner._resolveBinding(binding, hint, resolutionPath, materializationStack);
+		return this._resolveBinding(binding, hint, resolutionPath, materializationStack);
+	}
+	_resolveBinding(binding, hint, resolutionPath, materializationStack) {
+		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return binding.value;
+		const scope = binding.scope ?? "transient";
+		if (scope === "singleton") {
+			if (this._scope.hasSingleton(binding.id)) return this._scope.getSingleton(binding.id);
+		}
+		if (scope === "scoped") {
+			if (!this._scope.isChild) throw new MissingScopeContextError(this._getTokenName(binding.token));
+			if (this._scope.hasScoped(binding.id)) return this._scope.getScoped(binding.id);
+		}
+		const frame = this._getMaterializationFrame(binding);
+		const tName = frame.tokenName;
+		const pathWithSet = resolutionPath;
+		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
+		if (resolutionSet === void 0 && resolutionPath.length >= RESOLUTION_SET_THRESHOLD) {
+			resolutionSet = new Set(resolutionPath);
+			pathWithSet[RESOLUTION_SET_KEY] = resolutionSet;
+		}
+		if (resolutionSet !== void 0 ? resolutionSet.has(tName) : resolutionPath.includes(tName)) throw new CircularDependencyError([...resolutionPath, tName]);
+		resolutionPath.push(tName);
+		resolutionSet?.add(tName);
+		materializationStack.push(frame);
+		const needsActivation = this._needsActivation(binding);
+		if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
+			const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, materializationStack, hint);
+			try {
+				const dynamicResult = binding.factory(resolutionCtx);
+				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+				materializationStack.pop();
+				resolutionPath.pop();
+				resolutionSet?.delete(tName);
+				return dynamicResult;
+			} catch (error) {
+				materializationStack.pop();
+				resolutionPath.pop();
+				resolutionSet?.delete(tName);
+				throw error;
+			}
+		}
 		try {
-			return this.instantiateBinding(binding, registryKey, hint, pathLabels, visiting, []);
+			const resolutionCtx = needsActivation || this._requiresResolutionContext(binding) ? this._acquireSyncResolutionContext(resolutionPath, materializationStack, hint) : void 0;
+			const instance = this._instantiateSync(binding, resolutionCtx, resolutionPath, materializationStack, hint);
+			let shouldActivate = needsActivation;
+			if (binding.kind === "class" && this._classHasPostConstruct.get(binding.target) === void 0) {
+				this._refreshClassPostConstructCache(binding.target);
+				this._activationNeedByBindingId.delete(binding.id);
+				shouldActivate = this._needsActivation(binding);
+			}
+			const activated = shouldActivate ? this._lifecycle.runActivationSync(resolutionCtx, binding, instance, this._metadataReader) : instance;
+			if (scope === "singleton") this._scope.setSingleton(binding.id, activated);
+			else if (scope === "scoped") this._scope.setScoped(binding.id, activated);
+			return activated;
 		} finally {
-			visiting.delete(registryKey);
-		}
-	}
-	/**
-	* Resolves every matching binding for `key` synchronously into an array.
-	* Returns an empty array when no bindings exist (does not throw).
-	*
-	* @throws {@link AsyncResolutionError} — any candidate is `async-dynamic`.
-	* @throws {@link NoMatchingBindingError} — hint was specified but no binding matched it.
-	* @throws {@link TokenNotBoundError} — nested dependency unbound (same as {@link resolveRoot}).
-	* @throws {@link CircularDependencyError} — cycle while materializing a candidate.
-	* @throws {@link ScopeViolationError} — captive dependency during materialization.
-	* @throws {@link MissingMetadataError} — class binding lacks injectable metadata when required.
-	*/
-	resolveAllRoot(key, hint) {
-		return this.resolveAll(key, hint, [], /* @__PURE__ */ new Set(), []);
-	}
-	/**
-	* Async counterpart of {@link resolveAllRoot}: resolves every matching binding for `key`,
-	* awaiting `async-dynamic` factories. Returns an empty array when no bindings exist.
-	*
-	* @throws {@link NoMatchingBindingError} — hint was specified but no binding matched it.
-	* @throws {@link TokenNotBoundError} — nested dependency unbound (same as {@link resolveAsyncRoot}).
-	* @throws {@link CircularDependencyError} — cycle while materializing a candidate.
-	* @throws {@link ScopeViolationError} — captive dependency during materialization.
-	* @throws {@link MissingMetadataError} — class binding lacks injectable metadata when required.
-	*/
-	async resolveAllAsyncRoot(key, hint) {
-		return this.resolveAllAsync(key, hint, [], /* @__PURE__ */ new Set(), []);
-	}
-	/**
-	* Context-aware sync `resolveAll`: extends the current resolution path and preserves
-	* visiting/materialization stacks so nested multi-resolution participates in cycle and
-	* captive-dependency checks exactly like single-value {@link resolve}.
-	*/
-	resolveAll(key, hint, pathLabels, visiting, materializationStack) {
-		const registryKey = key;
-		const label = registryKeyLabel(key);
-		const nextPath = [...pathLabels, label];
-		if (visiting.has(registryKey)) throw new CircularDependencyError(nextPath);
-		const bindings = this.deps.lookup(registryKey);
-		if (bindings === void 0 || bindings.length === 0) return [];
-		const candidates = filterMatchingBindings(bindings, hint, this.buildConstraintContext(nextPath, materializationStack, hint));
-		if (candidates.length === 0) {
-			if (hint !== void 0 && (hint.name !== void 0 || hint.tag !== void 0)) throw new NoMatchingBindingError(label, hint, nextPath);
-			return [];
-		}
-		visiting.add(registryKey);
-		const results = [];
+			materializationStack.pop();
+			resolutionPath.pop();
+			resolutionSet?.delete(tName);
+		}
+	}
+	_instantiateSync(binding, ctx, resolutionPath, materializationStack, hint) {
+		switch (binding.kind) {
+			case "constant": return binding.value;
+			case "dynamic": {
+				if (ctx === void 0) throw new InternalError("dynamic binding requires resolution context");
+				const r = binding.factory(ctx);
+				if (r instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+				return r;
+			}
+			case "dynamic-async": throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+			case "class": {
+				const deps = this._resolveClassDeps(binding.target, resolutionPath, materializationStack);
+				return this._instantiateClass(binding.target, deps);
+			}
+			case "resolved": {
+				const deps = this._resolveDescriptorDeps(binding.deps, resolutionPath, materializationStack, hint);
+				const r = binding.factory(...deps);
+				if (r instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+				return r;
+			}
+			case "resolved-async": throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+			case "alias": throw new InternalError("alias should have been followed before instantiation");
+		}
+	}
+	_resolveClassDeps(target, resolutionPath, materializationStack) {
+		const meta = this._getConstructorMetadata(target);
+		if (meta === void 0) {
+			if (target.length === 0) return [];
+			throw new MissingMetadataError(target.name);
+		}
+		if (meta.params.length === 0) return [];
+		if (meta.params.length === 1) {
+			const param = meta.params[0];
+			const paramHint = injectableSlotToResolveOptions(param);
+			if (param.multi) return [this.resolveAll(param.token, paramHint, resolutionPath, materializationStack)];
+			if (param.optional) return [this.resolveOptional(param.token, paramHint, resolutionPath, materializationStack)];
+			if (paramHint === void 0) return [this.resolveFromContext(param.token, resolutionPath, materializationStack)];
+			return [this.resolve(param.token, paramHint, resolutionPath, materializationStack)];
+		}
+		const deps = new Array(meta.params.length);
+		for (let index = 0; index < meta.params.length; index += 1) {
+			const param = meta.params[index];
+			const paramHint = injectableSlotToResolveOptions(param);
+			if (param.multi) {
+				deps[index] = this.resolveAll(param.token, paramHint, resolutionPath, materializationStack);
+				continue;
+			}
+			if (param.optional) {
+				deps[index] = this.resolveOptional(param.token, paramHint, resolutionPath, materializationStack);
+				continue;
+			}
+			deps[index] = paramHint === void 0 ? this.resolveFromContext(param.token, resolutionPath, materializationStack) : this.resolve(param.token, paramHint, resolutionPath, materializationStack);
+		}
+		return deps;
+	}
+	_resolveDescriptorDeps(deps, resolutionPath, materializationStack, _hint) {
+		const resolved = new Array(deps.length);
+		for (let index = 0; index < deps.length; index += 1) {
+			const dep = deps[index];
+			const depHint = injectableSlotToResolveOptions(dep);
+			if (dep.multi) {
+				resolved[index] = this.resolveAll(dep.token, depHint, resolutionPath, materializationStack);
+				continue;
+			}
+			if (dep.optional) {
+				resolved[index] = this.resolveOptional(dep.token, depHint, resolutionPath, materializationStack);
+				continue;
+			}
+			resolved[index] = depHint === void 0 ? this.resolveFromContext(dep.token, resolutionPath, materializationStack) : this.resolve(dep.token, depHint, resolutionPath, materializationStack);
+		}
+		return resolved;
+	}
+	resolveOptional(token, hint, resolutionPath, materializationStack) {
 		try {
-			for (const binding of candidates) {
-				this.assertDependencyScopeAllowed(binding, nextPath, materializationStack);
-				if (binding.kind === "async-dynamic") throw new AsyncResolutionError(label, nextPath, "encountered async-dynamic factory during synchronous resolveAll");
-				results.push(this.instantiateBinding(binding, registryKey, hint, nextPath, visiting, materializationStack));
+			return this.resolve(token, hint, resolutionPath, materializationStack);
+		} catch (e) {
+			if (e instanceof TokenNotBoundError || e instanceof NoMatchingBindingError) return;
+			throw e;
+		}
+	}
+	resolveAll(token, hint, resolutionPath, materializationStack) {
+		if (hint?.name !== void 0 && hint.tag === void 0 && (hint.tags?.length ?? 0) === 0) {
+			const namedCandidates = this._getSimpleNamedBindingsFromChain(token, hint.name);
+			if (namedCandidates.length === 0) return [];
+			const resolved = new Array(namedCandidates.length);
+			for (let index = 0; index < namedCandidates.length; index += 1) resolved[index] = this._resolveCandidateSync(namedCandidates[index], hint, resolutionPath, materializationStack);
+			return resolved;
+		}
+		const allBindings = this._getAllBindingsFromChain(token);
+		if (allBindings.length === 0) return [];
+		const candidates = selectAllBindings(allBindings, hint, this._makeConstraintContext(resolutionPath, materializationStack, hint));
+		const resolved = new Array(candidates.length);
+		for (let index = 0; index < candidates.length; index += 1) resolved[index] = this._resolveCandidateSync(candidates[index], hint, resolutionPath, materializationStack);
+		return resolved;
+	}
+	resolveAsyncFromContext(token, resolutionPath, materializationStack) {
+		const fastBinding = this._registry.getFastDefault(token);
+		if (fastBinding !== void 0) {
+			if (fastBinding.kind === "alias") return this.resolveAsyncFromContext(fastBinding.target, resolutionPath, materializationStack);
+			const scope = fastBinding.scope ?? "transient";
+			if (scope === "transient" && (fastBinding.kind === "dynamic" || fastBinding.kind === "dynamic-async") && fastBinding.onActivation === void 0 && (this._lifecycle.activationVersion === 0 || !this._lifecycle.hasActivationHandlers(fastBinding.token))) return this._resolveTransientDynamicAsyncFromContext(fastBinding, resolutionPath, materializationStack);
+			if (scope === "singleton" && this._scope.hasSingleton(fastBinding.id)) return Promise.resolve(this._scope.getSingleton(fastBinding.id));
+			if (scope === "scoped") {
+				if (!this._scope.isChild) return Promise.reject(new MissingScopeContextError(this._getTokenName(fastBinding.token)));
+				if (this._scope.hasScoped(fastBinding.id)) return Promise.resolve(this._scope.getScoped(fastBinding.id));
 			}
-		} finally {
-			visiting.delete(registryKey);
-		}
-		return results;
-	}
-	/**
-	* Async counterpart of {@link resolveAll}: keeps the current path and materialization stack
-	* so `when()` constraints and scope validation behave consistently for nested multi-resolution.
-	*/
-	async resolveAllAsync(key, hint, pathLabels, visiting, materializationStack) {
-		const registryKey = key;
-		const label = registryKeyLabel(key);
-		const nextPath = [...pathLabels, label];
-		if (visiting.has(registryKey)) throw new CircularDependencyError(nextPath);
-		const bindings = this.deps.lookup(registryKey);
-		if (bindings === void 0 || bindings.length === 0) return [];
-		const candidates = filterMatchingBindings(bindings, hint, this.buildConstraintContext(nextPath, materializationStack, hint));
-		if (candidates.length === 0) {
-			if (hint !== void 0 && (hint.name !== void 0 || hint.tag !== void 0)) throw new NoMatchingBindingError(label, hint, nextPath);
-			return [];
-		}
-		visiting.add(registryKey);
-		const results = [];
+			return this._resolveBindingAsync(fastBinding, void 0, resolutionPath, materializationStack);
+		}
+		return this.resolveAsync(token, void 0, resolutionPath, materializationStack);
+	}
+	async resolveAsync(token, hint, resolutionPath, materializationStack) {
+		const found = this._findBinding(token, hint, resolutionPath, materializationStack);
+		if (found === void 0) {
+			if (this._registry.getAll(token).length > 0) throw new NoMatchingBindingError(this._getTokenName(token), hint ?? {}, this._getAvailableSlots(token));
+			throw new TokenNotBoundError(this._getTokenName(token));
+		}
+		const { binding, owner } = found;
+		if (binding.kind === "alias") return this.resolveAsync(binding.target, hint, resolutionPath, materializationStack);
+		if ((binding.scope ?? "transient") === "singleton" && owner !== this) return owner._resolveBindingAsync(binding, hint, resolutionPath, materializationStack);
+		return this._resolveBindingAsync(binding, hint, resolutionPath, materializationStack);
+	}
+	async _resolveBindingAsync(binding, hint, resolutionPath, materializationStack) {
+		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return binding.value;
+		const scope = binding.scope ?? "transient";
+		if (scope === "singleton") {
+			if (this._scope.hasSingleton(binding.id)) return this._scope.getSingleton(binding.id);
+			const inflight = this._scope.getInflight(binding.id);
+			if (inflight !== void 0) return inflight;
+		}
+		if (scope === "scoped") {
+			if (!this._scope.isChild) throw new MissingScopeContextError(this._getTokenName(binding.token));
+			if (this._scope.hasScoped(binding.id)) return this._scope.getScoped(binding.id);
+		}
+		const frame = this._getMaterializationFrame(binding);
+		const tName = frame.tokenName;
+		const pathWithSet = resolutionPath;
+		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
+		if (resolutionSet === void 0 && resolutionPath.length >= RESOLUTION_SET_THRESHOLD) {
+			resolutionSet = new Set(resolutionPath);
+			pathWithSet[RESOLUTION_SET_KEY] = resolutionSet;
+		}
+		if (resolutionSet !== void 0 ? resolutionSet.has(tName) : resolutionPath.includes(tName)) throw new CircularDependencyError([...resolutionPath, tName]);
+		resolutionPath.push(tName);
+		resolutionSet?.add(tName);
+		materializationStack.push(frame);
+		const needsActivation = this._needsActivation(binding);
+		if (!needsActivation && scope === "transient" && (binding.kind === "dynamic" || binding.kind === "dynamic-async")) {
+			const resolutionCtx = new DefaultResolutionContext(this, resolutionPath, materializationStack, hint);
+			try {
+				if (binding.kind === "dynamic-async") return await binding.factory(resolutionCtx);
+				const dynamicResult = binding.factory(resolutionCtx);
+				return dynamicResult instanceof Promise ? await dynamicResult : dynamicResult;
+			} finally {
+				materializationStack.pop();
+				resolutionPath.pop();
+				resolutionSet?.delete(tName);
+			}
+		}
+		const resolutionCtx = needsActivation || this._requiresResolutionContext(binding) ? new DefaultResolutionContext(this, resolutionPath, materializationStack, hint) : void 0;
 		try {
-			for (const binding of candidates) {
-				this.assertDependencyScopeAllowed(binding, nextPath, materializationStack);
-				results.push(await this.instantiateBindingAsync(binding, registryKey, hint, nextPath, visiting, materializationStack));
+			if (scope === "singleton") {
+				const createSingletonPromise = async () => {
+					const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, materializationStack, hint);
+					let shouldActivate = needsActivation;
+					if (binding.kind === "class" && this._classHasPostConstruct.get(binding.target) === void 0) {
+						this._refreshClassPostConstructCache(binding.target);
+						this._activationNeedByBindingId.delete(binding.id);
+						shouldActivate = this._needsActivation(binding);
+					}
+					const activated = shouldActivate ? await this._lifecycle.runActivation(resolutionCtx, binding, instance, this._metadataReader) : instance;
+					this._scope.setSingleton(binding.id, activated);
+					this._scope.clearInflight(binding.id);
+					return activated;
+				};
+				const p = createSingletonPromise().catch((err) => {
+					this._scope.clearInflight(binding.id);
+					throw err;
+				});
+				this._scope.setInflight(binding.id, p);
+				return await p;
+			}
+			const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, materializationStack, hint);
+			let shouldActivate = needsActivation;
+			if (binding.kind === "class" && this._classHasPostConstruct.get(binding.target) === void 0) {
+				this._refreshClassPostConstructCache(binding.target);
+				this._activationNeedByBindingId.delete(binding.id);
+				shouldActivate = this._needsActivation(binding);
 			}
+			const activated = shouldActivate ? await this._lifecycle.runActivation(resolutionCtx, binding, instance, this._metadataReader) : instance;
+			if (scope === "scoped") this._scope.setScoped(binding.id, activated);
+			return activated;
 		} finally {
-			visiting.delete(registryKey);
+			materializationStack.pop();
+			resolutionPath.pop();
+			resolutionSet?.delete(tName);
+		}
+	}
+	async _instantiateAsync(binding, ctx, resolutionPath, materializationStack, hint) {
+		switch (binding.kind) {
+			case "constant": return binding.value;
+			case "dynamic": {
+				if (ctx === void 0) throw new InternalError("dynamic binding requires resolution context");
+				const r = binding.factory(ctx);
+				return r instanceof Promise ? r : Promise.resolve(r);
+			}
+			case "dynamic-async":
+				if (ctx === void 0) throw new InternalError("dynamic-async binding requires resolution context");
+				return binding.factory(ctx);
+			case "class": {
+				const deps = await this._resolveClassDepsAsync(binding.target, resolutionPath, materializationStack);
+				return this._instantiateClass(binding.target, deps);
+			}
+			case "resolved": {
+				if (ctx === void 0) throw new InternalError("resolved binding requires resolution context");
+				const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, materializationStack, hint);
+				const r = binding.factory(...deps);
+				return r instanceof Promise ? r : Promise.resolve(r);
+			}
+			case "resolved-async": {
+				const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, materializationStack, hint);
+				return binding.factory(...deps);
+			}
+			case "alias": throw new InternalError("alias should have been followed before instantiation");
+		}
+	}
+	async _resolveClassDepsAsync(target, resolutionPath, materializationStack) {
+		const meta = this._getConstructorMetadata(target);
+		if (meta === void 0) {
+			if (target.length === 0) return [];
+			throw new MissingMetadataError(target.name);
+		}
+		if (meta.params.length === 0) return [];
+		if (meta.params.length === 1) {
+			const param = meta.params[0];
+			const paramHint = injectableSlotToResolveOptions(param);
+			if (param.multi) return [await this.resolveAllAsync(param.token, paramHint, resolutionPath, materializationStack)];
+			if (param.optional) return [await this.resolveOptionalAsync(param.token, paramHint, resolutionPath, materializationStack)];
+			if (paramHint === void 0) return [await this.resolveAsyncFromContext(param.token, resolutionPath, materializationStack)];
+			return [await this.resolveAsync(param.token, paramHint, resolutionPath, materializationStack)];
+		}
+		const pending = new Array(meta.params.length);
+		const shouldCloneContext = meta.params.length > 1;
+		for (let index = 0; index < meta.params.length; index += 1) {
+			const param = meta.params[index];
+			const paramHint = injectableSlotToResolveOptions(param);
+			if (param.multi) pending[index] = this.resolveAllAsync(param.token, paramHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack);
+			else if (param.optional) pending[index] = this.resolveOptionalAsync(param.token, paramHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack);
+			else pending[index] = paramHint === void 0 ? this.resolveAsyncFromContext(param.token, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack) : this.resolveAsync(param.token, paramHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack);
+		}
+		return Promise.all(pending);
+	}
+	async _resolveDescriptorDepsAsync(deps, resolutionPath, materializationStack, _hint) {
+		const pending = new Array(deps.length);
+		const shouldCloneContext = deps.length > 1;
+		for (let index = 0; index < deps.length; index += 1) {
+			const dep = deps[index];
+			const depHint = injectableSlotToResolveOptions(dep);
+			if (dep.multi) pending[index] = this.resolveAllAsync(dep.token, depHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack);
+			else if (dep.optional) pending[index] = this.resolveOptionalAsync(dep.token, depHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack);
+			else pending[index] = depHint === void 0 ? this.resolveAsyncFromContext(dep.token, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack) : this.resolveAsync(dep.token, depHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...materializationStack] : materializationStack);
 		}
-		return results;
+		return Promise.all(pending);
 	}
-	/**
-	* Assembles the read-only {@link ConstraintContext} snapshot passed to `when()` predicates.
-	* Extracts the top-of-stack frame as `parent` and the rest as `ancestors`.
-	*/
-	buildConstraintContext(resolutionPath, materializationStack, currentResolveHint) {
+	async resolveOptionalAsync(token, hint, resolutionPath, materializationStack) {
+		try {
+			return await this.resolveAsync(token, hint, resolutionPath, materializationStack);
+		} catch (e) {
+			if (e instanceof TokenNotBoundError || e instanceof NoMatchingBindingError) return;
+			throw e;
+		}
+	}
+	async resolveAllAsync(token, hint, resolutionPath, materializationStack) {
+		if (hint?.name !== void 0 && hint.tag === void 0 && (hint.tags?.length ?? 0) === 0) {
+			const namedCandidates = this._getSimpleNamedBindingsFromChain(token, hint.name);
+			if (namedCandidates.length === 0) return [];
+			const pending = new Array(namedCandidates.length);
+			for (let index = 0; index < namedCandidates.length; index += 1) pending[index] = this._resolveCandidateAsync(namedCandidates[index], hint, resolutionPath, materializationStack);
+			return Promise.all(pending);
+		}
+		const allBindings = this._getAllBindingsFromChain(token);
+		if (allBindings.length === 0) return [];
+		const candidates = selectAllBindings(allBindings, hint, this._makeConstraintContext(resolutionPath, materializationStack, hint));
+		const pending = new Array(candidates.length);
+		for (let index = 0; index < candidates.length; index += 1) pending[index] = this._resolveCandidateAsync(candidates[index], hint, resolutionPath, materializationStack);
+		return Promise.all(pending);
+	}
+	_getAllBindingsFromChain(token) {
+		const ownBindings = this._registry.getAll(token);
+		if (this._parent === void 0) return ownBindings;
+		const result = [...ownBindings];
+		let current = this._parent;
+		while (current !== void 0) {
+			const own = current._registry.getAll(token);
+			if (own.length > 0) result.push(...own);
+			current = current._parent;
+		}
+		return result;
+	}
+	_getSimpleNamedBindingsFromChain(token, name) {
+		const ownBinding = this._registry.getSimpleNamed(token, name);
+		if (this._parent === void 0) return ownBinding !== void 0 ? [ownBinding] : [];
+		const result = [];
+		if (ownBinding !== void 0) result.push(ownBinding);
+		let current = this._parent;
+		while (current !== void 0) {
+			const binding = current._registry.getSimpleNamed(token, name);
+			if (binding !== void 0) result.push(binding);
+			current = current._parent;
+		}
+		return result;
+	}
+	_getAvailableSlots(token) {
+		return this._registry.availableSlotStrings(token);
+	}
+	_makeConstraintContext(resolutionPath, materializationStack, hint) {
+		if (hint === void 0 && resolutionPath.length === 0 && materializationStack.length === 0) return ROOT_CONSTRAINT_CONTEXT;
 		return {
 			resolutionPath,
 			materializationStack,
-			parent: materializationStack.length > 0 ? materializationStack[materializationStack.length - 1] : void 0,
-			ancestors: materializationStack.slice(0, -1),
-			currentResolveHint
+			parent: materializationStack.at(-1),
+			ancestors: materializationStack.length > 1 ? materializationStack.slice(0, -1) : [],
+			currentResolveHint: hint
 		};
 	}
-	/**
-	* Throws {@link ScopeViolationError} when the immediate consumer on the stack is a singleton
-	* and the dependency has `"scoped"` or `"transient"` lifetime (captive dependency).
-	* Constants are exempt — they have no scope cache.
-	*/
-	assertDependencyScopeAllowed(dependencyBinding, resolutionPath, materializationStack) {
-		const consumer = materializationStack[materializationStack.length - 1];
-		if (consumer === void 0) return;
-		if (consumer.scope !== "singleton") return;
-		if (dependencyBinding.kind === "constant") return;
-		if (dependencyBinding.scope === "transient" || dependencyBinding.scope === "scoped") {
-			const dependencyLabel = resolutionPath[resolutionPath.length - 1];
-			const consumerLabel = resolutionPath.length >= 2 ? resolutionPath[resolutionPath.length - 2] : void 0;
-			throw new ScopeViolationError({
-				consumerBindingId: consumer.bindingId,
-				consumerKind: consumer.bindingKind,
-				consumerScope: consumer.scope,
-				consumerLabel,
-				dependencyBindingId: dependencyBinding.id,
-				dependencyKind: dependencyBinding.kind,
-				dependencyScope: dependencyBinding.scope,
-				dependencyLabel,
-				resolutionPath: [...resolutionPath]
-			});
+	_matchesBindingFast(binding, hint, resolutionPath, materializationStack) {
+		if (!this._matchesSlotFast(binding.slot, hint)) return false;
+		if (binding.predicate === void 0) return true;
+		const ctx = this._makeConstraintContext(resolutionPath, materializationStack, hint);
+		return binding.predicate(ctx);
+	}
+	_matchesSlotFast(slot, hint) {
+		const hintName = hint?.name;
+		const hintTags = hint?.tags;
+		const singleHintTag = hint?.tag;
+		const hasHintTags = (hintTags?.length ?? 0) > 0 || singleHintTag !== void 0;
+		if (slot.name !== void 0) {
+			if (hintName === void 0 || slot.name !== hintName) return false;
+		} else if (hintName !== void 0) return false;
+		if (slot.tags.length > 0) {
+			if (!hasHintTags) return false;
+			for (const [tagKey, tagValue] of slot.tags) if (!this._matchesHintTag(tagKey, tagValue, hintTags, singleHintTag)) return false;
+		} else if (hasHintTags) return false;
+		return true;
+	}
+	_getTokenName(token) {
+		return tokenName(token);
+	}
+	_getConstructorMetadata(target) {
+		const cached = this._classConstructorMetadata.get(target);
+		if (cached !== void 0) return cached === null ? void 0 : cached;
+		const metadata = this._metadataReader.getConstructorMetadata(target);
+		this._classConstructorMetadata.set(target, metadata ?? null);
+		return metadata;
+	}
+	_instantiateClass(target, deps) {
+		let needsActiveContainer = this._classNeedsActiveContainer.get(target);
+		if (needsActiveContainer === void 0) {
+			needsActiveContainer = ((this._metadataReader.getAccessorMetadata?.(target))?.length ?? 0) > 0;
+			this._classNeedsActiveContainer.set(target, needsActiveContainer);
 		}
+		const invokable = target;
+		if (!needsActiveContainer) return new invokable(...deps);
+		return runWithContainer(this._container, () => new invokable(...deps));
 	}
-	/**
-	* Builds a {@link ResolutionContext} for use inside factories and lifecycle hooks.
-	* The `resolve` / `resolveAsync` / `resolveOptional` closures carry the current path and
-	* materialization stack forward so nested calls inherit captive-dependency checks.
-	*/
-	createContext(pathLabels, visiting, materializationStack, currentResolveHint) {
-		return {
-			resolve: (token, hint) => this.resolve(token, hint, [...pathLabels], visiting, materializationStack),
-			resolveAsync: (token, hint) => this.resolveAsync(token, hint, [...pathLabels], visiting, materializationStack),
-			resolveOptional: (token, hint) => {
-				try {
-					return this.resolve(token, hint, [...pathLabels], visiting, materializationStack);
-				} catch (caughtError) {
-					if (caughtError instanceof TokenNotBoundError) return;
-					throw caughtError;
-				}
-			},
-			resolveAll: (token, hint) => this.resolveAll(token, hint, [...pathLabels], visiting, materializationStack),
-			resolveAllAsync: (token, hint) => this.resolveAllAsync(token, hint, [...pathLabels], visiting, materializationStack),
-			graph: this.buildConstraintContext(pathLabels, materializationStack, currentResolveHint)
-		};
+	_matchesHintTag(tagKey, tagValue, hintTags, singleHintTag) {
+		if (singleHintTag !== void 0 && singleHintTag[0] === tagKey && Object.is(singleHintTag[1], tagValue)) return true;
+		if (hintTags === void 0 || hintTags.length === 0) return false;
+		for (let index = 0; index < hintTags.length; index += 1) {
+			const hintTag = hintTags[index];
+			if (hintTag[0] === tagKey && Object.is(hintTag[1], tagValue)) return true;
+		}
+		return false;
 	}
-	/**
-	* Core synchronous resolution: lookup → filter → cycle check → scope check → instantiate.
-	* Called recursively when a binding's dependencies need resolution.
-	*
-	* @param key - Token or constructor being resolved.
-	* @param hint - Optional name/tag filter for multi-binding selection.
-	* @param pathLabels - Mutable label path accumulated during graph walk; extended in place.
-	* @param visiting - Registry keys currently on the call stack; used for circular-dependency detection.
-	* @param materializationStack - Bindings along the current construction chain; used to block singleton→scoped/transient.
-	*/
-	resolve(key, hint, pathLabels, visiting, materializationStack) {
-		const registryKey = key;
-		const label = registryKeyLabel(key);
-		const nextPath = [...pathLabels, label];
-		if (visiting.has(registryKey)) throw new CircularDependencyError(nextPath);
-		const bindings = this.deps.lookup(registryKey);
-		if (bindings === void 0 || bindings.length === 0) throw new TokenNotBoundError(label, nextPath);
-		const binding = selectBindingForRegistry(bindings, hint, label, nextPath, this.buildConstraintContext(nextPath, materializationStack, hint));
-		this.assertDependencyScopeAllowed(binding, nextPath, materializationStack);
-		if (binding.kind === "async-dynamic") throw new AsyncResolutionError(label, nextPath, "encountered async-dynamic factory during synchronous resolution");
-		visiting.add(registryKey);
+	_resolveTransientDynamicSyncFromContext(binding, resolutionPath, materializationStack) {
+		if (resolutionPath.length < RESOLUTION_SET_THRESHOLD) {
+			const frame = this._getMaterializationFrame(binding);
+			const tName = frame.tokenName;
+			if (resolutionPath.includes(tName)) throw new CircularDependencyError([...resolutionPath, tName]);
+			resolutionPath.push(tName);
+			materializationStack.push(frame);
+			const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, materializationStack, void 0);
+			try {
+				const dynamicResult = binding.factory(resolutionCtx);
+				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tName, tName);
+				return dynamicResult;
+			} finally {
+				materializationStack.pop();
+				resolutionPath.pop();
+			}
+		}
+		if (this._deepActiveLevels > 0 && this._deepSyncCtxPath !== resolutionPath) return this._resolveTransientDynamicSyncSlow(binding, resolutionPath, materializationStack);
+		if (this._deepActiveLevels === 0) {
+			const gen = ++this._deepCycleGen;
+			for (const stackFrame of materializationStack) this._deepCycleMarks.set(stackFrame.bindingId, gen);
+			let ctx = this._deepSyncCtx;
+			if (ctx === void 0) {
+				ctx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+				this._deepSyncCtx = ctx;
+			} else ctx.reset(this, resolutionPath, materializationStack, void 0);
+			this._deepSyncCtxPath = resolutionPath;
+		}
+		if (this._deepCycleMarks.get(binding.id) === this._deepCycleGen) throw new CircularDependencyError([...resolutionPath, tokenName(binding.token)]);
+		this._deepCycleMarks.set(binding.id, this._deepCycleGen);
+		this._deepActiveLevels++;
 		try {
-			return this.instantiateBinding(binding, registryKey, hint, nextPath, visiting, materializationStack);
+			const dynamicResult = binding.factory(this._deepSyncCtx);
+			if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+			return dynamicResult;
 		} finally {
-			visiting.delete(registryKey);
-		}
-	}
-	/**
-	* Core async resolution: same pipeline as {@link resolve} but awaits `async-dynamic`
-	* factories and async lifecycle hooks instead of throwing {@link AsyncResolutionError}.
-	*
-	* @param key - Token or constructor being resolved.
-	* @param hint - Optional name/tag filter for multi-binding selection.
-	* @param pathLabels - Mutable label path accumulated during graph walk; extended in place.
-	* @param visiting - Registry keys currently on the call stack; used for circular-dependency detection.
-	* @param materializationStack - Same captive-dependency chain as {@link resolve}.
-	*/
-	async resolveAsync(key, hint, pathLabels, visiting, materializationStack) {
-		const registryKey = key;
-		const label = registryKeyLabel(key);
-		const nextPath = [...pathLabels, label];
-		if (visiting.has(registryKey)) throw new CircularDependencyError(nextPath);
-		const bindings = this.deps.lookup(registryKey);
-		if (bindings === void 0 || bindings.length === 0) throw new TokenNotBoundError(label, nextPath);
-		const binding = selectBindingForRegistry(bindings, hint, label, nextPath, this.buildConstraintContext(nextPath, materializationStack, hint));
-		this.assertDependencyScopeAllowed(binding, nextPath, materializationStack);
-		visiting.add(registryKey);
+			if (--this._deepActiveLevels === 0) this._deepSyncCtxPath = void 0;
+		}
+	}
+	_resolveTransientDynamicSyncSlow(binding, resolutionPath, materializationStack) {
+		const frame = this._getMaterializationFrame(binding);
+		const tName = frame.tokenName;
+		const pathWithSet = resolutionPath;
+		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
+		if (resolutionSet === void 0) {
+			resolutionSet = new Set(resolutionPath);
+			pathWithSet[RESOLUTION_SET_KEY] = resolutionSet;
+		}
+		if (resolutionSet.has(tName)) throw new CircularDependencyError([...resolutionPath, tName]);
+		resolutionPath.push(tName);
+		resolutionSet.add(tName);
+		materializationStack.push(frame);
+		const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, materializationStack, void 0);
 		try {
-			return await this.instantiateBindingAsync(binding, registryKey, hint, nextPath, visiting, materializationStack);
+			const dynamicResult = binding.factory(resolutionCtx);
+			if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tName, tName);
+			return dynamicResult;
 		} finally {
-			visiting.delete(registryKey);
-		}
-	}
-	/**
-	* Handles scope-cache lookup / storage and lifecycle hooks (`@postConstruct`, `onActivation`)
-	* around a synchronous call to {@link materialize}.
-	*/
-	instantiateBinding(binding, registryKey, hint, pathLabels, visiting, materializationStack) {
-		this.assertCaptiveDependencyFromMaterializationStack(binding, pathLabels, materializationStack);
-		return this.deps.scopeManager.getOrCreate(binding, () => {
-			const frame = bindingToMaterializationFrame(registryKey, binding);
-			const extendedStack = [...materializationStack, frame];
-			const ctx = this.createContext(pathLabels, visiting, extendedStack, hint);
-			const instance = this.materialize(binding, hint, ctx, pathLabels, visiting, extendedStack);
-			if (binding.kind === "class") runPostConstruct(binding.implementationClass, instance, pathLabels);
-			return runActivation(binding, instance, ctx, pathLabels);
-		});
-	}
-	/**
-	* Async counterpart of {@link instantiateBinding}: delegates to {@link materializeAsync}
-	* and awaits `@postConstruct` and `onActivation` hooks.
-	*/
-	async instantiateBindingAsync(binding, registryKey, hint, pathLabels, visiting, materializationStack) {
-		this.assertCaptiveDependencyFromMaterializationStack(binding, pathLabels, materializationStack);
-		return this.deps.scopeManager.getOrCreateAsync(binding, async () => {
-			const frame = bindingToMaterializationFrame(registryKey, binding);
-			const extendedStack = [...materializationStack, frame];
-			const ctx = this.createContext(pathLabels, visiting, extendedStack, hint);
-			const instance = await this.materializeAsync(binding, hint, ctx, pathLabels, visiting, extendedStack);
-			if (binding.kind === "class") await runPostConstructAsync(binding.implementationClass, instance);
-			return await runActivationAsync(binding, instance, ctx, pathLabels);
-		});
-	}
-	/**
-	* Duplicate captive-dependency guard applied at instantiation time (after scope-cache miss),
-	* checking the top of the materialization stack rather than the raw `ConstraintContext`.
-	*/
-	assertCaptiveDependencyFromMaterializationStack(dependencyBinding, resolutionPath, materializationStack) {
-		const parentFrame = materializationStack[materializationStack.length - 1];
-		if (parentFrame === void 0) return;
-		if (parentFrame.scope !== "singleton") return;
-		if (dependencyBinding.kind === "constant") return;
-		if (dependencyBinding.scope === "scoped" || dependencyBinding.scope === "transient") {
-			const dependencyLabel = resolutionPath[resolutionPath.length - 1];
-			const consumerLabel = resolutionPath.length >= 2 ? resolutionPath[resolutionPath.length - 2] : void 0;
-			throw new ScopeViolationError({
-				consumerBindingId: parentFrame.bindingId,
-				consumerKind: parentFrame.bindingKind,
-				consumerScope: parentFrame.scope,
-				consumerLabel,
-				dependencyBindingId: dependencyBinding.id,
-				dependencyKind: dependencyBinding.kind,
-				dependencyScope: dependencyBinding.scope,
-				dependencyLabel,
-				resolutionPath: [...resolutionPath]
-			});
+			materializationStack.pop();
+			resolutionPath.pop();
+			resolutionSet.delete(tName);
 		}
 	}
-	/**
-	* Synchronously produces the raw instance for a binding **without** touching the scope cache
-	* or running lifecycle hooks. The caller ({@link instantiateBinding}) wraps this with
-	* cache logic and post-construction hooks.
-	*
-	* Dispatches on `binding.kind`; throws {@link AsyncResolutionError} if the binding is
-	* `async-dynamic` or if a `dynamic` / `resolved` factory returns a Promise.
-	*/
-	materialize(binding, hint, ctx, pathLabels, visiting, materializationStack) {
-		switch (binding.kind) {
-			case "constant": return binding.value;
-			case "class": return this.instantiateClassBinding(binding, pathLabels, visiting, materializationStack);
-			case "dynamic": {
-				const factoryResult = binding.factory(ctx);
-				if (isPromiseLike(factoryResult)) throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "dynamic factory returned a Promise during synchronous resolution");
-				return factoryResult;
+	_resolveTransientDynamicAsyncFromContext(binding, resolutionPath, materializationStack) {
+		if (resolutionPath.length < RESOLUTION_SET_THRESHOLD) {
+			const tName = tokenName(binding.token);
+			if (resolutionPath.includes(tName)) return Promise.reject(new CircularDependencyError([...resolutionPath, tName]));
+			resolutionPath.push(tName);
+			let ctx;
+			let isOwnerLevel;
+			if (this._deepAsyncCtxPath === resolutionPath) {
+				ctx = this._deepAsyncCtx;
+				isOwnerLevel = true;
+			} else if (this._deepAsyncCtxPath === void 0) {
+				const existing = this._deepAsyncCtx;
+				if (existing === void 0) {
+					ctx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+					this._deepAsyncCtx = ctx;
+				} else {
+					existing.reset(this, resolutionPath, materializationStack, void 0);
+					ctx = existing;
+				}
+				this._deepAsyncCtxPath = resolutionPath;
+				isOwnerLevel = true;
+			} else {
+				ctx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+				isOwnerLevel = false;
 			}
-			case "async-dynamic": throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "async-dynamic factory cannot be materialized synchronously");
-			case "resolved": {
-				const deps = [];
-				for (const depToken of binding.dependencyTokens) deps.push(this.resolve(depToken, void 0, pathLabels, visiting, materializationStack));
-				const resolvedValue = binding.factory(...deps);
-				if (isPromiseLike(resolvedValue)) throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "resolved factory returned a Promise during synchronous resolution");
-				return resolvedValue;
+			if (isOwnerLevel) this._deepAsyncActiveLevels++;
+			let factoryPromise;
+			try {
+				if (binding.kind === "dynamic-async") factoryPromise = binding.factory(ctx);
+				else {
+					const r = binding.factory(ctx);
+					factoryPromise = r instanceof Promise ? r : Promise.resolve(r);
+				}
+			} catch (err) {
+				resolutionPath.pop();
+				if (isOwnerLevel && --this._deepAsyncActiveLevels === 0) this._deepAsyncCtxPath = void 0;
+				return Promise.reject(err);
 			}
-			case "alias": return this.resolve(binding.targetToken, hint, pathLabels, visiting, materializationStack);
-			default: return binding;
+			return factoryPromise.then((value) => {
+				resolutionPath.pop();
+				if (isOwnerLevel && --this._deepAsyncActiveLevels === 0) this._deepAsyncCtxPath = void 0;
+				return value;
+			}, (err) => {
+				resolutionPath.pop();
+				if (isOwnerLevel && --this._deepAsyncActiveLevels === 0) this._deepAsyncCtxPath = void 0;
+				throw err;
+			});
 		}
+		return this._resolveTransientDynamicAsyncSlow(binding, resolutionPath, materializationStack);
 	}
-	/**
-	* Async counterpart of {@link materialize}; awaits `async-dynamic` factories and
-	* recursively resolves `resolved`-binding dependencies with {@link resolveAsync}.
-	*/
-	async materializeAsync(binding, hint, ctx, pathLabels, visiting, materializationStack) {
-		switch (binding.kind) {
-			case "constant": return binding.value;
-			case "class": return this.instantiateClassBindingAsync(binding, pathLabels, visiting, materializationStack);
-			case "dynamic": return binding.factory(ctx);
-			case "async-dynamic": return await binding.factory(ctx);
-			case "resolved": {
-				const deps = [];
-				for (const depToken of binding.dependencyTokens) deps.push(await this.resolveAsync(depToken, void 0, pathLabels, visiting, materializationStack));
-				return binding.factory(...deps);
-			}
-			case "alias": return this.resolveAsync(binding.targetToken, hint, pathLabels, visiting, materializationStack);
-			default: return binding;
-		}
-	}
-	/**
-	* Reads `@injectable()` constructor metadata and synchronously resolves each parameter,
-	* then calls `new ImplementationClass(...deps)`. Throws {@link MissingMetadataError} when
-	* the class has constructor parameters but no metadata.
-	*/
-	instantiateClassBinding(binding, pathLabels, visiting, materializationStack) {
-		const reader = this.deps.metadataReader;
-		const ImplementationClass = binding.implementationClass;
-		if (reader === void 0) return new ImplementationClass();
-		const meta = reader.getConstructorMetadata(binding.implementationClass);
-		if (ImplementationClass.length > 0 && meta === void 0) throw new MissingMetadataError(registryKeyLabel(binding.implementationClass), pathLabels);
-		if (meta === void 0 || meta.params.length === 0) return new ImplementationClass();
-		return new ImplementationClass(...meta.params.map((param) => {
-			const paramHint = param.name !== void 0 ? { name: param.name } : param.tag !== void 0 ? { tag: param.tag } : void 0;
-			if (param.all === true) return this.resolveAll(param.token, paramHint, pathLabels, visiting, materializationStack);
-			if (param.optional) try {
-				return this.resolve(param.token, paramHint, pathLabels, visiting, materializationStack);
-			} catch (caughtError) {
-				if (caughtError instanceof TokenNotBoundError) return;
-				throw caughtError;
-			}
-			return this.resolve(param.token, paramHint, pathLabels, visiting, materializationStack);
-		}));
-	}
-	/**
-	* Async counterpart of {@link instantiateClassBinding}: resolves constructor dependencies
-	* with {@link resolveAsync} so `async-dynamic` parameters are awaited in order.
-	*/
-	async instantiateClassBindingAsync(binding, pathLabels, visiting, materializationStack) {
-		const reader = this.deps.metadataReader;
-		const ImplementationClass = binding.implementationClass;
-		if (reader === void 0) return new ImplementationClass();
-		const meta = reader.getConstructorMetadata(binding.implementationClass);
-		if (ImplementationClass.length > 0 && meta === void 0) throw new MissingMetadataError(registryKeyLabel(binding.implementationClass), pathLabels);
-		if (meta === void 0 || meta.params.length === 0) return new ImplementationClass();
-		const deps = [];
-		for (const param of meta.params) {
-			const paramHint = param.name !== void 0 ? { name: param.name } : param.tag !== void 0 ? { tag: param.tag } : void 0;
-			if (param.all === true) {
-				deps.push(await this.resolveAllAsync(param.token, paramHint, pathLabels, visiting, materializationStack));
-				continue;
-			}
-			if (param.optional) try {
-				deps.push(await this.resolveAsync(param.token, paramHint, pathLabels, visiting, materializationStack));
-			} catch (caughtError) {
-				if (caughtError instanceof TokenNotBoundError) deps.push(void 0);
-				else throw caughtError;
-			}
-			else deps.push(await this.resolveAsync(param.token, paramHint, pathLabels, visiting, materializationStack));
+	async _resolveTransientDynamicAsyncSlow(binding, resolutionPath, materializationStack) {
+		const frame = this._getMaterializationFrame(binding);
+		const tName = frame.tokenName;
+		const pathWithSet = resolutionPath;
+		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
+		if (resolutionSet === void 0) {
+			resolutionSet = new Set(resolutionPath);
+			pathWithSet[RESOLUTION_SET_KEY] = resolutionSet;
+		}
+		if (resolutionSet.has(tName)) throw new CircularDependencyError([...resolutionPath, tName]);
+		resolutionPath.push(tName);
+		resolutionSet.add(tName);
+		materializationStack.push(frame);
+		const resolutionCtx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+		try {
+			if (binding.kind === "dynamic-async") return await binding.factory(resolutionCtx);
+			const dynamicResult = binding.factory(resolutionCtx);
+			return dynamicResult instanceof Promise ? await dynamicResult : dynamicResult;
+		} finally {
+			materializationStack.pop();
+			resolutionPath.pop();
+			resolutionSet.delete(tName);
+		}
+	}
+	_resolveCandidateSync(binding, hint, resolutionPath, materializationStack) {
+		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return binding.value;
+		if (binding.kind === "alias") return this.resolve(binding.target, hint, resolutionPath, materializationStack);
+		const scope = binding.scope ?? "transient";
+		if (scope === "singleton" && this._scope.hasSingleton(binding.id)) return this._scope.getSingleton(binding.id);
+		if (scope === "scoped") {
+			if (!this._scope.isChild) throw new MissingScopeContextError(this._getTokenName(binding.token));
+			if (this._scope.hasScoped(binding.id)) return this._scope.getScoped(binding.id);
+		}
+		return this._resolveBinding(binding, hint, resolutionPath, materializationStack);
+	}
+	_resolveCandidateAsync(binding, hint, resolutionPath, materializationStack) {
+		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return Promise.resolve(binding.value);
+		const isolatedPath = [...resolutionPath];
+		const isolatedStack = [...materializationStack];
+		if (binding.kind === "alias") return this.resolveAsync(binding.target, hint, isolatedPath, isolatedStack);
+		const scope = binding.scope ?? "transient";
+		if (scope === "singleton" && this._scope.hasSingleton(binding.id)) return Promise.resolve(this._scope.getSingleton(binding.id));
+		if (scope === "scoped") {
+			if (!this._scope.isChild) return Promise.reject(new MissingScopeContextError(this._getTokenName(binding.token)));
+			if (this._scope.hasScoped(binding.id)) return Promise.resolve(this._scope.getScoped(binding.id));
+		}
+		return this._resolveBindingAsync(binding, hint, isolatedPath, isolatedStack);
+	}
+	_getMaterializationFrame(binding) {
+		const existing = this._frameByBindingId.get(binding.id);
+		if (existing !== void 0) return existing;
+		const scope = binding.scope ?? "transient";
+		const frame = buildMaterializationFrame(tokenName(binding.token), scope, binding.id, binding.kind, binding.slot);
+		this._frameByBindingId.set(binding.id, frame);
+		return frame;
+	}
+	_needsActivation(binding) {
+		const lifecycleVersion = this._lifecycle.activationVersion;
+		if (lifecycleVersion === 0 && binding.kind !== "class" && binding.kind !== "alias" && binding.onActivation === void 0) return false;
+		if (this._activationCacheVersion !== lifecycleVersion) {
+			this._activationNeedByBindingId.clear();
+			this._activationCacheVersion = lifecycleVersion;
+		}
+		const cached = this._activationNeedByBindingId.get(binding.id);
+		if (cached !== void 0) return cached;
+		if (binding.kind === "class") {
+			let hasActivation = this._lifecycle.hasActivationHandlers(binding.token) || binding.onActivation !== void 0;
+			const cachedPostConstruct = this._classHasPostConstruct.get(binding.target);
+			if (cachedPostConstruct === void 0) hasActivation = true;
+			else if (cachedPostConstruct) hasActivation = true;
+			this._activationNeedByBindingId.set(binding.id, hasActivation);
+			return hasActivation;
+		}
+		let hasActivation = false;
+		if (binding.kind !== "alias" && binding.onActivation !== void 0) hasActivation = true;
+		else if (this._lifecycle.hasActivationHandlers(binding.token)) hasActivation = true;
+		this._activationNeedByBindingId.set(binding.id, hasActivation);
+		return hasActivation;
+	}
+	_refreshClassPostConstructCache(target) {
+		const lifecycle = this._metadataReader.getLifecycleMetadata(target);
+		const hasPostConstruct = lifecycle !== void 0 && lifecycle.postConstruct !== void 0 && lifecycle.postConstruct.length > 0;
+		this._classHasPostConstruct.set(target, hasPostConstruct);
+	}
+	_requiresResolutionContext(binding) {
+		return binding.kind === "dynamic" || binding.kind === "dynamic-async";
+	}
+	_acquireSyncResolutionContext(resolutionPath, materializationStack, hint) {
+		const depth = materializationStack.length;
+		const existing = this._syncResolutionContextPool[depth];
+		if (existing !== void 0) {
+			existing.reset(this, resolutionPath, materializationStack, hint);
+			return existing;
 		}
-		return new ImplementationClass(...deps);
+		const created = new DefaultResolutionContext(this, resolutionPath, materializationStack, hint);
+		this._syncResolutionContextPool[depth] = created;
+		return created;
 	}
 };
 //#endregion