@codefast/di-testing 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # @codefast/di-testing
 
+## 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
+
+- [#892](https://github.com/codefastlabs/codefast/pull/892) [`4c97c5b`](https://github.com/codefastlabs/codefast/commit/4c97c5b8c2314f25ee9df7eac5a4b5dd723d6d90) Thanks [@thevuong](https://github.com/thevuong)! - Lower the monorepo's Node floor from 24 to 22.12, so the packages install and run on the active Node 22 LTS line.
+
+  `engines.node` becomes `>=22.12.0` across every package — the floor the shared toolchain (oxlint, Vite, Vitest, TanStack
+  Start) already requires. Development stays on the latest Node (`.node-version`) for speed, and a CI matrix exercises the
+  floor and the active LTS directly, so the floor is a contract CI proves rather than one everyone has to run.
+  `@types/node` is pinned to the floor's major (`^22`), with a workspace override holding the whole tree there so a dev
+  tool's `@types/node: "*"` peer can no longer pull a newer major and mask an API the floor lacks. The floor stays
+  mechanical, not advisory: `@codefast/di` keeps its own `Map` upsert helpers rather than the ES2025
+  `Map.prototype.getOrInsert` (which would raise the floor to 26) and its `lib` stays `ES2024`. `@codefast/cli`'s mirror
+  step now calls the `node:path` functions directly instead of aliasing them, which the floor's types correctly flag as
+  unbound methods.
+
+  The shared `@codefast/typescript-config` presets pin `lib` and `target` to `ES2024` (was `ESNext`) so the compiler's
+  ECMAScript surface matches the Node floor: an ES2025 builtin such as `Map.prototype.getOrInsert` now fails to type-check
+  rather than compiling and crashing on Node 22.12. `@codefast/di` and `@codefast/di-testing` already pinned `lib` and are
+  unchanged.
+
+  Internal subpath imports move from a `#/` prefix to a bare `#` (`#core/token`, not `#/core/token`), and the
+  `package.json#imports` keys become `#*`/`#tests/*`/`#examples/*` to match. Node's native ESM resolver rejects a
+  `#/`-prefixed specifier with `ERR_INVALID_MODULE_SPECIFIER` on the whole Node 22 line (and on Node 24 before 24.14), and
+  each package ships those specifiers verbatim inside its published `dist/*.js` for a consumer's Node to resolve — so this
+  rename is what actually lets the packages import on the new floor. Purely internal: a consumer's own import paths are
+  unchanged.
+
+- Updated dependencies [[`4c97c5b`](https://github.com/codefastlabs/codefast/commit/4c97c5b8c2314f25ee9df7eac5a4b5dd723d6d90)]:
+  - @codefast/di@0.10.1
+
 ## 0.1.3
 
 ### 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 24 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
 

package/dist/discovery/dependency-scanner.js

@@ -1,5 +1,5 @@
 /** Reads the dependencies a class declares, the input every auto-mock is built from. */
-import { NotInjectableError } from "#/errors/errors";
+import { NotInjectableError } from "#errors/errors";
 /**
  * Reads every dependency a class declares — constructor parameters first, then accessor injections.
  *

package/dist/discovery/mock-binder.d.ts

@@ -1,6 +1,6 @@
 /** Binds a unit's discovered dependencies onto a container as mocks — the sole container coupling. */
 import type { BindingTag, Constructor, Container, DependencyKey, DependencySlot, InjectOptions } from "@codefast/di";
-import type { MockFactory } from "#/mocking/mock-factory";
+import type { MockFactory } from "#mocking/mock-factory";
 /**
  * How one dependency is supplied instead of a plain auto-mock.
  *

package/dist/discovery/mock-binder.js

@@ -1,7 +1,7 @@
 /** Binds a unit's discovered dependencies onto a container as mocks — the sole container coupling. */
 import { slotName, tokenName } from "@codefast/di";
-import { OverrideMismatchError, UndeclaredDependencyError } from "#/errors/errors";
-import { createAutoMock } from "#/mocking/auto-mock";
+import { OverrideMismatchError, UndeclaredDependencyError } from "#errors/errors";
+import { createAutoMock } from "#mocking/auto-mock";
 /** The name prefix `usingAll` elements are bound under, so identical constants keep distinct slots. */
 const ALL_ELEMENT_SLOT_PREFIX = "di-testing: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,16 +1,16 @@
 /** Solitary and sociable auto-mocking test beds for `@codefast/di`. */
-export { 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";
-export type { SociableTestBedBuilder } from "#/test-bed/sociable-builder";
-export type { SociableUnitTestBed, UnitReference, UnitTestBed } from "#/test-bed/unit-test-bed";
-export { createAutoMock, MOCK_RESET } from "#/mocking/auto-mock";
-export type { DeepPartial, Mocked } from "#/mocking/auto-mock";
-export { defaultMockFactory } from "#/mocking/mock-factory";
-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 type { SealedCause } from "#/errors/errors";
+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";
+export type { SociableTestBedBuilder } from "#test-bed/sociable-builder";
+export type { SociableUnitTestBed, UnitReference, UnitTestBed } from "#test-bed/unit-test-bed";
+export { createAutoMock, MOCK_RESET } from "#mocking/auto-mock";
+export type { DeepPartial, Mocked } from "#mocking/auto-mock";
+export { defaultMockFactory } from "#mocking/mock-factory";
+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 { 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 { 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 { 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 { MissingMockFactoryError, ExposureError, NotInjectableError, OverrideMismatchError, SealedDependencyError, TestingError, UndeclaredDependencyError, } from "#errors/errors";

package/dist/mocking/auto-mock.d.ts

@@ -1,6 +1,6 @@
 /** 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";
+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.
  *

package/dist/mocking/mock-factory.d.ts

@@ -1,5 +1,5 @@
 /** The pluggable seam that decides which spy backend the auto-mocks are built from. */
-import type { Spy } from "#/mocking/spy";
+import type { Spy } from "#mocking/spy";
 /**
  * The loose callable an auto-mock materializes for each accessed property.
  *

package/dist/mocking/mock-factory.js

@@ -1,5 +1,5 @@
 /** The pluggable seam that decides which spy backend the auto-mocks are built from. */
-import { createSpy } from "#/mocking/spy";
+import { createSpy } from "#mocking/spy";
 /**
  * The default `MockFactory` — one built-in {@link Spy} per call, with no test-framework dependency.
  *

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

@@ -1,21 +1,21 @@
 /** The override-recording core both test-bed builders extend. */
 import type { Constructor, Container, DependencyKey, InjectOptions, MetadataReader } from "@codefast/di";
-import type { BoundMock, SlottedOverride } from "#/discovery/mock-binder";
-import type { DeepPartial } from "#/mocking/auto-mock";
-import type { MockFactory, MockFunction } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
-import type { InjectionIdentifier } from "#/types";
+import type { BoundMock, SlottedOverride } from "#discovery/mock-binder";
+import type { DeepPartial } from "#mocking/auto-mock";
+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 { criteriaEquals, normalizeCriteria } from "#/discovery/mock-binder";
-import { defaultMockFactory } from "#/mocking/mock-factory";
+import { criteriaEquals, normalizeCriteria } from "#discovery/mock-binder";
 /**
  * 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.d.ts

@@ -1,11 +1,11 @@
 /** The fluent builder that compiles a unit together with chosen real collaborators. */
 import type { Constructor, InjectOptions } from "@codefast/di";
-import type { MockFunction } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
-import type { MockOverrideBuilder } from "#/test-bed/bed-builder";
-import { BedBuilder } from "#/test-bed/bed-builder";
-import type { SociableUnitTestBed } from "#/test-bed/unit-test-bed";
-import type { InjectionIdentifier } from "#/types";
+import type { MockFunction } from "#mocking/mock-factory";
+import type { Spy } from "#mocking/spy";
+import type { MockOverrideBuilder } from "#test-bed/bed-builder";
+import { BedBuilder } from "#test-bed/bed-builder";
+import type { SociableUnitTestBed } from "#test-bed/unit-test-bed";
+import type { InjectionIdentifier } from "#types";
 /**
  * A sociable build in progress: expose real collaborators, override the rest, then compile.
  *

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

@@ -1,10 +1,10 @@
 /** The fluent builder that compiles a unit together with chosen real collaborators. */
 import { Container, token } from "@codefast/di";
-import { scanSociableDependencies } from "#/discovery/dependency-scanner";
-import { bindMocks } from "#/discovery/mock-binder";
-import { ExposureError } from "#/errors/errors";
-import { BedBuilder } from "#/test-bed/bed-builder";
-import { createSociableUnitTestBed, createUnitTestBed } from "#/test-bed/unit-test-bed";
+import { scanSociableDependencies } from "#discovery/dependency-scanner";
+import { bindMocks } from "#discovery/mock-binder";
+import { ExposureError } from "#errors/errors";
+import { BedBuilder } from "#test-bed/bed-builder";
+import { createSociableUnitTestBed, createUnitTestBed } from "#test-bed/unit-test-bed";
 /**
  * The default {@link SociableTestBedBuilder}, backed by a fresh container per compile.
  *

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

@@ -1,11 +1,11 @@
 /** The fluent builder that compiles a solitary unit under test. */
 import type { InjectOptions } from "@codefast/di";
-import type { MockFunction } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
-import type { MockOverrideBuilder } from "#/test-bed/bed-builder";
-import { BedBuilder } from "#/test-bed/bed-builder";
-import type { UnitTestBed } from "#/test-bed/unit-test-bed";
-import type { InjectionIdentifier } from "#/types";
+import type { MockFunction } from "#mocking/mock-factory";
+import type { Spy } from "#mocking/spy";
+import type { MockOverrideBuilder } from "#test-bed/bed-builder";
+import { BedBuilder } from "#test-bed/bed-builder";
+import type { UnitTestBed } from "#test-bed/unit-test-bed";
+import type { InjectionIdentifier } from "#types";
 /**
  * A solitary build in progress: register overrides, then compile.
  *

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

@@ -1,9 +1,9 @@
 /** The fluent builder that compiles a solitary unit under test. */
 import { Container } from "@codefast/di";
-import { scanDependencies } from "#/discovery/dependency-scanner";
-import { bindMocks } from "#/discovery/mock-binder";
-import { BedBuilder } from "#/test-bed/bed-builder";
-import { createUnitTestBed } from "#/test-bed/unit-test-bed";
+import { scanDependencies } from "#discovery/dependency-scanner";
+import { bindMocks } from "#discovery/mock-binder";
+import { BedBuilder } from "#test-bed/bed-builder";
+import { createUnitTestBed } from "#test-bed/unit-test-bed";
 /**
  * The default {@link SolitaryTestBedBuilder}, backed by a fresh container per compile.
  *

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

@@ -1,38 +1,48 @@
-/** 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";
-import type { TestBedOptions } from "#/test-bed/bed-builder";
-import type { SociableTestBedBuilder } from "#/test-bed/sociable-builder";
-import type { SolitaryTestBedBuilder } from "#/test-bed/solitary-builder";
+import type { MockFunction } from "#mocking/mock-factory";
+import type { Spy } from "#mocking/spy";
+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. */
-import { SociableBuilder } from "#/test-bed/sociable-builder";
-import { SolitaryBuilder } from "#/test-bed/solitary-builder";
+/** 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.d.ts

@@ -1,9 +1,9 @@
 /** The compiled result of a test bed: the real unit plus handles to its mocks. */
 import type { Constructor, Container, DependencyKey, InjectOptions, TokenValue } from "@codefast/di";
-import type { BoundMock } from "#/discovery/mock-binder";
-import type { Mocked } from "#/mocking/auto-mock";
-import type { MockFunction } from "#/mocking/mock-factory";
-import type { Spy } from "#/mocking/spy";
+import type { BoundMock } from "#discovery/mock-binder";
+import type { Mocked } from "#mocking/auto-mock";
+import type { MockFunction } from "#mocking/mock-factory";
+import type { Spy } from "#mocking/spy";
 /**
  * A lookup from a dependency's token or class to the mock the unit was built with.
  *

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

@@ -1,8 +1,8 @@
-/// <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";
-import { MOCK_RESET } from "#/mocking/auto-mock";
+import { criteriaEquals, normalizeCriteria } from "#discovery/mock-binder";
+import { ExposureError, SealedDependencyError, UndeclaredDependencyError } from "#errors/errors";
+import { MOCK_RESET } from "#mocking/auto-mock";
 /**
  * Wraps a compiled bed with access to its exposed real collaborators.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/di-testing",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Solitary and sociable auto-mocking test beds for @codefast/di",
   "keywords": [
     "auto-mock",
@@ -36,7 +36,7 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "imports": {
-    "#/*": {
+    "#*": {
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     }
@@ -100,7 +100,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@codefast/di": ">=0.9.0"
+    "@codefast/di": ">=0.11.0"
   },
   "engines": {
     "node": ">=24.0.0"