@codefast/di 0.3.13 → 0.3.14-canary.1

package/dist/resolver.mjs

@@ -1,8 +1,10 @@
 import { AsyncResolutionError, CircularDependencyError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError } from "./errors.mjs";
 import { filterMatchingBindings, registryKeyLabel, selectBindingForRegistry } from "./binding-select.mjs";
-import { runActivation, runActivationAsync, runPostConstruct, runPostConstructAsync } from "./lifecycle.mjs";
+import { isPromiseLike, runActivation, runActivationAsync, runPostConstruct, runPostConstructAsync } from "./lifecycle.mjs";
 //#region src/resolver.ts
-/** Converts a registry key + binding into a {@link MaterializationFrame} for the captive-dependency stack. */
+/**
+* Converts a registry key + binding into a {@link MaterializationFrame} for the captive-dependency stack.
+*/
 function bindingToMaterializationFrame(registryKey, binding) {
 	return {
 		registryKey,
@@ -13,22 +15,66 @@ function bindingToMaterializationFrame(registryKey, binding) {
 	};
 }
 /**
-* Walks the binding graph, manages circular-dependency detection, delegates caching to
-* {@link ScopeManager}, and calls lifecycle hooks. Used exclusively by the container.
+* 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.
 */
 var DependencyResolver = class {
 	constructor(deps) {
 		this.deps = deps;
 	}
-	/** Entry point for synchronous single-binding resolution (no path prefix). */
+	/**
+	* 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 (no path prefix). */
+	/**
+	* 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(), []);
 	}
-	/** Returns `undefined` instead of throwing when no binding is found; still throws on circular deps or async factories. */
+	/**
+	* 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);
@@ -53,54 +99,88 @@ var DependencyResolver = class {
 			visiting.delete(registryKey);
 		}
 	}
-	/** Resolves all bindings for `key` synchronously; throws on async factories. */
+	/**
+	* 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 basePath = [label];
+		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(basePath, [], hint));
+		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, basePath);
+			if (hint !== void 0 && (hint.name !== void 0 || hint.tag !== void 0)) throw new NoMatchingBindingError(label, hint, nextPath);
 			return [];
 		}
+		visiting.add(registryKey);
 		const results = [];
-		for (const binding of candidates) {
-			this.assertDependencyScopeAllowed(binding, basePath, []);
-			if (binding.kind === "async-dynamic") throw new AsyncResolutionError(label, basePath, "encountered async-dynamic factory during synchronous resolveAll");
-			const visiting = /* @__PURE__ */ new Set();
-			visiting.add(registryKey);
-			try {
-				results.push(this.instantiateBinding(binding, registryKey, hint, basePath, visiting, []));
-			} finally {
-				visiting.delete(registryKey);
+		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));
 			}
+		} finally {
+			visiting.delete(registryKey);
 		}
 		return results;
 	}
-	/** Resolves all bindings for `key`, awaiting any async factories in the set. */
-	async resolveAllAsyncRoot(key, hint) {
+	/**
+	* 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 basePath = [label];
+		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(basePath, [], hint));
+		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, basePath);
+			if (hint !== void 0 && (hint.name !== void 0 || hint.tag !== void 0)) throw new NoMatchingBindingError(label, hint, nextPath);
 			return [];
 		}
+		visiting.add(registryKey);
 		const results = [];
-		for (const binding of candidates) {
-			this.assertDependencyScopeAllowed(binding, basePath, []);
-			const visiting = /* @__PURE__ */ new Set();
-			visiting.add(registryKey);
-			try {
-				results.push(await this.instantiateBindingAsync(binding, registryKey, hint, basePath, visiting, []));
-			} finally {
-				visiting.delete(registryKey);
+		try {
+			for (const binding of candidates) {
+				this.assertDependencyScopeAllowed(binding, nextPath, materializationStack);
+				results.push(await this.instantiateBindingAsync(binding, registryKey, hint, nextPath, visiting, materializationStack));
 			}
+		} finally {
+			visiting.delete(registryKey);
 		}
 		return results;
 	}
@@ -160,10 +240,15 @@ var DependencyResolver = class {
 					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)
 		};
 	}
 	/**
+	* 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.
@@ -188,6 +273,9 @@ var DependencyResolver = class {
 		}
 	}
 	/**
+	* 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.
@@ -266,8 +354,12 @@ var DependencyResolver = class {
 		}
 	}
 	/**
-	* Synchronously produces the raw instance for a binding without touching the scope cache.
-	* Dispatches on `binding.kind`; throws {@link AsyncResolutionError} for `async-dynamic` factories.
+	* 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) {
@@ -275,7 +367,7 @@ var DependencyResolver = class {
 			case "class": return this.instantiateClassBinding(binding, pathLabels, visiting, materializationStack);
 			case "dynamic": {
 				const factoryResult = binding.factory(ctx);
-				if (typeof factoryResult === "object" && factoryResult !== null && "then" in factoryResult && typeof factoryResult.then === "function") throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "dynamic factory returned a Promise during synchronous resolution");
+				if (isPromiseLike(factoryResult)) throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "dynamic factory returned a Promise during synchronous resolution");
 				return factoryResult;
 			}
 			case "async-dynamic": throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "async-dynamic factory cannot be materialized synchronously");
@@ -283,7 +375,7 @@ var DependencyResolver = class {
 				const deps = [];
 				for (const depToken of binding.dependencyTokens) deps.push(this.resolve(depToken, void 0, pathLabels, visiting, materializationStack));
 				const resolvedValue = binding.factory(...deps);
-				if (typeof resolvedValue === "object" && resolvedValue !== null && "then" in resolvedValue && typeof resolvedValue.then === "function") throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "resolved factory returned a Promise during synchronous resolution");
+				if (isPromiseLike(resolvedValue)) throw new AsyncResolutionError(pathLabels[pathLabels.length - 1] ?? "(unknown)", pathLabels, "resolved factory returned a Promise during synchronous resolution");
 				return resolvedValue;
 			}
 			case "alias": return this.resolve(binding.targetToken, hint, pathLabels, visiting, materializationStack);
@@ -323,6 +415,7 @@ var DependencyResolver = class {
 		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) {
@@ -346,6 +439,10 @@ var DependencyResolver = class {
 		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) {

package/dist/scope-validation.d.mts

@@ -5,8 +5,9 @@ import { MetadataReader } from "./metadata/metadata-types.mjs";
 //#region src/scope-validation.d.ts
 /**
  * Walks every binding in the registry and throws {@link ScopeViolationError} on the first
- * captive-dependency violation found: a singleton that directly or transitively depends on a
- * scoped or transient binding. Constant bindings are exempt (no stateful instance to capture).
+ * captive-dependency violation found **along a direct static edge**: for each binding, only
+ * targets returned by {@link listResolvedDependencies} are considered (not a full recursive
+ * graph walk). Constant bindings are exempt.
  *
  * Called by {@link Container.validate} and automatically after each `load()` in non-production
  * environments.

package/dist/scope-validation.mjs

@@ -4,8 +4,9 @@ import { listResolvedDependencies } from "./dependency-graph.mjs";
 //#region src/scope-validation.ts
 /**
 * Walks every binding in the registry and throws {@link ScopeViolationError} on the first
-* captive-dependency violation found: a singleton that directly or transitively depends on a
-* scoped or transient binding. Constant bindings are exempt (no stateful instance to capture).
+* captive-dependency violation found **along a direct static edge**: for each binding, only
+* targets returned by {@link listResolvedDependencies} are considered (not a full recursive
+* graph walk). Constant bindings are exempt.
 *
 * Called by {@link Container.validate} and automatically after each `load()` in non-production
 * environments.

package/dist/scope.d.mts

@@ -2,19 +2,49 @@ import { Binding, BindingIdentifier } from "./binding.mjs";
 
 //#region src/scope.d.ts
 /**
- * Caches singleton and scoped instances and runs deactivation hooks on disposal.
+ * Caches singleton and scoped instances, deduplicates concurrent async creation, and runs
+ * deactivation hooks (`onDeactivation`, `@preDestroy`) on disposal.
+ *
+ * A root scope manager owns both singleton and scoped caches. A child scope manager (created
+ * via {@link createChildScope}) shares the parent's singleton cache but receives a fresh scoped
+ * cache — singletons are shared across the hierarchy, scoped instances are isolated per child.
+ *
+ * Invariant: `ownsSingletonDisposal` is `true` only for the root. When a child disposes, only
+ * its scoped bindings are deactivated; singletons remain alive until the root disposes.
  */
 declare class ScopeManager {
-  /** Cached singleton instances: `bindingId → { binding, instance }`. */
+  /**
+   * Cached singleton instances: `bindingId → { binding, instance }`.
+   */
   private readonly singletonCache;
-  /** Cached scoped instances for this container level: `bindingId → { binding, instance }`. */
+  /**
+   * Cached scoped instances for this container level: `bindingId → { binding, instance }`.
+   */
   private readonly scopedCache;
+  /**
+   * True only for the root scope manager. Controls whether {@link dispose} / {@link disposeAsync}
+   * also drain the shared singleton cache; child scopes leave singleton disposal to the root.
+   */
   private readonly ownsSingletonDisposal;
-  /** In-flight async singleton creation promises (deduplicate concurrent resolveAsync calls). */
+  /**
+   * In-flight async singleton creation promises.
+   * Guards against double-instantiation when multiple `resolveAsync` calls for the same
+   * singleton binding overlap before the first one settles.
+   */
   private readonly singletonPendingPromises;
+  /**
+   * In-flight async scoped creation promises (same deduplication role as
+   * {@link singletonPendingPromises} but for scoped bindings).
+   */
   private readonly scopedPendingPromises;
+  /**
+   * Internal constructor for root/child scope managers.
+   * Prefer {@link createRoot} and {@link createChildScope}.
+   */
   private constructor();
-  /** Creates a root scope manager that owns both the singleton cache and scoped cache. */
+  /**
+   * Creates a root scope manager that owns both the singleton cache and scoped cache.
+   */
   static createRoot(): ScopeManager;
   /**
    * Shares the parent singleton cache; receives a fresh scoped cache (for child containers).
@@ -24,7 +54,9 @@ declare class ScopeManager {
    * Whether a singleton/scoped binding currently has a cached instance (always false for transient).
    */
   isBindingCached(binding: Binding<unknown>): boolean;
-  /** Returns the cached instance for singleton/scoped bindings, or calls `createInstance` on first access. */
+  /**
+   * Returns the cached instance for singleton/scoped bindings, or calls `createInstance` on first access.
+   */
   getOrCreate(binding: Binding<unknown>, createInstance: () => unknown): unknown;
   /**
    * Async variant of {@link getOrCreate}. Deduplicates concurrent creation calls for the same

package/dist/scope.mjs

@@ -1,22 +1,46 @@
 import { InternalError } from "./errors.mjs";
-import { runPreDestroy, runPreDestroyAsync } from "./lifecycle.mjs";
+import { isPromiseLike, runPreDestroy, runPreDestroyAsync } from "./lifecycle.mjs";
 //#region src/scope.ts
-/** Returns `true` when `value` is a thenable (duck-typed Promise check). */
-function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
 /**
-* Caches singleton and scoped instances and runs deactivation hooks on disposal.
+* Caches singleton and scoped instances, deduplicates concurrent async creation, and runs
+* deactivation hooks (`onDeactivation`, `@preDestroy`) on disposal.
+*
+* A root scope manager owns both singleton and scoped caches. A child scope manager (created
+* via {@link createChildScope}) shares the parent's singleton cache but receives a fresh scoped
+* cache — singletons are shared across the hierarchy, scoped instances are isolated per child.
+*
+* Invariant: `ownsSingletonDisposal` is `true` only for the root. When a child disposes, only
+* its scoped bindings are deactivated; singletons remain alive until the root disposes.
 */
 var ScopeManager = class ScopeManager {
-	/** Cached singleton instances: `bindingId → { binding, instance }`. */
+	/**
+	* Cached singleton instances: `bindingId → { binding, instance }`.
+	*/
 	singletonCache;
-	/** Cached scoped instances for this container level: `bindingId → { binding, instance }`. */
+	/**
+	* Cached scoped instances for this container level: `bindingId → { binding, instance }`.
+	*/
 	scopedCache;
+	/**
+	* True only for the root scope manager. Controls whether {@link dispose} / {@link disposeAsync}
+	* also drain the shared singleton cache; child scopes leave singleton disposal to the root.
+	*/
 	ownsSingletonDisposal;
-	/** In-flight async singleton creation promises (deduplicate concurrent resolveAsync calls). */
+	/**
+	* In-flight async singleton creation promises.
+	* Guards against double-instantiation when multiple `resolveAsync` calls for the same
+	* singleton binding overlap before the first one settles.
+	*/
 	singletonPendingPromises;
+	/**
+	* In-flight async scoped creation promises (same deduplication role as
+	* {@link singletonPendingPromises} but for scoped bindings).
+	*/
 	scopedPendingPromises;
+	/**
+	* Internal constructor for root/child scope managers.
+	* Prefer {@link createRoot} and {@link createChildScope}.
+	*/
 	constructor(singletonCache, scopedCache, ownsSingletonDisposal, singletonPendingPromises, scopedPendingPromises) {
 		this.singletonCache = singletonCache;
 		this.scopedCache = scopedCache;
@@ -24,7 +48,9 @@ var ScopeManager = class ScopeManager {
 		this.singletonPendingPromises = singletonPendingPromises;
 		this.scopedPendingPromises = scopedPendingPromises;
 	}
-	/** Creates a root scope manager that owns both the singleton cache and scoped cache. */
+	/**
+	* Creates a root scope manager that owns both the singleton cache and scoped cache.
+	*/
 	static createRoot() {
 		return new ScopeManager(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), true, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
 	}
@@ -41,7 +67,9 @@ var ScopeManager = class ScopeManager {
 		if (binding.scope === "transient") return false;
 		return (binding.scope === "singleton" ? this.singletonCache : this.scopedCache).has(binding.id);
 	}
-	/** Returns the cached instance for singleton/scoped bindings, or calls `createInstance` on first access. */
+	/**
+	* Returns the cached instance for singleton/scoped bindings, or calls `createInstance` on first access.
+	*/
 	getOrCreate(binding, createInstance) {
 		if (binding.scope === "transient") return createInstance();
 		const cache = binding.scope === "singleton" ? this.singletonCache : this.scopedCache;
@@ -153,8 +181,9 @@ var ScopeManager = class ScopeManager {
 	* synchronously. Throws {@link InternalError} if any handler returns a Promise.
 	*/
 	disposeMap(store) {
-		for (const [bindingId, entry] of [...store.entries()]) {
-			store.delete(bindingId);
+		const entries = [...store.values()];
+		store.clear();
+		for (const entry of entries) {
 			const handler = entry.binding.onDeactivation;
 			if (handler !== void 0) {
 				if (isPromiseLike(handler(entry.instance))) throw new InternalError("onDeactivation returned a Promise; use disposeAsync() instead of dispose().");

package/dist/token.d.mts

@@ -9,11 +9,18 @@ type Token<Value> = {
   readonly name: string;
 };
 /**
- * Extracts the value type carried by a {@link Token}.
+ * Extracts the value type carried by a {@link Token} or the instance type of a {@link Constructor}.
+ * Falls through to `never` for types that are neither a token nor a constructor.
  */
 type TokenValue<Type> = Type extends Token<infer Value> ? Value : Type extends (abstract new (...args: never[]) => infer Value) ? Value : never;
 /**
- * Creates a type-safe injection token identified by `name` (for debugging and errors).
+ * Creates a frozen, type-safe injection token identified by `name`.
+ *
+ * The returned object is `Object.freeze`-d; `name` is used only for debugging and error
+ * messages — binding lookup relies on **reference equality** of the token object.
+ * Store the return value in a module-level `const` and import it wherever needed.
+ *
+ * @param name - Human-readable label (appears in error messages, graph output, and debug snapshots).
  */
 declare function token<Value>(name: string): Token<Value>;
 //#endregion

package/dist/token.mjs

@@ -1,6 +1,12 @@
 //#region src/token.ts
 /**
-* Creates a type-safe injection token identified by `name` (for debugging and errors).
+* Creates a frozen, type-safe injection token identified by `name`.
+*
+* The returned object is `Object.freeze`-d; `name` is used only for debugging and error
+* messages — binding lookup relies on **reference equality** of the token object.
+* Store the return value in a module-level `const` and import it wherever needed.
+*
+* @param name - Human-readable label (appears in error messages, graph output, and debug snapshots).
 */
 function token(name) {
 	return Object.freeze({ name });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/di",
-  "version": "0.3.13",
+  "version": "0.3.14-canary.1",
   "description": "Lightweight dependency injection primitives for Codefast",
   "keywords": [
     "codefast",
@@ -81,6 +81,22 @@
       "types": "./dist/errors.d.mts",
       "import": "./dist/errors.mjs"
     },
+    "./graph-adapters/cytoscape": {
+      "types": "./dist/graph-adapters/cytoscape.d.mts",
+      "import": "./dist/graph-adapters/cytoscape.mjs"
+    },
+    "./graph-adapters/dot": {
+      "types": "./dist/graph-adapters/dot.d.mts",
+      "import": "./dist/graph-adapters/dot.mjs"
+    },
+    "./graph-adapters/reactflow": {
+      "types": "./dist/graph-adapters/reactflow.d.mts",
+      "import": "./dist/graph-adapters/reactflow.mjs"
+    },
+    "./graph-adapters/types": {
+      "types": "./dist/graph-adapters/types.d.mts",
+      "import": "./dist/graph-adapters/types.mjs"
+    },
     "./inspector": {
       "types": "./dist/inspector.d.mts",
       "import": "./dist/inspector.mjs"
@@ -141,7 +157,7 @@
     "typescript": "^6.0.2",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.1.4",
-    "@codefast/typescript-config": "0.3.13"
+    "@codefast/typescript-config": "0.3.14-canary.1"
   },
   "engines": {
     "node": ">=22.0.0"