@codefast/di 0.9.0 → 0.10.0

package/dist/core/state-epoch.js

@@ -0,0 +1,21 @@
+/**
+ * The process-wide counter every container mutation advances, so a chain walk can be skipped while nothing moved.
+ */
+let epoch = 0;
+/**
+ * The current state epoch: unchanged between two reads exactly when no registry or lifecycle table
+ * in the process was mutated in between.
+ *
+ * @since 0.10.0
+ */
+export function stateEpoch() {
+    return epoch;
+}
+/**
+ * Advances the epoch; every registry version bump and every activation-hook registration calls it.
+ *
+ * @since 0.10.0
+ */
+export function advanceStateEpoch() {
+    epoch += 1;
+}

package/dist/core/types.d.ts

@@ -17,11 +17,14 @@ export type DependencyKey = Token<unknown> | Constructor;
 export type BindingScope = "singleton" | "transient" | "scoped";
 declare const BINDING_ID_BRAND: unique symbol;
 /**
- * A branded string that uniquely identifies one binding.
+ * A branded number that uniquely identifies one binding for the life of the process.
+ *
+ * @remarks Minted from a counter, never parsed or displayed as an identity: the brand is what makes
+ * it opaque, and a number costs a plain bind nothing where a string cost it an allocation.
  *
  * @since 0.3.16-canary.0
  */
-export type BindingIdentifier = string & {
+export type BindingIdentifier = number & {
     readonly [BINDING_ID_BRAND]: true;
 };
 /**
@@ -109,8 +112,8 @@ export interface ResolutionContext {
     resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
     resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
     resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
-    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
+    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): ReadonlyArray<Value>;
+    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
     readonly graph: ConstraintContext;
 }
 /**

package/dist/errors/diagnostics.d.ts

@@ -25,6 +25,8 @@ export interface ResolutionDiagnostics {
     readonly compiledPlanCount: number;
     /** Bindings with a compiled async instantiation plan. */
     readonly compiledAsyncPlanCount: number;
+    /** Plans this container's resolver has generated as functions of their own. */
+    readonly generatedPlanCount: number;
     /** Contexts held by the depth-indexed sync pool. */
     readonly syncContextPoolSize: number;
     /** Scoped instances currently cached by this container's scope manager. */

package/dist/errors/errors.d.ts

@@ -232,6 +232,35 @@ export declare class MissingContainerContextError extends DiError {
  *
  * @since 0.5.0-canary.8
  */
+/**
+ * A second `to*()` on a chain that already registered its binding.
+ *
+ * @remarks A chain is its binding, so it registers exactly once; a token bound twice is two `bind()`
+ * calls, the second of which displaces the first under slot last-wins.
+ *
+ * @since 0.10.0
+ */
+export declare class ChainAlreadyRegisteredError extends DiError {
+    readonly code = "CHAIN_ALREADY_REGISTERED";
+    readonly tokenName: string;
+    constructor(tokenName: string);
+}
+/**
+ * `many()` on a binding with a named or tagged slot, or a slot constraint on a collection member.
+ *
+ * @remarks A collection member keeps the default slot: its membership replaces slot last-wins, and a
+ * tagged member would have no index able to return every member of the tag.
+ *
+ * @since 0.10.0
+ */
+export declare class ManyBindingSlotError extends DiError {
+    readonly code = "MANY_BINDING_SLOT";
+    readonly tokenName: string;
+    constructor(tokenName: string);
+}
+/**
+ * @since 0.10.0
+ */
 export declare class ChainNotRegisteredError extends DiError {
     readonly code = "CHAIN_NOT_REGISTERED";
     readonly tokenName: string;

package/dist/errors/errors.js

@@ -325,6 +325,41 @@ export class MissingContainerContextError extends DiError {
  *
  * @since 0.5.0-canary.8
  */
+/**
+ * A second `to*()` on a chain that already registered its binding.
+ *
+ * @remarks A chain is its binding, so it registers exactly once; a token bound twice is two `bind()`
+ * calls, the second of which displaces the first under slot last-wins.
+ *
+ * @since 0.10.0
+ */
+export class ChainAlreadyRegisteredError extends DiError {
+    code = "CHAIN_ALREADY_REGISTERED";
+    tokenName;
+    constructor(tokenName) {
+        super(`The binding for token '${tokenName}' is already registered on this chain. Call bind() again to register another binding for the token.`);
+        this.tokenName = tokenName;
+    }
+}
+/**
+ * `many()` on a binding with a named or tagged slot, or a slot constraint on a collection member.
+ *
+ * @remarks A collection member keeps the default slot: its membership replaces slot last-wins, and a
+ * tagged member would have no index able to return every member of the tag.
+ *
+ * @since 0.10.0
+ */
+export class ManyBindingSlotError extends DiError {
+    code = "MANY_BINDING_SLOT";
+    tokenName;
+    constructor(tokenName) {
+        super(`A many() binding for token '${tokenName}' keeps the default slot: it cannot also declare whenNamed() or whenTagged().`);
+        this.tokenName = tokenName;
+    }
+}
+/**
+ * @since 0.10.0
+ */
 export class ChainNotRegisteredError extends DiError {
     code = "CHAIN_NOT_REGISTERED";
     tokenName;

package/dist/index.d.ts

@@ -25,7 +25,7 @@ export { MetadataReaderToken } from "#/metadata/metadata-reader-token";
 export type { ConstructorMetadata, LifecycleMetadata, MetadataReader, MutableLifecycleMetadata, ParamMetadata, } from "#/metadata/metadata-types";
 export { defaultMetadataReader, SymbolMetadataReader } from "#/metadata/symbol-metadata-reader";
 export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll, } from "#/resolution/select/constraints";
-export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainNotRegisteredError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#/errors/errors";
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainAlreadyRegisteredError, ChainNotRegisteredError, ManyBindingSlotError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#/errors/errors";
 export type { ScopeViolationDetails } from "#/errors/errors";
 export { toDotGraph } from "#/introspection/graph-adapters/dot";
 export { toCytoscapeGraph } from "#/introspection/graph-adapters/cytoscape";

package/dist/index.js

@@ -25,7 +25,7 @@ export { defaultMetadataReader, SymbolMetadataReader } from "#/metadata/symbol-m
 // Constraints — contextual injection predicates for .when()
 export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll, } from "#/resolution/select/constraints";
 // Errors
-export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainNotRegisteredError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#/errors/errors";
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainAlreadyRegisteredError, ChainNotRegisteredError, ManyBindingSlotError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#/errors/errors";
 // Graph adapters — render `generateDependencyGraph()` output for common viewers
 export { toDotGraph } from "#/introspection/graph-adapters/dot";
 export { toCytoscapeGraph } from "#/introspection/graph-adapters/cytoscape";

package/dist/injection/descriptor.d.ts

@@ -51,7 +51,7 @@ export type InjectableDependency<Value = unknown> = Token<Value> | Constructor<V
  */
 export type ResolvedDependencyValue<Dependency> = Dependency extends {
     readonly multi: true;
-} ? Array<DescribedValue<Dependency>> : Dependency extends {
+} ? ReadonlyArray<DescribedValue<Dependency>> : Dependency extends {
     readonly optional: true;
 } ? DescribedValue<Dependency> | undefined : DescribedValue<Dependency>;
 /**
@@ -59,7 +59,7 @@ export type ResolvedDependencyValue<Dependency> = Dependency extends {
  *
  * @remarks Split out because a hand-written descriptor states its flags and its value type
  * separately, and only the flags are load-bearing: `{ token: Plugin, multi: true }` says `Plugin`
- * and delivers `Array<Plugin>`. `injectAll()` and `optional()` already fold their effect in, so the
+ * and delivers `ReadonlyArray<Plugin>`. `injectAll()` and `optional()` already fold their effect in, so the
  * flags find an array or an optional there and leave it alone.
  */
 type DescribedValue<Dependency> = Dependency extends InjectionDescriptor<infer Value> ? Value : TokenValue<Dependency>;
@@ -88,9 +88,11 @@ export declare function buildInjectionDescriptor<Value, Names extends string = s
  */
 export declare function optional<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<Value | undefined>;
 /**
- * Creates a descriptor that resolves every matching binding for the token into an array.
+ * Creates a descriptor that resolves every matching binding for the token into a read-only array.
+ *
+ * @remarks Read-only because a root-level read may hand out the engine's own cached list.
  *
  * @since 0.3.16-canary.0
  */
-export declare function injectAll<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<Array<Value>>;
+export declare function injectAll<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<ReadonlyArray<Value>>;
 export {};

package/dist/injection/descriptor.js

@@ -112,7 +112,9 @@ export function optional(token, options) {
     }, options);
 }
 /**
- * Creates a descriptor that resolves every matching binding for the token into an array.
+ * Creates a descriptor that resolves every matching binding for the token into a read-only array.
+ *
+ * @remarks Read-only because a root-level read may hand out the engine's own cached list.
  *
  * @since 0.3.16-canary.0
  */

package/dist/injection/resolve-options.d.ts

@@ -26,6 +26,12 @@ export interface DependencySlot {
  * @since 0.5.0-canary.9
  */
 export declare function singleCriterionOnlyOf(options: ResolveOptions | undefined): BindingTag | undefined;
+/**
+ * The one tag a request carries beside its name, for the name-plus-tag lane; `undefined` for every other shape.
+ *
+ * @since 0.10.0
+ */
+export declare function loneTagBesideNameOf(options: ResolveOptions): BindingTag | undefined;
 /**
  * Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
  * omits keys instead of assigning `undefined`.

package/dist/injection/resolve-options.js

@@ -22,6 +22,22 @@ export function singleCriterionOnlyOf(options) {
     }
     return listed !== undefined && listed.length === 1 ? listed[0] : undefined;
 }
+/**
+ * The one tag a request carries beside its name, for the name-plus-tag lane; `undefined` for every other shape.
+ *
+ * @since 0.10.0
+ */
+export function loneTagBesideNameOf(options) {
+    if (options.name === undefined) {
+        return undefined;
+    }
+    const listed = options.tags;
+    const shorthand = options.tag;
+    if (shorthand !== undefined) {
+        return listed === undefined || listed.length === 0 ? shorthand : undefined;
+    }
+    return listed !== undefined && listed.length === 1 ? listed[0] : undefined;
+}
 /** The name spelling's half of the fold, kept apart so the common body stays small enough to inline. */
 function loneNameCriterionOf(options) {
     // A name next to any tag means the request carries two criteria, which no single index answers.

package/dist/introspection/dependency-graph.js

@@ -100,7 +100,7 @@ function addDependencyEdges(accumulator, from, ref, index, lookup) {
             : label;
         accumulator.edges.push({
             from,
-            to: target.id,
+            to: String(target.identifier),
             label: perTargetLabel,
             optional: ref.optional,
             ...(edgeSlotName !== undefined ? { slotName: edgeSlotName } : {}),
@@ -113,21 +113,26 @@ function addBindingEdges(accumulator, binding, metadataReader, lookup) {
         const meta = metadataReader.getConstructorMetadata(binding.target);
         if (meta !== undefined) {
             for (const [index, param] of meta.params.entries()) {
-                addDependencyEdges(accumulator, binding.id, param, index, lookup);
+                addDependencyEdges(accumulator, String(binding.identifier), param, index, lookup);
             }
         }
         return;
     }
     if (binding.kind === "resolved" || binding.kind === "resolved-async") {
         for (const [index, dependency] of binding.deps.entries()) {
-            addDependencyEdges(accumulator, binding.id, dependency, index, lookup);
+            addDependencyEdges(accumulator, String(binding.identifier), dependency, index, lookup);
         }
         return;
     }
     if (binding.kind === "alias") {
         const aliasRef = { token: binding.target, optional: false, multi: false };
         for (const target of matchingTargets(lookup(binding.target), aliasRef)) {
-            accumulator.edges.push({ from: binding.id, to: target.id, label: "alias", optional: false });
+            accumulator.edges.push({
+                from: String(binding.identifier),
+                to: String(target.identifier),
+                label: "alias",
+                optional: false,
+            });
         }
     }
 }
@@ -135,7 +140,7 @@ function addRegistryBindings(accumulator, sourceRegistry, metadataReader, fromPa
     const lookup = bindingLookup(sourceRegistry, fallbackRegistry);
     for (const binding of sourceRegistry.allBindings()) {
         accumulator.nodes.push({
-            id: binding.id,
+            id: String(binding.identifier),
             tokenName: tokenName(binding.token),
             tokenKey: tokenKeyOf(binding.token),
             kind: binding.kind,

package/dist/introspection/inspector.d.ts

@@ -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

@@ -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.js

@@ -1,4 +1,5 @@
 import { getOrInsert } from "#/core/map-upsert";
+import { advanceStateEpoch } from "#/core/state-epoch";
 import { tokenName } from "#/core/token";
 import { AsyncActivationError, AsyncDeactivationError, InvalidMetadataError } from "#/errors/errors";
 /**
@@ -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.js

@@ -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/resolution/cache/activation-need.d.ts

@@ -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

@@ -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;
 }