@codefast/di 0.7.1 → 0.8.0

package/src/core/registry.ts

@@ -17,15 +17,13 @@ export class BindingRegistry {
   readonly #bindings = new Map<DependencyKey, Array<Binding>>();
   // Fast lookup by binding ID
   readonly #byId = new Map<BindingIdentifier, Binding>();
-  // Fast lookup for slot { name, tags: [] } — unallocated until a named binding is registered.
-  #simpleNamed: Map<DependencyKey, Map<string, Binding>> | undefined;
   // Fast path for one default slot binding with no predicate
   readonly #fastDefault = new Map<DependencyKey, Binding>();
-  // Fast lookup for a slot carrying exactly one tag — keyed by the interned criterion itself, so
-  // the (key, value) pair is one hash rather than two. Unallocated until a tagged binding lands.
+  // Fast lookup for a slot carrying exactly one criterion (a lone name folds here too) — keyed by
+  // the interned criterion itself, so the pair is one hash. Unallocated until such a slot lands.
   #simpleTagged: Map<DependencyKey, Map<BindingTag, Binding>> | undefined;
-  // Name-less slots with two or more tags, bucketed by their FIRST criterion. A matching slot's
-  // every tag is in the request, so walking the request's buckets finds each candidate exactly once.
+  // Slots with two or more criteria, bucketed by their FIRST criterion. A matching slot's every
+  // criterion is in the request, so walking the request's buckets finds each candidate exactly once.
   #multiTagged: Map<DependencyKey, Map<BindingTag, Array<Binding>>> | undefined;
 
   // Set on the first constant registered and never cleared. Teardown only needs the negative answer
@@ -79,7 +77,6 @@ export class BindingRegistry {
         if (existingIndex !== -1) {
           displacedBinding = bindingsForToken[existingIndex]!;
           this.#byId.delete(displacedBinding.id);
-          this.#deindexSimpleNamedBinding(key, displacedBinding);
           this.#deindexSimpleTaggedBinding(key, displacedBinding);
           this.#deindexMultiTaggedBinding(key, displacedBinding);
         }
@@ -92,7 +89,6 @@ export class BindingRegistry {
 
     this.#bindings.set(key, nextBindings);
     this.#byId.set(binding.id, binding);
-    this.#indexSimpleNamedBinding(key, binding);
     this.#indexSimpleTaggedBinding(key, binding);
     this.#indexMultiTaggedBinding(key, binding);
     this.#refreshFastDefaultForToken(key);
@@ -105,7 +101,6 @@ export class BindingRegistry {
     const key: DependencyKey = token;
     const bindingsForToken = this.#bindings.get(key) ?? [];
     this.#bindings.delete(key);
-    this.#simpleNamed?.delete(key);
     this.#simpleTagged?.delete(key);
     this.#multiTagged?.delete(key);
     this.#fastDefault.delete(key);
@@ -129,12 +124,10 @@ export class BindingRegistry {
       const bindingIndex = bindingsForToken.findIndex((candidate) => candidate.id === id);
       // Copy-on-write, like `add`: a walk holding the current array must not lose its place.
       const remaining = bindingIndex === -1 ? bindingsForToken : bindingsForToken.toSpliced(bindingIndex, 1);
-      this.#deindexSimpleNamedBinding(key, binding);
       this.#deindexSimpleTaggedBinding(key, binding);
       this.#deindexMultiTaggedBinding(key, binding);
       if (remaining.length === 0) {
         this.#bindings.delete(key);
-        this.#simpleNamed?.delete(key);
         this.#simpleTagged?.delete(key);
         this.#multiTagged?.delete(key);
         this.#fastDefault.delete(key);
@@ -178,7 +171,6 @@ export class BindingRegistry {
     const all = this.allBindings();
     this.#bindings.clear();
     this.#byId.clear();
-    this.#simpleNamed?.clear();
     this.#simpleTagged?.clear();
     this.#multiTagged?.clear();
     this.#fastDefault.clear();
@@ -199,10 +191,6 @@ export class BindingRegistry {
     );
   }
 
-  getSimpleNamed(token: Token<unknown> | Constructor, name: string): Binding | undefined {
-    return this.#simpleNamed?.get(token)?.get(name);
-  }
-
   /**
    * The binding indexed under one criterion.
    *
@@ -287,33 +275,6 @@ export class BindingRegistry {
     }
   }
 
-  #indexSimpleNamedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const name = simpleNameOf(binding);
-    if (name === undefined) {
-      return;
-    }
-    this.#simpleNamed ??= new Map();
-    const bindingsByName = getOrInsert(this.#simpleNamed, tokenKey, new Map<string, Binding>());
-    bindingsByName.set(name, binding);
-  }
-
-  #deindexSimpleNamedBinding(tokenKey: DependencyKey, binding: Binding): void {
-    const name = simpleNameOf(binding);
-    if (name === undefined) {
-      return;
-    }
-    const bindingsByName = this.#simpleNamed?.get(tokenKey);
-    if (bindingsByName === undefined) {
-      return;
-    }
-    if (bindingsByName.get(name)?.id === binding.id) {
-      bindingsByName.delete(name);
-      if (bindingsByName.size === 0) {
-        this.#simpleNamed!.delete(tokenKey);
-      }
-    }
-  }
-
   #refreshFastDefaultForToken(tokenKey: DependencyKey): void {
     const bindingsForToken = this.#bindings.get(tokenKey);
     const onlyBinding = bindingsForToken?.length === 1 ? bindingsForToken[0]! : undefined;
@@ -324,48 +285,35 @@ export class BindingRegistry {
     this.#fastDefault.delete(tokenKey);
   }
 
-  /** Whether the deferred named-slot index has had to be built. */
-  get isNamedIndexBuilt(): boolean {
-    return this.#simpleNamed !== undefined;
-  }
-
   /** Whether the deferred tagged-slot index has had to be built. */
   get isTaggedIndexBuilt(): boolean {
     return this.#simpleTagged !== 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.
+ * The criterion a binding is indexed under, or `undefined` when its slot carries more than one.
  *
- * @remarks Carries predicate-bearing bindings too, exactly as the name index does: every lane that
- * reads this index already re-checks what it finds, so an indexed hit was never unconditional.
+ * @remarks Carries predicate-bearing bindings too: every lane that reads this index already
+ * re-checks what it finds, so an indexed hit was never unconditional.
  */
 function simpleTagOf(binding: Binding): BindingTag | undefined {
-  const { name, tags } = binding.slot;
-  return name === undefined && tags.length === 1 ? tags[0] : undefined;
+  const { tags } = binding.slot;
+  return tags.length === 1 ? tags[0] : undefined;
 }
 
-/** The first criterion a multi-tag slot is bucketed under, or `undefined` for any other shape. */
+/** The first criterion a multi-criterion slot is bucketed under, or `undefined` for any other shape. */
 function multiTagFirstOf(binding: Binding): BindingTag | undefined {
-  const { name, tags } = binding.slot;
-  return name === undefined && tags.length >= 2 ? tags[0] : undefined;
+  const { tags } = binding.slot;
+  return tags.length >= 2 ? 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;
+  return binding.slot.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;
+  return binding.predicate !== undefined && binding.slot.tags.length === 0;
 }

package/src/core/tag.ts

@@ -58,6 +58,14 @@ export interface TagKey<Value = unknown> {
   readonly mask: TagKeyMask;
   /** The criterion for one value, interned: the same value always yields the same object. */
   of(value: Value): BindingTag<Value>;
+  /**
+   * The interned criterion for a value, or `undefined` when none was ever minted.
+   *
+   * @remarks Reading without minting is what keeps a request-side value from being retained for
+   * the process lifetime: a value no binding ever declared has no criterion, so a lookup can
+   * answer "no match" without inserting one.
+   */
+  peek(value: Value): BindingTag<Value> | undefined;
 }
 
 let tagKeyCounter = -1;
@@ -101,6 +109,28 @@ export function tag<Value = unknown>(name: string): TagKey<Value> {
   let lastValue: Value | undefined;
   let lastPair: BindingTag<Value> | undefined;
 
+  // The miss paths live outside `of()`/`peek()` so the hot wrappers stay small enough to inline.
+  const internPair = (value: Value): BindingTag<Value> => {
+    const cacheKey = internKeyFor(value);
+    const existing = interned.get(cacheKey);
+
+    if (existing !== undefined) {
+      lastValue = value;
+      lastPair = existing;
+
+      return existing;
+    }
+
+    const pair = { key, value, mask } as BindingTag<Value>;
+
+    interned.set(cacheKey, pair);
+    lastValue = value;
+    lastPair = pair;
+
+    return pair;
+  };
+  const peekInterned = (value: Value): BindingTag<Value> | undefined => interned.get(internKeyFor(value));
+
   const key: TagKey<Value> = {
     name,
     id,
@@ -109,30 +139,54 @@ export function tag<Value = unknown>(name: string): TagKey<Value> {
       if (lastPair !== undefined && Object.is(value, lastValue)) {
         return lastPair;
       }
-
-      const cacheKey = internKeyFor(value);
-      const existing = interned.get(cacheKey);
-
-      if (existing !== undefined) {
-        lastValue = value;
-        lastPair = existing;
-
-        return existing;
+      return internPair(value);
+    },
+    peek(value: Value): BindingTag<Value> | undefined {
+      if (lastPair !== undefined && Object.is(value, lastValue)) {
+        return lastPair;
       }
-
-      const pair = { key, value, mask } as BindingTag<Value>;
-
-      interned.set(cacheKey, pair);
-      lastValue = value;
-      lastPair = pair;
-
-      return pair;
+      return peekInterned(value);
     },
   };
 
   return key;
 }
 
+/**
+ * The reserved key a slot's name is a criterion of.
+ *
+ * @remarks `whenNamed(n)` and a request's `name` are sugar for `slotName.of(n)`, so one selection
+ * model serves both spellings — a name takes part in key masks, indexes and specificity like any
+ * criterion. What reserves the key is its identity; diagnostics render its criteria as `name:<value>`.
+ *
+ * @since 0.8.0
+ */
+export const slotName: TagKey<string> = tag<string>("di:name");
+
+// One-entry front for the reserved key's read: a name's criterion never changes once minted, so a
+// hit is sound forever, and a miss is never cached so a later `whenNamed` bind is still seen.
+let lastPeekedName: string | undefined;
+let lastPeekedCriterion: BindingTag<string> | undefined;
+
+/**
+ * The reserved criterion for a name, or `undefined` while no binding has declared it.
+ *
+ * @remarks Reads without minting, so a request-side name no binding declared is never retained.
+ *
+ * @since 0.8.0
+ */
+export function slotNameCriterionOf(name: string): BindingTag<string> | undefined {
+  if (name === lastPeekedName) {
+    return lastPeekedCriterion;
+  }
+  const criterion = slotName.peek(name);
+  if (criterion !== undefined) {
+    lastPeekedName = name;
+    lastPeekedCriterion = criterion;
+  }
+  return criterion;
+}
+
 /**
  * The key set a list of criteria covers.
  *

package/src/errors/errors.ts

@@ -1,3 +1,5 @@
+import type { BindingTag } from "#/core/tag";
+import { slotName } from "#/core/tag";
 import type { BindingIdentifier, BindingScope, ResolveOptions } from "#/core/types";
 
 /**
@@ -43,13 +45,34 @@ export class TokenNotBoundError extends DiError {
 }
 
 // Options carry caller values a tag may hold — a bigint or a circular object must not make the
-// diagnostic itself throw and mask the real error.
+// diagnostic itself throw and mask the real error. The reserved criterion renders as `name`.
 function describeResolveOptions(options: ResolveOptions): string {
   try {
-    return (
-      JSON.stringify(options, (_key, value: unknown) => (typeof value === "bigint" ? `${String(value)}n` : value)) ??
-      "undefined"
-    );
+    let name = options.name;
+    const criteria: Array<string> = [];
+    const add = (criterion: BindingTag): void => {
+      if (criterion.key === slotName) {
+        name ??= String(criterion.value);
+      } else {
+        criteria.push(`${criterion.key.name}=${String(criterion.value)}`);
+      }
+    };
+    if (options.tag !== undefined) {
+      add(options.tag);
+    }
+    if (options.tags !== undefined) {
+      for (const criterion of options.tags) {
+        add(criterion);
+      }
+    }
+    const display: { name?: string; tags?: Array<string> } = {};
+    if (name !== undefined) {
+      display.name = name;
+    }
+    if (criteria.length > 0) {
+      display.tags = criteria;
+    }
+    return JSON.stringify(display) ?? "undefined";
   } catch {
     return "[unserializable options]";
   }

package/src/index.ts

@@ -21,7 +21,7 @@ export { token, tokenName } from "#/core/token";
 export type { Token } from "#/core/token";
 
 // Tag — the interned slot criteria a `whenTagged` and a resolve both take
-export { coversTagKeys, NO_TAG_KEYS, tag, tagKeyMaskOf } from "#/core/tag";
+export { coversTagKeys, NO_TAG_KEYS, slotName, tag, tagKeyMaskOf } from "#/core/tag";
 export type { TagKey, TagKeyMask } from "#/core/tag";
 
 // Binding builders — types only

package/src/injection/resolve-options.ts

@@ -1,4 +1,5 @@
 import type { BindingTag } from "#/core/tag";
+import { slotName, slotNameCriterionOf } from "#/core/tag";
 import type { Token } from "#/core/token";
 import type { Constructor, ResolveOptions } from "#/core/types";
 
@@ -19,37 +20,39 @@ export interface DependencySlot {
 }
 
 /**
- * A request whose only criterion is a name — the shape the registry has a direct index for.
+ * The lone criterion of a request that carries exactly one, whatever its spelling — the shape the
+ * registry has a direct index for.
  *
- * @since 0.5.0-canary.9
- */
-export function isNameOnlyOptions(options: ResolveOptions): options is ResolveOptions & { name: string } {
-  return (
-    options.name !== undefined && options.tag === undefined && (options.tags === undefined || options.tags.length === 0)
-  );
-}
-
-/**
- * The lone tag of a request that asks for exactly one, written either way — the shape the registry
- * has a direct tag index for.
- *
- * @remarks Both spellings answer here, so the index is not something one of them silently misses.
+ * @remarks Every spelling answers here, so the index is not something one of them silently misses;
+ * a name folds to the reserved `slotName` criterion, making the name lane the tag lane.
  *
  * @since 0.5.0-canary.9
  */
-export function singleTagOnlyOf(options: ResolveOptions): BindingTag | undefined {
-  if (options.name !== undefined) {
+export function singleCriterionOnlyOf(options: ResolveOptions | undefined): BindingTag | undefined {
+  if (options === undefined) {
     return undefined;
   }
+  if (options.name !== undefined) {
+    return loneNameCriterionOf(options);
+  }
   const listed = options.tags;
   const shorthand = options.tag;
   if (shorthand !== undefined) {
-    // Both sources present means the request carries two tags, which no single-tag index can answer.
     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: ResolveOptions): BindingTag | undefined {
+  // A name next to any tag means the request carries two criteria, which no single index answers.
+  if (options.tag !== undefined || (options.tags !== undefined && options.tags.length > 0)) {
+    return undefined;
+  }
+  // Read, not minted: a request must not retain a name no binding ever declared.
+  return slotNameCriterionOf(options.name as string);
+}
+
 /** Shared core: build a ResolveOptions from already-normalised name + tags. */
 function buildOptions(
   name: string | undefined,
@@ -83,8 +86,12 @@ export function injectionSlotToResolveOptions(
 /** Where a slot's derived options are memoized, so the same object is handed out every resolve. */
 const MEMOIZED_RESOLVE_OPTIONS: unique symbol = Symbol("di:resolve-options");
 
+/** Where a slot's folded lone criterion is memoized — `null` records "computed: none". */
+const MEMOIZED_SINGLE_CRITERION: unique symbol = Symbol("di:single-criterion");
+
 interface SlotWithMemoizedOptions {
   [MEMOIZED_RESOLVE_OPTIONS]?: ResolveOptions;
+  [MEMOIZED_SINGLE_CRITERION]?: BindingTag | null;
 }
 
 /**
@@ -126,6 +133,44 @@ function memoizeResolveOptions(
   return built;
 }
 
+/**
+ * The lone criterion a dependency's fixed criteria fold to, memoized on the slot like its options —
+ * `null` means the fold answered "none".
+ *
+ * @remarks A slot's criteria never change after declaration, so the fold happens once per slot
+ * rather than per hop — which is what keeps a named dependency's resolve off the intern map. A
+ * lone name whose criterion is not interned yet is left unmemoized: a later `whenNamed` binding
+ * mints it, and the next fold must see that.
+ *
+ * @since 0.8.0
+ */
+export function singleCriterionForSlot(injectionSlot: DependencySlot): BindingTag | null {
+  const slot = injectionSlot as SlotWithMemoizedOptions;
+  const memoized = slot[MEMOIZED_SINGLE_CRITERION];
+  if (memoized !== undefined) {
+    return memoized;
+  }
+  const options = resolveOptionsForSlot(injectionSlot);
+  const criterion = singleCriterionOnlyOf(options);
+  const folded = criterion ?? null;
+  if (criterion !== undefined || !isLoneNameOptions(options)) {
+    try {
+      slot[MEMOIZED_SINGLE_CRITERION] = folded;
+    } catch {
+      // A frozen slot re-folds on every hop rather than throwing.
+    }
+  }
+  return folded;
+}
+
+/** A slot request whose only criterion is a name — the one shape whose fold can change after a bind. */
+function isLoneNameOptions(options: ResolveOptions | undefined): boolean {
+  // Slot-derived options never carry the `tag` shorthand — `buildOptions` folds it into `tags`.
+  return (
+    options !== undefined && options.name !== undefined && (options.tags === undefined || options.tags.length === 0)
+  );
+}
+
 /**
  * Resolve options derived from a binding slot (tags may be empty; omits when nothing to match).
  *
@@ -140,5 +185,17 @@ export function bindingSlotToResolveOptions(bindingSlot: {
   readonly tags?: ReadonlyArray<BindingTag> | undefined;
 }): ResolveOptions | undefined {
   const tags = bindingSlot.tags;
-  return buildOptions(bindingSlot.name, tags !== undefined && tags.length > 0 ? tags : undefined);
+  let name = bindingSlot.name;
+  let criteria: ReadonlyArray<BindingTag> | undefined = tags !== undefined && tags.length > 0 ? tags : undefined;
+  if (criteria !== undefined) {
+    // A reserved criterion folds into `name` — carried in `tags` it would be said twice or, on a
+    // descriptor that spells its name as a tag, not at all.
+    const reserved = criteria.find((criterion) => criterion.key === slotName);
+    if (reserved !== undefined) {
+      name ??= reserved.value as string;
+      const rest = criteria.filter((criterion) => criterion.key !== slotName);
+      criteria = rest.length > 0 ? rest : undefined;
+    }
+  }
+  return buildOptions(name, criteria);
 }

package/src/introspection/dependency-graph.ts

@@ -1,6 +1,7 @@
 import type { Binding } from "#/core/binding";
 import { effectiveBindingScope } from "#/core/binding-scope";
 import type { BindingRegistry } from "#/core/registry";
+import { slotName } from "#/core/tag";
 import type { Token } from "#/core/token";
 import { tokenName } from "#/core/token";
 import type { BindingKind, BindingScope, Constructor } from "#/core/types";
@@ -96,12 +97,23 @@ function matchingTargets(candidates: ReadonlyArray<Binding>, ref: DependencySlot
   return candidates.filter((candidate) => matchesSlot(candidate.slot, criterion));
 }
 
+/** The name a dependency asks for, whichever spelling carries it. */
+function refSlotName(ref: DependencySlot): string | undefined {
+  if (ref.name !== undefined) {
+    return ref.name;
+  }
+  const reserved = ref.tags?.find((criterion) => criterion.key === slotName);
+  return reserved === undefined ? undefined : String(reserved.value);
+}
+
 function edgeLabel(ref: DependencySlot, index: number): string {
+  const name = refSlotName(ref);
+  const firstPlainTag = ref.tags?.find((criterion) => criterion.key !== slotName);
   const criterion =
-    ref.name !== undefined
-      ? `name:${ref.name}`
-      : ref.tags !== undefined && ref.tags.length > 0
-        ? `tag:${ref.tags[0]?.key.name}=${String(ref.tags[0]?.value)}`
+    name !== undefined
+      ? `name:${name}`
+      : firstPlainTag !== undefined
+        ? `tag:${firstPlainTag.key.name}=${String(firstPlainTag.value)}`
         : `[${index}]`;
 
   return ref.optional ? `${criterion} optional` : criterion;
@@ -170,23 +182,25 @@ function addDependencyEdges(
       return;
     }
 
+    const unboundSlotName = refSlotName(ref);
     accumulator.edges.push({
       from,
       to: unboundNodeIdFor(accumulator, ref.token),
       label,
       optional: true,
-      ...(ref.name !== undefined ? { slotName: ref.name } : {}),
+      ...(unboundSlotName !== undefined ? { slotName: unboundSlotName } : {}),
     });
 
     return;
   }
 
+  const requestedName = refSlotName(ref);
   for (const target of targets) {
     // A multi dep with no criterion of its own fans out — each edge names the slot it hits.
-    const slotName = target.slot.name ?? ref.name;
+    const edgeSlotName = target.slot.name ?? requestedName;
     const perTargetLabel =
-      ref.multi && ref.name === undefined && slotName !== undefined
-        ? edgeLabel({ ...ref, name: slotName }, index)
+      ref.multi && requestedName === undefined && edgeSlotName !== undefined
+        ? edgeLabel({ ...ref, name: edgeSlotName }, index)
         : label;
 
     accumulator.edges.push({
@@ -194,7 +208,7 @@ function addDependencyEdges(
       to: target.id,
       label: perTargetLabel,
       optional: ref.optional,
-      ...(slotName !== undefined ? { slotName } : {}),
+      ...(edgeSlotName !== undefined ? { slotName: edgeSlotName } : {}),
     });
   }
 }

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

@@ -31,15 +31,10 @@ export interface DefaultLookupEntry<Owner> {
  */
 export const ALIAS_HOP_LIMIT = 32;
 
-/**
- * @since 0.5.0-canary.8
- */
-const newNameToEntryMap = <Owner>(): Map<string, DefaultLookupEntry<Owner> | null> => new Map();
-
 const newTagToEntryMap = <Owner>(): Map<BindingTag, DefaultLookupEntry<Owner> | null> => new Map();
 
 /**
- * A version-stamped cache of binding lookups by token, name, and tag across the container chain.
+ * A version-stamped cache of binding lookups by token and criterion across the container chain.
  *
  * @since 0.5.0-canary.9
  */
@@ -51,8 +46,6 @@ export class BindingLookupCache<Owner> {
   // 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;
   readonly #byTokenAndTag = new Map<Token<unknown> | Constructor, Map<BindingTag, DefaultLookupEntry<Owner> | null>>();
   #taggedVersion = -1;
   // One entry in front of the tag map, and the map is not written until a second distinct request
@@ -101,24 +94,6 @@ export class BindingLookupCache<Owner> {
     return entry;
   }
 
-  /** `null` when the name's shape needs the full selection path. */
-  namedEntry(token: Token<unknown> | Constructor, name: string): DefaultLookupEntry<Owner> | null {
-    const version = this.chainVersion();
-    if (version !== this.#namedVersion) {
-      this.#byTokenAndName.clear();
-      this.#namedVersion = version;
-    }
-    // Computed, not eager: this runs on every named resolve, and the eager form would allocate a
-    // Map per call only to discard it on the hit that follows.
-    const byName = getOrInsertComputed(this.#byTokenAndName, token, newNameToEntryMap);
-    let entry = byName.get(name);
-    if (entry === undefined) {
-      entry = this.#findNamedInChain(token, name);
-      byName.set(name, entry);
-    }
-    return entry;
-  }
-
   /** `null` when the tag's shape needs the full selection path. */
   taggedEntry(token: Token<unknown> | Constructor, tag: BindingTag): DefaultLookupEntry<Owner> | null {
     const version = this.chainVersion();
@@ -177,21 +152,6 @@ export class BindingLookupCache<Owner> {
     return this.#parent === undefined ? null : this.#parent.#findDefaultInChain(token);
   }
 
-  #findNamedInChain(token: Token<unknown> | Constructor, name: string): DefaultLookupEntry<Owner> | null {
-    const named = this.#registry.getSimpleNamed(token, name);
-    if (named !== undefined) {
-      // Predicates need a live context; aliases carry options through the full path.
-      if (named.predicate !== undefined || named.kind === "alias") {
-        return null;
-      }
-      return { binding: named, owner: this.#owner };
-    }
-    if (this.#registry.has(token)) {
-      return null;
-    }
-    return this.#parent === undefined ? null : this.#parent.#findNamedInChain(token, name);
-  }
-
   #findTaggedInChain(token: Token<unknown> | Constructor, tag: BindingTag): DefaultLookupEntry<Owner> | null {
     const tagged = this.#registry.getSimpleTagged(token, tag);
     if (tagged !== undefined) {