@fluojs/di 1.0.0-beta.1

package/dist/container.js

@@ -0,0 +1,697 @@
+import { InvariantError, formatTokenName } from '@fluojs/core';
+import { getClassDiMetadata } from '@fluojs/core/internal';
+import { CircularDependencyError, ContainerResolutionError, DuplicateProviderError, InvalidProviderError, RequestScopeResolutionError, ScopeMismatchError } from './errors.js';
+import { Scope, isForwardRef, isOptionalToken } from './types.js';
+function isClassConstructor(value) {
+  return typeof value === 'function';
+}
+function isValueProvider(value) {
+  return typeof value === 'object' && value !== null && 'useValue' in value;
+}
+function isFactoryProvider(value) {
+  return typeof value === 'object' && value !== null && 'useFactory' in value;
+}
+function isClassProvider(value) {
+  return typeof value === 'object' && value !== null && 'useClass' in value;
+}
+function isExistingProvider(value) {
+  return typeof value === 'object' && value !== null && 'useExisting' in value;
+}
+function normalizeInjectToken(token) {
+  if (token == null) {
+    throw new InvalidProviderError('Inject token must not be null or undefined. Check that all tokens in @Inject(...) are defined at the point of decoration (forward-reference cycles require forwardRef()).');
+  }
+  return token;
+}
+function normalizeProvider(provider) {
+  if (isClassConstructor(provider)) {
+    const metadata = getClassDiMetadata(provider);
+    return {
+      inject: (metadata?.inject ?? []).map(normalizeInjectToken),
+      provide: provider,
+      scope: metadata?.scope ?? Scope.DEFAULT,
+      type: 'class',
+      useClass: provider
+    };
+  }
+  if (isValueProvider(provider)) {
+    return {
+      inject: [],
+      multi: provider.multi,
+      provide: provider.provide,
+      scope: Scope.DEFAULT,
+      type: 'value',
+      useValue: provider.useValue
+    };
+  }
+  if (isFactoryProvider(provider)) {
+    const metadata = provider.resolverClass ? getClassDiMetadata(provider.resolverClass) : undefined;
+    return {
+      inject: (provider.inject ?? []).map(normalizeInjectToken),
+      multi: provider.multi,
+      provide: provider.provide,
+      scope: provider.scope ?? metadata?.scope ?? Scope.DEFAULT,
+      type: 'factory',
+      useFactory: provider.useFactory
+    };
+  }
+  if (isClassProvider(provider)) {
+    const metadata = getClassDiMetadata(provider.useClass);
+    return {
+      inject: (provider.inject ?? metadata?.inject ?? []).map(normalizeInjectToken),
+      multi: provider.multi,
+      provide: provider.provide,
+      scope: provider.scope ?? metadata?.scope ?? Scope.DEFAULT,
+      type: 'class',
+      useClass: provider.useClass
+    };
+  }
+  if (isExistingProvider(provider)) {
+    return {
+      inject: [],
+      provide: provider.provide,
+      scope: Scope.DEFAULT,
+      type: 'existing',
+      useExisting: provider.useExisting
+    };
+  }
+  throw new InvalidProviderError('Unsupported provider type.');
+}
+
+/**
+ * Scope-aware dependency injection container for Fluo providers.
+ */
+export class Container {
+  registrations = new Map();
+  multiRegistrations = new Map();
+  multiOverriddenTokens = new Set();
+  requestCache = new Map();
+  multiRequestCache = new Map();
+  multiSingletonCache = new Map();
+  staleDisposalTasks = new Set();
+  staleDisposalErrors = [];
+  singletonCache;
+  childScopes = new Set();
+  disposePromise;
+  disposed = false;
+  constructor(parent, requestScopeEnabled = false, singletonCache) {
+    this.parent = parent;
+    this.requestScopeEnabled = requestScopeEnabled;
+    this.singletonCache = singletonCache ?? new Map();
+  }
+
+  /**
+   * Registers providers in the current container scope.
+   *
+   * @param providers Provider definitions to register in this container.
+   * @returns The same container instance for fluent registration chains.
+   * @throws {ContainerResolutionError} When called after the container was disposed.
+   * @throws {ScopeMismatchError} When registering singleton providers directly on a request scope.
+   * @throws {DuplicateProviderError} When registration conflicts with existing single/multi mappings.
+   * @throws {InvalidProviderError} When a provider definition is structurally invalid.
+   */
+  register(...providers) {
+    if (this.disposed) {
+      throw new ContainerResolutionError('Container has been disposed and can no longer register providers.', {
+        hint: 'Ensure providers are registered before calling container.dispose().'
+      });
+    }
+    for (const provider of providers) {
+      const normalized = normalizeProvider(provider);
+      if (this.requestScopeEnabled && normalized.scope === Scope.DEFAULT && normalized.multi !== true) {
+        throw new ScopeMismatchError(`Singleton provider ${String(normalized.provide)} cannot be registered on a request-scope container.`, {
+          token: normalized.provide,
+          scope: 'singleton',
+          hint: 'Register it on the root container before creating the request scope, or use container.override() within the request scope instead.'
+        });
+      }
+      this.assertNoRegistrationConflict(normalized.provide, normalized.multi === true);
+      if (normalized.multi) {
+        const existing = this.multiRegistrations.get(normalized.provide);
+        if (existing) {
+          existing.push(normalized);
+          continue;
+        }
+        this.multiRegistrations.set(normalized.provide, [normalized]);
+      } else {
+        this.registrations.set(normalized.provide, normalized);
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Override one or more already-registered providers.
+   *
+   * **Multi-provider destructive replacement**: when the incoming provider has `multi: true`,
+   * the entire existing multi-registration array for that token is deleted before the new entry
+   * is added. There is intentionally no way to replace a single entry within a multi-provider
+   * set — the whole set is replaced. If you need to preserve other entries, re-register them
+   * together with the replacement in one `override()` call.
+   *
+   * @param providers Provider definitions that should replace existing registrations for each token.
+   * @returns The same container instance for fluent override chains.
+   * @throws {ContainerResolutionError} When called after the container was disposed.
+   * @throws {InvalidProviderError} When a provider definition is structurally invalid.
+   */
+  override(...providers) {
+    if (this.disposed) {
+      throw new ContainerResolutionError('Container has been disposed and can no longer override providers.', {
+        hint: 'Ensure overrides are applied before calling container.dispose().'
+      });
+    }
+    for (const provider of providers) {
+      const normalized = normalizeProvider(provider);
+      const existing = this.lookupProvider(normalized.provide);
+      this.registrations.delete(normalized.provide);
+      this.multiRegistrations.delete(normalized.provide);
+      this.invalidateCachedEntry(normalized.provide, existing?.scope ?? normalized.scope);
+      if (normalized.multi) {
+        this.multiRegistrations.set(normalized.provide, [normalized]);
+        this.multiOverriddenTokens.add(normalized.provide);
+        continue;
+      }
+      this.multiOverriddenTokens.add(normalized.provide);
+      this.registrations.set(normalized.provide, normalized);
+    }
+    return this;
+  }
+
+  /**
+   * Returns whether a token is registered in this scope chain.
+   *
+   * @param token Token to check across this container and its ancestors.
+   * @returns `true` when a single or multi provider exists for the token.
+   */
+  has(token) {
+    return this.lookupProvider(token) !== undefined || this.hasMulti(token);
+  }
+
+  /**
+   * Creates a child request-scope container that shares root singleton cache.
+   *
+   * @returns A request-scope child container bound to this container hierarchy.
+   * @throws {ContainerResolutionError} When called after the container was disposed.
+   */
+  createRequestScope() {
+    if (this.disposed) {
+      throw new ContainerResolutionError('Container has been disposed and can no longer create request scopes.', {
+        hint: 'Create request scopes before calling container.dispose().'
+      });
+    }
+    const child = new Container(this, true, this.root().singletonCache);
+    this.root().childScopes.add(child);
+    return child;
+  }
+
+  /**
+   * Resolves a token to an instance using scope-aware caching rules.
+   *
+   * @param token Token to resolve.
+   * @returns A promise that resolves to the token instance (or multi-provider instance array).
+   * @throws {ContainerResolutionError} When called after disposal or when no provider is registered.
+   * @throws {RequestScopeResolutionError} When request-scoped providers are resolved from root scope.
+   * @throws {ScopeMismatchError} When singleton providers depend on request-scoped providers.
+   * @throws {CircularDependencyError} When provider dependency resolution detects a cycle.
+   */
+  async resolve(token) {
+    if (this.disposed) {
+      throw new ContainerResolutionError('Container has been disposed and can no longer resolve providers.', {
+        token,
+        hint: 'Ensure all resolves complete before calling container.dispose().'
+      });
+    }
+    return this.resolveWithChain(token, [], new Set());
+  }
+
+  /**
+   * Disposes cached instances and nested request scopes.
+   *
+   * @returns A promise that settles after all cached disposable instances are torn down.
+   * @throws {Error} Propagates one or more disposal errors (`AggregateError` when multiple failures occur).
+   */
+  async dispose() {
+    if (this.disposePromise) {
+      await this.disposePromise;
+      return;
+    }
+    this.disposed = true;
+    this.disposePromise = this.disposeAll();
+    try {
+      await this.disposePromise;
+    } catch (error) {
+      this.disposePromise = undefined;
+      throw error;
+    }
+  }
+  async disposeAll() {
+    try {
+      // Dispose all live request-scope children first (root only)
+      if (!this.parent && this.childScopes.size > 0) {
+        await Promise.all(Array.from(this.childScopes).map(child => child.dispose()));
+        this.childScopes.clear();
+      }
+      await this.disposeCache(this.disposalCacheEntries());
+    } finally {
+      if (this.parent) {
+        this.root().childScopes.delete(this);
+      }
+    }
+  }
+  hasMulti(token) {
+    if (this.multiRegistrations.has(token)) return true;
+    return this.parent?.hasMulti(token) ?? false;
+  }
+  assertNoRegistrationConflict(token, multi) {
+    if (multi) {
+      if (this.registrations.has(token)) {
+        throw new DuplicateProviderError(token);
+      }
+      if (this.hasAncestorSingleRegistration(token)) {
+        throw new DuplicateProviderError(token);
+      }
+      return;
+    }
+    if (this.registrations.has(token) || this.multiRegistrations.has(token)) {
+      throw new DuplicateProviderError(token);
+    }
+    if (this.hasAncestorMultiRegistration(token)) {
+      throw new DuplicateProviderError(token);
+    }
+  }
+  hasAncestorSingleRegistration(token) {
+    return this.parent?.hasSingleRegistration(token) ?? false;
+  }
+  hasSingleRegistration(token) {
+    if (this.registrations.has(token)) return true;
+    return this.parent?.hasSingleRegistration(token) ?? false;
+  }
+  hasAncestorMultiRegistration(token) {
+    return this.parent?.hasMultiRegistration(token) ?? false;
+  }
+  hasMultiRegistration(token) {
+    if (this.multiRegistrations.has(token)) return true;
+    return this.parent?.hasMultiRegistration(token) ?? false;
+  }
+  collectMultiProviders(token) {
+    const local = this.multiRegistrations.get(token);
+    if (this.multiOverriddenTokens.has(token)) {
+      return local ?? [];
+    }
+    const fromParent = this.parent ? this.parent.collectMultiProviders(token) : [];
+    if (local) {
+      return [...fromParent, ...local];
+    }
+    return fromParent;
+  }
+  async resolveWithChain(token, chain, activeTokens, allowForwardRef = false) {
+    const cachedForwardRef = this.resolveForwardRefCircularDependency(token, chain, activeTokens, allowForwardRef);
+    if (cachedForwardRef !== undefined) {
+      return await cachedForwardRef;
+    }
+    return await this.resolveFromRegisteredProviders(token, chain, activeTokens);
+  }
+  async resolveFromRegisteredProviders(token, chain, activeTokens) {
+    const localSingleProvider = this.registrations.get(token);
+    if (!localSingleProvider) {
+      const multiProviders = this.collectMultiProviders(token);
+      if (multiProviders.length > 0) {
+        const instances = await this.withTokenInChain(token, chain, activeTokens, async (c, at) => this.resolveMultiProviderInstances(multiProviders, c, at));
+        return instances;
+      }
+    }
+    const provider = this.requireProvider(token);
+    const existingTarget = this.resolveExistingProviderTarget(provider);
+    if (existingTarget !== undefined) {
+      return await this.resolveAliasTarget(existingTarget, token, chain, activeTokens);
+    }
+    if (provider.scope === 'transient') {
+      return await this.withTokenInChain(token, chain, activeTokens, async (c, at) => this.instantiate(provider, c, at));
+    }
+    return await this.withTokenInChain(token, chain, activeTokens, async (c, at) => this.resolveScopedOrSingletonInstance(provider, c, at));
+  }
+  requireProvider(token) {
+    const provider = this.lookupProvider(token);
+    if (!provider) {
+      throw new ContainerResolutionError(`No provider registered for token ${formatTokenName(token)}.`, {
+        token,
+        hint: 'Ensure the provider is registered in a module\'s providers array, or that the module exporting it is imported by the consuming module.'
+      });
+    }
+    return provider;
+  }
+  async resolveAliasTarget(existingTarget, token, chain, activeTokens) {
+    return await this.withTokenInChain(token, chain, activeTokens, async (c, at) => this.resolveWithChain(existingTarget, c, at));
+  }
+  resolveForwardRefCircularDependency(token, chain, activeTokens, allowForwardRef) {
+    if (!activeTokens.has(token)) {
+      return undefined;
+    }
+    if (allowForwardRef) {
+      throw new CircularDependencyError([...chain, token], 'forwardRef only defers token lookup and does not resolve true circular construction.');
+    }
+    throw new CircularDependencyError([...chain, token]);
+  }
+  async resolveMultiProviderInstances(providers, chain, activeTokens) {
+    const instances = [];
+    for (const provider of providers) {
+      instances.push(await this.resolveMultiProviderInstance(provider, chain, activeTokens));
+    }
+    return instances;
+  }
+  async resolveMultiProviderInstance(provider, chain, activeTokens) {
+    if (provider.type === 'existing') {
+      return await this.resolveWithChain(provider.useExisting, chain, activeTokens);
+    }
+    if (provider.scope === 'transient') {
+      return await this.instantiate(provider, chain, activeTokens);
+    }
+    if (this.shouldResolveMultiProviderFromRoot(provider)) {
+      return await this.root().resolveMultiProviderInstance(provider, chain, activeTokens);
+    }
+    const cache = this.multiCacheFor(provider);
+    if (!cache.has(provider)) {
+      const promise = this.instantiate(provider, chain, activeTokens);
+      cache.set(provider, promise);
+      promise.catch(() => cache.delete(provider));
+    }
+    return await cache.get(provider);
+  }
+  resolveExistingProviderTarget(provider) {
+    if (provider.type !== 'existing') {
+      return undefined;
+    }
+    return provider.useExisting;
+  }
+  async resolveScopedOrSingletonInstance(provider, chain, activeTokens) {
+    if (this.shouldResolveFromRoot(provider)) {
+      return await this.root().resolveScopedOrSingletonInstance(provider, chain, activeTokens);
+    }
+    const cache = this.cacheFor(provider);
+    if (!cache.has(provider.provide)) {
+      const promise = this.instantiate(provider, chain, activeTokens).catch(error => {
+        cache.delete(provider.provide);
+        throw error;
+      });
+      cache.set(provider.provide, promise);
+    }
+    return cache.get(provider.provide);
+  }
+  shouldResolveFromRoot(provider) {
+    return provider.scope === Scope.DEFAULT && this.requestScopeEnabled && !this.registrations.has(provider.provide);
+  }
+  shouldResolveMultiProviderFromRoot(provider) {
+    return provider.scope === Scope.DEFAULT && this.requestScopeEnabled && !this.hasLocalMultiProvider(provider);
+  }
+  async resolveDepToken(depEntry, chain, activeTokens) {
+    if (isOptionalToken(depEntry)) {
+      const innerToken = depEntry.token;
+      if (!this.has(innerToken)) {
+        return undefined;
+      }
+      return this.resolveWithChain(innerToken, chain, activeTokens);
+    }
+    if (isForwardRef(depEntry)) {
+      const resolvedToken = depEntry.forwardRef();
+      return this.resolveWithChain(resolvedToken, chain, activeTokens, /* allowForwardRef */true);
+    }
+    return this.resolveWithChain(depEntry, chain, activeTokens);
+  }
+  async withTokenInChain(token, chain, activeTokens, run) {
+    chain.push(token);
+    activeTokens.add(token);
+    try {
+      return await run(chain, activeTokens);
+    } finally {
+      activeTokens.delete(token);
+      chain.pop();
+    }
+  }
+  root() {
+    return this.parent ? this.parent.root() : this;
+  }
+  lookupProvider(token) {
+    const local = this.registrations.get(token);
+    if (local) {
+      return local;
+    }
+    return this.parent?.lookupProvider(token);
+  }
+
+  /**
+   * Resolve the cache map that should hold the instance for `provider`.
+   *
+   * **Singleton-in-request-scope**: if a provider with `scope: 'singleton'` (the default) is
+   * registered directly on a request-scope child container (rather than the root), it is cached
+   * in the child's `requestCache` instead of the root's `singletonCache`. This means it behaves
+   * as request-scoped despite the singleton scope annotation. This is intentional — it allows
+   * test and override scenarios to inject short-lived values without polluting the global cache
+   * — but the divergence from the declared scope is a known footgun for consumers who
+   * inadvertently register singletons on child containers.
+   */
+  cacheFor(provider) {
+    if (provider.scope === Scope.DEFAULT) {
+      if (this.requestScopeEnabled && this.registrations.has(provider.provide)) {
+        return this.requestCache;
+      }
+      return this.root().singletonCache;
+    }
+    if (!this.requestScopeEnabled) {
+      throw new RequestScopeResolutionError(`Request-scoped provider ${formatTokenName(provider.provide)} cannot be resolved outside request scope.`, {
+        token: provider.provide,
+        scope: 'request',
+        hint: 'Wrap the resolve call inside a request-scoped child container created via container.createRequestScope().'
+      });
+    }
+    return this.requestCache;
+  }
+  multiCacheFor(provider) {
+    if (provider.scope === Scope.DEFAULT) {
+      if (this.requestScopeEnabled && this.hasLocalMultiProvider(provider)) {
+        return this.multiRequestCache;
+      }
+      return this.root().multiSingletonCache;
+    }
+    if (!this.requestScopeEnabled) {
+      throw new RequestScopeResolutionError(`Request-scoped provider ${formatTokenName(provider.provide)} cannot be resolved outside request scope.`, {
+        token: provider.provide,
+        scope: 'request',
+        hint: 'Wrap the resolve call inside a request-scoped child container created via container.createRequestScope().'
+      });
+    }
+    return this.multiRequestCache;
+  }
+  hasLocalMultiProvider(provider) {
+    return this.multiRegistrations.get(provider.provide)?.includes(provider) ?? false;
+  }
+  disposalCacheEntries() {
+    if (this.parent) {
+      const entries = Array.from(this.requestCache.entries());
+      for (const [provider, promise] of this.multiRequestCache.entries()) {
+        entries.push([provider, promise]);
+      }
+      return entries;
+    }
+    const entries = Array.from(this.singletonCache.entries());
+    for (const [provider, promise] of this.multiSingletonCache.entries()) {
+      entries.push([provider, promise]);
+    }
+    return entries;
+  }
+  async disposeCache(entries) {
+    await this.waitForStaleDisposalTasks();
+    const {
+      disposables,
+      errors
+    } = await this.collectDisposableInstances(entries);
+    errors.push(...this.staleDisposalErrors.splice(0, this.staleDisposalErrors.length));
+    errors.push(...(await this.disposeInstancesInReverseOrder(disposables)));
+    this.clearDisposalCaches();
+    this.throwDisposalErrors(errors);
+  }
+  async collectDisposableInstances(entries) {
+    const disposables = [];
+    const seenInstances = new Set();
+    const errors = [];
+    const settled = await Promise.allSettled(entries.map(([, p]) => p));
+    for (const result of settled) {
+      if (result.status === 'rejected') {
+        errors.push(result.reason);
+        continue;
+      }
+      const instance = result.value;
+      if (this.isDisposable(instance) && !seenInstances.has(instance)) {
+        seenInstances.add(instance);
+        disposables.push(instance);
+      }
+    }
+    return {
+      disposables,
+      errors
+    };
+  }
+  async disposeInstancesInReverseOrder(disposables) {
+    const errors = [];
+    for (const instance of [...disposables].reverse()) {
+      try {
+        await instance.onDestroy();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    return errors;
+  }
+  clearDisposalCaches() {
+    if (this.parent) {
+      this.requestCache.clear();
+      this.multiRequestCache.clear();
+      return;
+    }
+    this.singletonCache.clear();
+    this.multiSingletonCache.clear();
+  }
+  async waitForStaleDisposalTasks() {
+    while (this.staleDisposalTasks.size > 0) {
+      await Promise.all(Array.from(this.staleDisposalTasks));
+    }
+  }
+  scheduleStaleDisposal(instancePromise) {
+    let task;
+    task = (async () => {
+      try {
+        const instance = await instancePromise;
+        if (this.isDisposable(instance)) {
+          await instance.onDestroy();
+        }
+      } catch (error) {
+        this.staleDisposalErrors.push(error);
+      }
+    })().finally(() => {
+      this.staleDisposalTasks.delete(task);
+    });
+    this.staleDisposalTasks.add(task);
+  }
+  throwDisposalErrors(errors) {
+    if (errors.length === 1) {
+      throw errors[0];
+    }
+    if (errors.length > 1) {
+      throw new AggregateError(errors, 'Container disposal failed for one or more providers.');
+    }
+  }
+  isDisposable(value) {
+    return typeof value === 'object' && value !== null && 'onDestroy' in value && typeof value.onDestroy === 'function';
+  }
+  async instantiate(provider, chain, activeTokens) {
+    this.assertSingletonDependencyScopes(provider);
+    switch (provider.type) {
+      case 'value':
+        return provider.useValue;
+      case 'existing':
+        return await this.resolveWithChain(provider.useExisting, [], new Set());
+      case 'factory':
+        {
+          if (!provider.useFactory) {
+            throw new InvariantError('Factory provider is missing useFactory.');
+          }
+          const deps = await this.resolveProviderDeps(provider, chain, activeTokens);
+          return provider.useFactory(...deps);
+        }
+      case 'class':
+        {
+          if (!provider.useClass) {
+            throw new InvariantError('Class provider is missing useClass.');
+          }
+          const deps = await this.resolveProviderDeps(provider, chain, activeTokens);
+          return new provider.useClass(...deps);
+        }
+      default:
+        throw new InvariantError('Unknown provider type.');
+    }
+  }
+  assertSingletonDependencyScopes(provider) {
+    if (provider.scope !== Scope.DEFAULT) {
+      return;
+    }
+    for (const depEntry of provider.inject) {
+      const depToken = this.resolveProviderDependencyToken(depEntry);
+      const effectiveProvider = this.resolveEffectiveProvider(depToken);
+      if (effectiveProvider?.scope === 'request') {
+        throw new ScopeMismatchError(`Singleton provider ${formatTokenName(provider.provide)} depends on request-scoped provider ${formatTokenName(depToken)}.`, {
+          token: provider.provide,
+          scope: 'singleton',
+          hint: `Singleton providers cannot depend on request-scoped providers. Either change ${formatTokenName(depToken)} to singleton/transient scope, or change ${formatTokenName(provider.provide)} to request scope.`
+        });
+      }
+    }
+  }
+  resolveEffectiveProvider(token, visited = new Set(), chain = []) {
+    let currentToken = token;
+    while (true) {
+      if (visited.has(currentToken)) {
+        throw new CircularDependencyError([...chain, currentToken]);
+      }
+      visited.add(currentToken);
+      const provider = this.lookupProvider(currentToken);
+      if (!provider) {
+        return undefined;
+      }
+      if (provider.type !== 'existing' || provider.useExisting === undefined) {
+        return provider;
+      }
+      chain.push(currentToken);
+      currentToken = provider.useExisting;
+    }
+  }
+  resolveProviderDependencyToken(depEntry) {
+    if (isForwardRef(depEntry)) {
+      return depEntry.forwardRef();
+    }
+    if (isOptionalToken(depEntry)) {
+      return depEntry.token;
+    }
+    return depEntry;
+  }
+  async resolveProviderDeps(provider, chain, activeTokens) {
+    const deps = new Array(provider.inject.length);
+    for (const [index, entry] of provider.inject.entries()) {
+      deps[index] = await this.resolveDepToken(entry, chain, activeTokens);
+    }
+    return deps;
+  }
+  invalidateCachedEntry(token, scope) {
+    if (this.requestCache.has(token)) {
+      const cached = this.requestCache.get(token);
+      if (cached) {
+        this.scheduleStaleDisposal(cached);
+      }
+      this.requestCache.delete(token);
+    }
+    if (!this.parent && scope === Scope.DEFAULT) {
+      const singletonCache = this.singletonCache;
+      if (singletonCache.has(token)) {
+        const cached = singletonCache.get(token);
+        if (cached) {
+          this.scheduleStaleDisposal(cached);
+        }
+        singletonCache.delete(token);
+      }
+    }
+    if (!this.parent) {
+      for (const [provider, cached] of this.multiSingletonCache.entries()) {
+        if (provider.provide !== token) {
+          continue;
+        }
+        this.scheduleStaleDisposal(cached);
+        this.multiSingletonCache.delete(provider);
+      }
+    }
+    for (const [provider, cached] of this.multiRequestCache.entries()) {
+      if (provider.provide !== token) {
+        continue;
+      }
+      this.scheduleStaleDisposal(cached);
+      this.multiRequestCache.delete(provider);
+    }
+  }
+}