@codefast/di 0.3.16-canary.2 → 0.4.0-canary.4

package/src/lifecycle.ts

@@ -0,0 +1,217 @@
+import type { Binding } from "#/binding";
+import { AsyncActivationError, AsyncDeactivationError } from "#/errors";
+import type { MetadataReader } from "#/metadata/metadata-types";
+import type { Token } from "#/token";
+import { tokenName } from "#/token";
+import type { ActivationHandler, Constructor, DeactivationHandler, ResolutionContext } from "#/types";
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export class LifecycleManager {
+  // Container-level activation/deactivation hooks per token
+  private readonly _activationHooks = new Map<Token<unknown> | Constructor, Array<ActivationHandler<unknown>>>();
+  private readonly _deactivationHooks = new Map<Token<unknown> | Constructor, Array<DeactivationHandler<unknown>>>();
+  private _activationVersion = 0;
+
+  registerActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void {
+    this._activationVersion += 1;
+    // ✓ TS6.0: Map.getOrInsert (ES2025)
+    const list = this._activationHooks.getOrInsert(token as Token<unknown> | Constructor, []);
+    list.push(handler as ActivationHandler<unknown>);
+  }
+
+  hasActivationHandlers<const Value>(token: Token<Value> | Constructor<Value>): boolean {
+    if (this._activationHooks.size === 0) {
+      return false;
+    }
+    const list = this._activationHooks.get(token as Token<unknown> | Constructor);
+    return list !== undefined && list.length > 0;
+  }
+
+  get activationVersion(): number {
+    return this._activationVersion;
+  }
+
+  registerDeactivation<const Value>(
+    token: Token<Value> | Constructor<Value>,
+    handler: DeactivationHandler<Value>,
+  ): void {
+    const list = this._deactivationHooks.getOrInsert(token as Token<unknown> | Constructor, []);
+    list.push(handler as DeactivationHandler<unknown>);
+  }
+
+  async runActivation<const Value>(
+    resolutionContext: ResolutionContext,
+    binding: Binding<Value>,
+    instance: Value,
+    metadataReader: MetadataReader,
+  ): Promise<Value> {
+    let activatedInstance: Value = instance;
+
+    // 1. @postConstruct() — after TC39 construction (constructor + accessor addInitializer callbacks)
+    if (binding.kind === "class") {
+      const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+      if (lifecycle?.postConstruct && lifecycle.postConstruct.length > 0) {
+        for (const methodName of lifecycle.postConstruct) {
+          const method = (activatedInstance as Record<string, unknown>)[methodName];
+          if (typeof method === "function") {
+            const hookResult = (method as () => unknown).call(activatedInstance);
+            if (hookResult instanceof Promise) {
+              await hookResult;
+            }
+          }
+        }
+      }
+    }
+
+    // 2. per-binding onActivation
+    if (binding.kind !== "alias" && binding.onActivation !== undefined) {
+      const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+      activatedInstance = activationResult instanceof Promise ? await activationResult : activationResult;
+    }
+
+    // 3. container-level onActivation
+    const containerHooks = this._activationHooks.get(binding.token as Token<unknown> | Constructor);
+    if (containerHooks !== undefined) {
+      for (const hook of containerHooks) {
+        const activationResult = hook(resolutionContext, activatedInstance);
+        activatedInstance = (activationResult instanceof Promise ? await activationResult : activationResult) as Value;
+      }
+    }
+
+    return activatedInstance;
+  }
+
+  runActivationSync<const Value>(
+    resolutionContext: ResolutionContext,
+    binding: Binding<Value>,
+    instance: Value,
+    metadataReader: MetadataReader,
+  ): Value {
+    let activatedInstance: Value = instance;
+
+    // 1. @postConstruct() — must be sync (instance fully constructed per TC39 order)
+    if (binding.kind === "class") {
+      const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+      if (lifecycle?.postConstruct && lifecycle.postConstruct.length > 0) {
+        for (const methodName of lifecycle.postConstruct) {
+          const method = (activatedInstance as Record<string, unknown>)[methodName];
+          if (typeof method === "function") {
+            const hookResult = (method as () => unknown).call(activatedInstance);
+            if (hookResult instanceof Promise) {
+              throw new AsyncActivationError(tokenName(binding.token), "postConstruct", methodName);
+            }
+          }
+        }
+      }
+    }
+
+    // 2. per-binding onActivation (must be sync)
+    if (binding.kind !== "alias" && binding.onActivation !== undefined) {
+      const activationResult = binding.onActivation(resolutionContext, activatedInstance);
+      if (activationResult instanceof Promise) {
+        throw new AsyncActivationError(tokenName(binding.token), "onActivation");
+      }
+      activatedInstance = activationResult;
+    }
+
+    // 3. container-level onActivation (must be sync)
+    const tokenDisplayName = tokenName(binding.token);
+    const containerHooks = this._activationHooks.get(binding.token as Token<unknown> | Constructor);
+    if (containerHooks !== undefined) {
+      for (const hook of containerHooks) {
+        const activationResult = hook(resolutionContext, activatedInstance);
+        if (activationResult instanceof Promise) {
+          throw new AsyncActivationError(tokenDisplayName, "onActivation");
+        }
+        activatedInstance = activationResult as Value;
+      }
+    }
+
+    return activatedInstance;
+  }
+
+  async runDeactivation<const Value>(
+    binding: Binding<Value>,
+    instance: Value,
+    metadataReader: MetadataReader,
+  ): Promise<void> {
+    const tokenKey = binding.token as Token<unknown> | Constructor;
+
+    // 1. container-level onDeactivation
+    const containerHooks = this._deactivationHooks.get(tokenKey);
+    if (containerHooks !== undefined) {
+      for (const hook of containerHooks) {
+        const hookResult = hook(instance);
+        if (hookResult instanceof Promise) {
+          await hookResult;
+        }
+      }
+    }
+
+    // 2. per-binding onDeactivation
+    if (binding.kind !== "alias" && binding.onDeactivation !== undefined) {
+      const hookResult = binding.onDeactivation(instance);
+      if (hookResult instanceof Promise) {
+        await hookResult;
+      }
+    }
+
+    // 3. @preDestroy() — all methods in declaration order
+    if (binding.kind === "class") {
+      const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+      if (lifecycle?.preDestroy && lifecycle.preDestroy.length > 0) {
+        for (const methodName of lifecycle.preDestroy) {
+          const method = (instance as Record<string, unknown>)[methodName];
+          if (typeof method === "function") {
+            const hookResult = (method as () => unknown).call(instance);
+            if (hookResult instanceof Promise) {
+              await hookResult;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  runDeactivationSync<const Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): void {
+    const tokenDisplayName = tokenName(binding.token);
+    const tokenKey = binding.token as Token<unknown> | Constructor;
+
+    // 1. container-level onDeactivation
+    const containerHooks = this._deactivationHooks.get(tokenKey);
+    if (containerHooks !== undefined) {
+      for (const hook of containerHooks) {
+        const hookResult = hook(instance);
+        if (hookResult instanceof Promise) {
+          throw new AsyncDeactivationError(tokenDisplayName);
+        }
+      }
+    }
+
+    // 2. per-binding onDeactivation
+    if (binding.kind !== "alias" && binding.onDeactivation !== undefined) {
+      const hookResult = binding.onDeactivation(instance);
+      if (hookResult instanceof Promise) {
+        throw new AsyncDeactivationError(tokenDisplayName);
+      }
+    }
+
+    // 3. @preDestroy()
+    if (binding.kind === "class") {
+      const lifecycle = metadataReader.getLifecycleMetadata(binding.target);
+      if (lifecycle?.preDestroy && lifecycle.preDestroy.length > 0) {
+        for (const methodName of lifecycle.preDestroy) {
+          const method = (instance as Record<string, unknown>)[methodName];
+          if (typeof method === "function") {
+            const hookResult = (method as () => unknown).call(instance);
+            if (hookResult instanceof Promise) {
+              throw new AsyncDeactivationError(tokenDisplayName);
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/metadata/metadata-keys.ts

@@ -0,0 +1,25 @@
+/**
+ * @since 0.3.16-canary.0
+ */
+export const INJECTABLE_KEY: unique symbol = Symbol("di:injectable");
+/**
+ * @since 0.3.16-canary.0
+ */
+export const LIFECYCLE_KEY: unique symbol = Symbol("di:lifecycle");
+/**
+ * @since 0.3.16-canary.0
+ */
+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.
+ *
+ * `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.
+ *
+ * @since 0.3.16-canary.0
+ */
+export const METADATA_SYMBOL: symbol = Symbol.metadata ?? Symbol.for("Symbol.metadata");

package/src/metadata/metadata-reader-token.ts

@@ -0,0 +1,8 @@
+import type { MetadataReader } from "#/metadata/metadata-types";
+import { token } from "#/token";
+import type { Token } from "#/token";
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export const MetadataReaderToken: Token<MetadataReader> = token<MetadataReader>("MetadataReader");

package/src/metadata/metadata-types.ts

@@ -0,0 +1,51 @@
+import type { InjectionDescriptor } from "#/decorators/inject";
+import type { Token } from "#/token";
+import type { Constructor } from "#/types";
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface ParamMetadata {
+  readonly index: number;
+  readonly token: Token<unknown> | Constructor;
+  readonly optional: boolean;
+  readonly multi: boolean;
+  readonly name?: string;
+  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
+}
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface ConstructorMetadata {
+  readonly params: ReadonlyArray<ParamMetadata>;
+}
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface LifecycleMetadata {
+  readonly postConstruct: ReadonlyArray<string>;
+  readonly preDestroy: ReadonlyArray<string>;
+}
+
+/**
+ * Mutable buckets used while aggregating decorator metadata (same keys as {@link LifecycleMetadata}).
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface MutableLifecycleMetadata {
+  postConstruct: Array<string>;
+  preDestroy: Array<string>;
+}
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface MetadataReader {
+  getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined;
+  getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined;
+  getAccessorMetadata?(
+    target: Constructor,
+  ): ReadonlyArray<{ readonly key: string | symbol; readonly descriptor: InjectionDescriptor }> | undefined;
+}

package/src/metadata/symbol-metadata-reader.ts

@@ -0,0 +1,45 @@
+import type { InjectionDescriptor } from "#/decorators/inject";
+import { INJECT_ACCESSOR_KEY, INJECTABLE_KEY, LIFECYCLE_KEY, METADATA_SYMBOL } from "#/metadata/metadata-keys";
+import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#/metadata/metadata-types";
+import type { Constructor } from "#/types";
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export class SymbolMetadataReader implements MetadataReader {
+  private _getMetadataRecord(target: Constructor, key: string | symbol): Record<string | symbol, unknown> | undefined {
+    const descriptor = Object.getOwnPropertyDescriptor(target, METADATA_SYMBOL);
+    if (descriptor === undefined) {
+      return undefined;
+    }
+    const record = descriptor.value as Record<string | symbol, unknown> | null | undefined;
+    if (!record || typeof record !== "object" || !Object.hasOwn(record, key)) {
+      return undefined;
+    }
+    return record;
+  }
+
+  getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined {
+    const record = this._getMetadataRecord(target, INJECTABLE_KEY);
+    return record?.[INJECTABLE_KEY] as ConstructorMetadata | undefined;
+  }
+
+  getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined {
+    const record = this._getMetadataRecord(target, LIFECYCLE_KEY);
+    return record?.[LIFECYCLE_KEY] as LifecycleMetadata | undefined;
+  }
+
+  getAccessorMetadata(
+    target: Constructor,
+  ): Array<{ key: string | symbol; descriptor: InjectionDescriptor }> | undefined {
+    const record = this._getMetadataRecord(target, INJECT_ACCESSOR_KEY);
+    return record?.[INJECT_ACCESSOR_KEY] as
+      | Array<{ key: string | symbol; descriptor: InjectionDescriptor }>
+      | undefined;
+  }
+}
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export const defaultMetadataReader = new SymbolMetadataReader();

package/src/module.ts

@@ -0,0 +1,93 @@
+import type { BindToBuilder } from "#/binding";
+import type { Token } from "#/token";
+import type { Constructor } from "#/types";
+
+// ── Branded types (runtime symbols for branding) ─────────────────────────────
+
+const SYNC_MODULE_BRAND: unique symbol = Symbol("di:sync-module");
+const ASYNC_MODULE_BRAND: unique symbol = Symbol("di:async-module");
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface SyncModule {
+  readonly name: string;
+  readonly [SYNC_MODULE_BRAND]: true;
+  readonly _setup: (builder: ModuleBuilder) => void;
+}
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface AsyncModule {
+  readonly name: string;
+  readonly [ASYNC_MODULE_BRAND]: true;
+  readonly _setup: (builder: AsyncModuleBuilder) => Promise<void>;
+}
+
+// ── Builder interfaces ────────────────────────────────────────────────────────
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface ModuleBuilder {
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  import(...modules: Array<SyncModule>): void;
+}
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export interface AsyncModuleBuilder {
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  import(...modules: Array<SyncModule | AsyncModule>): void;
+}
+
+// ── Static factories ──────────────────────────────────────────────────────────
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export const SyncModule = {
+  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule {
+    return {
+      name,
+      [SYNC_MODULE_BRAND]: true as const,
+      _setup: setup,
+    } as SyncModule;
+  },
+};
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export const AsyncModule = {
+  create(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule {
+    return {
+      name,
+      [ASYNC_MODULE_BRAND]: true as const,
+      _setup: setup,
+    } as AsyncModule;
+  },
+};
+
+// ── Module — unified API ──────────────────────────────────────────────────────
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export const Module = {
+  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule {
+    return SyncModule.create(name, setup);
+  },
+  createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule {
+    return AsyncModule.create(name, setup);
+  },
+};
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export function isSyncModule(module: SyncModule | AsyncModule): module is SyncModule {
+  return (module as SyncModule)[SYNC_MODULE_BRAND];
+}

package/src/registry.ts

@@ -0,0 +1,232 @@
+import type { Binding } from "#/binding";
+import { bindingSlotEquals, bindingSlotToString } from "#/binding";
+import type { Token } from "#/token";
+import type { BindingIdentifier, Constructor, DependencyKey } from "#/types";
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export class BindingRegistry {
+  // Map from token key -> array of bindings (order matters for last-wins)
+  private readonly _bindings = new Map<DependencyKey, Array<Binding>>();
+  // Fast lookup by binding ID
+  private readonly _byId = new Map<BindingIdentifier, Binding>();
+  // Fast lookup for slot { name, tags: [] }
+  private readonly _simpleNamed = new Map<DependencyKey, Map<string, Binding>>();
+  // Fast path for one default slot binding with no predicate
+  private readonly _fastDefault = new Map<DependencyKey, Binding>();
+  // Fast lookup for slot { name: undefined, tags: [[key, value]] } with no predicate
+  private readonly _simpleTagged = new Map<DependencyKey, Map<string, Map<unknown, Binding>>>();
+
+  /** Add or replace binding using slot-aware last-wins. */
+  add(binding: Binding): void {
+    const key = binding.token as DependencyKey;
+    // ✓ TS6.0: Map.getOrInsert (ES2025) replaces the manual get+check+set upsert
+    const bindingsForToken = this._bindings.getOrInsert(key, []);
+
+    // Only apply last-wins for slot-based bindings (not predicate-only)
+    if (!this._isPurePredicateBinding(binding)) {
+      const existingIndex = bindingsForToken.findIndex(
+        (candidate) => !this._isPurePredicateBinding(candidate) && bindingSlotEquals(candidate.slot, binding.slot),
+      );
+      if (existingIndex !== -1) {
+        const replacedBinding = bindingsForToken[existingIndex]!;
+        this._byId.delete(replacedBinding.id);
+        bindingsForToken.splice(existingIndex, 1);
+      }
+    }
+
+    bindingsForToken.push(binding);
+    this._byId.set(binding.id, binding);
+    this._indexSimpleNamedBinding(key, binding);
+    this._indexSimpleTaggedBinding(key, binding);
+    this._refreshFastDefaultForToken(key);
+  }
+
+  /** Remove all bindings for a token. Returns removed bindings. */
+  removeByToken(token: Token<unknown> | Constructor): Array<Binding> {
+    const key = token as DependencyKey;
+    const bindingsForToken = this._bindings.get(key) ?? [];
+    this._bindings.delete(key);
+    this._simpleNamed.delete(key);
+    this._simpleTagged.delete(key);
+    this._fastDefault.delete(key);
+    for (const binding of bindingsForToken) {
+      this._byId.delete(binding.id);
+    }
+    return bindingsForToken;
+  }
+
+  /** Remove a specific binding by ID. Returns the removed binding or undefined. */
+  removeById(id: BindingIdentifier): Binding | undefined {
+    const binding = this._byId.get(id);
+    if (binding === undefined) {
+      return undefined;
+    }
+    this._byId.delete(id);
+    const key = binding.token as DependencyKey;
+    const bindingsForToken = this._bindings.get(key);
+    if (bindingsForToken !== undefined) {
+      const bindingIndex = bindingsForToken.findIndex((candidate) => candidate.id === id);
+      if (bindingIndex !== -1) {
+        bindingsForToken.splice(bindingIndex, 1);
+      }
+      this._deindexSimpleNamedBinding(key, binding);
+      this._deindexSimpleTaggedBinding(key, binding);
+      if (bindingsForToken.length === 0) {
+        this._bindings.delete(key);
+        this._simpleNamed.delete(key);
+        this._simpleTagged.delete(key);
+        this._fastDefault.delete(key);
+      } else {
+        this._refreshFastDefaultForToken(key);
+      }
+    }
+    return binding;
+  }
+
+  /** Get all bindings for a token. */
+  getAll(token: Token<unknown> | Constructor): ReadonlyArray<Binding> {
+    return this._bindings.get(token as DependencyKey) ?? [];
+  }
+
+  /** Get binding by ID. */
+  getById(id: BindingIdentifier): Binding | undefined {
+    return this._byId.get(id);
+  }
+
+  /** Check if any binding exists for token. */
+  has(token: Token<unknown> | Constructor): boolean {
+    const key = token as DependencyKey;
+    const list = this._bindings.get(key);
+    return list !== undefined && list.length > 0;
+  }
+
+  /** All bindings in the registry. */
+  allBindings(): ReadonlyArray<Binding> {
+    const allBindings: Array<Binding> = [];
+    for (const bindingsForToken of this._bindings.values()) {
+      allBindings.push(...bindingsForToken);
+    }
+    return allBindings;
+  }
+
+  /** Remove all bindings. Returns all removed. */
+  clear(): ReadonlyArray<Binding> {
+    const all = this.allBindings();
+    this._bindings.clear();
+    this._byId.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);
+  }
+
+  getSimpleTagged(token: Token<unknown> | Constructor, tagKey: string, tagValue: unknown): Binding | undefined {
+    return this._simpleTagged
+      .get(token as DependencyKey)
+      ?.get(tagKey)
+      ?.get(tagValue);
+  }
+
+  getFastDefault(token: Token<unknown> | Constructor): Binding | undefined {
+    return this._fastDefault.get(token as DependencyKey);
+  }
+
+  /** Summarize available slot strings for a token (for error messages). */
+  availableSlotStrings(token: Token<unknown> | Constructor): Array<string> {
+    const bindingsForToken = this._bindings.get(token as DependencyKey) ?? [];
+    return bindingsForToken.map((binding) => bindingSlotToString(binding.slot));
+  }
+
+  private _indexSimpleTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
+    const slot = binding.slot;
+    if (slot.name !== undefined || slot.tags.length !== 1 || binding.predicate !== undefined) {
+      return;
+    }
+    const [tagKey, tagValue] = slot.tags[0]!;
+    const byTagKey = this._simpleTagged.getOrInsert(tokenKey, new Map<string, Map<unknown, Binding>>());
+    const byTagValue = byTagKey.getOrInsert(tagKey, new Map<unknown, Binding>());
+    byTagValue.set(tagValue, binding);
+  }
+
+  private _deindexSimpleTaggedBinding(tokenKey: DependencyKey, binding: Binding): void {
+    const slot = binding.slot;
+    if (slot.name !== undefined || slot.tags.length !== 1 || binding.predicate !== undefined) {
+      return;
+    }
+    const [tagKey, tagValue] = slot.tags[0]!;
+    const byTagKey = this._simpleTagged.get(tokenKey);
+    if (byTagKey === undefined) {
+      return;
+    }
+    const byTagValue = byTagKey.get(tagKey);
+    if (byTagValue === undefined) {
+      return;
+    }
+    const current = byTagValue.get(tagValue);
+    if (current?.id === binding.id) {
+      byTagValue.delete(tagValue);
+      if (byTagValue.size === 0) {
+        byTagKey.delete(tagKey);
+        if (byTagKey.size === 0) {
+          this._simpleTagged.delete(tokenKey);
+        }
+      }
+    }
+  }
+
+  private _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;
+  }
+
+  private _indexSimpleNamedBinding(tokenKey: DependencyKey, binding: Binding): void {
+    const slot = binding.slot;
+    if (slot.name === undefined || slot.tags.length > 0) {
+      return;
+    }
+    const bindingsByName = this._simpleNamed.getOrInsert(tokenKey, new Map<string, Binding>());
+    bindingsByName.set(slot.name, binding);
+  }
+
+  private _deindexSimpleNamedBinding(tokenKey: DependencyKey, binding: Binding): void {
+    const slot = binding.slot;
+    if (slot.name === undefined || slot.tags.length > 0) {
+      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.size === 0) {
+        this._simpleNamed.delete(tokenKey);
+      }
+    }
+  }
+
+  private _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);
+      return;
+    }
+    this._fastDefault.set(tokenKey, onlyBinding);
+  }
+}