@codefast/di 0.5.0 → 0.6.1

package/src/{resolution/lifecycle.ts → lifecycle/lifecycle-manager.ts}

@@ -1,9 +1,15 @@
-import type { Binding } from "#/binding";
-import { AsyncActivationError, AsyncDeactivationError } from "#/errors";
+import type { Binding } from "#/core/binding";
+import type { Token } from "#/core/token";
+import { tokenName } from "#/core/token";
+import type {
+  ActivationHandler,
+  Constructor,
+  DeactivationHandler,
+  DependencyKey,
+  ResolutionContext,
+} from "#/core/types";
+import { AsyncActivationError, AsyncDeactivationError, InvalidMetadataError } from "#/errors/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
@@ -11,8 +17,8 @@ import type { ActivationHandler, Constructor, DeactivationHandler, ResolutionCon
 export class LifecycleManager {
   // Container-level activation/deactivation hooks per token — most containers register none, so
   // both tables stay unallocated until the first hook arrives.
-  #activationHooks: Map<Token<unknown> | Constructor, Array<ActivationHandler<unknown>>> | undefined;
-  #deactivationHooks: Map<Token<unknown> | Constructor, Array<DeactivationHandler<unknown>>> | undefined;
+  #activationHooks: Map<DependencyKey, Array<ActivationHandler<unknown>>> | undefined;
+  #deactivationHooks: Map<DependencyKey, Array<DeactivationHandler<unknown>>> | undefined;
   #activationVersion = 0;
 
   // One-entry cache in front of the map: a resolve loop asks about the same token over and over,
@@ -20,16 +26,15 @@ export class LifecycleManager {
   #cachedToken: Token<unknown> | Constructor | undefined;
   #cachedHooks: Array<ActivationHandler<unknown>> | undefined;
 
-  registerActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void {
+  registerActivation<Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void {
     this.#activationVersion += 1;
     this.#cachedToken = undefined;
     this.#cachedHooks = undefined;
-    // ✓ TS6.0: Map.getOrInsert (ES2025)
-    const list = (this.#activationHooks ??= new Map()).getOrInsert(token as Token<unknown> | Constructor, []);
+    const list = (this.#activationHooks ??= new Map()).getOrInsert(token, []);
     list.push(handler as ActivationHandler<unknown>);
   }
 
-  hasActivationHandlers<const Value>(token: Token<Value> | Constructor<Value>): boolean {
+  hasActivationHandlers<Value>(token: Token<Value> | Constructor<Value>): boolean {
     const list = this.activationHandlersFor(token);
     return list !== undefined && list.length > 0;
   }
@@ -39,14 +44,14 @@ export class LifecycleManager {
   }
 
   /** Container-level activation handlers for a token — hot-path accessor, no copies. */
-  activationHandlersFor<const Value>(
+  activationHandlersFor<Value>(
     token: Token<Value> | Constructor<Value>,
   ): ReadonlyArray<ActivationHandler<unknown>> | undefined {
     const hooks = this.#activationHooks;
     if (hooks === undefined) {
       return undefined;
     }
-    const key = token as Token<unknown> | Constructor;
+    const key: DependencyKey = token;
     if (key === this.#cachedToken) {
       return this.#cachedHooks;
     }
@@ -56,15 +61,30 @@ export class LifecycleManager {
     return list;
   }
 
-  registerDeactivation<const Value>(
-    token: Token<Value> | Constructor<Value>,
-    handler: DeactivationHandler<Value>,
-  ): void {
-    const list = (this.#deactivationHooks ??= new Map()).getOrInsert(token as Token<unknown> | Constructor, []);
+  registerDeactivation<Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void {
+    const list = (this.#deactivationHooks ??= new Map()).getOrInsert(token, []);
     list.push(handler as DeactivationHandler<unknown>);
   }
 
-  async runActivation<const Value>(
+  /** Asked only while tearing down, so it reads the map directly rather than caching like activation. */
+  hasDeactivationHandlers<Value>(token: Token<Value> | Constructor<Value>): boolean {
+    const list = this.#deactivationHooks?.get(token);
+    return list !== undefined && list.length > 0;
+  }
+
+  /** Every token carrying a container-level hook, paired with the phase that registered it. */
+  hookedTokens(): Array<[DependencyKey, "onActivation" | "onDeactivation"]> {
+    const hooked: Array<[DependencyKey, "onActivation" | "onDeactivation"]> = [];
+    for (const key of this.#activationHooks?.keys() ?? []) {
+      hooked.push([key, "onActivation"]);
+    }
+    for (const key of this.#deactivationHooks?.keys() ?? []) {
+      hooked.push([key, "onDeactivation"]);
+    }
+    return hooked;
+  }
+
+  async runActivation<Value>(
     resolutionContext: ResolutionContext,
     binding: Binding<Value>,
     instance: Value,
@@ -87,7 +107,7 @@ export class LifecycleManager {
     }
 
     // 3. container-level onActivation
-    const containerHooks = this.#activationHooks?.get(binding.token as Token<unknown> | Constructor);
+    const containerHooks = this.#activationHooks?.get(binding.token);
     if (containerHooks !== undefined) {
       for (const hook of containerHooks) {
         const activationResult = hook(resolutionContext, activatedInstance);
@@ -98,7 +118,7 @@ export class LifecycleManager {
     return activatedInstance;
   }
 
-  runActivationSync<const Value>(
+  runActivationSync<Value>(
     resolutionContext: ResolutionContext,
     binding: Binding<Value>,
     instance: Value,
@@ -124,7 +144,7 @@ export class LifecycleManager {
 
     // 3. container-level onActivation (must be sync)
     const tokenDisplayName = tokenName(binding.token);
-    const containerHooks = this.#activationHooks?.get(binding.token as Token<unknown> | Constructor);
+    const containerHooks = this.#activationHooks?.get(binding.token);
     if (containerHooks !== undefined) {
       for (const hook of containerHooks) {
         const activationResult = hook(resolutionContext, activatedInstance);
@@ -138,12 +158,12 @@ export class LifecycleManager {
     return activatedInstance;
   }
 
-  async runDeactivation<const Value>(
+  async runDeactivation<Value>(
     binding: Binding<Value>,
     instance: Value,
     metadataReader: MetadataReader,
   ): Promise<void> {
-    const tokenKey = binding.token as Token<unknown> | Constructor;
+    const tokenKey: DependencyKey = binding.token;
 
     // 1. container-level onDeactivation
     const containerHooks = this.#deactivationHooks?.get(tokenKey);
@@ -173,9 +193,9 @@ export class LifecycleManager {
     }
   }
 
-  runDeactivationSync<const Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): void {
+  runDeactivationSync<Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): void {
     const tokenDisplayName = tokenName(binding.token);
-    const tokenKey = binding.token as Token<unknown> | Constructor;
+    const tokenKey: DependencyKey = binding.token;
 
     // 1. container-level onDeactivation
     const containerHooks = this.#deactivationHooks?.get(tokenKey);
@@ -204,8 +224,8 @@ export class LifecycleManager {
     }
   }
 
-  /** Whether the deferred table behind `#activationHooks` has had to be built. */
-  get isBuilt(): boolean {
+  /** Whether the deferred activation-hook table has had to be built. */
+  get isActivationTableBuilt(): boolean {
     return this.#activationHooks !== undefined;
   }
 }
@@ -213,7 +233,7 @@ export class LifecycleManager {
 const NO_METHODS: ReadonlyArray<string> = [];
 
 /** The `@postConstruct` / `@preDestroy` methods a binding declares — only a class can declare any. */
-function lifecycleMethods<const Value>(
+function lifecycleMethods<Value>(
   binding: Binding<Value>,
   metadataReader: MetadataReader,
   phase: "postConstruct" | "preDestroy",
@@ -224,8 +244,24 @@ function lifecycleMethods<const Value>(
   return metadataReader.getLifecycleMetadata(binding.target)?.[phase] ?? NO_METHODS;
 }
 
-/** Invokes a hook by name, tolerating a name whose member is not (or no longer) a method. */
+/**
+ * Invokes a lifecycle hook by name.
+ *
+ * @remarks A name that is not a method can only come from a {@link MetadataReader} that answered
+ * wrongly, so it is reported rather than skipped — a hook that never runs is the failure a caller
+ * cannot see. A non-object instance has no hooks to run and is not an error.
+ */
 function callHook(instance: unknown, methodName: string): unknown {
-  const method = (instance as Record<string, unknown>)[methodName];
-  return typeof method === "function" ? (method as () => unknown).call(instance) : undefined;
+  if (typeof instance !== "object" || instance === null) {
+    return undefined;
+  }
+  const method: unknown = Reflect.get(instance, methodName);
+  if (typeof method !== "function") {
+    // The class is derived here rather than passed in, so the happy path carries no extra argument.
+    const constructor: unknown = Reflect.get(instance, "constructor");
+    const className = typeof constructor === "function" && constructor.name !== "" ? constructor.name : "(anonymous)";
+    throw new InvalidMetadataError(className, `lifecycle method '${methodName}' is not a method on the instance`);
+  }
+
+  return method.call(instance);
 }

package/src/lifecycle/scope-manager.ts

@@ -0,0 +1,156 @@
+import type { Binding } from "#/core/binding";
+import { NO_INSTANCE } from "#/core/binding";
+import { tokenName } from "#/core/token";
+import type { BindingIdentifier } from "#/core/types";
+import { MissingScopeContextError } from "#/errors/errors";
+
+/**
+ * @since 0.3.16-canary.0
+ */
+export class ScopeManager {
+  // Instances live on their binding; this list only lets disposal and `inspect()` enumerate them.
+  #singletonBindings: Array<Binding<unknown>> | undefined;
+  // In-flight promises for async singleton creation — only an async resolve ever needs it.
+  #inflight: Map<BindingIdentifier, Promise<unknown>> | undefined;
+  // Scoped cache — only a child container resolving a `scoped` binding ever needs it.
+  #scoped: Map<BindingIdentifier, unknown> | undefined;
+  // Set once by the owning container's dispose — refuses new materializations into torn-down state.
+  #closed = false;
+
+  readonly isChild: boolean;
+
+  constructor(isChild = false) {
+    this.isChild = isChild;
+  }
+
+  get isClosed(): boolean {
+    return this.#closed;
+  }
+
+  markClosed(): void {
+    this.#closed = true;
+  }
+
+  /** Awaits every in-flight async materialization, so teardown deactivates what they produce. */
+  async settleInflight(): Promise<void> {
+    let previousSize = -1;
+    while (this.#inflight !== undefined && this.#inflight.size > 0 && this.#inflight.size !== previousSize) {
+      previousSize = this.#inflight.size;
+      await Promise.allSettled(this.#inflight.values());
+    }
+  }
+
+  setSingleton<Value>(binding: Binding<Value>, instance: unknown): void {
+    if (binding.instance === NO_INSTANCE) {
+      (this.#singletonBindings ??= []).push(binding as Binding<unknown>);
+    }
+    binding.instance = instance;
+  }
+
+  /** Every binding in this container holding a cached singleton. */
+  cachedSingletons(): ReadonlyArray<Binding<unknown>> {
+    return this.#singletonBindings ?? EMPTY_BINDINGS;
+  }
+
+  deleteSingleton<Value>(binding: Binding<Value>): boolean {
+    if (binding.instance === NO_INSTANCE) {
+      return false;
+    }
+    binding.instance = NO_INSTANCE;
+    const tracked = this.#singletonBindings;
+    if (tracked !== undefined) {
+      const index = tracked.indexOf(binding as Binding<unknown>);
+      if (index !== -1) {
+        tracked.splice(index, 1);
+      }
+    }
+    return true;
+  }
+
+  /** Swaps a re-slotted binding's tracked entry, so teardown pairs the instance with the live object. */
+  replaceSingleton(previous: Binding, next: Binding): void {
+    const tracked = this.#singletonBindings;
+    if (tracked === undefined) {
+      return;
+    }
+    const index = tracked.indexOf(previous as Binding<unknown>);
+    if (index !== -1) {
+      tracked[index] = next as Binding<unknown>;
+    }
+  }
+
+  getInflight(id: BindingIdentifier): Promise<unknown> | undefined {
+    return this.#inflight?.get(id);
+  }
+
+  setInflight(id: BindingIdentifier, promise: Promise<unknown>): void {
+    (this.#inflight ??= new Map()).set(id, promise);
+  }
+
+  clearInflight(id: BindingIdentifier): void {
+    this.#inflight?.delete(id);
+  }
+
+  /**
+   * The cached scoped instance, or {@link SCOPED_MISS}.
+   *
+   * @remarks One map read answers both existence and value; a cached `undefined` is the only
+   * shape that pays for a second, and it is the rare one.
+   */
+  readScoped(id: BindingIdentifier): unknown {
+    const scoped = this.#scoped;
+    if (scoped === undefined) {
+      return SCOPED_MISS;
+    }
+    const cached = scoped.get(id);
+    if (cached !== undefined) {
+      return cached;
+    }
+    return scoped.has(id) ? undefined : SCOPED_MISS;
+  }
+
+  /** Takes the binding rather than its id, so a failure here can name the token — as `setSingleton` does. */
+  setScoped(binding: Binding, instance: unknown): void {
+    if (!this.isChild) {
+      throw new MissingScopeContextError(tokenName(binding.token));
+    }
+    (this.#scoped ??= new Map()).set(binding.id, instance);
+  }
+
+  /** Releases a removed binding's scoped instance. A scoped instance has no deactivation. */
+  deleteScoped(id: BindingIdentifier): void {
+    this.#scoped?.delete(id);
+  }
+
+  /** Scoped instances currently cached — a structural count for diagnostics. */
+  get scopedCount(): number {
+    return this.#scoped?.size ?? 0;
+  }
+
+  clearAll(): void {
+    const tracked = this.#singletonBindings;
+    if (tracked !== undefined) {
+      for (const binding of tracked) {
+        binding.instance = NO_INSTANCE;
+      }
+      tracked.length = 0;
+    }
+    this.#inflight?.clear();
+    this.#scoped?.clear();
+  }
+  /** Whether the deferred scoped-instance cache has had to be built. */
+  get isScopedCacheBuilt(): boolean {
+    return this.#scoped !== undefined;
+  }
+}
+
+const EMPTY_BINDINGS: ReadonlyArray<Binding<unknown>> = [];
+
+/**
+ * Absent scoped entry — distinguishes it from a cached `undefined`.
+ *
+ * @remarks A `unique symbol`, so no value a caller could cache can ever equal it.
+ *
+ * @since 0.6.0
+ */
+export const SCOPED_MISS: unique symbol = Symbol("di:scoped-miss");

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

@@ -1,6 +1,6 @@
+import { token } from "#/core/token";
+import type { Token } from "#/core/token";
 import type { MetadataReader } from "#/metadata/metadata-types";
-import { token } from "#/token";
-import type { Token } from "#/token";
 
 /**
  * @since 0.3.16-canary.0

package/src/metadata/metadata-types.ts

@@ -1,17 +1,17 @@
-import type { InjectionDescriptor } from "#/decorators/inject";
-import type { Token } from "#/token";
-import type { Constructor } from "#/types";
+import type { Constructor } from "#/core/types";
+import type { InjectionDescriptor } from "#/injection/descriptor";
+import type { DependencySlot } from "#/injection/resolve-options";
 
 /**
+ * One constructor parameter's declaration.
+ *
+ * @remarks Extends {@link DependencySlot} so the two dependency sources stay literally one shape
+ * rather than two that happen to match; `index` is the only thing a parameter adds.
+ *
  * @since 0.3.16-canary.0
  */
-export interface ParamMetadata {
+export interface ParamMetadata extends DependencySlot {
   readonly index: number;
-  readonly token: Token<unknown> | Constructor;
-  readonly optional: boolean;
-  readonly multi: boolean;
-  readonly name?: string;
-  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
 }
 
 /**

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

@@ -1,45 +1,122 @@
-import type { InjectionDescriptor } from "#/decorators/inject";
+import type { Constructor } from "#/core/types";
+import type { InjectionDescriptor } from "#/injection/descriptor";
 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";
+
+type AccessorEntry = { readonly key: string | symbol; readonly descriptor: InjectionDescriptor };
 
 /**
  * @since 0.3.16-canary.0
  */
 export class SymbolMetadataReader implements MetadataReader {
-  #getMetadataRecord(target: Constructor, key: string | symbol): Record<string | symbol, unknown> | undefined {
+  // Merged chain answers, cached per class: decorator metadata cannot change once a class is defined.
+  #lifecycleByClass: WeakMap<Constructor, LifecycleMetadata | null> | undefined;
+  #accessorsByClass: WeakMap<Constructor, ReadonlyArray<AccessorEntry> | null> | undefined;
+
+  /**
+   * Whatever a decorator stored under `key` on this exact class, narrowed as far as the platform allows.
+   *
+   * @remarks Own-property only: an inherited `Symbol.metadata` belongs to the base class. Constructor
+   * metadata must not be borrowed (each class opts into its deps); the lifecycle and accessor readers
+   * walk the base chain themselves, because the platform runs inherited members regardless.
+   */
+  #read(target: object, key: string | symbol): unknown {
     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)) {
+    const record: unknown = descriptor.value;
+    if (typeof record !== "object" || record === null || !Object.hasOwn(record, key)) {
       return undefined;
     }
-    return record;
+    return Reflect.get(record, key);
+  }
+
+  /** Each class level's own bucket under `key`, base first — the order construction runs them. */
+  #ownBucketsBaseFirst(target: Constructor, key: string | symbol): Array<unknown> {
+    const buckets: Array<unknown> = [];
+    let current: unknown = target;
+    while (typeof current === "function" && current !== Function.prototype) {
+      const bucket = this.#read(current, key);
+      if (bucket !== undefined) {
+        buckets.unshift(bucket);
+      }
+      current = Object.getPrototypeOf(current);
+    }
+    return buckets;
   }
 
   getConstructorMetadata(target: Constructor): ConstructorMetadata | undefined {
-    const record = this.#getMetadataRecord(target, INJECTABLE_KEY);
-    return record?.[INJECTABLE_KEY] as ConstructorMetadata | undefined;
+    return this.#read(target, INJECTABLE_KEY) as ConstructorMetadata | undefined;
   }
 
+  /**
+   * Lifecycle hooks aggregated over the base chain — an inherited hook method exists on the instance.
+   *
+   * @remarks `postConstruct` runs base first (a derived hook may rely on base state); `preDestroy`
+   * runs derived first, mirroring teardown. A method name repeated across levels runs once.
+   */
   getLifecycleMetadata(target: Constructor): LifecycleMetadata | undefined {
-    const record = this.#getMetadataRecord(target, LIFECYCLE_KEY);
-    return record?.[LIFECYCLE_KEY] as LifecycleMetadata | undefined;
+    const cached = this.#lifecycleByClass?.get(target);
+    if (cached !== undefined) {
+      return cached ?? undefined;
+    }
+    const buckets = this.#ownBucketsBaseFirst(target, LIFECYCLE_KEY) as Array<LifecycleMetadata>;
+    let merged: LifecycleMetadata | null;
+    if (buckets.length === 0) {
+      merged = null;
+    } else if (buckets.length === 1) {
+      merged = buckets[0]!;
+    } else {
+      merged = {
+        postConstruct: mergeUniqueNames(buckets.map((bucket) => bucket.postConstruct)),
+        preDestroy: mergeUniqueNames(buckets.map((bucket) => bucket.preDestroy).reverse()),
+      };
+    }
+    (this.#lifecycleByClass ??= new WeakMap()).set(target, merged);
+    return merged ?? 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;
+  /**
+   * Accessor injections aggregated over the base chain, base first — the order initializers run.
+   *
+   * @remarks Not deduplicated: a derived accessor shadowing a base one still runs both initializers.
+   */
+  getAccessorMetadata(target: Constructor): ReadonlyArray<AccessorEntry> | undefined {
+    const cached = this.#accessorsByClass?.get(target);
+    if (cached !== undefined) {
+      return cached ?? undefined;
+    }
+    const buckets = this.#ownBucketsBaseFirst(target, INJECT_ACCESSOR_KEY) as Array<ReadonlyArray<AccessorEntry>>;
+    let merged: ReadonlyArray<AccessorEntry> | null;
+    if (buckets.length === 0) {
+      merged = null;
+    } else if (buckets.length === 1) {
+      merged = buckets[0]!;
+    } else {
+      merged = buckets.flat();
+    }
+    (this.#accessorsByClass ??= new WeakMap()).set(target, merged);
+    return merged ?? undefined;
+  }
+}
+
+/** Concatenates hook-name lists in the given order, keeping each name's first occurrence. */
+function mergeUniqueNames(lists: Array<ReadonlyArray<string>>): Array<string> {
+  const seen = new Set<string>();
+  const merged: Array<string> = [];
+  for (const list of lists) {
+    for (const name of list) {
+      if (!seen.has(name)) {
+        seen.add(name);
+        merged.push(name);
+      }
+    }
   }
+  return merged;
 }
 
 /**
  * @since 0.3.16-canary.0
  */
-export const defaultMetadataReader = new SymbolMetadataReader();
+export const defaultMetadataReader: SymbolMetadataReader = new SymbolMetadataReader();

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

@@ -0,0 +1,41 @@
+/**
+ * Wraps a foreign {@link MetadataReader} so its answers are verified before anything dereferences
+ * them.
+ */
+
+import type { MetadataReader } from "#/metadata/metadata-types";
+import { defaultMetadataReader } from "#/metadata/symbol-metadata-reader";
+import {
+  verifyAccessorMetadata,
+  verifyConstructorMetadata,
+  verifyLifecycleMetadata,
+} from "#/resolution/cache/class-introspector";
+
+// Wrapping a wrapper would stack a layer per child container, so each one is remembered.
+const verifyingReaders = new WeakSet<MetadataReader>();
+
+/**
+ * The reader a container should hand its resolver: verified when it came from outside.
+ *
+ * @remarks The decorator reader writes the metadata it later reads, so there is nothing to check and
+ * nothing to pay — a container that supplies no reader of its own is left on the same code path it
+ * has always taken. A supplied reader is a claim, and only its callers can be charged for checking.
+ *
+ * @since 0.6.0
+ */
+export function verifyingMetadataReader(reader: MetadataReader): MetadataReader {
+  if (reader === defaultMetadataReader || verifyingReaders.has(reader)) {
+    return reader;
+  }
+  const verifying: MetadataReader = {
+    getConstructorMetadata: (target) => verifyConstructorMetadata(reader, target),
+    getLifecycleMetadata: (target) => verifyLifecycleMetadata(reader, target),
+    ...(reader.getAccessorMetadata === undefined
+      ? {}
+      : { getAccessorMetadata: (target) => verifyAccessorMetadata(reader, target) }),
+  };
+
+  verifyingReaders.add(verifying);
+
+  return verifying;
+}

package/src/resolution/{activation-need.ts → cache/activation-need.ts}

@@ -4,11 +4,11 @@
  * @remarks Versioned on the lifecycle manager plus the own registry, since `onActivation` can be
  * registered at any time and a rebind mints binding ids the memo must not keep forever.
  */
-import type { Binding } from "#/binding";
-import type { BindingRegistry } from "#/registry";
-import type { ClassIntrospector } from "#/resolution/class-introspector";
-import type { LifecycleManager } from "#/resolution/lifecycle";
-import type { BindingIdentifier } from "#/types";
+import type { Binding } from "#/core/binding";
+import type { BindingRegistry } from "#/core/registry";
+import type { BindingIdentifier } from "#/core/types";
+import type { LifecycleManager } from "#/lifecycle/lifecycle-manager";
+import type { ClassIntrospector } from "#/resolution/cache/class-introspector";
 
 /**
  * @since 0.5.0-canary.8
@@ -26,7 +26,7 @@ export class ActivationNeedCache {
     this.#registry = registry;
   }
 
-  needsActivation<const Value>(binding: Binding<Value>): boolean {
+  needsActivation<Value>(binding: Binding<Value>): boolean {
     // The chain writes a binding's own hook in place with no version anything here can see, so it
     // is read fresh on every call; the memo covers only container hooks and lifecycle metadata.
     if (binding.kind !== "alias" && binding.onActivation !== undefined) {
@@ -71,7 +71,7 @@ export class ActivationNeedCache {
   }
 
   // Own hooks are answered before the memo, so both computations cover the memoizable rest only.
-  #classNeedsActivation<const Value>(binding: Binding<Value> & { kind: "class" }): boolean {
+  #classNeedsActivation<Value>(binding: Binding<Value> & { kind: "class" }): boolean {
     if (this.#lifecycle.hasActivationHandlers(binding.token)) {
       return true;
     }
@@ -79,7 +79,7 @@ export class ActivationNeedCache {
     return this.#classes.knownPostConstruct(binding.target) !== false;
   }
 
-  #nonClassNeedsActivation<const Value>(binding: Binding<Value>): boolean {
+  #nonClassNeedsActivation<Value>(binding: Binding<Value>): boolean {
     return this.#lifecycle.hasActivationHandlers(binding.token);
   }
 }