@codefast/di 0.5.0-canary.7 → 0.5.0-canary.8

package/src/container/container.ts

@@ -1,6 +1,7 @@
 import type { Binding, BindToBuilder } from "#/binding";
-import { bindingSlotEquals } from "#/binding";
-import { BindingEntry } from "#/container/binding-builders";
+import { NO_INSTANCE } from "#/binding";
+import type { BindingRegistration } from "#/container/binding-builders";
+import { BindingChain } from "#/container/binding-builders";
 import type { AutoRegisterRegistry } from "#/decorators/injectable";
 import {
   AsyncModuleLoadError,
@@ -23,6 +24,8 @@ import type { AsyncModuleBuilder } from "#/module";
 import { isSyncModule, MODULE_SETUP } from "#/module";
 import { BindingRegistry } from "#/registry";
 import { effectiveBindingScope } from "#/resolution/binding-scope";
+import type { ResolutionDiagnostics } from "#/resolution/diagnostics";
+import { RESOLUTION_DIAGNOSTICS } from "#/resolution/diagnostics";
 import { LifecycleManager } from "#/resolution/lifecycle";
 import { injectionSlotToResolveOptions, bindingSlotToResolveOptions } from "#/resolution/resolve-options";
 import { DependencyResolver } from "#/resolution/resolver";
@@ -38,17 +41,6 @@ import type {
   ResolveOptions,
 } from "#/types";
 
-// True when re-adding `restored` would immediately be displaced again by `current`
-// (both slot-based with equal slots) — in that case the replacement was legitimate.
-function displacesRestoredBinding(current: Binding, restored: Binding): boolean {
-  const currentIsPurePredicate =
-    current.predicate !== undefined && current.slot.name === undefined && current.slot.tags.length === 0;
-  if (currentIsPurePredicate) {
-    return false;
-  }
-  return bindingSlotEquals(current.slot, restored.slot);
-}
-
 // ── Container interface ────────────────────────────────────────────────────────
 
 /**
@@ -119,23 +111,54 @@ class DefaultContainer implements Container {
   readonly #scope: ScopeManager;
   readonly #lifecycle: LifecycleManager;
   #resolver!: DependencyResolver;
-  readonly #inspector: Inspector;
+  // Built on the first introspecting call — a container that only binds and resolves never needs it.
+  #inspector: Inspector | undefined;
   readonly #parent: DefaultContainer | undefined;
 
-  // Module tracking: module -> ref count
-  readonly #moduleRefs = new Map<object, number>();
+  // Module tracking: module -> ref count. Both tables stay unallocated until a module is loaded.
+  #moduleRefs: Map<object, number> | undefined;
   // Module bindings: module -> array of binding IDs registered by it
-  readonly #moduleBindingIds = new Map<object, Array<BindingIdentifier>>();
+  #moduleBindingIds: Map<object, Array<BindingIdentifier>> | undefined;
+  // One shared registration for every chain this container's own `bind()` creates.
+  #registration: BindingRegistration | undefined;
 
   constructor(parent?: DefaultContainer) {
     this.#parent = parent;
     this.#registry = new BindingRegistry();
     this.#scope = new ScopeManager(parent !== undefined);
     this.#lifecycle = new LifecycleManager();
-    this.#inspector = new Inspector(this.#registry, this.#scope, parent !== undefined, () => this.#disposed);
     this.#initResolver();
   }
 
+  #getInspector(): Inspector {
+    return (this.#inspector ??= new Inspector(
+      this.#registry,
+      this.#scope,
+      this.#parent !== undefined,
+      () => this.#disposed,
+    ));
+  }
+
+  [RESOLUTION_DIAGNOSTICS](): ResolutionDiagnostics {
+    const builtSubsystems: Array<string> = [];
+    if (this.#inspector !== undefined) {
+      builtSubsystems.push("container.inspector");
+    }
+    if (this.#moduleRefs !== undefined || this.#moduleBindingIds !== undefined) {
+      builtSubsystems.push("container.moduleTables");
+    }
+    if (this.#registry.isBuilt) {
+      builtSubsystems.push("registry.namedIndex");
+    }
+    if (this.#scope.isBuilt) {
+      builtSubsystems.push("scope.scoped");
+    }
+    if (this.#lifecycle.isBuilt) {
+      builtSubsystems.push("lifecycle.activationHooks");
+    }
+    return { ...this.#resolver.describeCaches(), builtSubsystems };
+  }
+
   #initResolver(): void {
     const metadataReader = this.#getMetadataReader();
     const parentResolver = this.#parent === undefined ? undefined : this.#parent.#resolver;
@@ -176,63 +199,24 @@ class DefaultContainer implements Container {
     return this.#createBindToBuilder(token);
   }
 
+  /** The registration every non-module chain shares, so `bind()` allocates only the builder. */
+  #ownRegistration(): BindingRegistration {
+    return (this.#registration ??= { registry: this.#registry, moduleBindingIds: undefined });
+  }
+
+  /** One registration per module load, holding that module's id list directly. */
+  #moduleRegistration(moduleRef: object): BindingRegistration {
+    return {
+      registry: this.#registry,
+      moduleBindingIds: (this.#moduleBindingIds ??= new Map()).getOrInsert(moduleRef, []),
+    };
+  }
+
   #createBindToBuilder<const Value>(
     token: Token<Value> | Constructor<Value>,
-    moduleRef?: object,
+    registration: BindingRegistration = this.#ownRegistration(),
   ): BindToBuilder<Value> {
-    const registry = this.#registry;
-    // Bindings displaced by this fluent chain's commits — each stays restorable
-    // until the chain settles on a shape that genuinely conflicts with it. A list,
-    // because one chain can displace several bindings (the default at an
-    // intermediate commit, then a named/tagged binding at the final one).
-    const displacedByChain: Array<Binding> = [];
-
-    const commitBinding = <BindingValue>(
-      binding: Binding<BindingValue>,
-      previousId?: BindingIdentifier,
-    ): BindingIdentifier => {
-      if (previousId !== undefined) {
-        registry.removeById(previousId);
-        if (moduleRef !== undefined) {
-          const ids = this.#moduleBindingIds.get(moduleRef);
-          if (ids !== undefined) {
-            const idx = ids.indexOf(previousId);
-            if (idx !== -1) {
-              ids.splice(idx, 1);
-            }
-          }
-        }
-      }
-      // The registry stores value-erased bindings — this is the single erasure point for the builder chain.
-      const displaced = registry.add(binding as Binding);
-      if (displaced !== undefined) {
-        // A fluent chain commits eagerly on each refinement, so an intermediate
-        // commit can displace a binding that the final shape would never conflict
-        // with. Remember it so a later re-commit that morphs away (named/tagged
-        // slot, pure predicate) can restore it.
-        displacedByChain.push(displaced);
-      }
-      if (previousId !== undefined && displacedByChain.length > 0) {
-        for (let index = displacedByChain.length - 1; index >= 0; index -= 1) {
-          const candidate = displacedByChain[index]!;
-          if (!displacesRestoredBinding(binding as Binding, candidate)) {
-            registry.add(candidate);
-            displacedByChain.splice(index, 1);
-          }
-        }
-      }
-      if (moduleRef !== undefined) {
-        let ids = this.#moduleBindingIds.get(moduleRef);
-        if (ids === undefined) {
-          ids = [];
-          this.#moduleBindingIds.set(moduleRef, ids);
-        }
-        ids.push(binding.id);
-      }
-      return binding.id;
-    };
-
-    return new BindingEntry<Value>(token, commitBinding);
+    return new BindingChain<Value>(token, registration);
   }
 
   unbind(tokenOrId: Token<unknown> | Constructor | BindingIdentifier): void {
@@ -255,9 +239,9 @@ class DefaultContainer implements Container {
   #drainSingletons(bindings: ReadonlyArray<Binding>): Array<[Binding, unknown]> {
     const pairs: Array<[Binding, unknown]> = [];
     for (const binding of bindings) {
-      if (this.#scope.hasSingleton(binding.id)) {
-        pairs.push([binding, this.#scope.getSingleton(binding.id)]);
-        this.#scope.deleteSingleton(binding.id);
+      if (binding.instance !== NO_INSTANCE) {
+        pairs.push([binding, binding.instance]);
+        this.#scope.deleteSingleton(binding);
       }
     }
     return pairs;
@@ -319,12 +303,13 @@ class DefaultContainer implements Container {
         throw new AsyncModuleLoadError(module.name);
       }
       const moduleRef = module as object;
-      const existing = this.#moduleRefs.get(moduleRef);
+      const moduleRefs = (this.#moduleRefs ??= new Map());
+      const existing = moduleRefs.get(moduleRef);
       if (existing !== undefined) {
-        this.#moduleRefs.set(moduleRef, existing + 1);
+        moduleRefs.set(moduleRef, existing + 1);
         continue;
       }
-      this.#moduleRefs.set(moduleRef, 1);
+      moduleRefs.set(moduleRef, 1);
       const builder = this.#createModuleBuilder(moduleRef);
       module[MODULE_SETUP](builder);
     }
@@ -359,12 +344,13 @@ class DefaultContainer implements Container {
 
   async #loadOneModuleAsync(module: SyncModule | AsyncModule): Promise<void> {
     const moduleRef = module as object;
-    const existing = this.#moduleRefs.get(moduleRef);
+    const moduleRefs = (this.#moduleRefs ??= new Map());
+    const existing = moduleRefs.get(moduleRef);
     if (existing !== undefined) {
-      this.#moduleRefs.set(moduleRef, existing + 1);
+      moduleRefs.set(moduleRef, existing + 1);
       return;
     }
-    this.#moduleRefs.set(moduleRef, 1);
+    moduleRefs.set(moduleRef, 1);
 
     if (isSyncModule(module)) {
       const builder = this.#createModuleBuilder(moduleRef);
@@ -381,9 +367,10 @@ class DefaultContainer implements Container {
   }
 
   #createModuleBuilder(moduleRef: object): ModuleBuilder {
+    const registration = this.#moduleRegistration(moduleRef);
     return {
       bind: <const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value> =>
-        this.#createBindToBuilder(token, moduleRef),
+        this.#createBindToBuilder(token, registration),
       import: (...modules: Array<SyncModule>): void => {
         this.#loadSyncModules(modules);
       },
@@ -391,9 +378,10 @@ class DefaultContainer implements Container {
   }
 
   #createAsyncModuleBuilder(moduleRef: object, importPromises: Array<Promise<void>>): AsyncModuleBuilder {
+    const registration = this.#moduleRegistration(moduleRef);
     return {
       bind: <const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value> =>
-        this.#createBindToBuilder(token, moduleRef),
+        this.#createBindToBuilder(token, registration),
       import: (...modules: Array<SyncModule | AsyncModule>): void => {
         for (const module of modules) {
           importPromises.push(this.#loadOneModuleAsync(module));
@@ -411,17 +399,17 @@ class DefaultContainer implements Container {
 
   /** Unregister module bindings and collect [binding, instance] pairs for deactivation. */
   #removeModuleBindings(ref: object): Array<[Binding, unknown]> {
-    this.#moduleRefs.delete(ref);
-    const ids = this.#moduleBindingIds.get(ref) ?? [];
-    this.#moduleBindingIds.delete(ref);
+    this.#moduleRefs?.delete(ref);
+    const ids = this.#moduleBindingIds?.get(ref) ?? [];
+    this.#moduleBindingIds?.delete(ref);
     const pairs: Array<[Binding, unknown]> = [];
     for (const id of ids) {
       const binding = this.#registry.getById(id);
       if (binding !== undefined) {
         this.#registry.removeById(id);
-        if (this.#scope.hasSingleton(id)) {
-          pairs.push([binding, this.#scope.getSingleton(id)]);
-          this.#scope.deleteSingleton(id);
+        if (binding.instance !== NO_INSTANCE) {
+          pairs.push([binding, binding.instance]);
+          this.#scope.deleteSingleton(binding);
         }
       }
     }
@@ -429,14 +417,14 @@ class DefaultContainer implements Container {
   }
 
   #unloadModuleSync(ref: object): void {
-    const count = this.#moduleRefs.get(ref) ?? 0;
+    const count = this.#moduleRefs?.get(ref) ?? 0;
     if (count <= 1) {
       const reader = this.#getMetadataReader();
       for (const [binding, instance] of this.#removeModuleBindings(ref)) {
         this.#lifecycle.runDeactivationSync(binding, instance, reader);
       }
     } else {
-      this.#moduleRefs.set(ref, count - 1);
+      this.#moduleRefs!.set(ref, count - 1);
     }
   }
 
@@ -448,14 +436,14 @@ class DefaultContainer implements Container {
   }
 
   async #unloadModuleAsync(ref: object): Promise<void> {
-    const count = this.#moduleRefs.get(ref) ?? 0;
+    const count = this.#moduleRefs?.get(ref) ?? 0;
     if (count <= 1) {
       const reader = this.#getMetadataReader();
       for (const [binding, instance] of this.#removeModuleBindings(ref)) {
         await this.#lifecycle.runDeactivation(binding, instance, reader);
       }
     } else {
-      this.#moduleRefs.set(ref, count - 1);
+      this.#moduleRefs!.set(ref, count - 1);
     }
   }
 
@@ -549,11 +537,10 @@ class DefaultContainer implements Container {
 
     // Deactivate all singletons in this container (own only)
     const reader = this.#getMetadataReader();
-    for (const [id, instance] of this.#scope.getAllSingletons()) {
-      const binding = this.#registry.getById(id);
-      if (binding !== undefined) {
-        await this.#lifecycle.runDeactivation(binding, instance, reader);
-      }
+    // Iterate a copy: a deactivation handler is user code, and the live list is what
+    // materializing or dropping a singleton mutates.
+    for (const binding of this.#scope.cachedSingletons().slice()) {
+      await this.#lifecycle.runDeactivation(binding, binding.instance, reader);
     }
 
     this.#scope.clearAll();
@@ -577,7 +564,7 @@ class DefaultContainer implements Container {
         continue;
       }
       const scope = effectiveBindingScope(binding);
-      if (scope === "singleton" && !this.#scope.hasSingleton(binding.id)) {
+      if (scope === "singleton" && binding.instance === NO_INSTANCE) {
         if (binding.predicate !== undefined) {
           continue;
         }
@@ -777,22 +764,22 @@ class DefaultContainer implements Container {
 
   has(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean {
     this.#assertNotDisposed();
-    return this.#inspector.has(token, options, () => this.#parent?.has(token, options) ?? false);
+    return this.#getInspector().has(token, options, () => this.#parent?.has(token, options) ?? false);
   }
 
   hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean {
     this.#assertNotDisposed();
-    return this.#inspector.hasOwn(token, options);
+    return this.#getInspector().hasOwn(token, options);
   }
 
   lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot> {
     this.#assertNotDisposed();
-    return this.#inspector.lookupBindings(token);
+    return this.#getInspector().lookupBindings(token);
   }
 
   inspect(): ContainerSnapshot {
     this.#assertNotDisposed();
-    return this.#inspector.inspect();
+    return this.#getInspector().inspect();
   }
 
   generateDependencyGraph(options?: GraphOptions): ContainerGraphJson {

package/src/decorators/inject.ts

@@ -34,10 +34,8 @@ export type InjectableDependency<Value = unknown> = Token<Value> | Constructor<V
 /**
  * The value a factory receives for one declared dependency.
  *
- * @remarks `optional()` and `injectAll()` already fold their effect into the descriptor's own
- * type parameter — `InjectionDescriptor<Value | undefined>` and `InjectionDescriptor<Array<Value>>`
- * — so reading that parameter back is enough; bare tokens and constructors fall through to
- * {@link TokenValue}.
+ * @remarks `optional()` and `injectAll()` fold their effect into the descriptor's own type
+ * parameter, so reading it back is enough; bare tokens fall through to {@link TokenValue}.
  *
  * @since 0.5.0-canary.7
  */
@@ -195,7 +193,7 @@ export function inject<const Value>(
   }
   Object.defineProperties(decoratorFn, props);
 
-  return decoratorFn as unknown as InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
+  return decoratorFn as InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
 }
 
 // ── optional() ────────────────────────────────────────────────────────────────

package/src/errors.ts

@@ -212,6 +212,27 @@ export class MissingContainerContextError extends DiError {
   }
 }
 
+/**
+ * A fluent chain was refined before a `to*()` call gave it a binding to refine.
+ *
+ * @remarks The builder types make this unreachable from TypeScript — `bind()` returns
+ * `BindToBuilder`, which exposes only `to*()`. It exists for JavaScript callers and for anyone who
+ * casts past the types, so the misuse fails loudly instead of mutating nothing.
+ *
+ * @since 0.5.0-canary.8
+ */
+export class ChainNotRegisteredError extends DiError {
+  readonly code = "CHAIN_NOT_REGISTERED";
+  readonly tokenName: string;
+
+  constructor(tokenName: string) {
+    super(
+      `Cannot refine the binding for token '${tokenName}' before choosing a target. Call a to*() method first — for example .to(SomeClass), .toConstantValue(value) or .toDynamic(factory).`,
+    );
+    this.tokenName = tokenName;
+  }
+}
+
 /**
  * @since 0.3.16-canary.0
  */

package/src/index.ts

@@ -85,6 +85,7 @@ export {
   AsyncDeactivationError,
   AsyncModuleLoadError,
   AsyncResolutionError,
+  ChainNotRegisteredError,
   CircularDependencyError,
   DiError,
   DisposedContainerError,

package/src/introspection/inspector.ts

@@ -63,7 +63,7 @@ export class Inspector {
     const snapshots = this.allBindingSnapshots();
     return {
       ownBindings: snapshots,
-      cachedSingletonCount: this.#scope.getAllSingletons().size,
+      cachedSingletonCount: this.#scope.cachedSingletons().length,
       hasParent: this.#hasParent,
       isDisposed: this.#isDisposed(),
     };

package/src/metadata/metadata-keys.ts

@@ -12,13 +12,10 @@ export const LIFECYCLE_KEY: unique symbol = Symbol("di:lifecycle");
 export const INJECT_ACCESSOR_KEY: unique symbol = Symbol("di:inject-accessor");
 
 /**
- * The well-known symbol used by TC39 Stage 3 decorator transforms to store class metadata.
+ * The symbol TC39 Stage 3 decorator transforms store class metadata under.
  *
- * `Symbol.metadata` is defined natively once the runtime ships the full TC39 decorator
- * proposal.  Until then (current Node.js / browsers), Babel and esbuild both fall back to
- * `Symbol.for("Symbol.metadata")` — a global-registry symbol with the same string key.
- * Resolving it here once keeps the reader and the decorator transforms in sync regardless
- * of which path is taken.
+ * @remarks Falls back to the global-registry symbol, which is what Babel and esbuild emit until
+ * a runtime ships `Symbol.metadata` natively.
  *
  * @since 0.3.16-canary.0
  */

package/src/registry.ts

@@ -3,44 +3,6 @@ import { bindingSlotEquals, bindingSlotToString } from "#/binding";
 import type { Token } from "#/token";
 import type { BindingIdentifier, Constructor, DependencyKey } from "#/types";
 
-// Superset of every binding kind's fields, used to normalize hidden classes below.
-type BindingFieldSuperset = Binding & {
-  readonly scope?: unknown;
-  readonly target?: unknown;
-  readonly factory?: unknown;
-  readonly deps?: unknown;
-  readonly value?: unknown;
-  readonly onActivation?: unknown;
-  readonly onDeactivation?: unknown;
-};
-
-/**
- * Rebuilds a binding with every kind's fields in one fixed key order, so all stored
- * bindings share a single V8 hidden class. Mixed binding kinds otherwise turn the
- * resolver's hot property reads (kind/scope/factory/...) megamorphic, which costs
- * ~30% throughput in processes that exercise many kinds. The value-erasing cast is
- * safe: every declared field is copied verbatim and `kind` stays the discriminant.
- */
-function normalizeBindingShape(binding: Binding): Binding {
-  const source = binding as BindingFieldSuperset;
-  return {
-    kind: source.kind,
-    id: source.id,
-    inFlight: false,
-    frame: undefined,
-    token: source.token,
-    slot: source.slot,
-    predicate: source.predicate,
-    scope: source.scope,
-    target: source.target,
-    factory: source.factory,
-    deps: source.deps,
-    value: source.value,
-    onActivation: source.onActivation,
-    onDeactivation: source.onDeactivation,
-  } as Binding;
-}
-
 /**
  * @since 0.3.16-canary.0
  */
@@ -51,22 +13,35 @@ 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: [] }
-  readonly #simpleNamed = new Map<DependencyKey, Map<string, 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 slot { name: undefined, tags: [[key, value]] } with no predicate
-  readonly #simpleTagged = new Map<DependencyKey, Map<string, Map<unknown, Binding>>>();
+  // Fast lookup for slot { name: undefined, tags: [[key, value]] } with no predicate — likewise
+  // unallocated until a tagged binding is registered.
+  #simpleTagged: Map<DependencyKey, Map<string, Map<unknown, Binding>>> | undefined;
 
   /** Monotonic version — increments on every mutation. */
   get version(): number {
     return this.#version;
   }
 
-  /** Add or replace binding using slot-aware last-wins. Returns the displaced binding, if any. */
-  add(uncommittedBinding: Binding): Binding | undefined {
+  /**
+   * Registers a mutation the indexes don't care about (a fluent chain refining scope or an
+   * activation hook in place), so version-stamped resolver caches still invalidate.
+   */
+  touch(): void {
+    this.#version += 1;
+  }
+
+  /**
+   * Add or replace binding using slot-aware last-wins. Returns the displaced binding, if any.
+   *
+   * @remarks The binding is stored by reference — it must come from `createBinding`, which is
+   * what guarantees the single hidden class the resolver's hot reads depend on.
+   */
+  add(binding: Binding): Binding | undefined {
     this.#version += 1;
-    const binding = normalizeBindingShape(uncommittedBinding);
     const key = binding.token as DependencyKey;
     // ✓ TS6.0: Map.getOrInsert (ES2025) replaces the manual get+check+set upsert
     const bindingsForToken = this.#bindings.getOrInsert(key, []);
@@ -100,8 +75,8 @@ export class BindingRegistry {
     const key = token as DependencyKey;
     const bindingsForToken = this.#bindings.get(key) ?? [];
     this.#bindings.delete(key);
-    this.#simpleNamed.delete(key);
-    this.#simpleTagged.delete(key);
+    this.#simpleNamed?.delete(key);
+    this.#simpleTagged?.delete(key);
     this.#fastDefault.delete(key);
     for (const binding of bindingsForToken) {
       this.#byId.delete(binding.id);
@@ -128,8 +103,8 @@ export class BindingRegistry {
       this.#deindexSimpleTaggedBinding(key, binding);
       if (bindingsForToken.length === 0) {
         this.#bindings.delete(key);
-        this.#simpleNamed.delete(key);
-        this.#simpleTagged.delete(key);
+        this.#simpleNamed?.delete(key);
+        this.#simpleTagged?.delete(key);
         this.#fastDefault.delete(key);
       } else {
         this.#refreshFastDefaultForToken(key);
@@ -170,19 +145,19 @@ export class BindingRegistry {
     const all = this.allBindings();
     this.#bindings.clear();
     this.#byId.clear();
-    this.#simpleNamed.clear();
-    this.#simpleTagged.clear();
+    this.#simpleNamed?.clear();
+    this.#simpleTagged?.clear();
     this.#fastDefault.clear();
     return all;
   }
 
   getSimpleNamed(token: Token<unknown> | Constructor, name: string): Binding | undefined {
-    return this.#simpleNamed.get(token as DependencyKey)?.get(name);
+    return this.#simpleNamed?.get(token as DependencyKey)?.get(name);
   }
 
   getSimpleTagged(token: Token<unknown> | Constructor, tagKey: string, tagValue: unknown): Binding | undefined {
     return this.#simpleTagged
-      .get(token as DependencyKey)
+      ?.get(token as DependencyKey)
       ?.get(tagKey)
       ?.get(tagValue);
   }
@@ -203,7 +178,7 @@ export class BindingRegistry {
       return;
     }
     const [tagKey, tagValue] = slot.tags[0]!;
-    const byTagKey = this.#simpleTagged.getOrInsert(tokenKey, new Map<string, Map<unknown, Binding>>());
+    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);
   }
@@ -214,7 +189,7 @@ export class BindingRegistry {
       return;
     }
     const [tagKey, tagValue] = slot.tags[0]!;
-    const byTagKey = this.#simpleTagged.get(tokenKey);
+    const byTagKey = this.#simpleTagged?.get(tokenKey);
     if (byTagKey === undefined) {
       return;
     }
@@ -228,7 +203,7 @@ export class BindingRegistry {
       if (byTagValue.size === 0) {
         byTagKey.delete(tagKey);
         if (byTagKey.size === 0) {
-          this.#simpleTagged.delete(tokenKey);
+          this.#simpleTagged!.delete(tokenKey);
         }
       }
     }
@@ -247,7 +222,7 @@ export class BindingRegistry {
     if (slot.name === undefined || slot.tags.length > 0) {
       return;
     }
-    const bindingsByName = this.#simpleNamed.getOrInsert(tokenKey, new Map<string, Binding>());
+    const bindingsByName = (this.#simpleNamed ??= new Map()).getOrInsert(tokenKey, new Map<string, Binding>());
     bindingsByName.set(slot.name, binding);
   }
 
@@ -256,7 +231,7 @@ export class BindingRegistry {
     if (slot.name === undefined || slot.tags.length > 0) {
       return;
     }
-    const bindingsByName = this.#simpleNamed.get(tokenKey);
+    const bindingsByName = this.#simpleNamed?.get(tokenKey);
     if (bindingsByName === undefined) {
       return;
     }
@@ -264,7 +239,7 @@ export class BindingRegistry {
     if (currentBinding?.id === binding.id) {
       bindingsByName.delete(slot.name);
       if (bindingsByName.size === 0) {
-        this.#simpleNamed.delete(tokenKey);
+        this.#simpleNamed!.delete(tokenKey);
       }
     }
   }
@@ -283,4 +258,8 @@ export class BindingRegistry {
     }
     this.#fastDefault.set(tokenKey, onlyBinding);
   }
+  /** Whether the deferred table behind `#simpleNamed` has had to be built. */
+  get isBuilt(): boolean {
+    return this.#simpleNamed !== undefined;
+  }
 }