@codefast/di 0.3.16-canary.1 → 0.3.16-canary.3

package/dist/resolver.mjs

@@ -1,8 +1,8 @@
 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";
+import { DefaultResolutionContext, buildResolutionFrame, runWithContainer } from "./environment.mjs";
+import { injectionSlotToResolveOptions } from "./resolve-options.mjs";
 //#region src/resolver.ts
 const RESOLUTION_SET_KEY = Symbol("di:resolution-set");
 const RESOLUTION_SET_THRESHOLD = 32;
@@ -10,7 +10,7 @@ const EMPTY_STRING_LIST = [];
 const EMPTY_FRAME_LIST = [];
 const ROOT_CONSTRAINT_CONTEXT = {
 	resolutionPath: EMPTY_STRING_LIST,
-	materializationStack: EMPTY_FRAME_LIST,
+	resolutionStack: EMPTY_FRAME_LIST,
 	parent: void 0,
 	ancestors: EMPTY_FRAME_LIST,
 	currentResolveHint: void 0
@@ -48,7 +48,7 @@ var DependencyResolver = class {
 		this._container = _container;
 		this._parent = _parent;
 	}
-	_findBinding(token, hint, resolutionPath, materializationStack) {
+	_findBinding(token, hint, resolutionPath, resolutionStack) {
 		if (hint === void 0) {
 			const fastDefaultBinding = this._registry.getFastDefault(token);
 			if (fastDefaultBinding !== void 0) return {
@@ -58,7 +58,7 @@ var DependencyResolver = class {
 		}
 		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 {
+			if (namedBinding !== void 0 && this._matchesBindingFast(namedBinding, hint, resolutionPath, resolutionStack)) return {
 				binding: namedBinding,
 				owner: this
 			};
@@ -80,18 +80,18 @@ var DependencyResolver = class {
 					binding: onlyBinding,
 					owner: this
 				};
-				if (this._matchesBindingFast(onlyBinding, hint, resolutionPath, materializationStack)) return {
+				if (this._matchesBindingFast(onlyBinding, hint, resolutionPath, resolutionStack)) return {
 					binding: onlyBinding,
 					owner: this
 				};
 			}
-			const binding = selectBinding(bindings, hint, this._makeConstraintContext(resolutionPath, materializationStack, hint), this._getTokenName(token));
+			const binding = selectBinding(bindings, hint, this._makeConstraintContext(resolutionPath, resolutionStack, 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);
+		if (this._parent !== void 0) return this._parent._findBinding(token, hint, resolutionPath, resolutionStack);
 	}
 	/**
 	* Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
@@ -108,33 +108,33 @@ var DependencyResolver = class {
 		if (allBindings.length === 0) return [];
 		return selectAllBindings(allBindings, hint, this._makeConstraintContext([], [], hint));
 	}
-	resolveFromContext(token, resolutionPath, materializationStack) {
+	resolveFromContext(token, resolutionPath, resolutionStack) {
 		const fastBinding = this._registry.getFastDefault(token);
 		if (fastBinding !== void 0) {
-			if (fastBinding.kind === "alias") return this.resolveFromContext(fastBinding.target, resolutionPath, materializationStack);
+			if (fastBinding.kind === "alias") return this.resolveFromContext(fastBinding.target, resolutionPath, resolutionStack);
 			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 === "transient" && fastBinding.kind === "dynamic" && fastBinding.onActivation === void 0 && (this._lifecycle.activationVersion === 0 || !this._lifecycle.hasActivationHandlers(fastBinding.token))) return this._resolveTransientDynamicSyncFromContext(fastBinding, resolutionPath, resolutionStack);
 			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._resolveBinding(fastBinding, void 0, resolutionPath, resolutionStack);
 		}
-		return this.resolve(token, void 0, resolutionPath, materializationStack);
+		return this.resolve(token, void 0, resolutionPath, resolutionStack);
 	}
-	resolve(token, hint, resolutionPath, materializationStack) {
-		const found = this._findBinding(token, hint, resolutionPath, materializationStack);
+	resolve(token, hint, resolutionPath, resolutionStack) {
+		const found = this._findBinding(token, hint, resolutionPath, resolutionStack);
 		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);
+		if (binding.kind === "alias") return this.resolve(binding.target, hint, resolutionPath, resolutionStack);
+		if ((binding.scope ?? "transient") === "singleton" && owner !== this) return owner._resolveBinding(binding, hint, resolutionPath, resolutionStack);
+		return this._resolveBinding(binding, hint, resolutionPath, resolutionStack);
 	}
-	_resolveBinding(binding, hint, resolutionPath, materializationStack) {
+	_resolveBinding(binding, hint, resolutionPath, resolutionStack) {
 		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return binding.value;
 		const scope = binding.scope ?? "transient";
 		if (scope === "singleton") {
@@ -144,7 +144,7 @@ var DependencyResolver = class {
 			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 frame = this._getResolutionFrame(binding);
 		const tokenDisplayName = frame.tokenName;
 		const pathWithSet = resolutionPath;
 		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
@@ -155,44 +155,38 @@ var DependencyResolver = class {
 		if (resolutionSet !== void 0 ? resolutionSet.has(tokenDisplayName) : resolutionPath.includes(tokenDisplayName)) throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
 		resolutionPath.push(tokenDisplayName);
 		resolutionSet?.add(tokenDisplayName);
-		materializationStack.push(frame);
+		resolutionStack.push(frame);
 		const needsActivation = this._needsActivation(binding);
 		if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
-			const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, materializationStack, hint);
+			const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, resolutionStack, hint);
 			try {
 				const dynamicResult = binding.factory(resolutionCtx);
 				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
-				materializationStack.pop();
+				resolutionStack.pop();
 				resolutionPath.pop();
 				resolutionSet?.delete(tokenDisplayName);
 				return dynamicResult;
 			} catch (error) {
-				materializationStack.pop();
+				resolutionStack.pop();
 				resolutionPath.pop();
 				resolutionSet?.delete(tokenDisplayName);
 				throw error;
 			}
 		}
 		try {
-			const resolutionCtx = needsActivation || this._requiresResolutionContext(binding) ? this._acquireSyncResolutionContext(resolutionPath, materializationStack, hint) : void 0;
-			const instance = this._instantiateSync(binding, resolutionCtx, resolutionPath, materializationStack);
-			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;
+			const resolutionCtx = needsActivation || this._requiresResolutionContext(binding) ? this._acquireSyncResolutionContext(resolutionPath, resolutionStack, hint) : void 0;
+			const instance = this._instantiateSync(binding, resolutionCtx, resolutionPath, resolutionStack);
+			const activated = this._refreshActivationCacheIfNeeded(binding, needsActivation) ? 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 {
-			materializationStack.pop();
+			resolutionStack.pop();
 			resolutionPath.pop();
 			resolutionSet?.delete(tokenDisplayName);
 		}
 	}
-	_instantiateSync(binding, ctx, resolutionPath, materializationStack) {
+	_instantiateSync(binding, ctx, resolutionPath, resolutionStack) {
 		switch (binding.kind) {
 			case "constant": return binding.value;
 			case "dynamic": {
@@ -203,20 +197,20 @@ var DependencyResolver = class {
 			}
 			case "dynamic-async": throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
 			case "class": {
-				const deps = this._resolveClassDeps(binding.target, resolutionPath, materializationStack);
+				const deps = this._resolveClassDeps(binding.target, resolutionPath, resolutionStack);
 				return this._instantiateClass(binding.target, deps);
 			}
 			case "resolved": {
-				const deps = this._resolveDescriptorDeps(binding.deps, resolutionPath, materializationStack);
-				const r = binding.factory(...deps);
-				if (r instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
-				return r;
+				const deps = this._resolveDescriptorDeps(binding.deps, resolutionPath, resolutionStack);
+				const factoryResult = binding.factory(...deps);
+				if (factoryResult instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+				return factoryResult;
 			}
 			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) {
+	_resolveClassDeps(target, resolutionPath, resolutionStack) {
 		const meta = this._getConstructorMetadata(target);
 		if (meta === void 0) {
 			if (target.length === 0) return [];
@@ -225,91 +219,91 @@ var DependencyResolver = class {
 		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 paramHint = injectionSlotToResolveOptions(param);
+			if (param.multi) return [this.resolveAll(param.token, paramHint, resolutionPath, resolutionStack)];
+			if (param.optional) return [this.resolveOptional(param.token, paramHint, resolutionPath, resolutionStack)];
+			if (paramHint === void 0) return [this.resolveFromContext(param.token, resolutionPath, resolutionStack)];
+			return [this.resolve(param.token, paramHint, resolutionPath, resolutionStack)];
 		}
 		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);
+			const paramHint = injectionSlotToResolveOptions(param);
 			if (param.multi) {
-				deps[index] = this.resolveAll(param.token, paramHint, resolutionPath, materializationStack);
+				deps[index] = this.resolveAll(param.token, paramHint, resolutionPath, resolutionStack);
 				continue;
 			}
 			if (param.optional) {
-				deps[index] = this.resolveOptional(param.token, paramHint, resolutionPath, materializationStack);
+				deps[index] = this.resolveOptional(param.token, paramHint, resolutionPath, resolutionStack);
 				continue;
 			}
-			deps[index] = paramHint === void 0 ? this.resolveFromContext(param.token, resolutionPath, materializationStack) : this.resolve(param.token, paramHint, resolutionPath, materializationStack);
+			deps[index] = paramHint === void 0 ? this.resolveFromContext(param.token, resolutionPath, resolutionStack) : this.resolve(param.token, paramHint, resolutionPath, resolutionStack);
 		}
 		return deps;
 	}
-	_resolveDescriptorDeps(deps, resolutionPath, materializationStack) {
+	_resolveDescriptorDeps(deps, resolutionPath, resolutionStack) {
 		const resolved = new Array(deps.length);
 		for (let index = 0; index < deps.length; index += 1) {
 			const dep = deps[index];
-			const depHint = injectableSlotToResolveOptions(dep);
+			const depHint = injectionSlotToResolveOptions(dep);
 			if (dep.multi) {
-				resolved[index] = this.resolveAll(dep.token, depHint, resolutionPath, materializationStack);
+				resolved[index] = this.resolveAll(dep.token, depHint, resolutionPath, resolutionStack);
 				continue;
 			}
 			if (dep.optional) {
-				resolved[index] = this.resolveOptional(dep.token, depHint, resolutionPath, materializationStack);
+				resolved[index] = this.resolveOptional(dep.token, depHint, resolutionPath, resolutionStack);
 				continue;
 			}
-			resolved[index] = depHint === void 0 ? this.resolveFromContext(dep.token, resolutionPath, materializationStack) : this.resolve(dep.token, depHint, resolutionPath, materializationStack);
+			resolved[index] = depHint === void 0 ? this.resolveFromContext(dep.token, resolutionPath, resolutionStack) : this.resolve(dep.token, depHint, resolutionPath, resolutionStack);
 		}
 		return resolved;
 	}
-	resolveOptional(token, hint, resolutionPath, materializationStack) {
-		if (this._findBinding(token, hint, resolutionPath, materializationStack) === void 0) return;
-		return this.resolve(token, hint, resolutionPath, materializationStack);
+	resolveOptional(token, hint, resolutionPath, resolutionStack) {
+		if (this._findBinding(token, hint, resolutionPath, resolutionStack) === void 0) return;
+		return this.resolve(token, hint, resolutionPath, resolutionStack);
 	}
-	resolveAll(token, hint, resolutionPath, materializationStack) {
+	resolveAll(token, hint, resolutionPath, resolutionStack) {
 		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);
+			for (let index = 0; index < namedCandidates.length; index += 1) resolved[index] = this._resolveCandidateSync(namedCandidates[index], hint, resolutionPath, resolutionStack);
 			return resolved;
 		}
 		const allBindings = this._getAllBindingsFromChain(token);
 		if (allBindings.length === 0) return [];
-		const candidates = selectAllBindings(allBindings, hint, this._makeConstraintContext(resolutionPath, materializationStack, hint));
+		const candidates = selectAllBindings(allBindings, hint, this._makeConstraintContext(resolutionPath, resolutionStack, 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);
+		for (let index = 0; index < candidates.length; index += 1) resolved[index] = this._resolveCandidateSync(candidates[index], hint, resolutionPath, resolutionStack);
 		return resolved;
 	}
-	resolveAsyncFromContext(token, resolutionPath, materializationStack) {
+	resolveAsyncFromContext(token, resolutionPath, resolutionStack) {
 		const fastBinding = this._registry.getFastDefault(token);
 		if (fastBinding !== void 0) {
-			if (fastBinding.kind === "alias") return this.resolveAsyncFromContext(fastBinding.target, resolutionPath, materializationStack);
+			if (fastBinding.kind === "alias") return this.resolveAsyncFromContext(fastBinding.target, resolutionPath, resolutionStack);
 			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 === "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, resolutionStack);
 			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));
 			}
-			return this._resolveBindingAsync(fastBinding, void 0, resolutionPath, materializationStack);
+			return this._resolveBindingAsync(fastBinding, void 0, resolutionPath, resolutionStack);
 		}
-		return this.resolveAsync(token, void 0, resolutionPath, materializationStack);
+		return this.resolveAsync(token, void 0, resolutionPath, resolutionStack);
 	}
-	async resolveAsync(token, hint, resolutionPath, materializationStack) {
-		const found = this._findBinding(token, hint, resolutionPath, materializationStack);
+	async resolveAsync(token, hint, resolutionPath, resolutionStack) {
+		const found = this._findBinding(token, hint, resolutionPath, resolutionStack);
 		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);
+		if (binding.kind === "alias") return this.resolveAsync(binding.target, hint, resolutionPath, resolutionStack);
+		if ((binding.scope ?? "transient") === "singleton" && owner !== this) return owner._resolveBindingAsync(binding, hint, resolutionPath, resolutionStack);
+		return this._resolveBindingAsync(binding, hint, resolutionPath, resolutionStack);
 	}
-	async _resolveBindingAsync(binding, hint, resolutionPath, materializationStack) {
+	async _resolveBindingAsync(binding, hint, resolutionPath, resolutionStack) {
 		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return binding.value;
 		const scope = binding.scope ?? "transient";
 		if (scope === "singleton") {
@@ -321,43 +315,37 @@ var DependencyResolver = class {
 			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 frame = this._getResolutionFrame(binding);
+		const frameName = 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);
+		if (resolutionSet !== void 0 ? resolutionSet.has(frameName) : resolutionPath.includes(frameName)) throw new CircularDependencyError([...resolutionPath, frameName]);
+		resolutionPath.push(frameName);
+		resolutionSet?.add(frameName);
+		resolutionStack.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);
+			const resolutionCtx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, 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();
+				resolutionStack.pop();
 				resolutionPath.pop();
-				resolutionSet?.delete(tName);
+				resolutionSet?.delete(frameName);
 			}
 		}
-		const resolutionCtx = needsActivation || this._requiresResolutionContext(binding) ? new DefaultResolutionContext(this, resolutionPath, materializationStack, hint) : void 0;
+		const resolutionCtx = needsActivation || this._requiresResolutionContext(binding) ? new DefaultResolutionContext(this, resolutionPath, resolutionStack, hint) : void 0;
 		try {
 			if (scope === "singleton") {
 				const createSingletonPromise = async () => {
-					const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, materializationStack);
-					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;
+					const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, resolutionStack);
+					const activated = this._refreshActivationCacheIfNeeded(binding, needsActivation) ? await this._lifecycle.runActivation(resolutionCtx, binding, instance, this._metadataReader) : instance;
 					this._scope.setSingleton(binding.id, activated);
 					this._scope.clearInflight(binding.id);
 					return activated;
@@ -369,51 +357,45 @@ var DependencyResolver = class {
 				this._scope.setInflight(binding.id, singletonPromise);
 				return await singletonPromise;
 			}
-			const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, materializationStack);
-			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;
+			const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, resolutionStack);
+			const activated = this._refreshActivationCacheIfNeeded(binding, needsActivation) ? await this._lifecycle.runActivation(resolutionCtx, binding, instance, this._metadataReader) : instance;
 			if (scope === "scoped") this._scope.setScoped(binding.id, activated);
 			return activated;
 		} finally {
-			materializationStack.pop();
+			resolutionStack.pop();
 			resolutionPath.pop();
-			resolutionSet?.delete(tName);
+			resolutionSet?.delete(frameName);
 		}
 	}
-	async _instantiateAsync(binding, ctx, resolutionPath, materializationStack) {
+	async _instantiateAsync(binding, ctx, resolutionPath, resolutionStack) {
 		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);
+				const factoryResult = binding.factory(ctx);
+				return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
 			}
 			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);
+				const deps = await this._resolveClassDepsAsync(binding.target, resolutionPath, resolutionStack);
 				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);
-				const r = binding.factory(...deps);
-				return r instanceof Promise ? r : Promise.resolve(r);
+				const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, resolutionStack);
+				const factoryResult = binding.factory(...deps);
+				return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
 			}
 			case "resolved-async": {
-				const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, materializationStack);
+				const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, resolutionStack);
 				return binding.factory(...deps);
 			}
 			case "alias": throw new InternalError("alias should have been followed before instantiation");
 		}
 	}
-	async _resolveClassDepsAsync(target, resolutionPath, materializationStack) {
+	async _resolveClassDepsAsync(target, resolutionPath, resolutionStack) {
 		const meta = this._getConstructorMetadata(target);
 		if (meta === void 0) {
 			if (target.length === 0) return [];
@@ -422,52 +404,52 @@ var DependencyResolver = class {
 		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 paramHint = injectionSlotToResolveOptions(param);
+			if (param.multi) return [await this.resolveAllAsync(param.token, paramHint, resolutionPath, resolutionStack)];
+			if (param.optional) return [await this.resolveOptionalAsync(param.token, paramHint, resolutionPath, resolutionStack)];
+			if (paramHint === void 0) return [await this.resolveAsyncFromContext(param.token, resolutionPath, resolutionStack)];
+			return [await this.resolveAsync(param.token, paramHint, resolutionPath, resolutionStack)];
 		}
 		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);
+			const paramHint = injectionSlotToResolveOptions(param);
+			if (param.multi) pending[index] = this.resolveAllAsync(param.token, paramHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
+			else if (param.optional) pending[index] = this.resolveOptionalAsync(param.token, paramHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
+			else pending[index] = paramHint === void 0 ? this.resolveAsyncFromContext(param.token, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack) : this.resolveAsync(param.token, paramHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
 		}
 		return Promise.all(pending);
 	}
-	async _resolveDescriptorDepsAsync(deps, resolutionPath, materializationStack) {
+	async _resolveDescriptorDepsAsync(deps, resolutionPath, resolutionStack) {
 		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);
+			const depHint = injectionSlotToResolveOptions(dep);
+			if (dep.multi) pending[index] = this.resolveAllAsync(dep.token, depHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
+			else if (dep.optional) pending[index] = this.resolveOptionalAsync(dep.token, depHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
+			else pending[index] = depHint === void 0 ? this.resolveAsyncFromContext(dep.token, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack) : this.resolveAsync(dep.token, depHint, shouldCloneContext ? [...resolutionPath] : resolutionPath, shouldCloneContext ? [...resolutionStack] : resolutionStack);
 		}
 		return Promise.all(pending);
 	}
-	async resolveOptionalAsync(token, hint, resolutionPath, materializationStack) {
-		if (this._findBinding(token, hint, resolutionPath, materializationStack) === void 0) return;
-		return this.resolveAsync(token, hint, resolutionPath, materializationStack);
+	async resolveOptionalAsync(token, hint, resolutionPath, resolutionStack) {
+		if (this._findBinding(token, hint, resolutionPath, resolutionStack) === void 0) return;
+		return this.resolveAsync(token, hint, resolutionPath, resolutionStack);
 	}
-	async resolveAllAsync(token, hint, resolutionPath, materializationStack) {
+	async resolveAllAsync(token, hint, resolutionPath, resolutionStack) {
 		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);
+			for (let index = 0; index < namedCandidates.length; index += 1) pending[index] = this._resolveCandidateAsync(namedCandidates[index], hint, resolutionPath, resolutionStack);
 			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 candidates = selectAllBindings(allBindings, hint, this._makeConstraintContext(resolutionPath, resolutionStack, 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);
+		for (let index = 0; index < candidates.length; index += 1) pending[index] = this._resolveCandidateAsync(candidates[index], hint, resolutionPath, resolutionStack);
 		return Promise.all(pending);
 	}
 	_getAllBindingsFromChain(token) {
@@ -498,20 +480,20 @@ var DependencyResolver = class {
 	_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;
+	_makeConstraintContext(resolutionPath, resolutionStack, hint) {
+		if (hint === void 0 && resolutionPath.length === 0 && resolutionStack.length === 0) return ROOT_CONSTRAINT_CONTEXT;
 		return {
 			resolutionPath,
-			materializationStack,
-			parent: materializationStack.at(-1),
-			ancestors: materializationStack.length > 1 ? materializationStack.slice(0, -1) : [],
+			resolutionStack,
+			parent: resolutionStack.at(-1),
+			ancestors: resolutionStack.length > 1 ? resolutionStack.slice(0, -1) : [],
 			currentResolveHint: hint
 		};
 	}
-	_matchesBindingFast(binding, hint, resolutionPath, materializationStack) {
+	_matchesBindingFast(binding, hint, resolutionPath, resolutionStack) {
 		if (!this._matchesSlotFast(binding.slot, hint)) return false;
 		if (binding.predicate === void 0) return true;
-		const ctx = this._makeConstraintContext(resolutionPath, materializationStack, hint);
+		const ctx = this._makeConstraintContext(resolutionPath, resolutionStack, hint);
 		return binding.predicate(ctx);
 	}
 	_matchesSlotFast(slot, hint) {
@@ -557,32 +539,32 @@ var DependencyResolver = class {
 		}
 		return false;
 	}
-	_resolveTransientDynamicSyncFromContext(binding, resolutionPath, materializationStack) {
+	_resolveTransientDynamicSyncFromContext(binding, resolutionPath, resolutionStack) {
 		if (resolutionPath.length < RESOLUTION_SET_THRESHOLD) {
-			const frame = this._getMaterializationFrame(binding);
+			const frame = this._getResolutionFrame(binding);
 			const tokenDisplayName = frame.tokenName;
 			if (resolutionPath.includes(tokenDisplayName)) throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
 			resolutionPath.push(tokenDisplayName);
-			materializationStack.push(frame);
-			const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, materializationStack, void 0);
+			resolutionStack.push(frame);
+			const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, resolutionStack, void 0);
 			try {
 				const dynamicResult = binding.factory(resolutionCtx);
 				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
 				return dynamicResult;
 			} finally {
-				materializationStack.pop();
+				resolutionStack.pop();
 				resolutionPath.pop();
 			}
 		}
-		if (this._deepActiveLevels > 0 && this._deepSyncCtxPath !== resolutionPath) return this._resolveTransientDynamicSyncSlow(binding, resolutionPath, materializationStack);
+		if (this._deepActiveLevels > 0 && this._deepSyncCtxPath !== resolutionPath) return this._resolveTransientDynamicSyncSlow(binding, resolutionPath, resolutionStack);
 		if (this._deepActiveLevels === 0) {
 			const gen = ++this._deepCycleGen;
-			for (const stackFrame of materializationStack) this._deepCycleMarks.set(stackFrame.bindingId, gen);
+			for (const stackFrame of resolutionStack) this._deepCycleMarks.set(stackFrame.bindingId, gen);
 			let ctx = this._deepSyncCtx;
 			if (ctx === void 0) {
-				ctx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+				ctx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, void 0);
 				this._deepSyncCtx = ctx;
-			} else ctx.reset(this, resolutionPath, materializationStack, void 0);
+			} else ctx.reset(this, resolutionPath, resolutionStack, void 0);
 			this._deepSyncCtxPath = resolutionPath;
 		}
 		if (this._deepCycleMarks.get(binding.id) === this._deepCycleGen) throw new CircularDependencyError([...resolutionPath, tokenName(binding.token)]);
@@ -596,8 +578,8 @@ var DependencyResolver = class {
 			if (--this._deepActiveLevels === 0) this._deepSyncCtxPath = void 0;
 		}
 	}
-	_resolveTransientDynamicSyncSlow(binding, resolutionPath, materializationStack) {
-		const frame = this._getMaterializationFrame(binding);
+	_resolveTransientDynamicSyncSlow(binding, resolutionPath, resolutionStack) {
+		const frame = this._getResolutionFrame(binding);
 		const tokenDisplayName = frame.tokenName;
 		const pathWithSet = resolutionPath;
 		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
@@ -608,19 +590,19 @@ var DependencyResolver = class {
 		if (resolutionSet.has(tokenDisplayName)) throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
 		resolutionPath.push(tokenDisplayName);
 		resolutionSet.add(tokenDisplayName);
-		materializationStack.push(frame);
-		const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, materializationStack, void 0);
+		resolutionStack.push(frame);
+		const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, resolutionStack, void 0);
 		try {
 			const dynamicResult = binding.factory(resolutionCtx);
 			if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
 			return dynamicResult;
 		} finally {
-			materializationStack.pop();
+			resolutionStack.pop();
 			resolutionPath.pop();
 			resolutionSet.delete(tokenDisplayName);
 		}
 	}
-	_resolveTransientDynamicAsyncFromContext(binding, resolutionPath, materializationStack) {
+	_resolveTransientDynamicAsyncFromContext(binding, resolutionPath, resolutionStack) {
 		if (resolutionPath.length < RESOLUTION_SET_THRESHOLD) {
 			const tokenDisplayName = tokenName(binding.token);
 			if (resolutionPath.includes(tokenDisplayName)) return Promise.reject(new CircularDependencyError([...resolutionPath, tokenDisplayName]));
@@ -633,16 +615,16 @@ var DependencyResolver = class {
 			} else if (this._deepAsyncCtxPath === void 0) {
 				const existing = this._deepAsyncCtx;
 				if (existing === void 0) {
-					ctx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+					ctx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, void 0);
 					this._deepAsyncCtx = ctx;
 				} else {
-					existing.reset(this, resolutionPath, materializationStack, void 0);
+					existing.reset(this, resolutionPath, resolutionStack, void 0);
 					ctx = existing;
 				}
 				this._deepAsyncCtxPath = resolutionPath;
 				isOwnerLevel = true;
 			} else {
-				ctx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+				ctx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, void 0);
 				isOwnerLevel = false;
 			}
 			if (isOwnerLevel) this._deepAsyncActiveLevels++;
@@ -668,10 +650,10 @@ var DependencyResolver = class {
 				throw err;
 			});
 		}
-		return this._resolveTransientDynamicAsyncSlow(binding, resolutionPath, materializationStack);
+		return this._resolveTransientDynamicAsyncSlow(binding, resolutionPath, resolutionStack);
 	}
-	async _resolveTransientDynamicAsyncSlow(binding, resolutionPath, materializationStack) {
-		const frame = this._getMaterializationFrame(binding);
+	async _resolveTransientDynamicAsyncSlow(binding, resolutionPath, resolutionStack) {
+		const frame = this._getResolutionFrame(binding);
 		const tokenDisplayName = frame.tokenName;
 		const pathWithSet = resolutionPath;
 		let resolutionSet = pathWithSet[RESOLUTION_SET_KEY];
@@ -682,33 +664,33 @@ var DependencyResolver = class {
 		if (resolutionSet.has(tokenDisplayName)) throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
 		resolutionPath.push(tokenDisplayName);
 		resolutionSet.add(tokenDisplayName);
-		materializationStack.push(frame);
-		const resolutionCtx = new DefaultResolutionContext(this, resolutionPath, materializationStack, void 0);
+		resolutionStack.push(frame);
+		const resolutionCtx = new DefaultResolutionContext(this, resolutionPath, resolutionStack, 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();
+			resolutionStack.pop();
 			resolutionPath.pop();
 			resolutionSet.delete(tokenDisplayName);
 		}
 	}
-	_resolveCandidateSync(binding, hint, resolutionPath, materializationStack) {
+	_resolveCandidateSync(binding, hint, resolutionPath, resolutionStack) {
 		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);
+		if (binding.kind === "alias") return this.resolve(binding.target, hint, resolutionPath, resolutionStack);
 		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);
+		return this._resolveBinding(binding, hint, resolutionPath, resolutionStack);
 	}
-	_resolveCandidateAsync(binding, hint, resolutionPath, materializationStack) {
+	_resolveCandidateAsync(binding, hint, resolutionPath, resolutionStack) {
 		if (binding.kind === "constant" && binding.onActivation === void 0 && !this._lifecycle.hasActivationHandlers(binding.token)) return Promise.resolve(binding.value);
 		const isolatedPath = [...resolutionPath];
-		const isolatedStack = [...materializationStack];
+		const isolatedStack = [...resolutionStack];
 		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));
@@ -718,11 +700,11 @@ var DependencyResolver = class {
 		}
 		return this._resolveBindingAsync(binding, hint, isolatedPath, isolatedStack);
 	}
-	_getMaterializationFrame(binding) {
+	_getResolutionFrame(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);
+		const frame = buildResolutionFrame(tokenName(binding.token), scope, binding.id, binding.kind, binding.slot);
 		this._frameByBindingId.set(binding.id, frame);
 		return frame;
 	}
@@ -754,17 +736,29 @@ var DependencyResolver = class {
 		const hasPostConstruct = lifecycle !== void 0 && lifecycle.postConstruct !== void 0 && lifecycle.postConstruct.length > 0;
 		this._classHasPostConstruct.set(target, hasPostConstruct);
 	}
+	/**
+	* Refreshes the post-construct cache for class bindings on first instantiation and
+	* returns the (possibly updated) shouldActivate flag.
+	*/
+	_refreshActivationCacheIfNeeded(binding, needsActivation) {
+		if (binding.kind === "class" && this._classHasPostConstruct.get(binding.target) === void 0) {
+			this._refreshClassPostConstructCache(binding.target);
+			this._activationNeedByBindingId.delete(binding.id);
+			return this._needsActivation(binding);
+		}
+		return needsActivation;
+	}
 	_requiresResolutionContext(binding) {
 		return binding.kind === "dynamic" || binding.kind === "dynamic-async";
 	}
-	_acquireSyncResolutionContext(resolutionPath, materializationStack, hint) {
-		const depth = materializationStack.length;
+	_acquireSyncResolutionContext(resolutionPath, resolutionStack, hint) {
+		const depth = resolutionStack.length;
 		const existing = this._syncResolutionContextPool[depth];
 		if (existing !== void 0) {
-			existing.reset(this, resolutionPath, materializationStack, hint);
+			existing.reset(this, resolutionPath, resolutionStack, hint);
 			return existing;
 		}
-		const created = new DefaultResolutionContext(this, resolutionPath, materializationStack, hint);
+		const created = new DefaultResolutionContext(this, resolutionPath, resolutionStack, hint);
 		this._syncResolutionContextPool[depth] = created;
 		return created;
 	}