@codefast/di-testing 0.1.4 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,91 @@
 # @codefast/di-testing
 
+## 0.3.0
+
+### Minor Changes
+
+- [#999](https://github.com/codefastlabs/codefast/pull/999) Requires `@codefast/di` 0.12, whose chains declare a binding's slot before its strategy; the test beds bind their mocks
+  and real collaborators in that order.
+
+### Patch Changes
+
+- [#1005](https://github.com/codefastlabs/codefast/pull/1005) **Breaking for deep subpath imports only** — the root entry `@codefast/di` is unchanged. `src/` now follows three rules,
+  and the published subpaths follow `src/` with no exception: a directory names a family of two or more modules and a lone
+  module sits flat at its layer; a directory carries the topic and a file its role, so no file repeats its directory's
+  name; and the exports map is the source tree, so the `strip` that kept the introspection modules at flat specifiers is
+  gone.
+
+  Moves: the `MetadataReader` verification leaves `resolution/cache/class-introspector` for `metadata/verify` — it was the
+  one value import pointing up from `metadata/` into `resolution/`; the `RESOLUTION_DIAGNOSTICS` channel leaves `errors/`
+  for `introspection/diagnostics`; the fluent chain's contract leaves `core/binding` for `core/binding-builders`, and the
+  class implementing it is `container/binding-chain`; `effectiveBindingScope` folds into `core/binding`.
+
+  Renamed specifiers: `./errors/errors` → `./errors`; `./errors/diagnostics` → `./introspection/diagnostics`;
+  `./ambient/active-container` → `./ambient-container`; `./container/binding-builders` → `./container/binding-chain`;
+  `./core/binding-scope` → gone (`effectiveBindingScope` is in `./core/binding`); `./injection/resolve-options` →
+  `./injection/dependency-slot`;
+  `./metadata/{metadata-keys,metadata-types,metadata-reader-token,symbol-metadata-reader,verifying-metadata-reader}` →
+  `./metadata/{keys,types,reader-token,symbol-reader,verifying-reader}`; `./lifecycle/{lifecycle-manager,scope-manager}` →
+  `./lifecycle/{hooks,scopes}`; `./decorators/{lifecycle-decorators,decorator-metadata}` →
+  `./decorators/{lifecycle,metadata-record}`; `./resolution/path/resolution-path` → `./resolution/path`;
+  `./resolution/plan/{instantiation-plan,plan-codegen}` → `./resolution/plan/{compiler,codegen}`;
+  `./resolution/select/binding-select` → `./resolution/select/candidates`; `./resolution/cache/binding-lookup-cache` →
+  `./resolution/cache/lookup`; `./{inspector,explanation,dependency-graph,graph-adapters/*}` →
+  `./introspection/{inspector,explanation,dependency-graph,graph-adapters/*}`. New: `./core/binding-builders`,
+  `./metadata/verify`.
+
+  `@codefast/di-testing` follows the one specifier it imports, `metadata/verifying-reader`.
+
+- Updated dependencies:
+  - @codefast/di@0.12.0
+
+## 0.2.0
+
+### Minor Changes
+
+- [#952](https://github.com/codefastlabs/codefast/pull/952) A suite now states its mock backend once, and a test bed can no longer be typed against one backend and built from
+  another. `createTestBed({ mockFactory, metadataReader? })` returns the entry point every bed begins from, its `Backend`
+  inferred from the factory; `TestBed.solitary(target)` and `TestBed.sociable(target)` take the target only. The `TestBed`
+  export is `createTestBed({ mockFactory: defaultMockFactory })`, the built-in spy with no framework needed.
+
+  Before, the backend was chosen per call — `TestBed.solitary(Unit, { mockFactory: () => vi.fn() })` — and
+  `TestBed.solitary<Unit, SinonStub>(Unit)` with no factory type-checked, typed every mock as `SinonStub`, and built the
+  default spy. Migrate by creating the suite's entry point once:
+
+  ```ts
+  import { createTestBed } from "@codefast/di-testing";
+  import { vi } from "vitest";
+
+  export const TestBed = createTestBed({ mockFactory: () => vi.fn() });
+  ```
+
+  `TestBedOptions<Backend>` configures `createTestBed` and requires `mockFactory`; `TestBedStatic<Backend>` names the
+  entry point's backend and has no default. `createTestBed` throws the new `MissingMockFactoryError`
+  (`MISSING_MOCK_FACTORY`) for a caller past the types who passes no factory, instead of standing the built-in spy in for
+  a backend nobody chose.
+
+- [#976](https://github.com/codefastlabs/codefast/pull/976) `engines.node` is now `>=24.0.0`, up from `>=22.12.0`, and Node 22 is no longer supported. Node 24.0.0 is the first
+  release with explicit resource management built in (`using`, `await using`, `DisposableStack`, `AsyncDisposableStack`,
+  `SuppressedError`) and all of ES2025, so the packages use both as the platform ships them instead of shimming them for
+  an older line, and the CI matrix runs the unit suite on 24.0.0 itself. Move to Node 24, or stay on the current minor
+  while a deployment still runs Node 22.
+
+### Patch Changes
+
+- [#976](https://github.com/codefastlabs/codefast/pull/976) The README states what a program needs for the declarations' disposal members: the explicit resource management types,
+  which no numbered `lib` declares before ES2027. `@types/node` 24 or later loads them, and so does `ESNext.Disposable` in
+  `lib`. Without either, TypeScript 7 fails inside `container.d.ts` with TS2550 under `skipLibCheck: false`, and at
+  `await using` with TS2318. `@codefast/di-testing` drops a `/// <reference lib="esnext.disposable" />` that TypeScript 7
+  stripped from its emitted declarations anyway, and takes the lib from its `tsconfig.json` instead.
+
+- [#956](https://github.com/codefastlabs/codefast/pull/956) `README.md` no longer quotes the `@codefast/di` peer range, which had fallen behind `package.json` — the release tooling
+  moves that range, so the manifest is the one place it is stated.
+
+- [#965](https://github.com/codefastlabs/codefast/pull/965) `README.md` now states TypeScript 7 or later as the floor for the package's types — the one compiler every `@codefast/*`
+  package is built and checked with. No code or declaration changed.
+- Updated dependencies:
+  - @codefast/di@0.11.0
+
 ## 0.1.4
 
 ### Patch Changes

package/README.md

@@ -19,11 +19,13 @@ production — and you assert against the mocks the bed created.
   and builds a mock for each — no per-collaborator `bind(...).toConstantValue(...)`.
 - **Real instance, real wiring.** The unit is constructed through a container, so `@postConstruct`, accessor injection,
   and `@preDestroy` run exactly as in production.
-- **Zero test-framework dependency.** The default mock is a small built-in spy. Pass `() => vi.fn()` — or `jest.fn`,
-  `() => sinon.stub()` — to build the mocks from that backend and use its matchers instead.
-- **Backend-typed lookups.** The factory's return type flows through the whole bed: with `() => vi.fn()`,
-  `mocks.get(EmailToken).send` carries Vitest's own mock surface (`mockReturnValueOnce`, `mockClear`, and so on), with
-  no adapter package and no module augmentation.
+- **Zero test-framework dependency.** The default `TestBed` mocks with a small built-in spy. Create your suite's own
+  with `createTestBed({ mockFactory: () => vi.fn() })` — or `jest.fn`, `() => sinon.stub()` — to build every mock from
+  that backend and use its matchers instead.
+- **Backend-typed lookups.** The factory's return type flows through every bed the entry point begins: with
+  `() => vi.fn()`, `mocks.get(EmailToken).send` carries Vitest's own mock surface (`mockReturnValueOnce`, `mockClear`,
+  and so on), with no adapter package and no module augmentation. A bed can have no other backend than its entry point,
+  so a mock is never typed as one backend and built from another.
 
 ## Installation
 
@@ -31,17 +33,21 @@ production — and you assert against the mocks the bed created.
 pnpm add -D @codefast/di-testing
 ```
 
-`@codefast/di-testing` requires Node.js 22.12 or later and a peer install of `@codefast/di` (`>=0.8.0`), with the same
-TypeScript setup: native Stage 3 decorators, `experimentalDecorators` off. The package is published on 0.x and versioned
-on its own track: breaking changes ship as minor versions, so pin the minor version when you need stability.
+`@codefast/di-testing` requires Node.js 24 or later, TypeScript 7 or later, and a peer install of `@codefast/di`, with
+the same TypeScript setup: native Stage 3 decorators, `experimentalDecorators` off, and the explicit resource management
+types, from `@types/node` 24 or later or from `ESNext.Disposable` in `lib`. The package is published on 0.x and
+versioned on its own track: breaking changes ship as minor versions, so pin the minor version when you need stability.
 
 ## Quick start
 
 ```ts
 import { injectable, token } from "@codefast/di";
-import { TestBed } from "@codefast/di-testing";
+import { createTestBed } from "@codefast/di-testing";
 import { expect, it, vi } from "vitest";
 
+// The suite's entry point on Vitest spies, so matchers and mockReturnValue work on every mock.
+const TestBed = createTestBed({ mockFactory: () => vi.fn() });
+
 interface UserService {
   findUser(id: string): { id: string; email: string };
 }
@@ -73,7 +79,7 @@ class OrderProcessor {
 }
 
 it("charges then emails a confirmation", () => {
-  const { unit, mocks } = TestBed.solitary(OrderProcessor, { mockFactory: () => vi.fn() })
+  const { unit, mocks } = TestBed.solitary(OrderProcessor)
     .mock(UserServiceToken)
     .stub((fn) => ({ findUser: fn().mockReturnValue({ id: "u1", email: "alice@example.com" }) }))
     .compile();
@@ -85,8 +91,8 @@ it("charges then emails a confirmation", () => {
 });
 ```
 
-The zero-dependency default reads the same, minus the `mockFactory`. Assert against the built-in spy's `.mock.calls` and
-stub with `.mockReturnValue()`:
+The zero-dependency default is the `TestBed` export itself. Assert against the built-in spy's `.mock.calls` and stub
+with `.mockReturnValue()`:
 
 ```ts
 import { TestBed } from "@codefast/di-testing";
@@ -97,14 +103,29 @@ unit.placeOrder("u1", 42);
 assert.deepEqual(mocks.get(PaymentGatewayToken).charge.mock.calls[0], ["u1", 42]);
 ```
 
-## Solitary beds
+## Entry points
+
+A suite states its mock backend once. `createTestBed(options)` returns the entry point every bed in the suite begins
+from — typically created in one shared test-support module:
 
-`TestBed.solitary(target, options?)` begins a bed for `target` and auto-mocks every dependency it declares. Nothing is
-instantiated until you call `compile()`. The options:
+```ts
+import { createTestBed } from "@codefast/di-testing";
+import { vi } from "vitest";
+
+export const TestBed = createTestBed({ mockFactory: () => vi.fn() });
+```
 
-- `mockFactory?: () => spy` — the spy backend each auto-mock is built from. Defaults to the built-in spy.
+- `mockFactory: () => spy` — required: the spy backend each auto-mock is built from. Its return type is the entry
+  point's backend and types every bed it begins. Pass `defaultMockFactory` for the built-in spy.
 - `metadataReader?: MetadataReader` — the reader dependencies are discovered through. Defaults to di's reader.
 
+The `TestBed` export is `createTestBed({ mockFactory: defaultMockFactory })`: the built-in spy, no framework needed.
+
+## Solitary beds
+
+`TestBed.solitary(target)` begins a bed for `target` and auto-mocks every dependency it declares with the entry point's
+backend. Nothing is instantiated until you call `compile()`.
+
 The builder records overrides, then compiles:
 
 - `.mock(token).stub((fn) => stub)` — bind a partial stub built from the active spy factory; unlisted members stay
@@ -127,14 +148,17 @@ The builder records overrides, then compiles:
 ## Sociable beds
 
 A sociable bed keeps chosen collaborators real while everything else stays mocked — a unit test over a small real
-subtree, not an integration test. `TestBed.sociable(target, options?)` takes the same options and returns only
-`.expose()`, because a sociable bed with nothing exposed is a solitary bed.
+subtree, not an integration test. `TestBed.sociable(target)` mocks with the entry point's backend like `solitary` and
+returns only `.expose()`, because a sociable bed with nothing exposed is a solitary bed.
 
 ```ts
 import { injectable, token } from "@codefast/di";
-import { TestBed } from "@codefast/di-testing";
+import { createTestBed } from "@codefast/di-testing";
 import { expect, it, vi } from "vitest";
 
+// The suite's entry point on Vitest spies, so matchers and mockReturnValue work on every mock.
+const TestBed = createTestBed({ mockFactory: () => vi.fn() });
+
 interface TaxPolicy {
   rateFor(currency: string): number;
 }
@@ -160,7 +184,7 @@ class CheckoutService {
 }
 
 it("prices through the real PricingService over a mocked tax boundary", () => {
-  const bed = TestBed.sociable(CheckoutService, { mockFactory: () => vi.fn() })
+  const bed = TestBed.sociable(CheckoutService)
     .expose(PricingService)
     .mock(TaxPolicyToken)
     .stub((fn) => ({ rateFor: fn().mockReturnValue(0.1) }))
@@ -206,10 +230,10 @@ it("prices through the real PricingService over a mocked tax boundary", () => {
 - `dispose()` — run the unit's `@preDestroy` hooks and dispose the container.
 
 The bed implements `AsyncDisposable`, so `await using bed = TestBed.solitary(X).compile()` disposes it at the end of the
-block; that needs the `esnext.disposable` lib in your TypeScript configuration if your `target` does not include it.
+block.
 
 The lower-level pieces are exported too: `createAutoMock`, `createSpy`, `defaultMockFactory`, and the `Mocked`,
-`DeepPartial`, `MockFactory`, and `Spy` types.
+`DeepPartial`, `MockFactory`, `Spy`, and `TestBedOptions` types.
 
 ## Errors
 
@@ -227,7 +251,7 @@ extending it, so setup failures can be caught separately from resolution failure
 ## Documentation
 
 - [Rendered docs on codefastlabs.com](https://codefastlabs.com/docs/di-testing)
-- [`@codefast/di`](../di/README.md) — the container this package builds on, including its `SPEC.md`.
+- [`@codefast/di`](../di/README.md) — the container this package builds on, including its specification under `spec/`.
 - [`CHANGELOG.md`](./CHANGELOG.md) — release history.
 
 ## Contributing

package/dist/discovery/mock-binder.js

@@ -127,7 +127,7 @@ export function bindMocks(container, dependencies, overrides, mockFactory, expos
         }
     };
     const bindConstant = (slot, value) => {
-        const builder = container.bind(slot.token).toConstantValue(value);
+        const builder = container.bind(slot.token);
         if (slot.name !== undefined) {
             builder.whenNamed(slot.name);
         }
@@ -136,6 +136,7 @@ export function bindMocks(container, dependencies, overrides, mockFactory, expos
                 builder.whenTagged(tag);
             }
         }
+        builder.toConstantValue(value);
     };
     for (const slot of dependencies) {
         const list = overrides.get(slot.token) ?? [];
@@ -167,8 +168,8 @@ export function bindMocks(container, dependencies, overrides, mockFactory, expos
                     for (const [index, value] of values.entries()) {
                         container
                             .bind(slot.token)
-                            .toConstantValue(value)
-                            .whenNamed(`${ALL_ELEMENT_SLOT_PREFIX}${String(index)}`);
+                            .whenNamed(`${ALL_ELEMENT_SLOT_PREFIX}${String(index)}`)
+                            .toConstantValue(value);
                     }
                     record(slot.token, { criteria: override.criteria, value: values, kind: "all" });
                 }

package/dist/errors/errors.d.ts

@@ -21,6 +21,18 @@ export declare class NotInjectableError extends TestingError {
     readonly targetName: string;
     constructor(targetName: string);
 }
+/**
+ * A `createTestBed(...)` call with no mock factory to build its beds' mocks from.
+ *
+ * @remarks The types require the factory; this reaches a caller the compiler cannot, and stops the
+ * built-in spy from standing in for a backend nobody chose.
+ *
+ * @since 0.2.0
+ */
+export declare class MissingMockFactoryError extends TestingError {
+    readonly code = "MISSING_MOCK_FACTORY";
+    constructor();
+}
 /**
  * A `.mock(...)` override or a `mocks.get(...)` lookup named a token or slot the unit does not use.
  *

package/dist/errors/errors.js

@@ -26,6 +26,20 @@ export class NotInjectableError extends TestingError {
         this.targetName = targetName;
     }
 }
+/**
+ * A `createTestBed(...)` call with no mock factory to build its beds' mocks from.
+ *
+ * @remarks The types require the factory; this reaches a caller the compiler cannot, and stops the
+ * built-in spy from standing in for a backend nobody chose.
+ *
+ * @since 0.2.0
+ */
+export class MissingMockFactoryError extends TestingError {
+    code = "MISSING_MOCK_FACTORY";
+    constructor() {
+        super("createTestBed() needs a mockFactory to build every bed's mocks from: pass defaultMockFactory for the built-in spy, or a factory such as () => vi.fn().");
+    }
+}
 /**
  * A `.mock(...)` override or a `mocks.get(...)` lookup named a token or slot the unit does not use.
  *

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** Solitary and sociable auto-mocking test beds for `@codefast/di`. */
-export { TestBed } from "#test-bed/test-bed";
+export { createTestBed, TestBed } from "#test-bed/test-bed";
 export type { TestBedStatic } from "#test-bed/test-bed";
 export type { MockOverrideBuilder, PreparedBed, TestBedOptions } from "#test-bed/bed-builder";
 export type { SolitaryTestBedBuilder } from "#test-bed/solitary-builder";
@@ -12,5 +12,5 @@ export type { MockFactory, MockFunction } from "#mocking/mock-factory";
 export { createSpy } from "#mocking/spy";
 export type { Spy, SpyResult, SpyState } from "#mocking/spy";
 export type { InjectionIdentifier } from "#types";
-export { ExposureError, NotInjectableError, OverrideMismatchError, SealedDependencyError, TestingError, UndeclaredDependencyError, } from "#errors/errors";
+export { MissingMockFactoryError, ExposureError, NotInjectableError, OverrideMismatchError, SealedDependencyError, TestingError, UndeclaredDependencyError, } from "#errors/errors";
 export type { SealedCause } from "#errors/errors";

package/dist/index.js

@@ -1,6 +1,6 @@
 /** Solitary and sociable auto-mocking test beds for `@codefast/di`. */
-export { TestBed } from "#test-bed/test-bed";
+export { createTestBed, TestBed } from "#test-bed/test-bed";
 export { createAutoMock, MOCK_RESET } from "#mocking/auto-mock";
 export { defaultMockFactory } from "#mocking/mock-factory";
 export { createSpy } from "#mocking/spy";
-export { ExposureError, NotInjectableError, OverrideMismatchError, SealedDependencyError, TestingError, UndeclaredDependencyError, } from "#errors/errors";
+export { MissingMockFactoryError, ExposureError, NotInjectableError, OverrideMismatchError, SealedDependencyError, TestingError, UndeclaredDependencyError, } from "#errors/errors";

package/dist/test-bed/bed-builder.d.ts

@@ -6,16 +6,16 @@ import type { MockFactory, MockFunction } from "#mocking/mock-factory";
 import type { Spy } from "#mocking/spy";
 import type { InjectionIdentifier } from "#types";
 /**
- * Options that configure a whole test-bed compile.
+ * What `createTestBed` is configured with: the mock backend and the reader every bed it begins shares.
  *
  * @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;
+export interface TestBedOptions<Backend extends MockFunction> {
+    /** Spy factory each auto-mock property is materialized with; its return type is the beds' backend. */
+    readonly mockFactory: MockFactory<Backend>;
     /** Reader the dependency scan and the compile container both consult; defaults to di's reader. */
     readonly metadataReader?: MetadataReader | undefined;
 }
@@ -74,7 +74,7 @@ export declare abstract class BedBuilder<Class, Backend extends MockFunction = S
     protected readonly reader: MetadataReader;
     protected readonly mockFactory: MockFactory<Backend>;
     protected readonly overrides: ReadonlyMap<DependencyKey, ReadonlyArray<SlottedOverride>>;
-    constructor(target: Constructor<Class>, options?: TestBedOptions<Backend>);
+    constructor(target: Constructor<Class>, options: TestBedOptions<Backend>);
     /**
      * Replaces the auto-mock for one dependency with a hand-written stub or a concrete value.
      *

package/dist/test-bed/bed-builder.js

@@ -1,8 +1,7 @@
 /** The override-recording core both test-bed builders extend. */
 import { defaultMetadataReader } from "@codefast/di";
-import { verifyingMetadataReader } from "@codefast/di/metadata/verifying-metadata-reader";
+import { verifyingMetadataReader } from "@codefast/di/metadata/verifying-reader";
 import { criteriaEquals, normalizeCriteria } from "#discovery/mock-binder";
-import { defaultMockFactory } from "#mocking/mock-factory";
 /**
  * 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.
@@ -23,9 +22,8 @@ export class BedBuilder {
     constructor(target, options) {
         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;
+        this.reader = verifyingMetadataReader(options.metadataReader ?? defaultMetadataReader);
+        this.mockFactory = options.mockFactory;
     }
     /**
      * Replaces the auto-mock for one dependency with a hand-written stub or a concrete value.

package/dist/test-bed/sociable-builder.js

@@ -61,13 +61,14 @@ export class SociableBuilder extends BedBuilder {
                 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));
+                    const builder = container.bind(realClass);
                     if (slot.name !== undefined) {
                         builder.whenNamed(slot.name);
                     }
                     for (const tag of slot.tags ?? []) {
                         builder.whenTagged(tag);
                     }
+                    builder.toDynamic((context) => context.resolve(realToken));
                 }
             }
             // Sealed entries so mocks.get points at bed.exposed() instead of handing back a fake Mocked.

package/dist/test-bed/test-bed.d.ts

@@ -1,4 +1,4 @@
-/** The entry point for building isolated units under test. */
+/** The entry points for building isolated units under test. */
 import type { Constructor } from "@codefast/di";
 import type { MockFunction } from "#mocking/mock-factory";
 import type { Spy } from "#mocking/spy";
@@ -6,33 +6,43 @@ import type { TestBedOptions } from "#test-bed/bed-builder";
 import type { SociableTestBedBuilder } from "#test-bed/sociable-builder";
 import type { SolitaryTestBedBuilder } from "#test-bed/solitary-builder";
 /**
- * The factory surface for building isolated units under test.
+ * Begins test beds for classes under test, every one of them mocked with the same backend.
+ *
+ * @typeParam Backend - The spy type every bed's mocks are built with, fixed when the entry point is created.
  *
  * @since 0.1.0
  */
-export interface TestBedStatic {
+export interface TestBedStatic<Backend extends MockFunction> {
     /**
      * Begins a solitary test bed for `target`, auto-mocking every dependency it declares.
-     *
-     * @remarks The mock factory's return type becomes `Backend` and types every mock the bed hands
-     * out — pass `{ mockFactory: () => vi.fn() }` and `mocks.get(X).method` carries Vitest's own
-     * mock surface.
      */
-    solitary<Class, Backend extends MockFunction = Spy>(target: Constructor<Class>, options?: TestBedOptions<Backend>): SolitaryTestBedBuilder<Class, Backend>;
+    solitary<Class>(target: Constructor<Class>): SolitaryTestBedBuilder<Class, Backend>;
     /**
      * Begins a sociable test bed for `target`: chosen class collaborators stay real, tokens stay mocked.
      *
      * @remarks Returns only `expose` — a sociable bed without at least one exposed collaborator is a
      * solitary bed, so the type steers the first call.
      */
-    sociable<Class, Backend extends MockFunction = Spy>(target: Constructor<Class>, options?: TestBedOptions<Backend>): Pick<SociableTestBedBuilder<Class, Backend>, "expose">;
+    sociable<Class>(target: Constructor<Class>): Pick<SociableTestBedBuilder<Class, Backend>, "expose">;
 }
 /**
- * Entry point for auto-mocking a class in isolation from its collaborators.
+ * Creates the test-bed entry point for one mock backend, so a suite states its backend once.
+ *
+ * @remarks The factory's return type becomes `Backend` and types every mock the beds hand out —
+ * `createTestBed({ mockFactory: () => vi.fn() })` gives `mocks.get(X).method` Vitest's own mock
+ * surface. A bed can have no other backend than the entry point it was begun from.
+ *
+ * @throws MissingMockFactoryError When no factory is passed, which only a caller past the types can do.
+ *
+ * @since 0.2.0
+ */
+export declare function createTestBed<Backend extends MockFunction>(options: TestBedOptions<Backend>): TestBedStatic<Backend>;
+/**
+ * The test-bed entry point on the built-in spy, the backend with no test-framework dependency.
  *
- * @remarks `solitary` and `sociable` record the target and options only; nothing is instantiated
- * until `compile()`.
+ * @remarks `solitary` and `sociable` record the target only; nothing is instantiated until
+ * `compile()`. A suite on another backend creates its own with `createTestBed`.
  *
  * @since 0.1.0
  */
-export declare const TestBed: TestBedStatic;
+export declare const TestBed: TestBedStatic<Spy>;

package/dist/test-bed/test-bed.js

@@ -1,19 +1,37 @@
-/** The entry point for building isolated units under test. */
+/** The entry points for building isolated units under test. */
+import { MissingMockFactoryError } from "#errors/errors";
+import { defaultMockFactory } from "#mocking/mock-factory";
 import { SociableBuilder } from "#test-bed/sociable-builder";
 import { SolitaryBuilder } from "#test-bed/solitary-builder";
 /**
- * Entry point for auto-mocking a class in isolation from its collaborators.
+ * Creates the test-bed entry point for one mock backend, so a suite states its backend once.
  *
- * @remarks `solitary` and `sociable` record the target and options only; nothing is instantiated
- * until `compile()`.
+ * @remarks The factory's return type becomes `Backend` and types every mock the beds hand out —
+ * `createTestBed({ mockFactory: () => vi.fn() })` gives `mocks.get(X).method` Vitest's own mock
+ * surface. A bed can have no other backend than the entry point it was begun from.
+ *
+ * @throws MissingMockFactoryError When no factory is passed, which only a caller past the types can do.
+ *
+ * @since 0.2.0
+ */
+export function createTestBed(options) {
+    // Read once, so a later write to the caller's object cannot change the beds already begun.
+    const { mockFactory, metadataReader } = options;
+    if (typeof mockFactory !== "function") {
+        throw new MissingMockFactoryError();
+    }
+    const resolved = { mockFactory, metadataReader };
+    return {
+        solitary: (target) => new SolitaryBuilder(target, resolved),
+        sociable: (target) => new SociableBuilder(target, resolved),
+    };
+}
+/**
+ * The test-bed entry point on the built-in spy, the backend with no test-framework dependency.
+ *
+ * @remarks `solitary` and `sociable` record the target only; nothing is instantiated until
+ * `compile()`. A suite on another backend creates its own with `createTestBed`.
  *
  * @since 0.1.0
  */
-export const TestBed = {
-    solitary(target, options) {
-        return new SolitaryBuilder(target, options);
-    },
-    sociable(target, options) {
-        return new SociableBuilder(target, options);
-    },
-};
+export const TestBed = createTestBed({ mockFactory: defaultMockFactory });

package/dist/test-bed/unit-test-bed.js

@@ -1,4 +1,4 @@
-/// <reference lib="esnext.disposable" />
+/** The compiled result of a test bed: the real unit plus handles to its mocks. */
 import { tokenName } from "@codefast/di";
 import { criteriaEquals, normalizeCriteria } from "#discovery/mock-binder";
 import { ExposureError, SealedDependencyError, UndeclaredDependencyError } from "#errors/errors";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/di-testing",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "Solitary and sociable auto-mocking test beds for @codefast/di",
   "keywords": [
     "auto-mock",
@@ -100,9 +100,9 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@codefast/di": ">=0.10.1"
+    "@codefast/di": ">=0.12.0"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=24.0.0"
   }
 }