@codefast/di 0.9.0 → 0.10.1

package/dist/introspection/inspector.d.ts

@@ -1,7 +1,7 @@
-import type { BindingRegistry } from "#/core/registry";
-import type { Token } from "#/core/token";
-import type { BindingIdentifier, BindingKind, BindingScope, BindingTag, Constructor, ResolveOptions } from "#/core/types";
-import type { ScopeManager } from "#/lifecycle/scope-manager";
+import type { BindingRegistry } from "#core/registry";
+import type { Token } from "#core/token";
+import type { BindingIdentifier, BindingKind, BindingScope, BindingTag, Constructor, ResolveOptions } from "#core/types";
+import type { ScopeManager } from "#lifecycle/scope-manager";
 /**
  * A read-only view of one binding: token, kind, scope, slot, and id.
  *
@@ -16,6 +16,8 @@ export interface BindingSnapshot {
         readonly tags: ReadonlyArray<BindingTag>;
     };
     readonly id: BindingIdentifier;
+    /** Whether the binding is a collection member only, taken by `resolveAll` and never by `resolve`. */
+    readonly isMany: boolean;
 }
 /**
  * A read-only view of one container's own bindings and state.
@@ -38,6 +40,6 @@ export declare class Inspector {
     constructor(registry: BindingRegistry, scope: ScopeManager, hasParent: boolean, isDisposed: () => boolean);
     inspect(): ContainerSnapshot;
     lookupBindings<Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
-    has(token: Token<unknown> | Constructor, options?: ResolveOptions, parentHas?: () => boolean): boolean;
+    /** Whether this container's own registry holds a binding the request could select. */
     hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean;
 }

package/dist/introspection/inspector.js

@@ -1,6 +1,6 @@
-import { effectiveBindingScope } from "#/core/binding-scope";
-import { tokenName } from "#/core/token";
-import { selectAllBindings } from "#/resolution/select/binding-select";
+import { effectiveBindingScope } from "#core/binding-scope";
+import { tokenName } from "#core/token";
+import { selectAllBindings } from "#resolution/select/binding-select";
 // ── Inspector ────────────────────────────────────────────────────────────────────────────────────────────────────────
 /**
  * The read-only introspection surface behind a container's `inspect()`.
@@ -30,31 +30,16 @@ export class Inspector {
         const bindings = this.#registry.getAll(token);
         return bindings.map((binding) => this.#toSnapshot(binding));
     }
-    has(token, options, parentHas) {
-        const bindings = this.#registry.getAll(token);
-        if (bindings.length > 0) {
-            // An existence probe answers ambiguity with `true` — several matches still exist; only
-            // resolution has to pick one.
-            if (options !== undefined) {
-                if (selectAllBindings(bindings, options, this.#makeConstraintContext(options)).length > 0) {
-                    return true;
-                }
-            }
-            else {
-                return true;
-            }
-        }
-        return parentHas?.() ?? false;
-    }
+    /** Whether this container's own registry holds a binding the request could select. */
     hasOwn(token, options) {
-        const bindings = this.#registry.getAll(token);
-        if (bindings.length === 0) {
-            return false;
-        }
-        if (options !== undefined) {
-            return selectAllBindings(bindings, options, this.#makeConstraintContext(options)).length > 0;
+        // Presence alone is a registry probe; only a request carrying criteria has to see the list.
+        if (options === undefined) {
+            return this.#registry.has(token);
         }
-        return true;
+        const bindings = this.#registry.getAll(token);
+        // An existence probe answers ambiguity with `true` — several matches still exist; only
+        // resolution has to pick one.
+        return bindings.length > 0 && selectAllBindings(bindings, options, this.#makeConstraintContext(options)).length > 0;
     }
     #makeConstraintContext(options) {
         return {
@@ -76,7 +61,8 @@ export class Inspector {
             kind: binding.kind,
             scope: effectiveBindingScope(binding),
             slot,
-            id: binding.id,
+            id: binding.identifier,
+            isMany: binding.isMany,
         };
     }
 }

package/dist/lifecycle/lifecycle-manager.d.ts

@@ -1,7 +1,7 @@
-import type { Binding } from "#/core/binding";
-import type { Token } from "#/core/token";
-import type { ActivationHandler, Constructor, DeactivationHandler, DependencyKey, ResolutionContext } from "#/core/types";
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { Binding } from "#core/binding";
+import type { Token } from "#core/token";
+import type { ActivationHandler, Constructor, DeactivationHandler, DependencyKey, ResolutionContext } from "#core/types";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * One container's registry of container-level activation and deactivation hooks, keyed by token.
  *

package/dist/lifecycle/lifecycle-manager.js

@@ -1,6 +1,7 @@
-import { getOrInsert } from "#/core/map-upsert";
-import { tokenName } from "#/core/token";
-import { AsyncActivationError, AsyncDeactivationError, InvalidMetadataError } from "#/errors/errors";
+import { getOrInsert } from "#core/map-upsert";
+import { advanceStateEpoch } from "#core/state-epoch";
+import { tokenName } from "#core/token";
+import { AsyncActivationError, AsyncDeactivationError, InvalidMetadataError } from "#errors/errors";
 /**
  * One container's registry of container-level activation and deactivation hooks, keyed by token.
  *
@@ -18,6 +19,7 @@ export class LifecycleManager {
     #cachedHooks;
     registerActivation(token, handler) {
         this.#activationVersion += 1;
+        advanceStateEpoch();
         this.#cachedToken = undefined;
         this.#cachedHooks = undefined;
         this.#activationHooks ??= new Map();
@@ -77,8 +79,8 @@ export class LifecycleManager {
             }
         }
         // 2. per-binding onActivation
-        if (binding.kind !== "alias" && binding.onActivation !== undefined) {
-            const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+        if (binding.kind !== "alias" && binding.activationHook !== undefined) {
+            const activationResult = binding.activationHook(resolutionContext, activatedInstance);
             activatedInstance = activationResult instanceof Promise ? await activationResult : activationResult;
         }
         // 3. container-level onActivation
@@ -100,8 +102,8 @@ export class LifecycleManager {
             }
         }
         // 2. per-binding onActivation (must be sync)
-        if (binding.kind !== "alias" && binding.onActivation !== undefined) {
-            const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+        if (binding.kind !== "alias" && binding.activationHook !== undefined) {
+            const activationResult = binding.activationHook(resolutionContext, activatedInstance);
             if (activationResult instanceof Promise) {
                 throw new AsyncActivationError(tokenName(binding.token), "onActivation");
             }
@@ -134,8 +136,8 @@ export class LifecycleManager {
             }
         }
         // 2. per-binding onDeactivation
-        if (binding.kind !== "alias" && binding.onDeactivation !== undefined) {
-            const hookResult = binding.onDeactivation(instance);
+        if (binding.kind !== "alias" && binding.deactivationHook !== undefined) {
+            const hookResult = binding.deactivationHook(instance);
             if (hookResult instanceof Promise) {
                 await hookResult;
             }
@@ -162,8 +164,8 @@ export class LifecycleManager {
             }
         }
         // 2. per-binding onDeactivation
-        if (binding.kind !== "alias" && binding.onDeactivation !== undefined) {
-            const hookResult = binding.onDeactivation(instance);
+        if (binding.kind !== "alias" && binding.deactivationHook !== undefined) {
+            const hookResult = binding.deactivationHook(instance);
             if (hookResult instanceof Promise) {
                 throw new AsyncDeactivationError(tokenDisplayName);
             }

package/dist/lifecycle/scope-manager.d.ts

@@ -1,5 +1,5 @@
-import type { Binding } from "#/core/binding";
-import type { BindingIdentifier } from "#/core/types";
+import type { Binding } from "#core/binding";
+import type { BindingIdentifier } from "#core/types";
 /**
  * One container's instance caches — singletons, in-flight async creations, and the scoped cache.
  *

package/dist/lifecycle/scope-manager.js

@@ -1,6 +1,6 @@
-import { NO_INSTANCE } from "#/core/binding";
-import { tokenName } from "#/core/token";
-import { MissingScopeContextError } from "#/errors/errors";
+import { NO_INSTANCE } from "#core/binding";
+import { tokenName } from "#core/token";
+import { MissingScopeContextError } from "#errors/errors";
 /**
  * One container's instance caches — singletons, in-flight async creations, and the scoped cache.
  *
@@ -99,7 +99,7 @@ export class ScopeManager {
         if (!this.isChild) {
             throw new MissingScopeContextError(tokenName(binding.token));
         }
-        (this.#scoped ??= new Map()).set(binding.id, instance);
+        (this.#scoped ??= new Map()).set(binding.identifier, instance);
     }
     /** Releases a removed binding's scoped instance. A scoped instance has no deactivation. */
     deleteScoped(id) {

package/dist/metadata/metadata-reader-token.d.ts

@@ -1,5 +1,5 @@
-import type { Token } from "#/core/token";
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { Token } from "#core/token";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * The token a custom `MetadataReader` is bound to for a container to pick up.
  *

package/dist/metadata/metadata-reader-token.js

@@ -1,4 +1,4 @@
-import { token } from "#/core/token";
+import { token } from "#core/token";
 /**
  * The token a custom `MetadataReader` is bound to for a container to pick up.
  *

package/dist/metadata/metadata-types.d.ts

@@ -1,6 +1,6 @@
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor } from "#/injection/descriptor";
-import type { DependencySlot } from "#/injection/resolve-options";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
+import type { DependencySlot } from "#injection/resolve-options";
 /**
  * One constructor parameter's declaration.
  *

package/dist/metadata/symbol-metadata-reader.d.ts

@@ -1,6 +1,6 @@
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor } from "#/injection/descriptor";
-import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#/metadata/metadata-types";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
+import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#metadata/metadata-types";
 type AccessorEntry = {
     readonly key: string | symbol;
     readonly descriptor: InjectionDescriptor;

package/dist/metadata/symbol-metadata-reader.js

@@ -1,4 +1,4 @@
-import { INJECT_ACCESSOR_KEY, INJECTABLE_KEY, LIFECYCLE_KEY, METADATA_SYMBOL } from "#/metadata/metadata-keys";
+import { INJECT_ACCESSOR_KEY, INJECTABLE_KEY, LIFECYCLE_KEY, METADATA_SYMBOL } from "#metadata/metadata-keys";
 /**
  * The default `MetadataReader`, reading decorator metadata stored under `Symbol.metadata`.
  *

package/dist/metadata/verifying-metadata-reader.d.ts

@@ -2,7 +2,7 @@
  * Wraps a foreign {@link MetadataReader} so its answers are verified before anything dereferences
  * them.
  */
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * The reader a container should hand its resolver: verified when it came from outside.
  *

package/dist/metadata/verifying-metadata-reader.js

@@ -2,8 +2,8 @@
  * Wraps a foreign {@link MetadataReader} so its answers are verified before anything dereferences
  * them.
  */
-import { defaultMetadataReader } from "#/metadata/symbol-metadata-reader";
-import { verifyAccessorMetadata, verifyConstructorMetadata, verifyLifecycleMetadata, } from "#/resolution/cache/class-introspector";
+import { defaultMetadataReader } from "#metadata/symbol-metadata-reader";
+import { verifyAccessorMetadata, verifyConstructorMetadata, verifyLifecycleMetadata, } from "#resolution/cache/class-introspector";
 // Wrapping a wrapper would stack a layer per child container, so each one is remembered.
 const verifyingReaders = new WeakSet();
 /**

package/dist/resolution/cache/activation-need.d.ts

@@ -4,10 +4,10 @@
  * @remarks Versioned on the lifecycle manager plus the own registry, since `onActivation` can be
  * registered at any time and a rebind mints binding ids the memo must not keep forever.
  */
-import type { Binding } from "#/core/binding";
-import type { BindingRegistry } from "#/core/registry";
-import type { LifecycleManager } from "#/lifecycle/lifecycle-manager";
-import type { ClassIntrospector } from "#/resolution/cache/class-introspector";
+import type { Binding } from "#core/binding";
+import type { BindingRegistry } from "#core/registry";
+import type { LifecycleManager } from "#lifecycle/lifecycle-manager";
+import type { ClassIntrospector } from "#resolution/cache/class-introspector";
 /**
  * A per-binding cache of whether activation work — hooks or `@postConstruct` — is needed on resolve.
  *
@@ -16,6 +16,8 @@ import type { ClassIntrospector } from "#/resolution/cache/class-introspector";
 export declare class ActivationNeedCache {
     #private;
     constructor(lifecycle: LifecycleManager, classes: ClassIntrospector, registry: BindingRegistry);
+    /** Whether an answer the early returns could not give has had to allocate the memo. */
+    get isMemoBuilt(): boolean;
     needsActivation<Value>(binding: Binding<Value>): boolean;
     /**
      * Settles a class binding's answer once its lifecycle metadata has actually been read, which

package/dist/resolution/cache/activation-need.js

@@ -4,7 +4,9 @@
  * @since 0.5.0-canary.8
  */
 export class ActivationNeedCache {
-    #needByBindingId = new Map();
+    // Allocated by the first answer the early returns cannot give, so a hook-free container that
+    // resolves no class or alias never pays for it.
+    #needByBindingId;
     #version = -1;
     #lifecycle;
     #classes;
@@ -14,10 +16,14 @@ export class ActivationNeedCache {
         this.#classes = classes;
         this.#registry = registry;
     }
+    /** Whether an answer the early returns could not give has had to allocate the memo. */
+    get isMemoBuilt() {
+        return this.#needByBindingId !== undefined;
+    }
     needsActivation(binding) {
         // The chain writes a binding's own hook in place with no version anything here can see, so it
         // is read fresh on every call; the memo covers only container hooks and lifecycle metadata.
-        if (binding.kind !== "alias" && binding.onActivation !== undefined) {
+        if (binding.kind !== "alias" && binding.activationHook !== undefined) {
             return true;
         }
         const lifecycleVersion = this.#lifecycle.activationVersion;
@@ -29,15 +35,16 @@ export class ActivationNeedCache {
         // The registry version evicts entries for binding ids a rebind has retired.
         const version = lifecycleVersion + this.#registry.version;
         if (this.#version !== version) {
-            this.#needByBindingId.clear();
+            this.#needByBindingId?.clear();
             this.#version = version;
         }
-        const cached = this.#needByBindingId.get(binding.id);
+        const memo = (this.#needByBindingId ??= new Map());
+        const cached = memo.get(binding.identifier);
         if (cached !== undefined) {
             return cached;
         }
         const needsActivation = binding.kind === "class" ? this.#classNeedsActivation(binding) : this.#nonClassNeedsActivation(binding);
-        this.#needByBindingId.set(binding.id, needsActivation);
+        memo.set(binding.identifier, needsActivation);
         return needsActivation;
     }
     /**
@@ -52,7 +59,7 @@ export class ActivationNeedCache {
             return needsActivation;
         }
         this.#classes.discoverPostConstruct(binding.target);
-        this.#needByBindingId.delete(binding.id);
+        this.#needByBindingId?.delete(binding.identifier);
         return this.needsActivation(binding);
     }
     // Own hooks are answered before the memo, so both computations cover the memoizable rest only.

package/dist/resolution/cache/binding-lookup-cache.d.ts

@@ -4,11 +4,11 @@
  * @remarks Each cache links to its parent's, so a child answers from its own chain without walking
  * the container hierarchy again.
  */
-import type { Binding } from "#/core/binding";
-import type { BindingRegistry } from "#/core/registry";
-import type { BindingTag } from "#/core/tag";
-import type { Token } from "#/core/token";
-import type { Constructor } from "#/core/types";
+import type { Binding } from "#core/binding";
+import type { BindingRegistry } from "#core/registry";
+import type { BindingTag } from "#core/tag";
+import type { Token } from "#core/token";
+import type { Constructor } from "#core/types";
 /**
  * A token's terminal binding with alias hops already folded, plus the container that owns it.
  *
@@ -20,6 +20,20 @@ export interface DefaultLookupEntry<Owner> {
     readonly binding: Binding;
     readonly owner: Owner;
 }
+/**
+ * A root-level collection read, memoized until any registry in the chain changes.
+ *
+ * @remarks `values` is kept only while every member is a hook-free constant or a hook-free singleton
+ * whose instance is cached, and `activationVersion` is the chain's activation version that promise was
+ * made under.
+ *
+ * @since 0.10.0
+ */
+export interface CollectionEntry {
+    readonly candidates: ReadonlyArray<Binding>;
+    values: ReadonlyArray<unknown> | undefined;
+    activationVersion: number;
+}
 /**
  * Alias folding gives up past this many hops and defers to the full resolve loop, whose
  * Set-based traversal detects genuine cycles exactly rather than by an arbitrary cap.
@@ -35,10 +49,29 @@ export declare const ALIAS_HOP_LIMIT = 32;
 export declare class BindingLookupCache<Owner> {
     #private;
     constructor(registry: BindingRegistry, owner: Owner, parent: BindingLookupCache<Owner> | undefined);
-    /** Summed registry versions of this cache's whole chain — the memo stamp. */
+    /** Whether a second distinct token or tag has had to allocate a memo map behind the one-entry fronts. */
+    get isMemoBuilt(): boolean;
+    /**
+     * Summed registry versions of this cache's whole chain — the memo stamp.
+     *
+     * @remarks Re-summed only when the process-wide state epoch has moved since the last sum: no
+     * registry anywhere changed in between, so no registry in this chain did either.
+     */
     chainVersion(): number;
     /** `null` when the token's shape needs the full selection path. */
     defaultEntry(token: Token<unknown> | Constructor): DefaultLookupEntry<Owner> | null;
     /** `null` when the tag's shape needs the full selection path. */
     taggedEntry(token: Token<unknown> | Constructor, tag: BindingTag): DefaultLookupEntry<Owner> | null;
+    /**
+     * The memoized entry for a request carrying a name and one tag, or `null` when the answer is not this lane's.
+     *
+     * @remarks Same contract as the one-criterion memo: a predicate needs a live context and an alias
+     * carries options through the full path, so both decline; a registry that holds the token without the
+     * exact slot declines too, leaving the parent walk to the full lookup.
+     */
+    namedTaggedEntry(token: Token<unknown> | Constructor, nameCriterion: BindingTag, tag: BindingTag): DefaultLookupEntry<Owner> | null;
+    /** The memoized root-level collection for a token, or `undefined` once the chain changed since it was stored. */
+    collection(token: Token<unknown> | Constructor): CollectionEntry | undefined;
+    /** Stores a root-level collection under the chain version the last `collection()` read stamped. */
+    rememberCollection(token: Token<unknown> | Constructor, entry: CollectionEntry): void;
 }

package/dist/resolution/cache/binding-lookup-cache.js

@@ -1,4 +1,5 @@
-import { getOrInsertComputed } from "#/core/map-upsert";
+import { getOrInsertComputed } from "#core/map-upsert";
+import { stateEpoch } from "#core/state-epoch";
 /**
  * Alias folding gives up past this many hops and defers to the full resolve loop, whose
  * Set-based traversal detects genuine cycles exactly rather than by an arbitrary cap.
@@ -7,27 +8,37 @@ import { getOrInsertComputed } from "#/core/map-upsert";
  */
 export const ALIAS_HOP_LIMIT = 32;
 const newTagToEntryMap = () => new Map();
+const newNameToTagMap = () => new Map();
 /**
  * A version-stamped cache of binding lookups by token and criterion across the container chain.
  *
  * @since 0.5.0-canary.9
  */
 export class BindingLookupCache {
-    #byToken = new Map();
+    #byToken;
     #version = -1;
-    // One entry in front of the map: the two shapes that reach here — an alias, and a token owned by
-    // a parent — are both resolved in a loop over the same token. `null` is a real answer, so absence
-    // is tracked by the token slot rather than by the entry.
+    // The last chain sum and the epoch it was taken at.
+    #chainVersion = -1;
+    #chainEpoch = -1;
+    // One entry in front of the map, and the map is not written until a second distinct token appears
+    // in one generation: the two shapes that reach here — an alias, and a token owned by a parent —
+    // are both resolved in a loop over the same token. `null` is a real answer, so absence is tracked
+    // by the token slot rather than by the entry.
     #lastToken;
     #lastEntry = null;
-    #byTokenAndTag = new Map();
+    #byTokenAndTag;
     #taggedVersion = -1;
+    #byTokenNameAndTag;
+    #pairVersion = -1;
     // One entry in front of the tag map, and the map is not written until a second distinct request
     // shape appears: a per-request child usually asks one (token, tag) once, and the inner-map
     // allocation was that shape's whole regression when this memo landed.
     #lastTagToken;
     #lastTag;
     #lastTaggedEntry = null;
+    // Root-level collections by token, stamped with the chain version like the two memos above.
+    #collections;
+    #collectionsVersion = -1;
     #registry;
     #owner;
     #parent;
@@ -36,29 +47,56 @@ export class BindingLookupCache {
         this.#owner = owner;
         this.#parent = parent;
     }
-    /** Summed registry versions of this cache's whole chain — the memo stamp. */
+    /** Whether a second distinct token or tag has had to allocate a memo map behind the one-entry fronts. */
+    get isMemoBuilt() {
+        return this.#byToken !== undefined || this.#byTokenAndTag !== undefined || this.#byTokenNameAndTag !== undefined;
+    }
+    /**
+     * Summed registry versions of this cache's whole chain — the memo stamp.
+     *
+     * @remarks Re-summed only when the process-wide state epoch has moved since the last sum: no
+     * registry anywhere changed in between, so no registry in this chain did either.
+     */
     chainVersion() {
+        // A root's sum is its own version: one field read, cheaper than the memo it would stamp.
+        if (this.#parent === undefined) {
+            return this.#registry.version;
+        }
+        const epoch = stateEpoch();
+        if (epoch === this.#chainEpoch) {
+            return this.#chainVersion;
+        }
         let version = this.#registry.version;
         for (let cache = this.#parent; cache !== undefined; cache = cache.#parent) {
             version += cache.#registry.version;
         }
+        this.#chainEpoch = epoch;
+        this.#chainVersion = version;
         return version;
     }
     /** `null` when the token's shape needs the full selection path. */
     defaultEntry(token) {
         const version = this.chainVersion();
         if (version !== this.#version) {
-            this.#byToken.clear();
+            this.#byToken?.clear();
             this.#version = version;
             this.#lastToken = undefined;
         }
         else if (token === this.#lastToken) {
             return this.#lastEntry;
         }
-        let entry = this.#byToken.get(token);
-        if (entry === undefined) {
+        let entry;
+        if (this.#lastToken === undefined) {
+            // First token this cache generation sees: answer from the walk and defer the map entirely.
             entry = this.#foldAliases(token);
-            this.#byToken.set(token, entry);
+        }
+        else {
+            const byToken = (this.#byToken ??= new Map());
+            entry = byToken.get(token);
+            if (entry === undefined) {
+                entry = this.#foldAliases(token);
+                byToken.set(token, entry);
+            }
         }
         this.#lastToken = token;
         this.#lastEntry = entry;
@@ -68,7 +106,7 @@ export class BindingLookupCache {
     taggedEntry(token, tag) {
         const version = this.chainVersion();
         if (version !== this.#taggedVersion) {
-            this.#byTokenAndTag.clear();
+            this.#byTokenAndTag?.clear();
             this.#taggedVersion = version;
             this.#lastTagToken = undefined;
             this.#lastTag = undefined;
@@ -84,7 +122,7 @@ export class BindingLookupCache {
         else {
             // Keyed by the criterion object itself: criteria are interned, so identity is the slot
             // contract's own `Object.is` — the same exactness the registry's tagged index relies on.
-            const byTag = getOrInsertComputed(this.#byTokenAndTag, token, newTagToEntryMap);
+            const byTag = getOrInsertComputed((this.#byTokenAndTag ??= new Map()), token, newTagToEntryMap);
             entry = byTag.get(tag);
             if (entry === undefined) {
                 entry = this.#findTaggedInChain(token, tag);
@@ -96,6 +134,52 @@ export class BindingLookupCache {
         this.#lastTaggedEntry = entry;
         return entry;
     }
+    /**
+     * The memoized entry for a request carrying a name and one tag, or `null` when the answer is not this lane's.
+     *
+     * @remarks Same contract as the one-criterion memo: a predicate needs a live context and an alias
+     * carries options through the full path, so both decline; a registry that holds the token without the
+     * exact slot declines too, leaving the parent walk to the full lookup.
+     */
+    namedTaggedEntry(token, nameCriterion, tag) {
+        const version = this.chainVersion();
+        if (version !== this.#pairVersion) {
+            this.#byTokenNameAndTag?.clear();
+            this.#pairVersion = version;
+        }
+        const byName = getOrInsertComputed((this.#byTokenNameAndTag ??= new Map()), token, newNameToTagMap);
+        const byTag = getOrInsertComputed(byName, nameCriterion, newTagToEntryMap);
+        let entry = byTag.get(tag);
+        if (entry === undefined) {
+            entry = this.#findPairInChain(token, nameCriterion, tag);
+            byTag.set(tag, entry);
+        }
+        return entry;
+    }
+    #findPairInChain(token, nameCriterion, tag) {
+        const found = this.#registry.getPairTagged(token, nameCriterion, tag);
+        if (found !== undefined) {
+            return found.predicate !== undefined || found.kind === "alias" ? null : { binding: found, owner: this.#owner };
+        }
+        if (this.#registry.has(token)) {
+            return null;
+        }
+        return this.#parent === undefined ? null : this.#parent.#findPairInChain(token, nameCriterion, tag);
+    }
+    /** The memoized root-level collection for a token, or `undefined` once the chain changed since it was stored. */
+    collection(token) {
+        const version = this.chainVersion();
+        if (version !== this.#collectionsVersion) {
+            this.#collections?.clear();
+            this.#collectionsVersion = version;
+            return undefined;
+        }
+        return this.#collections?.get(token);
+    }
+    /** Stores a root-level collection under the chain version the last `collection()` read stamped. */
+    rememberCollection(token, entry) {
+        (this.#collections ??= new Map()).set(token, entry);
+    }
     #foldAliases(token) {
         let current = token;
         for (let hop = 0; hop < ALIAS_HOP_LIMIT; hop += 1) {

package/dist/resolution/cache/class-introspector.d.ts

@@ -3,11 +3,11 @@
  *
  * @remarks Metadata cannot change once a class is defined, so nothing here needs version stamping.
  */
-import type { AmbientResolution } from "#/ambient/active-container";
-import type { Container } from "#/container/container";
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor } from "#/injection/descriptor";
-import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#/metadata/metadata-types";
+import type { AmbientResolution } from "#ambient/active-container";
+import type { Container } from "#container/container";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
+import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#metadata/metadata-types";
 /**
  * A reader's constructor metadata for a class, verified the first time this process asks.
  *
@@ -52,7 +52,7 @@ export declare function verifyAccessorMetadata(reader: MetadataReader, target: C
  */
 export declare class ClassIntrospector {
     #private;
-    constructor(reader: MetadataReader, container: Container);
+    constructor(reader: MetadataReader, container: Container, inherited: ClassIntrospector | undefined);
     constructorMetadata(target: Constructor): ConstructorMetadata | undefined;
     /**
      * Whether the class has a `@postConstruct` hook, or `undefined` until {@link discoverPostConstruct}.