@codefast/di 0.3.16-canary.3 → 0.4.0-canary.5

package/src/resolver.ts

@@ -1,21 +1,10 @@
-import type { ConstructorInvocation } from "#/constructor-type";
-import type {
-  BindingIdentifier,
-  BindingScope,
-  BindingTag,
-  ConstraintContext,
-  Constructor,
-  ResolutionFrame,
-  ResolveOptions,
-} from "#/types";
-import type { Token } from "#/token";
 import type { Binding, BindingSlot } from "#/binding";
-import type { BindingRegistry } from "#/registry";
-import type { ScopeManager } from "#/scope";
-import type { LifecycleManager } from "#/lifecycle";
-import type { ConstructorMetadata, MetadataReader } from "#/metadata/metadata-types";
-import type { InjectionDescriptor } from "#/decorators/inject";
+import { selectAllBindings, selectBinding } from "#/binding-select";
+import type { ConstructorInvocation } from "#/constructor-type";
 import type { Container } from "#/container";
+import type { InjectionDescriptor } from "#/decorators/inject";
+import type { ResolverCallbacks } from "#/environment";
+import { buildResolutionFrame, DefaultResolutionContext, runWithContainer } from "#/environment";
 import {
   AsyncResolutionError,
   CircularDependencyError,
@@ -25,11 +14,22 @@ import {
   NoMatchingBindingError,
   TokenNotBoundError,
 } from "#/errors";
-import { tokenName } from "#/token";
-import type { ResolverCallbacks } from "#/environment";
-import { buildResolutionFrame, DefaultResolutionContext, runWithContainer } from "#/environment";
+import type { LifecycleManager } from "#/lifecycle";
+import type { ConstructorMetadata, MetadataReader } from "#/metadata/metadata-types";
+import type { BindingRegistry } from "#/registry";
 import { injectionSlotToResolveOptions } from "#/resolve-options";
-import { selectAllBindings, selectBinding } from "#/binding-select";
+import type { ScopeManager } from "#/scope";
+import type { Token } from "#/token";
+import { tokenName } from "#/token";
+import type {
+  BindingIdentifier,
+  BindingScope,
+  BindingTag,
+  ConstraintContext,
+  Constructor,
+  ResolutionFrame,
+  ResolveOptions,
+} from "#/types";
 
 type BindingWithScope = Binding & { scope: BindingScope };
 const RESOLUTION_SET_KEY: unique symbol = Symbol("di:resolution-set");
@@ -111,10 +111,7 @@ export class DependencyResolver {
   private _deepAsyncActiveLevels = 0;
   private readonly _classHasPostConstruct = new WeakMap<Constructor, boolean>();
   private readonly _classNeedsActiveContainer = new WeakMap<Constructor, boolean>();
-  private readonly _classConstructorMetadata = new WeakMap<
-    Constructor,
-    ConstructorMetadata | null
-  >();
+  private readonly _classConstructorMetadata = new WeakMap<Constructor, ConstructorMetadata | null>();
   private readonly _activationNeedByBindingId = new Map<BindingIdentifier, boolean>();
   private _activationCacheVersion = -1;
 
@@ -144,20 +141,12 @@ export class DependencyResolver {
 
     if (hint?.name !== undefined && hint.tag === undefined && (hint.tags?.length ?? 0) === 0) {
       const namedBinding = this._registry.getSimpleNamed(token, hint.name);
-      if (
-        namedBinding !== undefined &&
-        this._matchesBindingFast(namedBinding, hint, resolutionPath, resolutionStack)
-      ) {
+      if (namedBinding !== undefined && this._matchesBindingFast(namedBinding, hint, resolutionPath, resolutionStack)) {
         return { binding: namedBinding, owner: this };
       }
     }
 
-    if (
-      hint !== undefined &&
-      hint.name === undefined &&
-      hint.tag === undefined &&
-      (hint.tags?.length ?? 0) === 1
-    ) {
+    if (hint !== undefined && hint.name === undefined && hint.tag === undefined && (hint.tags?.length ?? 0) === 1) {
       const [tagKey, tagValue] = hint.tags![0]!;
       const tagged = this._registry.getSimpleTagged(token, tagKey, tagValue);
       if (tagged !== undefined) {
@@ -169,8 +158,7 @@ export class DependencyResolver {
     if (bindings.length > 0) {
       if (bindings.length === 1) {
         const onlyBinding = bindings[0]!;
-        const isDefaultSlot =
-          onlyBinding.slot.name === undefined && onlyBinding.slot.tags.length === 0;
+        const isDefaultSlot = onlyBinding.slot.name === undefined && onlyBinding.slot.tags.length === 0;
         if (hint === undefined && isDefaultSlot && onlyBinding.predicate === undefined) {
           return { binding: onlyBinding, owner: this };
         }
@@ -239,8 +227,7 @@ export class DependencyResolver {
         scope === "transient" &&
         fastBinding.kind === "dynamic" &&
         fastBinding.onActivation === undefined &&
-        (this._lifecycle.activationVersion === 0 ||
-          !this._lifecycle.hasActivationHandlers(fastBinding.token))
+        (this._lifecycle.activationVersion === 0 || !this._lifecycle.hasActivationHandlers(fastBinding.token))
       ) {
         return this._resolveTransientDynamicSyncFromContext(
           fastBinding as Binding<Value> & { kind: "dynamic" },
@@ -259,12 +246,7 @@ export class DependencyResolver {
           return this._scope.getScoped<Value>(fastBinding.id);
         }
       }
-      return this._resolveBinding(
-        fastBinding as Binding<Value>,
-        undefined,
-        resolutionPath,
-        resolutionStack,
-      );
+      return this._resolveBinding(fastBinding as Binding<Value>, undefined, resolutionPath, resolutionStack);
     }
 
     return this.resolve(token, undefined, resolutionPath, resolutionStack);
@@ -281,11 +263,7 @@ export class DependencyResolver {
     if (found === undefined) {
       const ownBindings = this._registry.getAll(token);
       if (ownBindings.length > 0) {
-        throw new NoMatchingBindingError(
-          this._getTokenName(token),
-          hint ?? {},
-          this._getAvailableSlots(token),
-        );
+        throw new NoMatchingBindingError(this._getTokenName(token), hint ?? {}, this._getAvailableSlots(token));
       }
       throw new TokenNotBoundError(this._getTokenName(token));
     }
@@ -294,24 +272,14 @@ export class DependencyResolver {
 
     // Follow alias
     if (binding.kind === "alias") {
-      return this.resolve(
-        binding.target as Token<Value> | Constructor<Value>,
-        hint,
-        resolutionPath,
-        resolutionStack,
-      );
+      return this.resolve(binding.target as Token<Value> | Constructor<Value>, hint, resolutionPath, resolutionStack);
     }
 
     const scope = (binding as BindingWithScope).scope ?? "transient";
 
     // Singleton from a parent resolver: delegate so the parent caches it correctly
     if (scope === "singleton" && owner !== this) {
-      return owner._resolveBinding(
-        binding as Binding<Value>,
-        hint,
-        resolutionPath,
-        resolutionStack,
-      );
+      return owner._resolveBinding(binding as Binding<Value>, hint, resolutionPath, resolutionStack);
     }
 
     // Scoped/transient (or own singleton): resolve with this resolver's container/scope
@@ -361,11 +329,7 @@ export class DependencyResolver {
     }
 
     // Circular dependency detection
-    if (
-      resolutionSet !== undefined
-        ? resolutionSet.has(tokenDisplayName)
-        : resolutionPath.includes(tokenDisplayName)
-    ) {
+    if (resolutionSet !== undefined ? resolutionSet.has(tokenDisplayName) : resolutionPath.includes(tokenDisplayName)) {
       const cycle = [...resolutionPath, tokenDisplayName];
       throw new CircularDependencyError(cycle);
     }
@@ -375,11 +339,7 @@ export class DependencyResolver {
     resolutionStack.push(frame);
     const needsActivation = this._needsActivation(binding);
     if (!needsActivation && scope === "transient" && binding.kind === "dynamic") {
-      const resolutionCtx = this._acquireSyncResolutionContext(
-        resolutionPath,
-        resolutionStack,
-        hint,
-      );
+      const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, resolutionStack, hint);
       try {
         const dynamicResult = binding.factory(resolutionCtx);
         if (dynamicResult instanceof Promise) {
@@ -403,12 +363,7 @@ export class DependencyResolver {
         ? this._acquireSyncResolutionContext(resolutionPath, resolutionStack, hint)
         : undefined;
 
-      const instance = this._instantiateSync(
-        binding,
-        resolutionCtx,
-        resolutionPath,
-        resolutionStack,
-      );
+      const instance = this._instantiateSync(binding, resolutionCtx, resolutionPath, resolutionStack);
 
       const shouldActivate = this._refreshActivationCacheIfNeeded(binding, needsActivation);
       const activated = shouldActivate
@@ -501,78 +456,32 @@ export class DependencyResolver {
       const param = meta.params[0]!;
       const paramHint = injectionSlotToResolveOptions(param);
       if (param.multi) {
-        return [
-          this.resolveAll(
-            param.token as Token<unknown> | Constructor,
-            paramHint,
-            resolutionPath,
-            resolutionStack,
-          ),
-        ];
+        return [this.resolveAll(param.token, paramHint, resolutionPath, resolutionStack)];
       }
       if (param.optional) {
-        return [
-          this.resolveOptional(
-            param.token as Token<unknown> | Constructor,
-            paramHint,
-            resolutionPath,
-            resolutionStack,
-          ),
-        ];
+        return [this.resolveOptional(param.token, paramHint, resolutionPath, resolutionStack)];
       }
       if (paramHint === undefined) {
-        return [
-          this.resolveFromContext(
-            param.token as Token<unknown> | Constructor,
-            resolutionPath,
-            resolutionStack,
-          ),
-        ];
+        return [this.resolveFromContext(param.token, resolutionPath, resolutionStack)];
       }
-      return [
-        this.resolve(
-          param.token as Token<unknown> | Constructor,
-          paramHint,
-          resolutionPath,
-          resolutionStack,
-        ),
-      ];
+      return [this.resolve(param.token, paramHint, resolutionPath, resolutionStack)];
     }
     const deps = new Array<unknown>(meta.params.length);
     for (let index = 0; index < meta.params.length; index += 1) {
       const param = meta.params[index]!;
       const paramHint = injectionSlotToResolveOptions(param);
       if (param.multi) {
-        deps[index] = this.resolveAll(
-          param.token as Token<unknown> | Constructor,
-          paramHint,
-          resolutionPath,
-          resolutionStack,
-        );
+        deps[index] = this.resolveAll(param.token, paramHint, resolutionPath, resolutionStack);
         continue;
       }
       if (param.optional) {
-        deps[index] = this.resolveOptional(
-          param.token as Token<unknown> | Constructor,
-          paramHint,
-          resolutionPath,
-          resolutionStack,
-        );
+        deps[index] = this.resolveOptional(param.token, paramHint, resolutionPath, resolutionStack);
         continue;
       }
       deps[index] =
         paramHint === undefined
-          ? this.resolveFromContext(
-              param.token as Token<unknown> | Constructor,
-              resolutionPath,
-              resolutionStack,
-            )
-          : this.resolve(
-              param.token as Token<unknown> | Constructor,
-              paramHint,
-              resolutionPath,
-              resolutionStack,
-            );
+          ? this.resolveFromContext(param.token, resolutionPath, resolutionStack)
+          : this.resolve(param.token, paramHint, resolutionPath, resolutionStack);
     }
     return deps;
   }
@@ -606,17 +515,8 @@ export class DependencyResolver {
       }
       resolved[index] =
         depHint === undefined
-          ? this.resolveFromContext(
-              dep.token as Token<unknown> | Constructor,
-              resolutionPath,
-              resolutionStack,
-            )
-          : this.resolve(
-              dep.token as Token<unknown> | Constructor,
-              depHint,
-              resolutionPath,
-              resolutionStack,
-            );
+          ? this.resolveFromContext(dep.token as Token<unknown> | Constructor, resolutionPath, resolutionStack)
+          : this.resolve(dep.token as Token<unknown> | Constructor, depHint, resolutionPath, resolutionStack);
     }
     return resolved;
   }
@@ -697,8 +597,7 @@ export class DependencyResolver {
         scope === "transient" &&
         (fastBinding.kind === "dynamic" || fastBinding.kind === "dynamic-async") &&
         fastBinding.onActivation === undefined &&
-        (this._lifecycle.activationVersion === 0 ||
-          !this._lifecycle.hasActivationHandlers(fastBinding.token))
+        (this._lifecycle.activationVersion === 0 || !this._lifecycle.hasActivationHandlers(fastBinding.token))
       ) {
         return this._resolveTransientDynamicAsyncFromContext(
           fastBinding as Binding<Value> & { kind: "dynamic" | "dynamic-async" },
@@ -711,20 +610,13 @@ export class DependencyResolver {
       }
       if (scope === "scoped") {
         if (!this._scope.isChild) {
-          return Promise.reject(
-            new MissingScopeContextError(this._getTokenName(fastBinding.token)),
-          );
+          return Promise.reject(new MissingScopeContextError(this._getTokenName(fastBinding.token)));
         }
         if (this._scope.hasScoped(fastBinding.id)) {
           return Promise.resolve(this._scope.getScoped<Value>(fastBinding.id));
         }
       }
-      return this._resolveBindingAsync(
-        fastBinding as Binding<Value>,
-        undefined,
-        resolutionPath,
-        resolutionStack,
-      );
+      return this._resolveBindingAsync(fastBinding as Binding<Value>, undefined, resolutionPath, resolutionStack);
     }
 
     return this.resolveAsync(token, undefined, resolutionPath, resolutionStack);
@@ -741,11 +633,7 @@ export class DependencyResolver {
     if (found === undefined) {
       const ownBindings = this._registry.getAll(token);
       if (ownBindings.length > 0) {
-        throw new NoMatchingBindingError(
-          this._getTokenName(token),
-          hint ?? {},
-          this._getAvailableSlots(token),
-        );
+        throw new NoMatchingBindingError(this._getTokenName(token), hint ?? {}, this._getAvailableSlots(token));
       }
       throw new TokenNotBoundError(this._getTokenName(token));
     }
@@ -764,20 +652,10 @@ export class DependencyResolver {
     const scope = (binding as BindingWithScope).scope ?? "transient";
 
     if (scope === "singleton" && owner !== this) {
-      return owner._resolveBindingAsync(
-        binding as Binding<Value>,
-        hint,
-        resolutionPath,
-        resolutionStack,
-      );
+      return owner._resolveBindingAsync(binding as Binding<Value>, hint, resolutionPath, resolutionStack);
     }
 
-    return this._resolveBindingAsync(
-      binding as Binding<Value>,
-      hint,
-      resolutionPath,
-      resolutionStack,
-    );
+    return this._resolveBindingAsync(binding as Binding<Value>, hint, resolutionPath, resolutionStack);
   }
 
   private async _resolveBindingAsync<const Value>(
@@ -827,11 +705,7 @@ export class DependencyResolver {
       pathWithSet[RESOLUTION_SET_KEY] = resolutionSet;
     }
 
-    if (
-      resolutionSet !== undefined
-        ? resolutionSet.has(frameName)
-        : resolutionPath.includes(frameName)
-    ) {
+    if (resolutionSet !== undefined ? resolutionSet.has(frameName) : resolutionPath.includes(frameName)) {
       throw new CircularDependencyError([...resolutionPath, frameName]);
     }
 
@@ -839,11 +713,7 @@ export class DependencyResolver {
     resolutionSet?.add(frameName);
     resolutionStack.push(frame);
     const needsActivation = this._needsActivation(binding);
-    if (
-      !needsActivation &&
-      scope === "transient" &&
-      (binding.kind === "dynamic" || binding.kind === "dynamic-async")
-    ) {
+    if (!needsActivation && scope === "transient" && (binding.kind === "dynamic" || binding.kind === "dynamic-async")) {
       const resolutionCtx = new DefaultResolutionContext(
         this as unknown as ResolverCallbacks,
         resolutionPath,
@@ -865,23 +735,13 @@ export class DependencyResolver {
 
     const needsResolutionContext = needsActivation || this._requiresResolutionContext(binding);
     const resolutionCtx = needsResolutionContext
-      ? new DefaultResolutionContext(
-          this as unknown as ResolverCallbacks,
-          resolutionPath,
-          resolutionStack,
-          hint,
-        )
+      ? new DefaultResolutionContext(this as unknown as ResolverCallbacks, resolutionPath, resolutionStack, hint)
       : undefined;
 
     try {
       if (scope === "singleton") {
         const createSingletonPromise = async (): Promise<Value> => {
-          const instance = await this._instantiateAsync(
-            binding,
-            resolutionCtx,
-            resolutionPath,
-            resolutionStack,
-          );
+          const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, resolutionStack);
 
           const shouldActivate = this._refreshActivationCacheIfNeeded(binding, needsActivation);
           const activated = shouldActivate
@@ -906,12 +766,7 @@ export class DependencyResolver {
         return await singletonPromise;
       }
 
-      const instance = await this._instantiateAsync(
-        binding,
-        resolutionCtx,
-        resolutionPath,
-        resolutionStack,
-      );
+      const instance = await this._instantiateAsync(binding, resolutionCtx, resolutionPath, resolutionStack);
 
       const shouldActivate = this._refreshActivationCacheIfNeeded(binding, needsActivation);
       const activated = shouldActivate
@@ -960,11 +815,7 @@ export class DependencyResolver {
         return binding.factory(ctx);
 
       case "class": {
-        const deps = await this._resolveClassDepsAsync(
-          binding.target,
-          resolutionPath,
-          resolutionStack,
-        );
+        const deps = await this._resolveClassDepsAsync(binding.target, resolutionPath, resolutionStack);
         const instance = this._instantiateClass(binding.target, deps);
         return instance as Value;
       }
@@ -973,21 +824,13 @@ export class DependencyResolver {
         if (ctx === undefined) {
           throw new InternalError("resolved binding requires resolution context");
         }
-        const deps = await this._resolveDescriptorDepsAsync(
-          binding.deps,
-          resolutionPath,
-          resolutionStack,
-        );
+        const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, resolutionStack);
         const factoryResult = binding.factory(...deps);
         return factoryResult instanceof Promise ? factoryResult : Promise.resolve(factoryResult);
       }
 
       case "resolved-async": {
-        const deps = await this._resolveDescriptorDepsAsync(
-          binding.deps,
-          resolutionPath,
-          resolutionStack,
-        );
+        const deps = await this._resolveDescriptorDepsAsync(binding.deps, resolutionPath, resolutionStack);
         return binding.factory(...deps);
       }
 
@@ -1015,42 +858,15 @@ export class DependencyResolver {
       const param = meta.params[0]!;
       const paramHint = injectionSlotToResolveOptions(param);
       if (param.multi) {
-        return [
-          await this.resolveAllAsync(
-            param.token as Token<unknown> | Constructor,
-            paramHint,
-            resolutionPath,
-            resolutionStack,
-          ),
-        ];
+        return [await this.resolveAllAsync(param.token, paramHint, resolutionPath, resolutionStack)];
       }
       if (param.optional) {
-        return [
-          await this.resolveOptionalAsync(
-            param.token as Token<unknown> | Constructor,
-            paramHint,
-            resolutionPath,
-            resolutionStack,
-          ),
-        ];
+        return [await this.resolveOptionalAsync(param.token, paramHint, resolutionPath, resolutionStack)];
       }
       if (paramHint === undefined) {
-        return [
-          await this.resolveAsyncFromContext(
-            param.token as Token<unknown> | Constructor,
-            resolutionPath,
-            resolutionStack,
-          ),
-        ];
+        return [await this.resolveAsyncFromContext(param.token, resolutionPath, resolutionStack)];
       }
-      return [
-        await this.resolveAsync(
-          param.token as Token<unknown> | Constructor,
-          paramHint,
-          resolutionPath,
-          resolutionStack,
-        ),
-      ];
+      return [await this.resolveAsync(param.token, paramHint, resolutionPath, resolutionStack)];
     }
     const pending = new Array<Promise<unknown>>(meta.params.length);
     const shouldCloneContext = meta.params.length > 1;
@@ -1059,14 +875,14 @@ export class DependencyResolver {
       const paramHint = injectionSlotToResolveOptions(param);
       if (param.multi) {
         pending[index] = this.resolveAllAsync(
-          param.token as Token<unknown> | Constructor,
+          param.token,
           paramHint,
           shouldCloneContext ? [...resolutionPath] : resolutionPath,
           shouldCloneContext ? [...resolutionStack] : resolutionStack,
         );
       } else if (param.optional) {
         pending[index] = this.resolveOptionalAsync(
-          param.token as Token<unknown> | Constructor,
+          param.token,
           paramHint,
           shouldCloneContext ? [...resolutionPath] : resolutionPath,
           shouldCloneContext ? [...resolutionStack] : resolutionStack,
@@ -1075,12 +891,12 @@ export class DependencyResolver {
         pending[index] =
           paramHint === undefined
             ? this.resolveAsyncFromContext(
-                param.token as Token<unknown> | Constructor,
+                param.token,
                 shouldCloneContext ? [...resolutionPath] : resolutionPath,
                 shouldCloneContext ? [...resolutionStack] : resolutionStack,
               )
             : this.resolveAsync(
-                param.token as Token<unknown> | Constructor,
+                param.token,
                 paramHint,
                 shouldCloneContext ? [...resolutionPath] : resolutionPath,
                 shouldCloneContext ? [...resolutionStack] : resolutionStack,
@@ -1207,10 +1023,7 @@ export class DependencyResolver {
     return result;
   }
 
-  private _getSimpleNamedBindingsFromChain(
-    token: Token<unknown> | Constructor,
-    name: string,
-  ): Array<Binding> {
+  private _getSimpleNamedBindingsFromChain(token: Token<unknown> | Constructor, name: string): Array<Binding> {
     const ownBinding = this._registry.getSimpleNamed(token, name);
     if (this._parent === undefined) {
       return ownBinding !== undefined ? [ownBinding] : [];
@@ -1333,11 +1146,7 @@ export class DependencyResolver {
     hintTags: ReadonlyArray<BindingTag> | undefined,
     singleHintTag: BindingTag | undefined,
   ): boolean {
-    if (
-      singleHintTag !== undefined &&
-      singleHintTag[0] === tagKey &&
-      Object.is(singleHintTag[1], tagValue)
-    ) {
+    if (singleHintTag !== undefined && singleHintTag[0] === tagKey && Object.is(singleHintTag[1], tagValue)) {
       return true;
     }
     if (hintTags === undefined || hintTags.length === 0) {
@@ -1369,11 +1178,7 @@ export class DependencyResolver {
       }
       resolutionPath.push(tokenDisplayName);
       resolutionStack.push(frame);
-      const resolutionCtx = this._acquireSyncResolutionContext(
-        resolutionPath,
-        resolutionStack,
-        undefined,
-      );
+      const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, resolutionStack, undefined);
       try {
         const dynamicResult = binding.factory(resolutionCtx);
         if (dynamicResult instanceof Promise) {
@@ -1477,11 +1282,7 @@ export class DependencyResolver {
     resolutionPath.push(tokenDisplayName);
     resolutionSet.add(tokenDisplayName);
     resolutionStack.push(frame);
-    const resolutionCtx = this._acquireSyncResolutionContext(
-      resolutionPath,
-      resolutionStack,
-      undefined,
-    );
+    const resolutionCtx = this._acquireSyncResolutionContext(resolutionPath, resolutionStack, undefined);
     try {
       const dynamicResult = binding.factory(resolutionCtx);
       if (dynamicResult instanceof Promise) {
@@ -1538,12 +1339,7 @@ export class DependencyResolver {
           );
           this._deepAsyncCtx = ctx;
         } else {
-          existing.reset(
-            this as unknown as ResolverCallbacks,
-            resolutionPath,
-            resolutionStack,
-            undefined,
-          );
+          existing.reset(this as unknown as ResolverCallbacks, resolutionPath, resolutionStack, undefined);
           ctx = existing;
         }
         this._deepAsyncCtxPath = resolutionPath;
@@ -1572,9 +1368,7 @@ export class DependencyResolver {
         } else {
           const factoryResult = binding.factory(ctx);
           factoryPromise =
-            factoryResult instanceof Promise
-              ? (factoryResult as Promise<Value>)
-              : Promise.resolve(factoryResult);
+            factoryResult instanceof Promise ? (factoryResult as Promise<Value>) : Promise.resolve(factoryResult);
         }
       } catch (err) {
         // Synchronous throw from the factory (rare) — clean up immediately.
@@ -1663,12 +1457,7 @@ export class DependencyResolver {
       return binding.value;
     }
     if (binding.kind === "alias") {
-      return this.resolve(
-        binding.target as Token<Value> | Constructor<Value>,
-        hint,
-        resolutionPath,
-        resolutionStack,
-      );
+      return this.resolve(binding.target, hint, resolutionPath, resolutionStack);
     }
     const scope = (binding as BindingWithScope).scope ?? "transient";
     if (scope === "singleton" && this._scope.hasSingleton(binding.id)) {
@@ -1701,12 +1490,7 @@ export class DependencyResolver {
     const isolatedPath = [...resolutionPath];
     const isolatedStack = [...resolutionStack];
     if (binding.kind === "alias") {
-      return this.resolveAsync(
-        binding.target as Token<Value> | Constructor<Value>,
-        hint,
-        isolatedPath,
-        isolatedStack,
-      );
+      return this.resolveAsync(binding.target, hint, isolatedPath, isolatedStack);
     }
     const scope = (binding as BindingWithScope).scope ?? "transient";
     if (scope === "singleton" && this._scope.hasSingleton(binding.id)) {
@@ -1729,13 +1513,7 @@ export class DependencyResolver {
       return existing;
     }
     const scope = (binding as BindingWithScope).scope ?? "transient";
-    const frame = buildResolutionFrame(
-      tokenName(binding.token),
-      scope,
-      binding.id,
-      binding.kind,
-      binding.slot,
-    );
+    const frame = buildResolutionFrame(tokenName(binding.token), scope, binding.id, binding.kind, binding.slot);
     this._frameByBindingId.set(binding.id, frame);
     return frame;
   }
@@ -1761,8 +1539,7 @@ export class DependencyResolver {
     }
 
     if (binding.kind === "class") {
-      let hasActivation =
-        this._lifecycle.hasActivationHandlers(binding.token) || binding.onActivation !== undefined;
+      let hasActivation = this._lifecycle.hasActivationHandlers(binding.token) || binding.onActivation !== undefined;
       const cachedPostConstruct = this._classHasPostConstruct.get(binding.target);
       // Unknown class lifecycle metadata: activate once, then cache after first instantiation.
       if (cachedPostConstruct === undefined) {
@@ -1788,9 +1565,7 @@ export class DependencyResolver {
   private _refreshClassPostConstructCache(target: Constructor): void {
     const lifecycle = this._metadataReader.getLifecycleMetadata(target);
     const hasPostConstruct =
-      lifecycle !== undefined &&
-      lifecycle.postConstruct !== undefined &&
-      lifecycle.postConstruct.length > 0;
+      lifecycle !== undefined && lifecycle.postConstruct !== undefined && lifecycle.postConstruct.length > 0;
     this._classHasPostConstruct.set(target, hasPostConstruct);
   }
 
@@ -1798,10 +1573,7 @@ export class DependencyResolver {
    * Refreshes the post-construct cache for class bindings on first instantiation and
    * returns the (possibly updated) shouldActivate flag.
    */
-  private _refreshActivationCacheIfNeeded<Value>(
-    binding: Binding<Value>,
-    needsActivation: boolean,
-  ): boolean {
+  private _refreshActivationCacheIfNeeded<Value>(binding: Binding<Value>, needsActivation: boolean): boolean {
     if (binding.kind === "class" && this._classHasPostConstruct.get(binding.target) === undefined) {
       this._refreshClassPostConstructCache(binding.target);
       this._activationNeedByBindingId.delete(binding.id);