@codefast/di-testing 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @codefast/di-testing
 
+## 0.1.2
+
+### Patch Changes
+
+- [#791](https://github.com/codefastlabs/codefast/pull/791) [`37a212b`](https://github.com/codefastlabs/codefast/commit/37a212b4d805588413159e11e872b98db82326bf) Thanks [@thevuong](https://github.com/thevuong)! - Point the README's license badge and "License" section at the package's own `LICENSE` file instead of the monorepo root.
+
+- [#796](https://github.com/codefastlabs/codefast/pull/796) [`ba04d27`](https://github.com/codefastlabs/codefast/commit/ba04d2703c59a1677f52e6a9fffd0ec202328218) Thanks [@thevuong](https://github.com/thevuong)! - Rewrite the README around one structure — what the package is, installation and requirements, a complete quick start,
+  the concepts in learning order, then the documents and the license — with every API claim checked against the current
+  code and no figures that go stale.
+
+- [#784](https://github.com/codefastlabs/codefast/pull/784) [`ad2f93a`](https://github.com/codefastlabs/codefast/commit/ad2f93a688e99c3ed8be6ceeae9d6cdd6be861bc) Thanks [@thevuong](https://github.com/thevuong)! - Ship the MIT `LICENSE` file in the published package. `files` already listed it, but the file was missing from the
+  package directory, so the tarball had none.
+- Updated dependencies [[`37a212b`](https://github.com/codefastlabs/codefast/commit/37a212b4d805588413159e11e872b98db82326bf), [`ba04d27`](https://github.com/codefastlabs/codefast/commit/ba04d2703c59a1677f52e6a9fffd0ec202328218), [`ad2f93a`](https://github.com/codefastlabs/codefast/commit/ad2f93a688e99c3ed8be6ceeae9d6cdd6be861bc)]:
+  - @codefast/di@0.8.1
+
+## 0.1.1
+
+### Patch Changes
+
+- [#774](https://github.com/codefastlabs/codefast/pull/774) [`176e95a`](https://github.com/codefastlabs/codefast/commit/176e95a32b44fa16d81a22e4a48f53176837c839) Thanks [@thevuong](https://github.com/thevuong)! - Fold di's reserved `slotName` criterion into slot addressing, so `{ name: "x" }` and `{ tag: slotName.of("x") }` — one
+  slot to the container — are one slot to TestBed too: a mock registered with either spelling now matches a dependency
+  declared with the other, and `mocks.get(token, options)` accepts both.
+- Updated dependencies [[`96af502`](https://github.com/codefastlabs/codefast/commit/96af502ed8dd7fc02c4440d03b40dc6677b7bcec)]:
+  - @codefast/di@0.8.0
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -1,28 +1,29 @@
 # @codefast/di-testing
 
-Solitary and sociable auto-mocking test beds for
-[`@codefast/di`](https://github.com/codefastlabs/codefast/tree/main/packages/di) — write an isolated unit test for an
-`@injectable` class in two lines, with every collaborator mocked for you, or keep chosen collaborators real.
+Solitary and sociable auto-mocking test beds for [`@codefast/di`](../di): unit-test an `@injectable` class with every
+collaborator mocked for you, or keep chosen collaborators real.
 
 [![npm version](https://img.shields.io/npm/v/@codefast/di-testing)](https://www.npmjs.com/package/@codefast/di-testing)
-[![license](https://img.shields.io/npm/l/@codefast/di-testing)](https://github.com/codefastlabs/codefast/blob/main/LICENSE)
+[![license](https://img.shields.io/npm/l/@codefast/di-testing)](./LICENSE)
+
+## Overview
+
+`@codefast/di-testing` gives you two auto-mocking test beds for [`@codefast/di`](../di). A **solitary** bed constructs
+the class under test with every collaborator mocked for you; a **sociable** bed keeps chosen collaborators real and
+mocks the rest.
+
+The unit is built through a real container, so `@postConstruct`, accessor injection, and `@preDestroy` run exactly as in
+production — and you assert against the mocks the bed created.
 
 - **Auto-mocking.** `TestBed.solitary(Class)` reads the class's declared dependencies through di's own `MetadataReader`
   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.
+- **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`, …) — no adapter
-  package, no module augmentation, no postinstall scripts.
-
-## Requirements
-
-- **Node.js 24 or later**, matching `@codefast/di`.
-- A peer install of `@codefast/di` with `@injectable` / `inject` classes to test.
-- Types for `AsyncDisposable` (`await using`): `@types/node` provides them; without it, add `"ESNext.Disposable"` to
-  your tsconfig `lib`.
+  `mocks.get(EmailToken).send` carries Vitest's own mock surface (`mockReturnValueOnce`, `mockClear`, and so on), with
+  no adapter package and no module augmentation.
 
 ## Installation
 
@@ -30,18 +31,32 @@ Solitary and sociable auto-mocking test beds for
 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.
+
 ## Quick start
 
-```typescript
-import { inject, injectable, token } from "@codefast/di";
+```ts
+import { injectable, token } from "@codefast/di";
 import { TestBed } from "@codefast/di-testing";
 import { expect, it, vi } from "vitest";
 
+interface UserService {
+  findUser(id: string): { id: string; email: string };
+}
+interface PaymentGateway {
+  charge(userId: string, amount: number): void;
+}
+interface EmailService {
+  send(to: string, body: string): void;
+}
+
 const UserServiceToken = token<UserService>("UserService");
 const PaymentGatewayToken = token<PaymentGateway>("PaymentGateway");
 const EmailServiceToken = token<EmailService>("EmailService");
 
-@injectable([inject(UserServiceToken), inject(PaymentGatewayToken), inject(EmailServiceToken)])
+@injectable([UserServiceToken, PaymentGatewayToken, EmailServiceToken])
 class OrderProcessor {
   constructor(
     private readonly users: UserService,
@@ -70,10 +85,10 @@ 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 reads the same, minus the `mockFactory`. Assert against the built-in spy's `.mock.calls` and
+stub with `.mockReturnValue()`:
 
-```typescript
+```ts
 import { TestBed } from "@codefast/di-testing";
 import assert from "node:assert/strict";
 
@@ -82,81 +97,143 @@ unit.placeOrder("u1", 42);
 assert.deepEqual(mocks.get(PaymentGatewayToken).charge.mock.calls[0], ["u1", 42]);
 ```
 
-## API
+## Solitary beds
 
-### `TestBed.solitary(target, options?)`
+`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:
 
-Begins a solitary test bed for `target`, auto-mocking every dependency it declares. `options`:
-
-- `mockFactory?: () => spy` — the spy backend for each auto-mock. Defaults to the built-in zero-dependency spy.
+- `mockFactory?: () => spy` — the spy backend each auto-mock is built from. Defaults to the built-in spy.
 - `metadataReader?: MetadataReader` — the reader dependencies are discovered through. Defaults to di's reader.
 
-### Builder
+The builder records overrides, then compiles:
 
 - `.mock(token).stub((fn) => stub)` — bind a partial stub built from the active spy factory; unlisted members stay
   auto-mocked. `fn()` is typed as whatever the backend produces, so `fn().mockReturnValue(...)` (jest-shaped) or
-  `fn().returns(...)` (Sinon) both type-check against the factory you chose.
+  `fn().returns(...)` (Sinon) type-check against the factory you chose.
 - `.mock(token).using(value)` — bind a fixed value. The value is **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.
 - `.mock(token).absent()` — leave the dependency unbound: an `optional()` slot resolves `undefined`, an `injectAll()`
-  slot `[]`. Anything else is an `OverrideMismatchError`.
+  slot `[]`. On a required dependency this is an `OverrideMismatchError`.
 - `.mock(token).usingAll([a, b])` — supply the elements of an unconstrained `injectAll()` slot, in order. Sealed like
   `.using`.
 - `.mock(token, { name })` / `.mock(token, { tag })` — target one slot of a token that is injected several ways; the
-  slotless form covers every slot without a more specific override.
-- `.compile()` — instantiate the unit synchronously (the primary path).
-- `.compileAsync()` — for a unit whose `@postConstruct` is asynchronous.
+  slotless form covers every slot without a more specific override. Registering the same target twice replaces the
+  earlier override.
+- `.compile()` — instantiate the unit synchronously, running accessor injection and `@postConstruct`.
+- `.compileAsync()` — the same for a unit whose `@postConstruct` is asynchronous.
+
+`.mock(...)` accepts a token or a class, matching how the unit declares the dependency.
 
-### `TestBed.sociable(target, options?)`
+## 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. It returns only `.expose()`, steering the first call:
+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.
+
+```ts
+import { injectable, token } from "@codefast/di";
+import { TestBed } from "@codefast/di-testing";
+import { expect, it, vi } from "vitest";
+
+interface TaxPolicy {
+  rateFor(currency: string): number;
+}
+
+const TaxPolicyToken = token<TaxPolicy>("TaxPolicy");
+
+@injectable([TaxPolicyToken])
+class PricingService {
+  constructor(private readonly tax: TaxPolicy) {}
 
-```typescript
-const bed = TestBed.sociable(CheckoutService, { mockFactory: () => vi.fn() })
-  .expose(PricingService) // real instance, wired through the container
-  .mock(TaxPolicyToken)
-  .stub((fn) => ({ rateFor: fn().mockReturnValue(0.1) }))
-  .compile();
+  total(amount: number, currency: string): number {
+    return amount * (1 + this.tax.rateFor(currency));
+  }
+}
+
+@injectable([PricingService])
+class CheckoutService {
+  constructor(private readonly pricing: PricingService) {}
+
+  checkout(amount: number, currency: string): number {
+    return this.pricing.total(amount, currency);
+  }
+}
+
+it("prices through the real PricingService over a mocked tax boundary", () => {
+  const bed = TestBed.sociable(CheckoutService, { mockFactory: () => vi.fn() })
+    .expose(PricingService)
+    .mock(TaxPolicyToken)
+    .stub((fn) => ({ rateFor: fn().mockReturnValue(0.1) }))
+    .compile();
 
-bed.unit.checkout(100, "USD"); // real PricingService math over the mocked tax boundary
-bed.exposed(PricingService); // the real instance the unit was built with
+  expect(bed.unit.checkout(100, "USD")).toBe(110);
+  expect(bed.exposed(PricingService)).toBeInstanceOf(PricingService);
+});
 ```
 
 - **Exposure follows class identity.** A class-keyed dependency — of the unit or of another exposed class — stays real
   when exposed, and its own dependencies follow the same rules recursively.
 - **Tokens are the boundary.** A `Token`-keyed dependency is always mocked, in both modes: tokens mark where the logic
   under test meets the outside world.
-- Exposed collaborators are real singletons resolved through the container, so their `@postConstruct` runs at compile
-  and `@preDestroy` on dispose. `bed.exposed(Class)` retrieves them; `mocks.get(Class)` refuses them
-  (`SealedDependencyError`) because they carry no mock surface.
-- Exposing a class the unit never reaches, or exposing and mocking the same class, is an error at compile.
-
-### Behavior notes
-
-- An `optional()` dependency is auto-mocked like any other — it resolves to the mock, not `undefined` as an unbound
-  optional would in production. Use `.mock(token).absent()` to exercise the absent branch.
+- Exposed collaborators are singletons resolved through the container, so their `@postConstruct` runs at compile and
+  `@preDestroy` on dispose. `bed.exposed(Class)` returns the instance the unit was built with; `mocks.get(Class)`
+  refuses it with a `SealedDependencyError` because it carries no mock surface.
+- Exposing the unit itself, or a class the unit never reaches through exposed collaborators, is an `ExposureError` at
+  compile.
+
+## Behaviour notes
+
+- A class whose constructor takes no parameters is testable without `@injectable`; a parameterful constructor with no
+  metadata is a `NotInjectableError`.
+- An `optional()` dependency is auto-mocked like any other — it resolves to the mock, not to the `undefined` an unbound
+  optional would give in production. Use `.mock(token).absent()` to exercise the absent branch.
 - An `injectAll()` dependency receives a one-element array holding the token's mock; use `.mock(token).usingAll([...])`
-  to supply several elements. When the same token also has a named or tagged slot, that slot's binding is collected by
-  the unconstrained `injectAll` too — di's `resolveAll` takes every binding of the token.
+  to supply several elements.
 - Named or tagged parameters of one token share the token's mock unless a slot-targeted `.mock(token, { name })` gives
   that slot its own; either way `mocks.get(token, { name })` addresses the slot directly.
+- A `.mock(...)` that names a token or slot the unit does not declare is an `UndeclaredDependencyError` at compile — a
+  typo fails loudly instead of binding an unused constant.
+- A failed compile disposes the container it was building, so no lifecycle state leaks between tests.
+
+## Result
 
-### Result — `UnitTestBed`
+`compile()` returns a `UnitTestBed` (a sociable bed returns a `SociableUnitTestBed`, which adds `exposed`):
 
 - `unit` — the real class under test.
-- `mocks.get(token, options?)` — the `Mocked<T>` bound for a dependency (or one slot of it). Only auto-mocks and `.stub`
-  stubs come back; sealed values throw `SealedDependencyError`.
-- `resetMocks()` — clear the call history and configured behaviour of every auto-mock the bed created.
-- `dispose()` — run the unit's `@preDestroy` hooks and dispose the container. Also runs via `await using`.
+- `mocks.get(token, options?)` — the `Mocked<T>` bound for a dependency, or for one slot of it. Only auto-mocks and
+  `.stub` stubs come back; sealed values and exposed classes throw `SealedDependencyError`.
+- `resetMocks()` — clear the call history and configured behaviour of every auto-mock and stub the bed created.
+- `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.
+
+The lower-level pieces are exported too: `createAutoMock`, `createSpy`, `defaultMockFactory`, and the `Mocked`,
+`DeepPartial`, `MockFactory`, and `Spy` types.
 
 ## Errors
 
-- `NotInjectableError` — the class under test takes constructor parameters but is not `@injectable`.
-- `UndeclaredDependencyError` — a `.mock(...)` or `mocks.get(...)` named a token or slot the class does not use.
-- `SealedDependencyError` — `mocks.get(...)` asked for a `.using()`/`.absent()`/`.all()` value.
-- `OverrideMismatchError` — `.absent()` on a required dependency, or `.all()` on a non-`injectAll` slot.
+Every error extends `TestingError` and carries a stable `code`. `TestingError` mirrors di's `DiError` shape without
+extending it, so setup failures can be caught separately from resolution failures.
+
+| Error                       | Code                    | Raised when                                                                                         |
+| --------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------- |
+| `NotInjectableError`        | `NOT_INJECTABLE`        | A scanned class takes constructor parameters but is not `@injectable`                               |
+| `UndeclaredDependencyError` | `UNDECLARED_DEPENDENCY` | A `.mock(...)` or `mocks.get(...)` named a token or slot the unit does not use                      |
+| `SealedDependencyError`     | `SEALED_DEPENDENCY`     | `mocks.get(...)` asked for a `.using()`/`.absent()`/`.usingAll()` value or an exposed class         |
+| `OverrideMismatchError`     | `OVERRIDE_MISMATCH`     | `.absent()` on a required dependency, or `.usingAll()` with no unconstrained `injectAll()` slot     |
+| `ExposureError`             | `EXPOSURE`              | An exposed class is the unit, is unreachable, or `bed.exposed()` names a class that was not exposed |
+
+## 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`.
+- [`CHANGELOG.md`](./CHANGELOG.md) — release history.
+
+## Contributing
+
+See the repo-wide [contributing guide](../../CONTRIBUTING.md) for setup, conventions, and the test taxonomy.
 
 ## License
 
-MIT
+Released under the [MIT License](./LICENSE).

package/dist/discovery/dependency-scanner.d.ts

@@ -31,5 +31,4 @@ export interface SociableScan {
  *
  * @since 0.1.0
  */
-export declare function scanSociableDependencies(target: Constructor, exposed: ReadonlySet<Constructor>, reader: MetadataReader): SociableScan;
-//# sourceMappingURL=dependency-scanner.d.ts.map
+export declare function scanSociableDependencies(target: Constructor, exposed: ReadonlySet<Constructor>, reader: MetadataReader): SociableScan;

package/dist/discovery/dependency-scanner.js

@@ -51,5 +51,4 @@ export function scanSociableDependencies(target, exposed, reader) {
         }
     }
     return { mockSlots, realClasses, realSlots };
-}
-//# sourceMappingURL=dependency-scanner.js.map
+}

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

@@ -60,7 +60,8 @@ export interface BoundMock {
  * Folds an `InjectOptions` into slot criteria, or `undefined` when it names no criterion.
  *
  * @remarks Tags are copied and deduplicated by identity — di interns each `(key, value)` pair, so a
- * repeated pair is the same object.
+ * repeated pair is the same object. A reserved `slotName` criterion folds into `name`, so both
+ * spellings address one slot.
  *
  * @since 0.1.0
  */
@@ -83,5 +84,4 @@ export declare function criteriaEquals(left: SlotCriteria, right: SlotCriteria):
  *
  * @since 0.1.0
  */
-export declare function bindMocks(container: Container, dependencies: ReadonlyArray<DependencySlot>, overrides: ReadonlyMap<DependencyKey, ReadonlyArray<SlottedOverride>>, mockFactory: MockFactory, exposed?: ReadonlySet<Constructor>): ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>;
-//# sourceMappingURL=mock-binder.d.ts.map
+export declare function bindMocks(container: Container, dependencies: ReadonlyArray<DependencySlot>, overrides: ReadonlyMap<DependencyKey, ReadonlyArray<SlottedOverride>>, mockFactory: MockFactory, exposed?: ReadonlySet<Constructor>): ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>;

package/dist/discovery/mock-binder.js

@@ -1,14 +1,28 @@
 /** Binds a unit's discovered dependencies onto a container as mocks — the sole container coupling. */
-import { tokenName } from "@codefast/di";
+import { slotName, tokenName } from "@codefast/di";
 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:";
+/**
+ * One name and plain tag set, with di's reserved criterion folded into the name.
+ *
+ * @remarks di treats `{name: "x"}` and `{tag: slotName.of("x")}` as one slot, so addressing here
+ * must too — mirroring `bindingSlotToResolveOptions` in di.
+ */
+function foldReservedName(name, tags) {
+    const reserved = tags.find((tag) => tag.key === slotName);
+    if (reserved === undefined) {
+        return { name, tags };
+    }
+    return { name: name ?? reserved.value, tags: tags.filter((tag) => tag.key !== slotName) };
+}
 /**
  * Folds an `InjectOptions` into slot criteria, or `undefined` when it names no criterion.
  *
  * @remarks Tags are copied and deduplicated by identity — di interns each `(key, value)` pair, so a
- * repeated pair is the same object.
+ * repeated pair is the same object. A reserved `slotName` criterion folds into `name`, so both
+ * spellings address one slot.
  *
  * @since 0.1.0
  */
@@ -16,12 +30,12 @@ export function normalizeCriteria(options) {
     if (options === undefined) {
         return undefined;
     }
-    const folded = options.tag === undefined ? (options.tags ?? []) : [options.tag, ...(options.tags ?? [])];
-    const tags = [...new Set(folded)];
-    if (options.name === undefined && tags.length === 0) {
+    const merged = options.tag === undefined ? (options.tags ?? []) : [options.tag, ...(options.tags ?? [])];
+    const { name, tags } = foldReservedName(options.name, [...new Set(merged)]);
+    if (name === undefined && tags.length === 0) {
         return undefined;
     }
-    return { name: options.name, tags };
+    return { name, tags };
 }
 /**
  * Returns whether two criteria address the same slot — equal name and the same tag set.
@@ -47,15 +61,16 @@ function tagSetEquals(left, right) {
 }
 /** Returns the slot's own criteria, or `undefined` for an unconstrained slot. */
 function criteriaOfSlot(slot) {
-    const tags = slot.tags ?? [];
-    if (slot.name === undefined && tags.length === 0) {
+    const { name, tags } = foldReservedName(slot.name, slot.tags ?? []);
+    if (name === undefined && tags.length === 0) {
         return undefined;
     }
-    return { name: slot.name, tags };
+    return { name, tags };
 }
 /** Returns whether an override's criteria address exactly this slot. */
 function matchesSlot(criteria, slot) {
-    return criteria.name === slot.name && tagSetEquals(criteria.tags, slot.tags ?? []);
+    const folded = foldReservedName(slot.name, slot.tags ?? []);
+    return criteria.name === folded.name && tagSetEquals(criteria.tags, folded.tags);
 }
 /** A readable rendering of criteria for error messages. */
 function describeCriteria(criteria) {
@@ -208,5 +223,4 @@ function buildMock(override, mockFactory) {
     }
     // The stub's seed is built here, once per compile, so beds never share seeded spies.
     return createAutoMock(mockFactory, override.setup(mockFactory));
-}
-//# sourceMappingURL=mock-binder.js.map
+}

package/dist/errors/errors.d.ts

@@ -74,5 +74,4 @@ export declare class ExposureError extends TestingError {
     readonly code = "EXPOSURE";
     readonly targetName: string;
     constructor(targetName: string, detail: string);
-}
-//# sourceMappingURL=errors.d.ts.map
+}

package/dist/errors/errors.js

@@ -91,5 +91,4 @@ export class ExposureError extends TestingError {
         super(`'${targetName}': ${detail}`);
         this.targetName = targetName;
     }
-}
-//# sourceMappingURL=errors.js.map
+}

package/dist/index.d.ts

@@ -13,5 +13,4 @@ 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";
-//# sourceMappingURL=index.d.ts.map
+export type { SealedCause } from "#/errors/errors";

package/dist/index.js

@@ -3,5 +3,4 @@ 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";
-//# sourceMappingURL=index.js.map
+export { ExposureError, NotInjectableError, OverrideMismatchError, SealedDependencyError, TestingError, UndeclaredDependencyError, } from "#/errors/errors";

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

@@ -51,5 +51,4 @@ export declare const MOCK_RESET: unique symbol;
  *
  * @since 0.1.0
  */
-export declare function createAutoMock<Dependency, Backend extends MockFunction = Spy>(mockFactory: MockFactory<Backend>, seed?: DeepPartial<Dependency>): Mocked<Dependency, Backend>;
-//# sourceMappingURL=auto-mock.d.ts.map
+export declare function createAutoMock<Dependency, Backend extends MockFunction = Spy>(mockFactory: MockFactory<Backend>, seed?: DeepPartial<Dependency>): Mocked<Dependency, Backend>;

package/dist/mocking/auto-mock.js

@@ -180,5 +180,4 @@ export function createAutoMock(mockFactory, seed) {
     });
     self = proxy;
     return proxy;
-}
-//# sourceMappingURL=auto-mock.js.map
+}

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

@@ -27,5 +27,4 @@ export type MockFactory<Backend extends MockFunction = MockFunction> = () => Bac
  *
  * @since 0.1.0
  */
-export declare const defaultMockFactory: MockFactory<Spy>;
-//# sourceMappingURL=mock-factory.d.ts.map
+export declare const defaultMockFactory: MockFactory<Spy>;

package/dist/mocking/mock-factory.js

@@ -5,5 +5,4 @@ import { createSpy } from "#/mocking/spy";
  *
  * @since 0.1.0
  */
-export const defaultMockFactory = () => createSpy();
-//# sourceMappingURL=mock-factory.js.map
+export const defaultMockFactory = () => createSpy();

package/dist/mocking/spy.d.ts

@@ -43,5 +43,4 @@ export interface Spy<Args extends ReadonlyArray<unknown> = ReadonlyArray<unknown
  *
  * @since 0.1.0
  */
-export declare function createSpy(): Spy;
-//# sourceMappingURL=spy.d.ts.map
+export declare function createSpy(): Spy;

package/dist/mocking/spy.js

@@ -41,5 +41,4 @@ export function createSpy() {
         },
     });
     return spy;
-}
-//# sourceMappingURL=spy.js.map
+}

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

@@ -87,5 +87,4 @@ export declare abstract class BedBuilder<Class, Backend extends MockFunction = S
     protected compileWith<Prepared extends PreparedBed, Bed>(prepare: () => Prepared, build: (unit: Class, prepared: Prepared) => Bed): Bed;
     /** The async twin of {@link compileWith}, for units whose activation is asynchronous. */
     protected compileWithAsync<Prepared extends PreparedBed, Bed>(prepare: () => Prepared, build: (unit: Class, prepared: Prepared) => Bed): Promise<Bed>;
-}
-//# sourceMappingURL=bed-builder.d.ts.map
+}

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

@@ -93,5 +93,4 @@ export class BedBuilder {
             list[existing] = { criteria, override };
         }
     }
-}
-//# sourceMappingURL=bed-builder.js.map
+}

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

@@ -41,5 +41,4 @@ export declare class SociableBuilder<Class, Backend extends MockFunction = Spy>
     expose(target: Constructor): this;
     compile(): SociableUnitTestBed<Class, Backend>;
     compileAsync(): Promise<SociableUnitTestBed<Class, Backend>>;
-}
-//# sourceMappingURL=sociable-builder.d.ts.map
+}

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

@@ -76,5 +76,4 @@ export class SociableBuilder extends BedBuilder {
         container.bind(this.target).toSelf().singleton();
         return { container, mocks: merged, realClasses };
     }
-}
-//# sourceMappingURL=sociable-builder.js.map
+}

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

@@ -34,5 +34,4 @@ export declare class SolitaryBuilder<Class, Backend extends MockFunction = Spy>
     #private;
     compile(): UnitTestBed<Class, Backend>;
     compileAsync(): Promise<UnitTestBed<Class, Backend>>;
-}
-//# sourceMappingURL=solitary-builder.d.ts.map
+}

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

@@ -27,5 +27,4 @@ export class SolitaryBuilder extends BedBuilder {
         container.bind(this.target).toSelf().singleton();
         return { container, mocks };
     }
-}
-//# sourceMappingURL=solitary-builder.js.map
+}

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

@@ -35,5 +35,4 @@ export interface TestBedStatic {
  *
  * @since 0.1.0
  */
-export declare const TestBed: TestBedStatic;
-//# sourceMappingURL=test-bed.d.ts.map
+export declare const TestBed: TestBedStatic;

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

@@ -16,5 +16,4 @@ export const TestBed = {
     sociable(target, options) {
         return new SociableBuilder(target, options);
     },
-};
-//# sourceMappingURL=test-bed.js.map
+};

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

@@ -71,5 +71,4 @@ export declare function createSociableUnitTestBed<Class, Backend extends MockFun
  *
  * @since 0.1.0
  */
-export declare function createUnitTestBed<Class, Backend extends MockFunction = Spy>(unit: Class, entries: ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>, container: Container): UnitTestBed<Class, Backend>;
-//# sourceMappingURL=unit-test-bed.d.ts.map
+export declare function createUnitTestBed<Class, Backend extends MockFunction = Spy>(unit: Class, entries: ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>, container: Container): UnitTestBed<Class, Backend>;

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

@@ -70,5 +70,4 @@ export function createUnitTestBed(unit, entries, container) {
         dispose,
         [Symbol.asyncDispose]: dispose,
     };
-}
-//# sourceMappingURL=unit-test-bed.js.map
+}

package/dist/types.d.ts

@@ -10,5 +10,4 @@ import type { Constructor, Token } from "@codefast/di";
  *
  * @since 0.1.0
  */
-export type InjectionIdentifier<Value> = Token<Value> | Constructor<Value>;
-//# sourceMappingURL=types.d.ts.map
+export type InjectionIdentifier<Value> = Token<Value> | Constructor<Value>;

package/dist/types.js

@@ -1,3 +1,2 @@
 /** Shared vocabulary the test bed keys its dependencies by. */
-export {};
-//# sourceMappingURL=types.js.map
+export {};