@codefast/di 0.3.15 → 0.3.16-canary.1

package/dist/registry.mjs

@@ -1,5 +1,8 @@
-import { slotKeyEquals } from "./binding.mjs";
+import { slotKeyEquals, slotKeyToString } from "./binding.mjs";
 //#region src/registry.ts
+/**
+* @since 0.3.16-canary.0
+*/
 var BindingRegistry = class {
 	_bindings = /* @__PURE__ */ new Map();
 	_byId = /* @__PURE__ */ new Map();
@@ -9,20 +12,20 @@ var BindingRegistry = class {
 	/** Add or replace binding using slot-aware last-wins. */
 	add(binding) {
 		const key = binding.token;
-		let list = this._bindings.get(key);
-		if (list === void 0) {
-			list = [];
-			this._bindings.set(key, list);
+		let bindingsForToken = this._bindings.get(key);
+		if (bindingsForToken === void 0) {
+			bindingsForToken = [];
+			this._bindings.set(key, bindingsForToken);
 		}
 		if (!this._isPurePredicateBinding(binding)) {
-			const existingIndex = list.findIndex((b) => !this._isPurePredicateBinding(b) && slotKeyEquals(b.slot, binding.slot));
+			const existingIndex = bindingsForToken.findIndex((b) => !this._isPurePredicateBinding(b) && slotKeyEquals(b.slot, binding.slot));
 			if (existingIndex !== -1) {
-				const old = list[existingIndex];
-				this._byId.delete(old.id);
-				list.splice(existingIndex, 1);
+				const replacedBinding = bindingsForToken[existingIndex];
+				this._byId.delete(replacedBinding.id);
+				bindingsForToken.splice(existingIndex, 1);
 			}
 		}
-		list.push(binding);
+		bindingsForToken.push(binding);
 		this._byId.set(binding.id, binding);
 		this._indexSimpleNamedBinding(key, binding);
 		this._indexSimpleTaggedBinding(key, binding);
@@ -31,13 +34,13 @@ var BindingRegistry = class {
 	/** Remove all bindings for a token. Returns removed bindings. */
 	removeByToken(t) {
 		const key = t;
-		const list = this._bindings.get(key) ?? [];
+		const bindingsForToken = this._bindings.get(key) ?? [];
 		this._bindings.delete(key);
 		this._simpleNamed.delete(key);
 		this._simpleTagged.delete(key);
 		this._fastDefault.delete(key);
-		for (const b of list) this._byId.delete(b.id);
-		return list;
+		for (const binding of bindingsForToken) this._byId.delete(binding.id);
+		return bindingsForToken;
 	}
 	/** Remove a specific binding by ID. Returns the removed binding or undefined. */
 	removeById(id) {
@@ -45,13 +48,13 @@ var BindingRegistry = class {
 		if (binding === void 0) return;
 		this._byId.delete(id);
 		const key = binding.token;
-		const list = this._bindings.get(key);
-		if (list !== void 0) {
-			const idx = list.findIndex((b) => b.id === id);
-			if (idx !== -1) list.splice(idx, 1);
+		const bindingsForToken = this._bindings.get(key);
+		if (bindingsForToken !== void 0) {
+			const bindingIndex = bindingsForToken.findIndex((candidate) => candidate.id === id);
+			if (bindingIndex !== -1) bindingsForToken.splice(bindingIndex, 1);
 			this._deindexSimpleNamedBinding(key, binding);
 			this._deindexSimpleTaggedBinding(key, binding);
-			if (list.length === 0) {
+			if (bindingsForToken.length === 0) {
 				this._bindings.delete(key);
 				this._simpleNamed.delete(key);
 				this._simpleTagged.delete(key);
@@ -76,9 +79,9 @@ var BindingRegistry = class {
 	}
 	/** All bindings in the registry. */
 	allBindings() {
-		const result = [];
-		for (const list of this._bindings.values()) result.push(...list);
-		return result;
+		const allBindings = [];
+		for (const bindingsForToken of this._bindings.values()) allBindings.push(...bindingsForToken);
+		return allBindings;
 	}
 	/** Remove all bindings. Returns all removed. */
 	clear() {
@@ -101,14 +104,7 @@ var BindingRegistry = class {
 	}
 	/** Summarize available slot strings for a token (for error messages). */
 	availableSlotStrings(t) {
-		return (this._bindings.get(t) ?? []).map((b) => {
-			const s = b.slot;
-			if (s.name === void 0 && s.tags.length === 0) return "default";
-			const parts = [];
-			if (s.name !== void 0) parts.push(`name:${s.name}`);
-			for (const [k, v] of s.tags) parts.push(`tag:${k}=${String(v)}`);
-			return parts.join(",");
-		});
+		return (this._bindings.get(t) ?? []).map((binding) => slotKeyToString(binding.slot));
 	}
 	_indexSimpleTaggedBinding(tokenKeyValue, binding) {
 		const slot = binding.slot;
@@ -151,30 +147,30 @@ var BindingRegistry = class {
 	_indexSimpleNamedBinding(tokenKeyValue, binding) {
 		const slot = binding.slot;
 		if (slot.name === void 0 || slot.tags.length > 0) return;
-		let byName = this._simpleNamed.get(tokenKeyValue);
-		if (byName === void 0) {
-			byName = /* @__PURE__ */ new Map();
-			this._simpleNamed.set(tokenKeyValue, byName);
+		let bindingsByName = this._simpleNamed.get(tokenKeyValue);
+		if (bindingsByName === void 0) {
+			bindingsByName = /* @__PURE__ */ new Map();
+			this._simpleNamed.set(tokenKeyValue, bindingsByName);
 		}
-		byName.set(slot.name, binding);
+		bindingsByName.set(slot.name, binding);
 	}
 	_deindexSimpleNamedBinding(tokenKeyValue, binding) {
 		const slot = binding.slot;
 		if (slot.name === void 0 || slot.tags.length > 0) return;
-		const byName = this._simpleNamed.get(tokenKeyValue);
-		if (byName === void 0) return;
-		if (byName.get(slot.name)?.id === binding.id) {
-			byName.delete(slot.name);
-			if (byName.size === 0) this._simpleNamed.delete(tokenKeyValue);
+		const bindingsByName = this._simpleNamed.get(tokenKeyValue);
+		if (bindingsByName === void 0) return;
+		if (bindingsByName.get(slot.name)?.id === binding.id) {
+			bindingsByName.delete(slot.name);
+			if (bindingsByName.size === 0) this._simpleNamed.delete(tokenKeyValue);
 		}
 	}
 	_refreshFastDefaultForToken(tokenKeyValue) {
-		const list = this._bindings.get(tokenKeyValue);
-		if (list === void 0 || list.length !== 1) {
+		const bindingsForToken = this._bindings.get(tokenKeyValue);
+		if (bindingsForToken === void 0 || bindingsForToken.length !== 1) {
 			this._fastDefault.delete(tokenKeyValue);
 			return;
 		}
-		const onlyBinding = list[0];
+		const onlyBinding = bindingsForToken[0];
 		if (!(onlyBinding.slot.name === void 0 && onlyBinding.slot.tags.length === 0) || onlyBinding.predicate !== void 0) {
 			this._fastDefault.delete(tokenKeyValue);
 			return;

package/dist/resolve-options.d.mts

@@ -5,6 +5,8 @@ import { SlotKey } from "./binding.mjs";
 /**
  * Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
  * omits keys instead of assigning `undefined`.
+ *
+ * @since 0.3.16-canary.0
  */
 declare function injectableSlotToResolveOptions(slot: {
   readonly name?: string;
@@ -12,6 +14,8 @@ declare function injectableSlotToResolveOptions(slot: {
 }): ResolveOptions | undefined;
 /**
  * Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+ *
+ * @since 0.3.16-canary.0
  */
 declare function slotKeyToResolveOptions(slot: SlotKey): ResolveOptions | undefined;
 //#endregion

package/dist/resolve-options.mjs

@@ -2,6 +2,8 @@
 /**
 * Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
 * omits keys instead of assigning `undefined`.
+*
+* @since 0.3.16-canary.0
 */
 function injectableSlotToResolveOptions(slot) {
 	const options = {};
@@ -11,6 +13,8 @@ function injectableSlotToResolveOptions(slot) {
 }
 /**
 * Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+*
+* @since 0.3.16-canary.0
 */
 function slotKeyToResolveOptions(slot) {
 	const options = {};

package/dist/resolver.d.mts

@@ -1,6 +1,7 @@
 import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
 import { MaterializationFrame, ResolveOptions } from "./types.mjs";
+import { Binding } from "./binding.mjs";
 import { BindingRegistry } from "./registry.mjs";
 import { ScopeManager } from "./scope.mjs";
 import { MetadataReader } from "./metadata/metadata-types.mjs";
@@ -8,6 +9,9 @@ import { Container } from "./container.mjs";
 import { LifecycleManager } from "./lifecycle.mjs";
 
 //#region src/resolver.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 declare class DependencyResolver {
   private readonly _registry;
   private readonly _scope;
@@ -32,22 +36,33 @@ declare class DependencyResolver {
   private _activationCacheVersion;
   constructor(_registry: BindingRegistry, _scope: ScopeManager, _lifecycle: LifecycleManager, _metadataReader: MetadataReader, _container: Container, _parent: DependencyResolver | undefined);
   private _findBinding;
-  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value;
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value;
+  /**
+   * Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
+   */
+  peekBindingForValidate(token: Token<unknown> | Constructor, hint: ResolveOptions | undefined): {
+    binding: Binding;
+    owner: DependencyResolver;
+  } | undefined;
+  /**
+   * Mirrors {@link DependencyResolver.resolveAll} candidate selection only (no instantiation).
+   */
+  peekCandidateBindingsForValidate(token: Token<unknown> | Constructor, hint: ResolveOptions | undefined): Array<Binding>;
+  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Value;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Value;
   private _resolveBinding;
   private _instantiateSync;
   private _resolveClassDeps;
   private _resolveDescriptorDeps;
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value | undefined;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Value[];
-  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value>;
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Value | undefined;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Array<Value>;
+  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Value>;
   private _resolveBindingAsync;
   private _instantiateAsync;
   private _resolveClassDepsAsync;
   private _resolveDescriptorDepsAsync;
-  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value | undefined>;
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: string[], materializationStack: MaterializationFrame[]): Promise<Value[]>;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Value | undefined>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Array<Value>>;
   private _getAllBindingsFromChain;
   private _getSimpleNamedBindingsFromChain;
   private _getAvailableSlots;

package/dist/resolver.mjs

@@ -15,7 +15,16 @@ const ROOT_CONSTRAINT_CONTEXT = {
 	ancestors: EMPTY_FRAME_LIST,
 	currentResolveHint: void 0
 };
+/**
+* @since 0.3.16-canary.0
+*/
 var DependencyResolver = class {
+	_registry;
+	_scope;
+	_lifecycle;
+	_metadataReader;
+	_container;
+	_parent;
 	_frameByBindingId = /* @__PURE__ */ new Map();
 	_syncResolutionContextPool = [];
 	_deepCycleMarks = /* @__PURE__ */ new Map();
@@ -84,6 +93,21 @@ var DependencyResolver = class {
 		}
 		if (this._parent !== void 0) return this._parent._findBinding(token, hint, resolutionPath, materializationStack);
 	}
+	/**
+	* Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
+	*/
+	peekBindingForValidate(token, hint) {
+		return this._findBinding(token, hint, [], []);
+	}
+	/**
+	* Mirrors {@link DependencyResolver.resolveAll} candidate selection only (no instantiation).
+	*/
+	peekCandidateBindingsForValidate(token, hint) {
+		if (hint?.name !== void 0 && hint.tag === void 0 && (hint.tags?.length ?? 0) === 0) return this._getSimpleNamedBindingsFromChain(token, hint.name);
+		const allBindings = this._getAllBindingsFromChain(token);
+		if (allBindings.length === 0) return [];
+		return selectAllBindings(allBindings, hint, this._makeConstraintContext([], [], hint));
+	}
 	resolveFromContext(token, resolutionPath, materializationStack) {
 		const fastBinding = this._registry.getFastDefault(token);
 		if (fastBinding !== void 0) {
@@ -121,16 +145,16 @@ var DependencyResolver = class {
 			if (this._scope.hasScoped(binding.id)) return this._scope.getScoped(binding.id);
 		}
 		const frame = this._getMaterializationFrame(binding);
-		const tName = frame.tokenName;
+		const tokenDisplayName = 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);
+		if (resolutionSet !== void 0 ? resolutionSet.has(tokenDisplayName) : resolutionPath.includes(tokenDisplayName)) throw new CircularDependencyError([...resolutionPath, tokenDisplayName]);
+		resolutionPath.push(tokenDisplayName);
+		resolutionSet?.add(tokenDisplayName);
 		materializationStack.push(frame);
 		const needsActivation = this._needsActivation(binding);
 		if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
@@ -140,18 +164,18 @@ var DependencyResolver = class {
 				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
 				materializationStack.pop();
 				resolutionPath.pop();
-				resolutionSet?.delete(tName);
+				resolutionSet?.delete(tokenDisplayName);
 				return dynamicResult;
 			} catch (error) {
 				materializationStack.pop();
 				resolutionPath.pop();
-				resolutionSet?.delete(tName);
+				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, hint);
+			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);
@@ -165,17 +189,17 @@ var DependencyResolver = class {
 		} finally {
 			materializationStack.pop();
 			resolutionPath.pop();
-			resolutionSet?.delete(tName);
+			resolutionSet?.delete(tokenDisplayName);
 		}
 	}
-	_instantiateSync(binding, ctx, resolutionPath, materializationStack, hint) {
+	_instantiateSync(binding, ctx, resolutionPath, materializationStack) {
 		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;
+				const factoryResult = binding.factory(ctx);
+				if (factoryResult instanceof Promise) throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
+				return factoryResult;
 			}
 			case "dynamic-async": throw new AsyncResolutionError(tokenName(binding.token), tokenName(binding.token));
 			case "class": {
@@ -183,7 +207,7 @@ var DependencyResolver = class {
 				return this._instantiateClass(binding.target, deps);
 			}
 			case "resolved": {
-				const deps = this._resolveDescriptorDeps(binding.deps, resolutionPath, materializationStack, hint);
+				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;
@@ -223,7 +247,7 @@ var DependencyResolver = class {
 		}
 		return deps;
 	}
-	_resolveDescriptorDeps(deps, resolutionPath, materializationStack, _hint) {
+	_resolveDescriptorDeps(deps, resolutionPath, materializationStack) {
 		const resolved = new Array(deps.length);
 		for (let index = 0; index < deps.length; index += 1) {
 			const dep = deps[index];
@@ -326,7 +350,7 @@ var DependencyResolver = class {
 		try {
 			if (scope === "singleton") {
 				const createSingletonPromise = async () => {
-					const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, materializationStack, hint);
+					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);
@@ -338,14 +362,14 @@ var DependencyResolver = class {
 					this._scope.clearInflight(binding.id);
 					return activated;
 				};
-				const p = createSingletonPromise().catch((err) => {
+				const singletonPromise = createSingletonPromise().catch((err) => {
 					this._scope.clearInflight(binding.id);
 					throw err;
 				});
-				this._scope.setInflight(binding.id, p);
-				return await p;
+				this._scope.setInflight(binding.id, singletonPromise);
+				return await singletonPromise;
 			}
-			const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, materializationStack, hint);
+			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);
@@ -361,7 +385,7 @@ var DependencyResolver = class {
 			resolutionSet?.delete(tName);
 		}
 	}
-	async _instantiateAsync(binding, ctx, resolutionPath, materializationStack, hint) {
+	async _instantiateAsync(binding, ctx, resolutionPath, materializationStack) {
 		switch (binding.kind) {
 			case "constant": return binding.value;
 			case "dynamic": {
@@ -378,12 +402,12 @@ var DependencyResolver = class {
 			}
 			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 deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, materializationStack);
 				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);
+				const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, materializationStack);
 				return binding.factory(...deps);
 			}
 			case "alias": throw new InternalError("alias should have been followed before instantiation");
@@ -415,7 +439,7 @@ var DependencyResolver = class {
 		}
 		return Promise.all(pending);
 	}
-	async _resolveDescriptorDepsAsync(deps, resolutionPath, materializationStack, _hint) {
+	async _resolveDescriptorDepsAsync(deps, resolutionPath, materializationStack) {
 		const pending = new Array(deps.length);
 		const shouldCloneContext = deps.length > 1;
 		for (let index = 0; index < deps.length; index += 1) {
@@ -536,14 +560,14 @@ var DependencyResolver = class {
 	_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);
+			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);
 			try {
 				const dynamicResult = binding.factory(resolutionCtx);
-				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tName, tName);
+				if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
 				return dynamicResult;
 			} finally {
 				materializationStack.pop();
@@ -574,33 +598,33 @@ var DependencyResolver = class {
 	}
 	_resolveTransientDynamicSyncSlow(binding, resolutionPath, materializationStack) {
 		const frame = this._getMaterializationFrame(binding);
-		const tName = frame.tokenName;
+		const tokenDisplayName = 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);
+		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);
 		try {
 			const dynamicResult = binding.factory(resolutionCtx);
-			if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tName, tName);
+			if (dynamicResult instanceof Promise) throw new AsyncResolutionError(tokenDisplayName, tokenDisplayName);
 			return dynamicResult;
 		} finally {
 			materializationStack.pop();
 			resolutionPath.pop();
-			resolutionSet.delete(tName);
+			resolutionSet.delete(tokenDisplayName);
 		}
 	}
 	_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);
+			const tokenDisplayName = tokenName(binding.token);
+			if (resolutionPath.includes(tokenDisplayName)) return Promise.reject(new CircularDependencyError([...resolutionPath, tokenDisplayName]));
+			resolutionPath.push(tokenDisplayName);
 			let ctx;
 			let isOwnerLevel;
 			if (this._deepAsyncCtxPath === resolutionPath) {
@@ -626,8 +650,8 @@ var DependencyResolver = class {
 			try {
 				if (binding.kind === "dynamic-async") factoryPromise = binding.factory(ctx);
 				else {
-					const r = binding.factory(ctx);
-					factoryPromise = r instanceof Promise ? r : Promise.resolve(r);
+					const factoryResult = binding.factory(ctx);
+					factoryPromise = factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
 				}
 			} catch (err) {
 				resolutionPath.pop();
@@ -648,16 +672,16 @@ var DependencyResolver = class {
 	}
 	async _resolveTransientDynamicAsyncSlow(binding, resolutionPath, materializationStack) {
 		const frame = this._getMaterializationFrame(binding);
-		const tName = frame.tokenName;
+		const tokenDisplayName = 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);
+		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);
 		try {
@@ -667,7 +691,7 @@ var DependencyResolver = class {
 		} finally {
 			materializationStack.pop();
 			resolutionPath.pop();
-			resolutionSet.delete(tName);
+			resolutionSet.delete(tokenDisplayName);
 		}
 	}
 	_resolveCandidateSync(binding, hint, resolutionPath, materializationStack) {

package/dist/scope.d.mts

@@ -1,6 +1,9 @@
 import { BindingIdentifier } from "./types.mjs";
 
 //#region src/scope.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 declare class ScopeManager {
   private readonly _singletons;
   private readonly _inflight;

package/dist/scope.mjs

@@ -1,5 +1,8 @@
 import { MissingScopeContextError } from "./errors.mjs";
 //#region src/scope.ts
+/**
+* @since 0.3.16-canary.0
+*/
 var ScopeManager = class {
 	_singletons = /* @__PURE__ */ new Map();
 	_inflight = /* @__PURE__ */ new Map();

package/dist/token.d.mts

@@ -2,12 +2,24 @@ import { Constructor } from "./constructor-type.mjs";
 
 //#region src/token.d.ts
 declare const TOKEN_BRAND: unique symbol;
+/**
+ * @since 0.3.16-canary.0
+ */
 interface Token<Value> {
   readonly name: string;
   readonly [TOKEN_BRAND]: Value;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function token<Value>(name: string): Token<Value>;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function tokenName(t: Token<unknown> | Constructor): string;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function isToken(value: unknown): value is Token<unknown>;
 //#endregion
 export { Token, isToken, token, tokenName };

package/dist/token.mjs

@@ -1,11 +1,20 @@
 //#region src/token.ts
+/**
+* @since 0.3.16-canary.0
+*/
 function token(name) {
 	return { name };
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function tokenName(t) {
 	if (typeof t === "function") return t.name;
 	return t.name;
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function isToken(value) {
 	return typeof value === "object" && value !== null && "name" in value && typeof value["name"] === "string" && typeof value !== "function";
 }