@codefast/di 0.8.0 → 0.8.1

package/src/lifecycle/lifecycle-manager.ts

@@ -1,272 +0,0 @@
-import type { Binding } from "#/core/binding";
-import { getOrInsert } from "#/core/map-upsert";
-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";
-
-/**
- * One container's registry of container-level activation and deactivation hooks, keyed by token.
- *
- * @since 0.3.16-canary.0
- */
-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<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,
-  // and registration is the only thing that can change the answer.
-  #cachedToken: Token<unknown> | Constructor | undefined;
-  #cachedHooks: Array<ActivationHandler<unknown>> | undefined;
-
-  registerActivation<Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void {
-    this.#activationVersion += 1;
-    this.#cachedToken = undefined;
-    this.#cachedHooks = undefined;
-    this.#activationHooks ??= new Map();
-    const list = getOrInsert(this.#activationHooks, token, []);
-    list.push(handler as ActivationHandler<unknown>);
-  }
-
-  hasActivationHandlers<Value>(token: Token<Value> | Constructor<Value>): boolean {
-    const list = this.activationHandlersFor(token);
-    return list !== undefined && list.length > 0;
-  }
-
-  get activationVersion(): number {
-    return this.#activationVersion;
-  }
-
-  /** Container-level activation handlers for a token — hot-path accessor, no copies. */
-  activationHandlersFor<Value>(
-    token: Token<Value> | Constructor<Value>,
-  ): ReadonlyArray<ActivationHandler<unknown>> | undefined {
-    const hooks = this.#activationHooks;
-    if (hooks === undefined) {
-      return undefined;
-    }
-    const key: DependencyKey = token;
-    if (key === this.#cachedToken) {
-      return this.#cachedHooks;
-    }
-    const list = hooks.get(key);
-    this.#cachedToken = key;
-    this.#cachedHooks = list;
-    return list;
-  }
-
-  registerDeactivation<Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void {
-    this.#deactivationHooks ??= new Map();
-    const list = getOrInsert(this.#deactivationHooks, token, []);
-    list.push(handler as DeactivationHandler<unknown>);
-  }
-
-  /** 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,
-    metadataReader: MetadataReader,
-  ): Promise<Value> {
-    let activatedInstance: Value = instance;
-
-    // 1. @postConstruct() — after TC39 construction (constructor + accessor addInitializer callbacks)
-    for (const methodName of lifecycleMethods(binding, metadataReader, "postConstruct")) {
-      const hookResult = callHook(activatedInstance, methodName);
-      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);
-    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<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)
-    for (const methodName of lifecycleMethods(binding, metadataReader, "postConstruct")) {
-      if (callHook(activatedInstance, methodName) 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);
-    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<Value>(
-    binding: Binding<Value>,
-    instance: Value,
-    metadataReader: MetadataReader,
-  ): Promise<void> {
-    const tokenKey: DependencyKey = binding.token;
-
-    // 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
-    for (const methodName of lifecycleMethods(binding, metadataReader, "preDestroy")) {
-      const hookResult = callHook(instance, methodName);
-      if (hookResult instanceof Promise) {
-        await hookResult;
-      }
-    }
-  }
-
-  runDeactivationSync<Value>(binding: Binding<Value>, instance: Value, metadataReader: MetadataReader): void {
-    const tokenDisplayName = tokenName(binding.token);
-    const tokenKey: DependencyKey = binding.token;
-
-    // 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()
-    for (const methodName of lifecycleMethods(binding, metadataReader, "preDestroy")) {
-      if (callHook(instance, methodName) instanceof Promise) {
-        throw new AsyncDeactivationError(tokenDisplayName);
-      }
-    }
-  }
-
-  /** Whether the deferred activation-hook table has had to be built. */
-  get isActivationTableBuilt(): boolean {
-    return this.#activationHooks !== undefined;
-  }
-}
-
-const NO_METHODS: ReadonlyArray<string> = [];
-
-/** The `@postConstruct` / `@preDestroy` methods a binding declares — only a class can declare any. */
-function lifecycleMethods<Value>(
-  binding: Binding<Value>,
-  metadataReader: MetadataReader,
-  phase: "postConstruct" | "preDestroy",
-): ReadonlyArray<string> {
-  if (binding.kind !== "class") {
-    return NO_METHODS;
-  }
-  return metadataReader.getLifecycleMetadata(binding.target)?.[phase] ?? NO_METHODS;
-}
-
-/**
- * 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 {
-  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

@@ -1,158 +0,0 @@
-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";
-
-/**
- * One container's instance caches — singletons, in-flight async creations, and the scoped cache.
- *
- * @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<BindingIdentifier, Promise<unknown>>()).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<BindingIdentifier, unknown>()).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-keys.ts

@@ -1,28 +0,0 @@
-/**
- * The metadata key `@injectable` writes a class's constructor dependencies under.
- *
- * @since 0.3.16-canary.0
- */
-export const INJECTABLE_KEY: unique symbol = Symbol("di:injectable");
-/**
- * The metadata key `@postConstruct` and `@preDestroy` record method names under.
- *
- * @since 0.3.16-canary.0
- */
-export const LIFECYCLE_KEY: unique symbol = Symbol("di:lifecycle");
-/**
- * The metadata key `@inject` accessors record their injection descriptors under.
- *
- * @since 0.3.16-canary.0
- */
-export const INJECT_ACCESSOR_KEY: unique symbol = Symbol("di:inject-accessor");
-
-/**
- * The symbol TC39 Stage 3 decorator transforms store class metadata under.
- *
- * @remarks Falls back to the global-registry symbol, which is what Babel and esbuild emit until
- * a runtime ships `Symbol.metadata` natively.
- *
- * @since 0.3.16-canary.0
- */
-export const METADATA_SYMBOL: symbol = Symbol.metadata ?? Symbol.for("Symbol.metadata");

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

@@ -1,10 +0,0 @@
-import { token } from "#/core/token";
-import type { Token } from "#/core/token";
-import type { MetadataReader } from "#/metadata/metadata-types";
-
-/**
- * The token a custom `MetadataReader` is bound to for a container to pick up.
- *
- * @since 0.3.16-canary.0
- */
-export const MetadataReaderToken: Token<MetadataReader> = token<MetadataReader>("MetadataReader");

package/src/metadata/metadata-types.ts

@@ -1,57 +0,0 @@
-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 extends DependencySlot {
-  readonly index: number;
-}
-
-/**
- * A class's declared constructor dependencies, as a `MetadataReader` reports them.
- *
- * @since 0.3.16-canary.0
- */
-export interface ConstructorMetadata {
-  readonly params: ReadonlyArray<ParamMetadata>;
-}
-
-/**
- * The `postConstruct` and `preDestroy` method names a class declares.
- *
- * @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>;
-}
-
-/**
- * The port a container reads class metadata through — constructor deps, lifecycle, and accessors.
- *
- * @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

@@ -1,126 +0,0 @@
-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";
-
-type AccessorEntry = { readonly key: string | symbol; readonly descriptor: InjectionDescriptor };
-
-/**
- * The default `MetadataReader`, reading decorator metadata stored under `Symbol.metadata`.
- *
- * @since 0.3.16-canary.0
- */
-export class SymbolMetadataReader implements MetadataReader {
-  // 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: unknown = descriptor.value;
-    if (typeof record !== "object" || record === null || !Object.hasOwn(record, key)) {
-      return undefined;
-    }
-    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 {
-    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 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<Constructor, LifecycleMetadata | null>()).set(target, merged);
-    return merged ?? 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<Constructor, ReadonlyArray<AccessorEntry> | null>()).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;
-}
-
-/**
- * The shared reader a container falls back to when given no custom `MetadataReader`.
- *
- * @since 0.3.16-canary.0
- */
-export const defaultMetadataReader: SymbolMetadataReader = new SymbolMetadataReader();

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

@@ -1,41 +0,0 @@
-/**
- * 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;
-}