@codefast/di-testing 0.1.1 → 0.1.3

package/src/mocking/auto-mock.ts

@@ -1,243 +0,0 @@
-/** The lazy `Proxy` that mocks an erased interface one accessed property at a time. */
-
-import type { MockFactory, MockFunction } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
-
-/**
- * A mocked view of `Dependency`: every member becomes a spy, nested objects are mocked in turn.
- *
- * @remarks With the default backend a method is a precisely-typed {@link Spy}; a custom backend
- * (`vi.fn`, `jest.fn`, a Sinon stub) intersects its own native surface with the method's signature,
- * so backend-specific APIs like `mockReturnValueOnce` or `returns` type-check without adapters. The
- * check is mutual, so a backend that merely resembles {@link Spy} still keeps its own surface.
- *
- * @typeParam Dependency - The dependency type being mocked.
- * @typeParam Backend - The spy type the active mock factory produces.
- *
- * @since 0.1.0
- */
-export type Mocked<Dependency, Backend extends MockFunction = Spy> = Dependency extends (
-  ...args: infer Args
-) => infer Return
-  ? [Backend] extends [Spy]
-    ? [Spy] extends [Backend]
-      ? Spy<Args, Return>
-      : Backend & ((...args: Args) => Return)
-    : Backend & ((...args: Args) => Return)
-  : Dependency extends object
-    ? { [Key in keyof Dependency]: Mocked<Dependency[Key], Backend> }
-    : Dependency;
-
-/**
- * A recursively optional view of `Dependency` — the shape a hand-written `.stub` seed may supply.
- *
- * @remarks Functions are kept whole (a stub replaces a whole method), everything else is made
- * optional so only the members a test cares about need spelling out.
- *
- * @typeParam Dependency - The dependency type being partially stubbed.
- *
- * @since 0.1.0
- */
-export type DeepPartial<Dependency> = Dependency extends (...args: Array<never>) => unknown
-  ? Dependency
-  : Dependency extends object
-    ? { [Key in keyof Dependency]?: DeepPartial<Dependency[Key]> }
-    : Dependency;
-
-/**
- * The key an auto-mock answers with its reset routine, clearing the root spy, every materialized
- * member, and the spies of its seed.
- *
- * @since 0.1.0
- */
-export const MOCK_RESET: unique symbol = Symbol("di-testing:mock-reset");
-
-// `then` would make every mock thenable and stall `await`; `toJSON` and `asymmetricMatch` are probed
-// by serializers and expect() and must not answer as callables.
-const UNMOCKED_KEYS: ReadonlySet<string> = new Set(["then", "toJSON", "asymmetricMatch"]);
-
-// Inherited members that inspection and printing rely on; every other inherited key (`apply`,
-// `call`, `bind`, the throwing `caller`/`arguments`) is fair game for a domain interface.
-const INHERITED_PASSTHROUGH: ReadonlySet<string> = new Set([
-  "constructor",
-  "toString",
-  "toLocaleString",
-  "valueOf",
-  "hasOwnProperty",
-  "isPrototypeOf",
-  "propertyIsEnumerable",
-]);
-
-/** Clears one spy through whichever reset method its backend spells, recursing into auto-mocks. */
-function resetSpy(spy: unknown): void {
-  if (spy === null || (typeof spy !== "object" && typeof spy !== "function")) {
-    return;
-  }
-  const candidate = spy as {
-    [MOCK_RESET]?: () => void;
-    mockReset?: () => void;
-    reset?: () => void;
-    resetHistory?: () => void;
-  };
-  if (typeof candidate[MOCK_RESET] === "function") {
-    candidate[MOCK_RESET]();
-  } else if (typeof candidate.mockReset === "function") {
-    candidate.mockReset();
-  } else if (typeof candidate.reset === "function") {
-    candidate.reset();
-  } else if (typeof candidate.resetHistory === "function") {
-    candidate.resetHistory();
-  }
-}
-
-/** Whether the seed supplies `key` itself — its prototype chain counts, the global prototypes don't. */
-function seedProvides(seed: object, key: PropertyKey): boolean {
-  let current: object | null = seed;
-  while (current !== null && current !== Object.prototype && current !== Function.prototype) {
-    if (Object.hasOwn(current, key)) {
-      return true;
-    }
-    current = Object.getPrototypeOf(current);
-  }
-  return false;
-}
-
-/**
- * Builds a lazy auto-mock for an erased interface: each accessed member becomes a cached child mock.
- *
- * @remarks The proxy target is itself a spy, so a function-typed dependency records calls, and every
- * materialized member is another auto-mock, so nested access (`repo.user.create`) works to any depth.
- * A `seed` wins for the members it supplies (inherited ones included; a primitive seed is returned
- * as the value itself); keys the root spy owns pass through, so its backend API stays real — which
- * also means a member sharing a name with a function's own `name`/`length` cannot be auto-mocked.
- *
- * @typeParam Dependency - The dependency type being mocked.
- * @typeParam Backend - The spy type the factory produces, threaded into the returned `Mocked` view.
- *
- * @since 0.1.0
- */
-export function createAutoMock<Dependency, Backend extends MockFunction = Spy>(
-  mockFactory: MockFactory<Backend>,
-  seed?: DeepPartial<Dependency>,
-): Mocked<Dependency, Backend> {
-  // A primitive stub has no members to mock — the seed is the dependency's whole value.
-  if (seed !== undefined && (typeof seed !== "object" || seed === null) && typeof seed !== "function") {
-    return seed as Mocked<Dependency, Backend>;
-  }
-
-  const cache = new Map<string, unknown>();
-  const methodWrappers = new Map<string, unknown>();
-  const seedRecord = seed as Record<PropertyKey, unknown> | undefined;
-  const target = mockFactory();
-  let self: unknown;
-
-  const reset = (): void => {
-    resetSpy(target);
-    for (const child of cache.values()) {
-      resetSpy(child);
-    }
-    if (seedRecord !== undefined) {
-      for (const value of Object.values(seedRecord)) {
-        resetSpy(value);
-      }
-    }
-  };
-
-  const proxy = new Proxy(target, {
-    get(fnTarget, key, receiver): unknown {
-      if (key === MOCK_RESET) {
-        return reset;
-      }
-      if (seedRecord !== undefined && seedProvides(seedRecord, key)) {
-        // A non-configurable, non-writable target property must report its own value (proxy invariant).
-        const own = Reflect.getOwnPropertyDescriptor(fnTarget, key);
-        if (own !== undefined && own.configurable === false && own.writable === false) {
-          return own.value;
-        }
-        return Reflect.get(seedRecord, key);
-      }
-      if (typeof key === "symbol" || UNMOCKED_KEYS.has(key)) {
-        return Reflect.get(fnTarget, key, receiver);
-      }
-      if (Object.hasOwn(fnTarget, key)) {
-        const value = Reflect.get(fnTarget, key);
-        if (typeof value !== "function") {
-          return value;
-        }
-        // The backend's own methods run against the target, and a chainable return re-enters the mock.
-        let wrapper = methodWrappers.get(key);
-        if (wrapper === undefined) {
-          wrapper = (...args: ReadonlyArray<unknown>): unknown => {
-            const result = (value as (...call: ReadonlyArray<unknown>) => unknown).call(fnTarget, ...args);
-            return result === fnTarget ? self : result;
-          };
-          methodWrappers.set(key, wrapper);
-        }
-        return wrapper;
-      }
-      if (INHERITED_PASSTHROUGH.has(key)) {
-        return Reflect.get(fnTarget, key);
-      }
-      let child = cache.get(key);
-      if (child === undefined) {
-        child = createAutoMock(mockFactory);
-        cache.set(key, child);
-      }
-      return child;
-    },
-    // `in` agrees with `get`: any mockable string key answers true, everything else asks the target.
-    has(fnTarget, key): boolean {
-      if (key === MOCK_RESET) {
-        return true;
-      }
-      if (seedRecord !== undefined && seedProvides(seedRecord, key)) {
-        return true;
-      }
-      if (typeof key === "symbol" || UNMOCKED_KEYS.has(key)) {
-        return Reflect.has(fnTarget, key);
-      }
-      return true;
-    },
-    // Enumeration shows the interface's materialized members, not the spy backend's internals.
-    ownKeys(fnTarget): Array<string | symbol> {
-      const keys = new Set<string | symbol>();
-      if (seedRecord !== undefined) {
-        for (const key of Reflect.ownKeys(seedRecord)) {
-          keys.add(key);
-        }
-      }
-      for (const key of cache.keys()) {
-        keys.add(key);
-      }
-      // Non-configurable target keys must be reported (proxy invariant); the rest stay hidden.
-      for (const key of Reflect.ownKeys(fnTarget)) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(fnTarget, key);
-        if (descriptor !== undefined && descriptor.configurable === false) {
-          keys.add(key);
-        }
-      }
-      return [...keys];
-    },
-    getOwnPropertyDescriptor(fnTarget, key): PropertyDescriptor | undefined {
-      if (typeof key === "string" && (cache.has(key) || (seedRecord !== undefined && seedProvides(seedRecord, key)))) {
-        return {
-          configurable: true,
-          enumerable: true,
-          writable: true,
-          value: (proxy as Record<string, unknown>)[key],
-        };
-      }
-      return Reflect.getOwnPropertyDescriptor(fnTarget, key);
-    },
-    deleteProperty(fnTarget, key): boolean {
-      if (typeof key === "string" && cache.delete(key)) {
-        return true;
-      }
-      return Reflect.deleteProperty(fnTarget, key);
-    },
-  });
-
-  self = proxy;
-
-  return proxy as unknown as Mocked<Dependency, Backend>;
-}

package/src/mocking/mock-factory.ts

@@ -1,35 +0,0 @@
-/** The pluggable seam that decides which spy backend the auto-mocks are built from. */
-
-import type { Spy } from "#/mocking/spy";
-import { createSpy } from "#/mocking/spy";
-
-/**
- * The loose callable an auto-mock materializes for each accessed property.
- *
- * @remarks Deliberately structural so any backend qualifies: the built-in {@link Spy}, a Vitest
- * `vi.fn()`, a `jest.fn()`, or a Sinon stub all satisfy it.
- *
- * @since 0.1.0
- */
-export type MockFunction = (...args: ReadonlyArray<unknown>) => unknown;
-
-/**
- * The factory each auto-mocked member is created by.
- *
- * @remarks `Backend` is the spy type the factory returns, and it flows through the whole test bed:
- * `Mocked` members, `mocks.get`, and the `.stub` callback are all typed against it, so
- * `() => vi.fn()` gives every mock Vitest's own surface and `() => sinon.stub()` gives Sinon's —
- * with no adapter package and no module augmentation.
- *
- * @typeParam Backend - The spy type one factory call produces; defaults to the loose callable.
- *
- * @since 0.1.0
- */
-export type MockFactory<Backend extends MockFunction = MockFunction> = () => Backend;
-
-/**
- * The default `MockFactory` — one built-in {@link Spy} per call, with no test-framework dependency.
- *
- * @since 0.1.0
- */
-export const defaultMockFactory: MockFactory<Spy> = () => createSpy();

package/src/mocking/spy.ts

@@ -1,92 +0,0 @@
-/** The built-in zero-dependency spy the default mock factory hands out. */
-
-/**
- * One recorded invocation's outcome — a returned value or a thrown error.
- *
- * @since 0.1.0
- */
-export interface SpyResult {
-  readonly type: "return" | "throw";
-  readonly value: unknown;
-}
-
-/**
- * The call log a spy exposes for assertions.
- *
- * @typeParam Args - The spy's argument tuple.
- *
- * @since 0.1.0
- */
-export interface SpyState<Args extends ReadonlyArray<unknown>> {
-  readonly calls: ReadonlyArray<Args>;
-  readonly results: ReadonlyArray<SpyResult>;
-}
-
-/* oxlint-disable typescript/no-explicit-any -- a spy must be assignable to any return type */
-/**
- * The built-in zero-dependency spy: callable, records calls, and takes a return value or implementation.
- *
- * @remarks `Return` defaults to `any` so a spy drops into any typed method slot, exactly as Vitest's
- * own mock type does — the package's one deliberate `any`.
- *
- * @since 0.1.0
- */
-export interface Spy<Args extends ReadonlyArray<unknown> = ReadonlyArray<unknown>, Return = any> {
-  (...args: Args): Return;
-  /** The recorded calls and their outcomes. */
-  readonly mock: SpyState<Args>;
-  /** Sets a fixed value returned by every subsequent call. */
-  mockReturnValue(value: Return): this;
-  /** Replaces the spy's behaviour with `fn`, still recording each call. */
-  mockImplementation(fn: (...args: Args) => Return): this;
-  /** Clears the recorded calls and any configured return value or implementation. */
-  mockReset(): void;
-}
-/* oxlint-enable typescript/no-explicit-any */
-
-/**
- * Creates a fresh zero-dependency spy that records its calls and returns `undefined` until configured.
- *
- * @since 0.1.0
- */
-export function createSpy(): Spy {
-  const calls: Array<ReadonlyArray<unknown>> = [];
-  const results: Array<SpyResult> = [];
-  let implementation: ((...args: ReadonlyArray<unknown>) => unknown) | undefined;
-  let returnValue: unknown;
-
-  const spy = Object.assign(
-    (...args: ReadonlyArray<unknown>): unknown => {
-      calls.push(args);
-      try {
-        const value = implementation === undefined ? returnValue : implementation(...args);
-        results.push({ type: "return", value });
-        return value;
-      } catch (error) {
-        results.push({ type: "throw", value: error });
-        throw error;
-      }
-    },
-    {
-      mock: { calls, results },
-      mockReturnValue(value: unknown): Spy {
-        returnValue = value;
-        implementation = undefined;
-        return spy;
-      },
-      mockImplementation(fn: (...args: ReadonlyArray<unknown>) => unknown): Spy {
-        implementation = fn;
-        return spy;
-      },
-      // Cleared in place so `mock` stays one stable object across resets.
-      mockReset(): void {
-        calls.length = 0;
-        results.length = 0;
-        implementation = undefined;
-        returnValue = undefined;
-      },
-    },
-  ) as Spy;
-
-  return spy;
-}

package/src/test-bed/bed-builder.ts

@@ -1,172 +0,0 @@
-/** The override-recording core both test-bed builders extend. */
-
-import type { Constructor, Container, DependencyKey, InjectOptions, MetadataReader } from "@codefast/di";
-import { defaultMetadataReader } from "@codefast/di";
-import { verifyingMetadataReader } from "@codefast/di/metadata/verifying-metadata-reader";
-
-import type { BoundMock, SlotCriteria, SlottedOverride } from "#/discovery/mock-binder";
-import { criteriaEquals, normalizeCriteria } from "#/discovery/mock-binder";
-import type { DeepPartial } from "#/mocking/auto-mock";
-import type { MockFactory, MockFunction } from "#/mocking/mock-factory";
-import { defaultMockFactory } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
-import type { InjectionIdentifier } from "#/types";
-
-/**
- * Options that configure a whole test-bed compile.
- *
- * @typeParam Backend - The spy type the mock factory produces; it flows into every `Mocked` member,
- * `mocks.get`, and the `.stub` callback, so `() => vi.fn()` yields Vitest's own mock typing.
- *
- * @since 0.1.0
- */
-export interface TestBedOptions<Backend extends MockFunction = Spy> {
-  /** Spy factory each auto-mock property is materialized with; defaults to the built-in spy. */
-  readonly mockFactory?: MockFactory<Backend> | undefined;
-  /** Reader the dependency scan and the compile container both consult; defaults to di's reader. */
-  readonly metadataReader?: MetadataReader | undefined;
-}
-
-/**
- * The override step: choose how one named dependency is supplied instead of a plain auto-mock.
- *
- * @typeParam Dependency - The dependency's value type.
- * @typeParam Owner - The builder the chain returns to.
- * @typeParam Backend - The spy type the bed's mock factory produces.
- *
- * @since 0.1.0
- */
-export interface MockOverrideBuilder<Dependency, Owner, Backend extends MockFunction = Spy> {
-  /**
-   * Supplies a fixed value for this dependency.
-   *
-   * @remarks The value is bound as-is and sealed: it has no mock surface, so `mocks.get` refuses
-   * it rather than hand it back mistyped — the test already holds the reference it passed in.
-   */
-  using(value: Dependency): Owner;
-  /**
-   * Supplies a partial stub, built from the active spy factory; unlisted members stay auto-mocked.
-   *
-   * @remarks The callback runs once per compile, so beds built from one builder never share spies.
-   */
-  stub(setup: (fn: MockFactory<Backend>) => DeepPartial<Dependency>): Owner;
-  /** Leaves the dependency unbound: an `optional()` slot resolves `undefined`, an `injectAll()` slot `[]`. */
-  absent(): Owner;
-  /** Supplies every element of an unconstrained `injectAll()` slot, in order. Sealed like `.using`. */
-  usingAll(values: ReadonlyArray<Dependency>): Owner;
-}
-
-/**
- * What a builder's prepare step hands the compile template: the container and the bound mock entries.
- *
- * @since 0.1.0
- */
-export interface PreparedBed {
-  readonly container: Container;
-  readonly mocks: ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>;
-}
-
-/**
- * The shared builder core: records overrides, resolves the reader and mock factory, and owns the
- * compile template that disposes the container when a build fails.
- *
- * @remarks Fields are `protected` rather than `#` so the two concrete builders stay thin; nothing
- * outside `test-bed/` extends this class.
- *
- * @typeParam Class - The class under test.
- * @typeParam Backend - The spy type the bed's mock factory produces.
- *
- * @since 0.1.0
- */
-export abstract class BedBuilder<Class, Backend extends MockFunction = Spy> {
-  protected readonly target: Constructor<Class>;
-  protected readonly reader: MetadataReader;
-  protected readonly mockFactory: MockFactory<Backend>;
-  protected readonly overrides: ReadonlyMap<DependencyKey, ReadonlyArray<SlottedOverride>> = new Map();
-
-  constructor(target: Constructor<Class>, options?: TestBedOptions<Backend>) {
-    this.target = target;
-    // A supplied reader is a claim — verify it the way the container itself does.
-    this.reader = verifyingMetadataReader(options?.metadataReader ?? defaultMetadataReader);
-    // With no factory the caller's Backend defaulted to Spy, which is what the default produces.
-    this.mockFactory = options?.mockFactory ?? (defaultMockFactory as unknown as MockFactory<Backend>);
-  }
-
-  /**
-   * Replaces the auto-mock for one dependency with a hand-written stub or a concrete value.
-   *
-   * @remarks Pass `options` (a name or tags) to target one slot of a token bound several ways;
-   * without them the override covers every slot of the token that has no more specific override.
-   * Registering the same target twice replaces the earlier override wholesale.
-   */
-  mock<Dependency>(
-    identifier: InjectionIdentifier<Dependency>,
-    options?: InjectOptions,
-  ): MockOverrideBuilder<Dependency, this, Backend> {
-    const key = identifier as DependencyKey;
-    const criteria = normalizeCriteria(options);
-    const set = (override: SlottedOverride["override"]): this => {
-      this.#register(key, criteria, override);
-      return this;
-    };
-    return {
-      using: (value) => set({ kind: "value", value }),
-      stub: (setup) => set({ kind: "stub", setup: setup as (fn: MockFactory) => unknown }),
-      absent: () => set({ kind: "absent" }),
-      usingAll: (values) => set({ kind: "all", values }),
-    };
-  }
-
-  /** Resolves the unit inside a guard that disposes the container when any compile step throws. */
-  protected compileWith<Prepared extends PreparedBed, Bed>(
-    prepare: () => Prepared,
-    build: (unit: Class, prepared: Prepared) => Bed,
-  ): Bed {
-    let prepared: Prepared | undefined;
-    try {
-      prepared = prepare();
-      const unit = prepared.container.resolve(this.target);
-      return build(unit, prepared);
-    } catch (error) {
-      // A failed compile still owns the container — dispose it so no lifecycle state leaks.
-      void prepared?.container.dispose().catch(() => undefined);
-      throw error;
-    }
-  }
-
-  /** The async twin of {@link compileWith}, for units whose activation is asynchronous. */
-  protected async compileWithAsync<Prepared extends PreparedBed, Bed>(
-    prepare: () => Prepared,
-    build: (unit: Class, prepared: Prepared) => Bed,
-  ): Promise<Bed> {
-    let prepared: Prepared | undefined;
-    try {
-      prepared = prepare();
-      const unit = await prepared.container.resolveAsync(this.target);
-      return build(unit, prepared);
-    } catch (error) {
-      await prepared?.container.dispose().catch(() => undefined);
-      throw error;
-    }
-  }
-
-  /** Records an override, replacing any earlier one that targets the same token and slot. */
-  #register(key: DependencyKey, criteria: SlotCriteria | undefined, override: SlottedOverride["override"]): void {
-    const overrides = this.overrides as Map<DependencyKey, Array<SlottedOverride>>;
-    let list = overrides.get(key);
-    if (list === undefined) {
-      list = [];
-      overrides.set(key, list);
-    }
-    const existing = list.findIndex((candidate) =>
-      candidate.criteria === undefined || criteria === undefined
-        ? candidate.criteria === criteria
-        : criteriaEquals(candidate.criteria, criteria),
-    );
-    if (existing === -1) {
-      list.push({ criteria, override });
-    } else {
-      list[existing] = { criteria, override };
-    }
-  }
-}

package/src/test-bed/sociable-builder.ts

@@ -1,148 +0,0 @@
-/** The fluent builder that compiles a unit together with chosen real collaborators. */
-
-import type { Constructor, DependencySlot, InjectOptions } from "@codefast/di";
-import { Container, token } from "@codefast/di";
-
-import { scanSociableDependencies } from "#/discovery/dependency-scanner";
-import { bindMocks } from "#/discovery/mock-binder";
-import { ExposureError } from "#/errors/errors";
-import type { MockFunction } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
-import type { MockOverrideBuilder, PreparedBed } from "#/test-bed/bed-builder";
-import { BedBuilder } from "#/test-bed/bed-builder";
-import type { SociableUnitTestBed } from "#/test-bed/unit-test-bed";
-import { createSociableUnitTestBed, createUnitTestBed } from "#/test-bed/unit-test-bed";
-import type { InjectionIdentifier } from "#/types";
-
-/**
- * A sociable build in progress: expose real collaborators, override the rest, then compile.
- *
- * @remarks Exposure follows class identity: a class-keyed dependency of the unit — or of another
- * exposed class — stays real when exposed. A `Token`-keyed dependency is always mocked, treating
- * tokens as the declared boundary between the logic under test and the outside world.
- *
- * @typeParam Class - The class under test.
- * @typeParam Backend - The spy type the bed's mock factory produces.
- *
- * @since 0.1.0
- */
-export interface SociableTestBedBuilder<Class, Backend extends MockFunction = Spy> {
-  /** Keeps a class-keyed collaborator real; its own dependencies follow the same exposure rules. */
-  expose(target: Constructor): SociableTestBedBuilder<Class, Backend>;
-  /** Replaces the auto-mock for one dependency with a hand-written stub or a concrete value. */
-  mock<Dependency>(
-    identifier: InjectionIdentifier<Dependency>,
-    options?: InjectOptions,
-  ): MockOverrideBuilder<Dependency, SociableTestBedBuilder<Class, Backend>, Backend>;
-  /** Instantiates the unit and its exposed subtree, mocking everything else. */
-  compile(): SociableUnitTestBed<Class, Backend>;
-  /** Async variant for a subtree whose `@postConstruct` is async; otherwise identical to {@link compile}. */
-  compileAsync(): Promise<SociableUnitTestBed<Class, Backend>>;
-}
-
-/** What the sociable prepare step adds to the shared shape: the reachable exposed classes. */
-type PreparedSociableBed = PreparedBed & { readonly realClasses: ReadonlySet<Constructor> };
-
-/**
- * The default {@link SociableTestBedBuilder}, backed by a fresh container per compile.
- *
- * @typeParam Class - The class under test.
- * @typeParam Backend - The spy type the bed's mock factory produces.
- *
- * @since 0.1.0
- */
-export class SociableBuilder<Class, Backend extends MockFunction = Spy>
-  extends BedBuilder<Class, Backend>
-  implements SociableTestBedBuilder<Class, Backend>
-{
-  readonly #exposed = new Set<Constructor>();
-
-  expose(target: Constructor): this {
-    this.#exposed.add(target);
-    return this;
-  }
-
-  compile(): SociableUnitTestBed<Class, Backend> {
-    return this.compileWith(
-      () => this.#prepare(),
-      (unit, prepared) =>
-        createSociableUnitTestBed(
-          createUnitTestBed(unit, prepared.mocks, prepared.container),
-          prepared.container,
-          prepared.realClasses,
-        ),
-    );
-  }
-
-  async compileAsync(): Promise<SociableUnitTestBed<Class, Backend>> {
-    return this.compileWithAsync(
-      () => this.#prepare(),
-      (unit, prepared) =>
-        createSociableUnitTestBed(
-          createUnitTestBed(unit, prepared.mocks, prepared.container),
-          prepared.container,
-          prepared.realClasses,
-        ),
-    );
-  }
-
-  /** Scans across the exposed set, binds mocks for the boundary, and binds every real class. */
-  #prepare(): PreparedSociableBed {
-    if (this.#exposed.has(this.target)) {
-      throw new ExposureError(this.target.name, "the unit under test is already real — expose only its collaborators.");
-    }
-
-    const container = Container.create({ metadataReader: this.reader });
-    const { mockSlots, realClasses, realSlots } = scanSociableDependencies(this.target, this.#exposed, this.reader);
-
-    // An exposed class the unit never reaches is a stale exposure — likely a typo or a refactor.
-    for (const exposedClass of this.#exposed) {
-      if (!realClasses.has(exposedClass)) {
-        throw new ExposureError(
-          exposedClass.name,
-          "the unit never reaches this class through exposed collaborators. Expose the intermediate classes on the path to it, or remove the exposure.",
-        );
-      }
-    }
-
-    const mocks = bindMocks(container, mockSlots, this.overrides, this.mockFactory, this.#exposed);
-
-    const constrainedSlots = new Map<Constructor, Array<DependencySlot>>();
-    for (const slot of realSlots) {
-      const list = constrainedSlots.get(slot.token as Constructor) ?? [];
-      list.push(slot);
-      constrainedSlots.set(slot.token as Constructor, list);
-    }
-
-    // Real collaborators are singletons, so the unit and bed.exposed() see one instance each,
-    // and their @preDestroy hooks run on dispose.
-    const merged = new Map(mocks);
-    for (const realClass of realClasses) {
-      const slots = constrainedSlots.get(realClass);
-      if (slots === undefined) {
-        container.bind(realClass).toSelf().singleton();
-      } else {
-        // A name/tag-constrained slot needs its own binding, and di rejects a self-alias — so the
-        // one real binding lives on a private token, and every slot of the class resolves it
-        // through a factory (an alias would forward the slot's criteria to the private token).
-        const realToken = token<unknown>(`di-testing:real:${realClass.name}`);
-        container.bind(realToken).to(realClass).singleton();
-        container.bind(realClass).toDynamic((context) => context.resolve(realToken));
-        for (const slot of slots) {
-          const builder = container.bind(realClass).toDynamic((context) => context.resolve(realToken));
-          if (slot.name !== undefined) {
-            builder.whenNamed(slot.name);
-          }
-          for (const tag of slot.tags ?? []) {
-            builder.whenTagged(tag);
-          }
-        }
-      }
-      // Sealed entries so mocks.get points at bed.exposed() instead of handing back a fake Mocked.
-      merged.set(realClass, [{ criteria: undefined, value: undefined, kind: "exposed" }]);
-    }
-    container.bind(this.target).toSelf().singleton();
-
-    return { container, mocks: merged, realClasses };
-  }
-}