@codefast/di 0.5.0-canary.8 → 0.5.0

package/src/container/container.ts

@@ -27,6 +27,8 @@ import { effectiveBindingScope } from "#/resolution/binding-scope";
 import type { ResolutionDiagnostics } from "#/resolution/diagnostics";
 import { RESOLUTION_DIAGNOSTICS } from "#/resolution/diagnostics";
 import { LifecycleManager } from "#/resolution/lifecycle";
+import { ROOT_BRANCH } from "#/resolution/resolution-path";
+import type { DependencySlot } from "#/resolution/resolve-options";
 import { injectionSlotToResolveOptions, bindingSlotToResolveOptions } from "#/resolution/resolve-options";
 import { DependencyResolver } from "#/resolution/resolver";
 import { ScopeManager } from "#/resolution/scope";
@@ -156,7 +158,7 @@ class DefaultContainer implements Container {
     if (this.#lifecycle.isBuilt) {
       builtSubsystems.push("lifecycle.activationHooks");
     }
-    return { ...this.#resolver.describeCaches(), builtSubsystems };
+    return { ...this.#resolver.describeCaches(), scopedInstanceCount: this.#scope.scopedCount, builtSubsystems };
   }
 
   #initResolver(): void {
@@ -235,7 +237,7 @@ class DefaultContainer implements Container {
     return this.#drainSingletons(this.#registry.removeByToken(tokenOrId));
   }
 
-  /** Drain singleton scope entries for a set of already-removed bindings. */
+  /** Drain scope entries for already-removed bindings; only singletons yield deactivation pairs. */
   #drainSingletons(bindings: ReadonlyArray<Binding>): Array<[Binding, unknown]> {
     const pairs: Array<[Binding, unknown]> = [];
     for (const binding of bindings) {
@@ -243,6 +245,7 @@ class DefaultContainer implements Container {
         pairs.push([binding, binding.instance]);
         this.#scope.deleteSingleton(binding);
       }
+      this.#scope.deleteScoped(binding.id);
     }
     return pairs;
   }
@@ -295,10 +298,10 @@ class DefaultContainer implements Container {
     this.#loadSyncModules(modules);
   }
 
-  #loadSyncModules(modules: Array<SyncModule>): void {
-    // Collect all modules in topological order (dedup by identity)
-    const toLoad = this.#collectModuleDeps(modules);
-    for (const module of toLoad) {
+  // Imports nested inside a module's setup re-enter here through the builder, so a module listed
+  // twice in one call is deduped by identity and the rest is ref-counting.
+  #loadSyncModules(modules: ReadonlyArray<SyncModule | AsyncModule>): void {
+    for (const module of new Set(modules)) {
       if (!isSyncModule(module)) {
         throw new AsyncModuleLoadError(module.name);
       }
@@ -315,26 +318,6 @@ class DefaultContainer implements Container {
     }
   }
 
-  #collectModuleDeps(modules: Array<SyncModule | AsyncModule>): Array<SyncModule | AsyncModule> {
-    const seen = new Set<object>();
-    const result: Array<SyncModule | AsyncModule> = [];
-
-    const visit = (module: SyncModule | AsyncModule): void => {
-      const moduleRef = module as object;
-      if (seen.has(moduleRef)) {
-        return;
-      }
-      seen.add(moduleRef);
-      // We'll collect deps during setup via the builder's import()
-      result.push(module);
-    };
-
-    for (const module of modules) {
-      visit(module);
-    }
-    return result;
-  }
-
   async loadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void> {
     this.#assertNotDisposed();
     for (const module of modules) {
@@ -411,6 +394,7 @@ class DefaultContainer implements Container {
           pairs.push([binding, binding.instance]);
           this.#scope.deleteSingleton(binding);
         }
+        this.#scope.deleteScoped(binding.id);
       }
     }
     return pairs;
@@ -480,23 +464,33 @@ class DefaultContainer implements Container {
 
   resolve<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value {
     this.#assertNotDisposed();
+    const rootStack = this.#resolver.rootStack;
+    // A resolve already holding the shared pair means this one is nested; it mints its own.
+    if (rootStack.length !== 0) {
+      return options === undefined
+        ? this.#resolver.resolveFromContext(token, [], [])
+        : this.#resolver.resolve(token, options, [], []);
+    }
     if (options === undefined) {
-      return this.#resolver.resolveFromContext(token, [], []);
+      return this.#resolver.resolveFromContext(token, this.#resolver.rootPath, rootStack);
     }
-    return this.#resolver.resolve(token, options, [], []);
+    return this.#resolver.resolve(token, options, this.#resolver.rootPath, rootStack);
   }
 
   resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value> {
     this.#assertNotDisposed();
     if (options === undefined) {
-      return this.#resolver.resolveAsyncFromContext(token, [], []);
+      return this.#resolver.resolveAsyncFromRoot(token) as Promise<Value>;
     }
-    return this.#resolver.resolveAsync(token, options, [], []);
+    return this.#resolver.resolveAsync(token, options, [], [], ROOT_BRANCH);
   }
 
   resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined {
     this.#assertNotDisposed();
-    return this.#resolver.resolveOptional(token, options, [], []);
+    const rootStack = this.#resolver.rootStack;
+    return rootStack.length === 0
+      ? this.#resolver.resolveOptional(token, options, this.#resolver.rootPath, rootStack)
+      : this.#resolver.resolveOptional(token, options, [], []);
   }
 
   resolveOptionalAsync<const Value>(
@@ -504,12 +498,15 @@ class DefaultContainer implements Container {
     options?: ResolveOptions,
   ): Promise<Value | undefined> {
     this.#assertNotDisposed();
-    return this.#resolver.resolveOptionalAsync(token, options, [], []);
+    return this.#resolver.resolveOptionalAsync(token, options, [], [], ROOT_BRANCH);
   }
 
   resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value> {
     this.#assertNotDisposed();
-    return this.#resolver.resolveAll(token, options, [], []);
+    const rootStack = this.#resolver.rootStack;
+    return rootStack.length === 0
+      ? this.#resolver.resolveAll(token, options, this.#resolver.rootPath, rootStack)
+      : this.#resolver.resolveAll(token, options, [], []);
   }
 
   resolveAllAsync<const Value>(
@@ -517,7 +514,7 @@ class DefaultContainer implements Container {
     options?: ResolveOptions,
   ): Promise<Array<Value>> {
     this.#assertNotDisposed();
-    return this.#resolver.resolveAllAsync(token, options, [], []);
+    return this.#resolver.resolveAllAsync(token, options, [], [], ROOT_BRANCH);
   }
 
   // ── Child ─────────────────────────────────────────────────────────────────
@@ -620,10 +617,7 @@ class DefaultContainer implements Container {
       for (const edge of this.#collectStaticDependencyEdges(current, reader)) {
         const { terminal, depTokenName } = edge;
         const depScope = this.#validationScopeFromTerminal(terminal);
-        if (depScope === "opaque") {
-          continue;
-        }
-        if (depScope === "scoped" || depScope === "transient") {
+        if (depScope !== "singleton") {
           throw new ScopeViolationError({
             consumerToken: rootName,
             consumerScope: "singleton",
@@ -641,27 +635,18 @@ class DefaultContainer implements Container {
     dfs(root, [rootName], new Set());
   }
 
-  #validationScopeFromTerminal(terminal: Binding): BindingScope | "opaque" {
-    switch (terminal.kind) {
-      case "constant":
-        return "singleton";
-      // A factory's *body* is not statically analyzable, but the scope it was bound with is
-      // declared like any other — so the captive-dependency check applies. The DFS below still
-      // refuses to descend into the factory; only this edge is judged.
-      case "dynamic":
-      case "dynamic-async":
-        return terminal.scope;
-      case "class":
-      case "resolved":
-      case "resolved-async":
-        return terminal.scope;
-      case "alias":
-        throw new InternalError("validate: expected terminal binding after alias resolution");
-      default: {
-        const exhaustive: never = terminal;
-        return exhaustive;
-      }
+  /**
+   * The scope this edge is judged against.
+   *
+   * @remarks A factory's *body* is not statically analyzable, but the scope it was bound with is
+   * declared like any other — so the captive-dependency check applies to it too. The DFS still
+   * refuses to descend into a factory; only the edge is judged.
+   */
+  #validationScopeFromTerminal(terminal: Binding): BindingScope {
+    if (terminal.kind === "alias") {
+      throw new InternalError("validate: expected terminal binding after alias resolution");
     }
+    return terminal.scope;
   }
 
   #followAliasChainToTerminal(binding: Binding, options: ResolveOptions | undefined): Binding | undefined {
@@ -685,75 +670,43 @@ class DefaultContainer implements Container {
     return current;
   }
 
+  /** What one dependency could resolve to: every candidate for `injectAll`, else at most one. */
+  #peekDependencyCandidates(dep: DependencySlot, options: ResolveOptions | undefined): ReadonlyArray<Binding> {
+    if (dep.multi) {
+      return this.#resolver.peekCandidateBindingsForValidate(dep.token, options);
+    }
+    const found = this.#resolver.peekBindingForValidate(dep.token, options);
+    return found === undefined ? [] : [found.binding];
+  }
+
+  /** What a binding declares up front — a class's params, a factory's descriptors, else nothing. */
+  #staticDependencies(binding: Binding, reader: MetadataReader): ReadonlyArray<DependencySlot> {
+    if (binding.kind === "class") {
+      return reader.getConstructorMetadata(binding.target as Constructor)?.params ?? [];
+    }
+    if (binding.kind === "resolved" || binding.kind === "resolved-async") {
+      return binding.deps;
+    }
+    return [];
+  }
+
   #collectStaticDependencyEdges(
     binding: Binding,
     reader: MetadataReader,
   ): Array<{ terminal: Binding; depTokenName: string }> {
     const edges: Array<{ terminal: Binding; depTokenName: string }> = [];
 
-    const pushTerminal = (terminal: Binding | undefined, displayName: string): void => {
-      if (terminal === undefined) {
-        return;
-      }
-      edges.push({ terminal, depTokenName: displayName });
-    };
-
-    if (binding.kind === "class") {
-      const meta = reader.getConstructorMetadata(binding.target as Constructor);
-      if (meta === undefined) {
-        return edges;
-      }
-      for (const param of meta.params) {
-        const paramOptions = injectionSlotToResolveOptions(param);
-        if (param.optional) {
-          continue;
-        }
-        const tokenRef = param.token;
-        if (param.multi) {
-          const candidates = this.#resolver.peekCandidateBindingsForValidate(tokenRef, paramOptions);
-          for (const cand of candidates) {
-            const term = this.#followAliasChainToTerminal(cand, paramOptions);
-            pushTerminal(term, term !== undefined ? tokenName(term.token as Token<unknown>) : "");
-          }
-          continue;
-        }
-        const found =
-          paramOptions === undefined
-            ? this.#resolver.peekBindingForValidate(tokenRef, undefined)
-            : this.#resolver.peekBindingForValidate(tokenRef, paramOptions);
-        if (found === undefined) {
-          continue;
-        }
-        const term = this.#followAliasChainToTerminal(found.binding, paramOptions);
-        pushTerminal(term, term !== undefined ? tokenName(term.token as Token<unknown>) : "");
+    for (const dep of this.#staticDependencies(binding, reader)) {
+      // An optional dependency imposes no scope constraint: it may legitimately be absent.
+      if (dep.optional) {
+        continue;
       }
-      return edges;
-    }
-
-    if (binding.kind === "resolved" || binding.kind === "resolved-async") {
-      for (const dep of binding.deps) {
-        const depOptions = injectionSlotToResolveOptions(dep);
-        if (dep.optional) {
-          continue;
-        }
-        const tokenRef = dep.token as Token<unknown> | Constructor;
-        if (dep.multi) {
-          const candidates = this.#resolver.peekCandidateBindingsForValidate(tokenRef, depOptions);
-          for (const cand of candidates) {
-            const term = this.#followAliasChainToTerminal(cand, depOptions);
-            pushTerminal(term, term !== undefined ? tokenName(term.token as Token<unknown>) : "");
-          }
-          continue;
-        }
-        const found =
-          depOptions === undefined
-            ? this.#resolver.peekBindingForValidate(tokenRef, undefined)
-            : this.#resolver.peekBindingForValidate(tokenRef, depOptions);
-        if (found === undefined) {
-          continue;
+      const depOptions = injectionSlotToResolveOptions(dep);
+      for (const candidate of this.#peekDependencyCandidates(dep, depOptions)) {
+        const terminal = this.#followAliasChainToTerminal(candidate, depOptions);
+        if (terminal !== undefined) {
+          edges.push({ terminal, depTokenName: tokenName(terminal.token as Token<unknown>) });
         }
-        const term = this.#followAliasChainToTerminal(found.binding, depOptions);
-        pushTerminal(term, term !== undefined ? tokenName(term.token as Token<unknown>) : "");
       }
     }
 

package/src/errors.ts

@@ -248,6 +248,23 @@ export class RebindUnboundTokenError extends DiError {
   }
 }
 
+/**
+ * `toSelf()` on a token that is not a class, so there is nothing to construct.
+ *
+ * @since 0.5.0-canary.9
+ */
+export class SelfBindingRequiresClassError extends DiError {
+  readonly code = "SELF_BINDING_REQUIRES_CLASS";
+  readonly tokenName: string;
+
+  constructor(tokenName: string) {
+    super(
+      `toSelf() needs the token to be the class it constructs, and '${tokenName}' is not a class. Use .to(SomeClass) to name the implementation, or bind the class itself with container.bind(SomeClass).toSelf().`,
+    );
+    this.tokenName = tokenName;
+  }
+}
+
 /**
  * @since 0.3.16-canary.0
  */

package/src/index.ts

@@ -36,7 +36,8 @@ export type {
 export { Container } from "#/container/container";
 export type { Container as ContainerInterface, ContainerStatic } from "#/container/container";
 
-export { effectiveBindingScope } from "#/resolution/binding-scope";
+// `effectiveBindingScope` is deliberately absent: it reads a `Binding`, which is internal, and no
+// public API hands one out. `BindingSnapshot.scope` and `GraphNode.scope` are the public answers.
 export { injectionSlotToResolveOptions, bindingSlotToResolveOptions } from "#/resolution/resolve-options";
 
 // Introspection types
@@ -96,6 +97,7 @@ export {
   NoMatchingBindingError,
   RebindUnboundTokenError,
   ScopeViolationError,
+  SelfBindingRequiresClassError,
   SyncDisposalNotSupportedError,
   TokenNotBoundError,
 } from "#/errors";

package/src/introspection/inspector.ts

@@ -60,9 +60,8 @@ export class Inspector {
   }
 
   inspect(): ContainerSnapshot {
-    const snapshots = this.allBindingSnapshots();
     return {
-      ownBindings: snapshots,
+      ownBindings: this.#registry.allBindings().map((binding) => this.#toSnapshot(binding)),
       cachedSingletonCount: this.#scope.cachedSingletons().length,
       hasParent: this.#hasParent,
       isDisposed: this.#isDisposed(),
@@ -109,12 +108,7 @@ export class Inspector {
     };
   }
 
-  private allBindingSnapshots(): ReadonlyArray<BindingSnapshot> {
-    return this.#registry.allBindings().map((binding) => this.#toSnapshot(binding));
-  }
-
   #toSnapshot(binding: Binding): BindingSnapshot {
-    const scope = effectiveBindingScope(binding);
     const slot: BindingSnapshot["slot"] =
       binding.slot.name !== undefined
         ? { name: binding.slot.name, tags: binding.slot.tags }
@@ -122,7 +116,7 @@ export class Inspector {
     return {
       tokenName: tokenName(binding.token),
       kind: binding.kind,
-      scope,
+      scope: effectiveBindingScope(binding),
       slot,
       id: binding.id,
     };

package/src/registry.ts

@@ -1,7 +1,7 @@
 import type { Binding } from "#/binding";
 import { bindingSlotEquals, bindingSlotToString } from "#/binding";
 import type { Token } from "#/token";
-import type { BindingIdentifier, Constructor, DependencyKey } from "#/types";
+import type { BindingIdentifier, BindingTag, Constructor, DependencyKey } from "#/types";
 
 /**
  * @since 0.3.16-canary.0
@@ -43,14 +43,15 @@ export class BindingRegistry {
   add(binding: Binding): Binding | undefined {
     this.#version += 1;
     const key = binding.token as DependencyKey;
-    // ✓ TS6.0: Map.getOrInsert (ES2025) replaces the manual get+check+set upsert
+    // Eager, not computed: a bind is usually the token's first, so the fallback is usually the
+    // one that gets stored — and the computed form would add a call to allocating it anyway.
     const bindingsForToken = this.#bindings.getOrInsert(key, []);
 
     // Only apply last-wins for slot-based bindings (not predicate-only)
     let displacedBinding: Binding | undefined;
-    if (!this.#isPurePredicateBinding(binding)) {
+    if (!isPurePredicateBinding(binding)) {
       const existingIndex = bindingsForToken.findIndex(
-        (candidate) => !this.#isPurePredicateBinding(candidate) && bindingSlotEquals(candidate.slot, binding.slot),
+        (candidate) => !isPurePredicateBinding(candidate) && bindingSlotEquals(candidate.slot, binding.slot),
       );
       if (existingIndex !== -1) {
         displacedBinding = bindingsForToken[existingIndex]!;
@@ -173,22 +174,22 @@ export class BindingRegistry {
   }
 
   #indexSimpleTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const slot = binding.slot;
-    if (slot.name !== undefined || slot.tags.length !== 1 || binding.predicate !== undefined) {
+    const tag = simpleTagOf(binding);
+    if (tag === undefined) {
       return;
     }
-    const [tagKey, tagValue] = slot.tags[0]!;
+    const [tagKey, tagValue] = tag;
     const byTagKey = (this.#simpleTagged ??= new Map()).getOrInsert(tokenKey, new Map<string, Map<unknown, Binding>>());
     const byTagValue = byTagKey.getOrInsert(tagKey, new Map<unknown, Binding>());
     byTagValue.set(tagValue, binding);
   }
 
   #deindexSimpleTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const slot = binding.slot;
-    if (slot.name !== undefined || slot.tags.length !== 1 || binding.predicate !== undefined) {
+    const tag = simpleTagOf(binding);
+    if (tag === undefined) {
       return;
     }
-    const [tagKey, tagValue] = slot.tags[0]!;
+    const [tagKey, tagValue] = tag;
     const byTagKey = this.#simpleTagged?.get(tokenKey);
     if (byTagKey === undefined) {
       return;
@@ -209,35 +210,26 @@ export class BindingRegistry {
     }
   }
 
-  #isPurePredicateBinding(binding: Binding): boolean {
-    const slot = binding.slot;
-    const hasPredicate = binding.predicate !== undefined;
-    const hasConstraint = slot.name !== undefined || slot.tags.length > 0;
-    // Pure predicate = has predicate but no slot constraint (name/tags)
-    return hasPredicate && !hasConstraint;
-  }
-
   #indexSimpleNamedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const slot = binding.slot;
-    if (slot.name === undefined || slot.tags.length > 0) {
+    const name = simpleNameOf(binding);
+    if (name === undefined) {
       return;
     }
     const bindingsByName = (this.#simpleNamed ??= new Map()).getOrInsert(tokenKey, new Map<string, Binding>());
-    bindingsByName.set(slot.name, binding);
+    bindingsByName.set(name, binding);
   }
 
   #deindexSimpleNamedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const slot = binding.slot;
-    if (slot.name === undefined || slot.tags.length > 0) {
+    const name = simpleNameOf(binding);
+    if (name === undefined) {
       return;
     }
     const bindingsByName = this.#simpleNamed?.get(tokenKey);
     if (bindingsByName === undefined) {
       return;
     }
-    const currentBinding = bindingsByName.get(slot.name);
-    if (currentBinding?.id === binding.id) {
-      bindingsByName.delete(slot.name);
+    if (bindingsByName.get(name)?.id === binding.id) {
+      bindingsByName.delete(name);
       if (bindingsByName.size === 0) {
         this.#simpleNamed!.delete(tokenKey);
       }
@@ -246,20 +238,45 @@ export class BindingRegistry {
 
   #refreshFastDefaultForToken(tokenKey: DependencyKey): void {
     const bindingsForToken = this.#bindings.get(tokenKey);
-    if (bindingsForToken === undefined || bindingsForToken.length !== 1) {
-      this.#fastDefault.delete(tokenKey);
-      return;
-    }
-    const onlyBinding = bindingsForToken[0]!;
-    const isDefaultSlot = onlyBinding.slot.name === undefined && onlyBinding.slot.tags.length === 0;
-    if (!isDefaultSlot || onlyBinding.predicate !== undefined) {
-      this.#fastDefault.delete(tokenKey);
+    const onlyBinding = bindingsForToken?.length === 1 ? bindingsForToken[0]! : undefined;
+    if (onlyBinding !== undefined && isDefaultSlotBinding(onlyBinding)) {
+      this.#fastDefault.set(tokenKey, onlyBinding);
       return;
     }
-    this.#fastDefault.set(tokenKey, onlyBinding);
+    this.#fastDefault.delete(tokenKey);
   }
+
   /** Whether the deferred table behind `#simpleNamed` has had to be built. */
   get isBuilt(): boolean {
     return this.#simpleNamed !== undefined;
   }
 }
+
+/** The name a binding is indexed under, or `undefined` when its slot is more than a plain name. */
+function simpleNameOf(binding: Binding): string | undefined {
+  const { name, tags } = binding.slot;
+  return name !== undefined && tags.length === 0 ? name : undefined;
+}
+
+/**
+ * The tag a binding is indexed under, or `undefined` when its slot is more than one plain tag.
+ *
+ * @remarks A predicate is excluded here — unlike the name index — because the tag index is read
+ * without a re-check, so an indexed hit must be unconditional.
+ */
+function simpleTagOf(binding: Binding): BindingTag | undefined {
+  const { name, tags } = binding.slot;
+  return name === undefined && tags.length === 1 && binding.predicate === undefined ? tags[0] : undefined;
+}
+
+/** A binding nothing has to be matched against: the default slot, no predicate. */
+function isDefaultSlotBinding(binding: Binding): boolean {
+  const { name, tags } = binding.slot;
+  return name === undefined && tags.length === 0 && binding.predicate === undefined;
+}
+
+/** A predicate with no slot constraint: last-wins does not apply to it. */
+function isPurePredicateBinding(binding: Binding): boolean {
+  const { name, tags } = binding.slot;
+  return binding.predicate !== undefined && name === undefined && tags.length === 0;
+}

package/src/resolution/activation-need.ts

@@ -1,9 +1,11 @@
 /**
  * Per binding: does resolving it have to go through the activation pipeline?
  *
- * @remarks Versioned on the lifecycle manager, since `onActivation` can be registered at any time.
+ * @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 "#/binding";
+import type { BindingRegistry } from "#/registry";
 import type { ClassIntrospector } from "#/resolution/class-introspector";
 import type { LifecycleManager } from "#/resolution/lifecycle";
 import type { BindingIdentifier } from "#/types";
@@ -16,27 +18,31 @@ export class ActivationNeedCache {
   #version = -1;
   readonly #lifecycle: LifecycleManager;
   readonly #classes: ClassIntrospector;
+  readonly #registry: BindingRegistry;
 
-  constructor(lifecycle: LifecycleManager, classes: ClassIntrospector) {
+  constructor(lifecycle: LifecycleManager, classes: ClassIntrospector, registry: BindingRegistry) {
     this.#lifecycle = lifecycle;
     this.#classes = classes;
+    this.#registry = registry;
   }
 
   needsActivation<const Value>(binding: Binding<Value>): boolean {
+    // 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) {
+      return true;
+    }
     const lifecycleVersion = this.#lifecycle.activationVersion;
     // No hooks registered anywhere and none on the binding: only classes can still surprise us,
     // via a @postConstruct we have not looked for yet.
-    if (
-      lifecycleVersion === 0 &&
-      binding.kind !== "class" &&
-      binding.kind !== "alias" &&
-      binding.onActivation === undefined
-    ) {
+    if (lifecycleVersion === 0 && binding.kind !== "class" && binding.kind !== "alias") {
       return false;
     }
-    if (this.#version !== lifecycleVersion) {
+    // 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.#version = lifecycleVersion;
+      this.#version = version;
     }
     const cached = this.#needByBindingId.get(binding.id);
     if (cached !== undefined) {
@@ -64,8 +70,9 @@ export class ActivationNeedCache {
     return this.needsActivation(binding);
   }
 
+  // Own hooks are answered before the memo, so both computations cover the memoizable rest only.
   #classNeedsActivation<const Value>(binding: Binding<Value> & { kind: "class" }): boolean {
-    if (this.#lifecycle.hasActivationHandlers(binding.token) || binding.onActivation !== undefined) {
+    if (this.#lifecycle.hasActivationHandlers(binding.token)) {
       return true;
     }
     // Unknown lifecycle metadata: activate once so the first instantiation can settle it.
@@ -73,9 +80,6 @@ export class ActivationNeedCache {
   }
 
   #nonClassNeedsActivation<const Value>(binding: Binding<Value>): boolean {
-    if (binding.kind !== "alias" && binding.onActivation !== undefined) {
-      return true;
-    }
     return this.#lifecycle.hasActivationHandlers(binding.token);
   }
 }

package/src/resolution/binding-lookup-cache.ts

@@ -31,9 +31,19 @@ export const ALIAS_HOP_LIMIT = 32;
 /**
  * @since 0.5.0-canary.8
  */
+const newNameToEntryMap = <Owner>(): Map<string, DefaultLookupEntry<Owner> | null> => new Map();
+
+/**
+ * @since 0.5.0-canary.9
+ */
 export class BindingLookupCache<Owner> {
   readonly #byToken = new Map<Token<unknown> | Constructor, DefaultLookupEntry<Owner> | null>();
   #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.
+  #lastToken: Token<unknown> | Constructor | undefined;
+  #lastEntry: DefaultLookupEntry<Owner> | null = null;
   readonly #byTokenAndName = new Map<Token<unknown> | Constructor, Map<string, DefaultLookupEntry<Owner> | null>>();
   #namedVersion = -1;
 
@@ -62,12 +72,17 @@ export class BindingLookupCache<Owner> {
     if (version !== this.#version) {
       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) {
       entry = this.#foldAliases(token);
       this.#byToken.set(token, entry);
     }
+    this.#lastToken = token;
+    this.#lastEntry = entry;
     return entry;
   }
 
@@ -78,8 +93,9 @@ export class BindingLookupCache<Owner> {
       this.#byTokenAndName.clear();
       this.#namedVersion = version;
     }
-    // ✓ TS6.0: Map.getOrInsert (ES2025)
-    const byName = this.#byTokenAndName.getOrInsert(token, new Map<string, DefaultLookupEntry<Owner> | null>());
+    // Computed, not eager: this runs on every named resolve, and `getOrInsert(token, new Map())`
+    // would allocate a Map per call only to discard it on the hit that follows.
+    const byName = this.#byTokenAndName.getOrInsertComputed(token, newNameToEntryMap);
     let entry = byName.get(name);
     if (entry === undefined) {
       entry = this.#findNamedInChain(token, name);