@codefast/di-testing 0.0.0

package/dist/errors/errors.js

@@ -0,0 +1,83 @@
+/** The error taxonomy `@codefast/di-testing` raises, each carrying a machine-readable `code`. */
+/**
+ * Base class for every error the testing library throws, each carrying a machine-readable `code`.
+ *
+ * @remarks Mirrors `@codefast/di`'s own `DiError` shape rather than extending it, so a caller can
+ * catch testing-setup failures separately from resolution failures.
+ */
+export class TestingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+/**
+ * A scanned class takes constructor parameters but carries no `@injectable` metadata.
+ */
+export class NotInjectableError extends TestingError {
+    code = "NOT_INJECTABLE";
+    targetName;
+    constructor(targetName) {
+        super(`Cannot mock the dependencies of '${targetName}': its constructor takes parameters but the class is not decorated with @injectable(...), so those dependencies cannot be discovered. Decorate the class, or bind its collaborators manually with a Container.`);
+        this.targetName = targetName;
+    }
+}
+/**
+ * A `.mock(...)` override or a `mocks.get(...)` lookup named a token or slot the unit does not use.
+ *
+ * @remarks Almost always a typo or a stale token reference; failing loudly beats silently binding an
+ * unused constant or returning `undefined`.
+ */
+export class UndeclaredDependencyError extends TestingError {
+    code = "UNDECLARED_DEPENDENCY";
+    tokenName;
+    constructor(tokenName, detail) {
+        super(`'${tokenName}'${detail === undefined ? "" : ` (${detail})`} is not a dependency of the class under test. Only tokens the class declares in its constructor or accessor injections can be mocked or retrieved.`);
+        this.tokenName = tokenName;
+    }
+}
+const SEALED_MESSAGES = {
+    value: "it was supplied with .using(), so it has no mock surface. Use the reference the test passed in.",
+    absent: "it was declared absent with .absent(), so there is nothing to retrieve.",
+    all: "its elements were supplied with .usingAll(). Use the references the test passed in.",
+    exposed: "it is exposed as a real collaborator. Retrieve it with bed.exposed(Class) instead.",
+};
+/**
+ * A `mocks.get(...)` lookup asked for a dependency that is not a retrievable mock.
+ *
+ * @remarks `.using()`, `.absent()`, and `.usingAll()` seal the value, and an exposed class is real —
+ * none of them carries a mock surface, so handing them back typed as `Mocked` would lie.
+ */
+export class SealedDependencyError extends TestingError {
+    code = "SEALED_DEPENDENCY";
+    tokenName;
+    constructor(tokenName, cause) {
+        super(`'${tokenName}' is not a retrievable mock: ${SEALED_MESSAGES[cause]}`);
+        this.tokenName = tokenName;
+    }
+}
+/**
+ * An override whose shape does not fit the slot it targets — `.absent()` on a required dependency,
+ * or `.usingAll()` where no unconstrained `injectAll()` slot exists.
+ */
+export class OverrideMismatchError extends TestingError {
+    code = "OVERRIDE_MISMATCH";
+    tokenName;
+    constructor(tokenName, detail) {
+        super(`'${tokenName}': ${detail}`);
+        this.tokenName = tokenName;
+    }
+}
+/**
+ * A sociable bed's exposure could not be honoured — the class is unreachable, already the unit, or
+ * was asked for without having been exposed.
+ */
+export class ExposureError extends TestingError {
+    code = "EXPOSURE";
+    targetName;
+    constructor(targetName, detail) {
+        super(`'${targetName}': ${detail}`);
+        this.targetName = targetName;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors/errors.ts"],"names":[],"mappings":"AAAA,iGAAiG;AAEjG;;;;;GAKG;AACH,MAAM,OAAgB,YAAa,SAAQ,KAAK;IAG9C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACpC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,kBAAmB,SAAQ,YAAY;IACzC,IAAI,GAAG,gBAAgB,CAAC;IACxB,UAAU,CAAS;IAE5B,YAAY,UAAkB;QAC5B,KAAK,CACH,oCAAoC,UAAU,gNAAgN,CAC/P,CAAC;QACF,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,OAAO,yBAA0B,SAAQ,YAAY;IAChD,IAAI,GAAG,uBAAuB,CAAC;IAC/B,SAAS,CAAS;IAE3B,YAAY,SAAiB,EAAE,MAAe;QAC5C,KAAK,CACH,IAAI,SAAS,IAAI,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,GAAG,oJAAoJ,CAChN,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CACF;AAKD,MAAM,eAAe,GAA0C;IAC7D,KAAK,EAAE,iGAAiG;IACxG,MAAM,EAAE,yEAAyE;IACjF,GAAG,EAAE,qFAAqF;IAC1F,OAAO,EAAE,oFAAoF;CAC9F,CAAC;AAEF;;;;;GAKG;AACH,MAAM,OAAO,qBAAsB,SAAQ,YAAY;IAC5C,IAAI,GAAG,mBAAmB,CAAC;IAC3B,SAAS,CAAS;IAE3B,YAAY,SAAiB,EAAE,KAAkB;QAC/C,KAAK,CAAC,IAAI,SAAS,gCAAgC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC7E,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,qBAAsB,SAAQ,YAAY;IAC5C,IAAI,GAAG,mBAAmB,CAAC;IAC3B,SAAS,CAAS;IAE3B,YAAY,SAAiB,EAAE,MAAc;QAC3C,KAAK,CAAC,IAAI,SAAS,MAAM,MAAM,EAAE,CAAC,CAAC;QACnC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,aAAc,SAAQ,YAAY;IACpC,IAAI,GAAG,UAAU,CAAC;IAClB,UAAU,CAAS;IAE5B,YAAY,UAAkB,EAAE,MAAc;QAC5C,KAAK,CAAC,IAAI,UAAU,MAAM,MAAM,EAAE,CAAC,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/** 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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uEAAuE;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC/F,YAAY,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,YAAY,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEhG,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9D,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,EACZ,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+/** 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";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uEAAuE;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAO9C,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAI1C,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,EACZ,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,47 @@
+/** The lazy `Proxy` that mocks an erased interface one accessed property at a time. */
+import type { MockFactory, MockFunction } from "#/mocking/mock-factory";
+import type { Spy } from "#/mocking/spy";
+/**
+ * A mocked view of `Dependency`: every member becomes a spy, nested objects are mocked in turn.
+ *
+ * @remarks With the default backend a method is a precisely-typed {@link Spy}; a custom backend
+ * (`vi.fn`, `jest.fn`, a Sinon stub) intersects its own native surface with the method's signature,
+ * so backend-specific APIs like `mockReturnValueOnce` or `returns` type-check without adapters. The
+ * check is mutual, so a backend that merely resembles {@link Spy} still keeps its own surface.
+ *
+ * @typeParam Dependency - The dependency type being mocked.
+ * @typeParam Backend - The spy type the active mock factory produces.
+ */
+export type Mocked<Dependency, Backend extends MockFunction = Spy> = Dependency extends (...args: infer Args) => infer Return ? [Backend] extends [Spy] ? [Spy] extends [Backend] ? Spy<Args, Return> : Backend & ((...args: Args) => Return) : Backend & ((...args: Args) => Return) : Dependency extends object ? {
+    [Key in keyof Dependency]: Mocked<Dependency[Key], Backend>;
+} : Dependency;
+/**
+ * A recursively optional view of `Dependency` — the shape a hand-written `.stub` seed may supply.
+ *
+ * @remarks Functions are kept whole (a stub replaces a whole method), everything else is made
+ * optional so only the members a test cares about need spelling out.
+ *
+ * @typeParam Dependency - The dependency type being partially stubbed.
+ */
+export type DeepPartial<Dependency> = Dependency extends (...args: Array<never>) => unknown ? Dependency : Dependency extends object ? {
+    [Key in keyof Dependency]?: DeepPartial<Dependency[Key]>;
+} : Dependency;
+/**
+ * The key an auto-mock answers with its reset routine, clearing the root spy, every materialized
+ * member, and the spies of its seed.
+ */
+export declare const MOCK_RESET: unique symbol;
+/**
+ * Builds a lazy auto-mock for an erased interface: each accessed member becomes a cached child mock.
+ *
+ * @remarks The proxy target is itself a spy, so a function-typed dependency records calls, and every
+ * materialized member is another auto-mock, so nested access (`repo.user.create`) works to any depth.
+ * A `seed` wins for the members it supplies (inherited ones included; a primitive seed is returned
+ * as the value itself); keys the root spy owns pass through, so its backend API stays real — which
+ * also means a member sharing a name with a function's own `name`/`length` cannot be auto-mocked.
+ *
+ * @typeParam Dependency - The dependency type being mocked.
+ * @typeParam Backend - The spy type the factory produces, threaded into the returned `Mocked` view.
+ */
+export declare function createAutoMock<Dependency, Backend extends MockFunction = Spy>(mockFactory: MockFactory<Backend>, seed?: DeepPartial<Dependency>): Mocked<Dependency, Backend>;
+//# sourceMappingURL=auto-mock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auto-mock.d.ts","sourceRoot":"","sources":["../../src/mocking/auto-mock.ts"],"names":[],"mappings":"AAAA,uFAAuF;AAEvF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,MAAM,MAAM,MAAM,CAAC,UAAU,EAAE,OAAO,SAAS,YAAY,GAAG,GAAG,IAAI,UAAU,SAAS,CACtF,GAAG,IAAI,EAAE,MAAM,IAAI,KAChB,MAAM,MAAM,GACb,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GACrB,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,GACrB,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,GACjB,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,GACvC,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,GACvC,UAAU,SAAS,MAAM,GACvB;KAAG,GAAG,IAAI,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;CAAE,GAC/D,UAAU,CAAC;AAEjB;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,UAAU,IAAI,UAAU,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,OAAO,GACvF,UAAU,GACV,UAAU,SAAS,MAAM,GACvB;KAAG,GAAG,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;CAAE,GAC5D,UAAU,CAAC;AAEjB;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,MAAwC,CAAC;AAoDzE;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,SAAS,YAAY,GAAG,GAAG,EAC3E,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,EACjC,IAAI,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,GAC7B,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAyH7B"}

package/dist/mocking/auto-mock.js

@@ -0,0 +1,180 @@
+/** The lazy `Proxy` that mocks an erased interface one accessed property at a time. */
+/**
+ * The key an auto-mock answers with its reset routine, clearing the root spy, every materialized
+ * member, and the spies of its seed.
+ */
+export const MOCK_RESET = Symbol("di-testing:mock-reset");
+// `then` would make every mock thenable and stall `await`; `toJSON` and `asymmetricMatch` are probed
+// by serializers and expect() and must not answer as callables.
+const UNMOCKED_KEYS = new Set(["then", "toJSON", "asymmetricMatch"]);
+// Inherited members that inspection and printing rely on; every other inherited key (`apply`,
+// `call`, `bind`, the throwing `caller`/`arguments`) is fair game for a domain interface.
+const INHERITED_PASSTHROUGH = new Set([
+    "constructor",
+    "toString",
+    "toLocaleString",
+    "valueOf",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+]);
+/** Clears one spy through whichever reset method its backend spells, recursing into auto-mocks. */
+function resetSpy(spy) {
+    if (spy === null || (typeof spy !== "object" && typeof spy !== "function")) {
+        return;
+    }
+    const candidate = spy;
+    if (typeof candidate[MOCK_RESET] === "function") {
+        candidate[MOCK_RESET]();
+    }
+    else if (typeof candidate.mockReset === "function") {
+        candidate.mockReset();
+    }
+    else if (typeof candidate.reset === "function") {
+        candidate.reset();
+    }
+    else if (typeof candidate.resetHistory === "function") {
+        candidate.resetHistory();
+    }
+}
+/** Whether the seed supplies `key` itself — its prototype chain counts, the global prototypes don't. */
+function seedProvides(seed, key) {
+    let current = seed;
+    while (current !== null && current !== Object.prototype && current !== Function.prototype) {
+        if (Object.hasOwn(current, key)) {
+            return true;
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return false;
+}
+/**
+ * Builds a lazy auto-mock for an erased interface: each accessed member becomes a cached child mock.
+ *
+ * @remarks The proxy target is itself a spy, so a function-typed dependency records calls, and every
+ * materialized member is another auto-mock, so nested access (`repo.user.create`) works to any depth.
+ * A `seed` wins for the members it supplies (inherited ones included; a primitive seed is returned
+ * as the value itself); keys the root spy owns pass through, so its backend API stays real — which
+ * also means a member sharing a name with a function's own `name`/`length` cannot be auto-mocked.
+ *
+ * @typeParam Dependency - The dependency type being mocked.
+ * @typeParam Backend - The spy type the factory produces, threaded into the returned `Mocked` view.
+ */
+export function createAutoMock(mockFactory, seed) {
+    // A primitive stub has no members to mock — the seed is the dependency's whole value.
+    if (seed !== undefined && (typeof seed !== "object" || seed === null) && typeof seed !== "function") {
+        return seed;
+    }
+    const cache = new Map();
+    const methodWrappers = new Map();
+    const seedRecord = seed;
+    const target = mockFactory();
+    let self;
+    const reset = () => {
+        resetSpy(target);
+        for (const child of cache.values()) {
+            resetSpy(child);
+        }
+        if (seedRecord !== undefined) {
+            for (const value of Object.values(seedRecord)) {
+                resetSpy(value);
+            }
+        }
+    };
+    const proxy = new Proxy(target, {
+        get(fnTarget, key, receiver) {
+            if (key === MOCK_RESET) {
+                return reset;
+            }
+            if (seedRecord !== undefined && seedProvides(seedRecord, key)) {
+                // A non-configurable, non-writable target property must report its own value (proxy invariant).
+                const own = Reflect.getOwnPropertyDescriptor(fnTarget, key);
+                if (own !== undefined && own.configurable === false && own.writable === false) {
+                    return own.value;
+                }
+                return Reflect.get(seedRecord, key);
+            }
+            if (typeof key === "symbol" || UNMOCKED_KEYS.has(key)) {
+                return Reflect.get(fnTarget, key, receiver);
+            }
+            if (Object.hasOwn(fnTarget, key)) {
+                const value = Reflect.get(fnTarget, key);
+                if (typeof value !== "function") {
+                    return value;
+                }
+                // The backend's own methods run against the target, and a chainable return re-enters the mock.
+                let wrapper = methodWrappers.get(key);
+                if (wrapper === undefined) {
+                    wrapper = (...args) => {
+                        const result = value.call(fnTarget, ...args);
+                        return result === fnTarget ? self : result;
+                    };
+                    methodWrappers.set(key, wrapper);
+                }
+                return wrapper;
+            }
+            if (INHERITED_PASSTHROUGH.has(key)) {
+                return Reflect.get(fnTarget, key);
+            }
+            let child = cache.get(key);
+            if (child === undefined) {
+                child = createAutoMock(mockFactory);
+                cache.set(key, child);
+            }
+            return child;
+        },
+        // `in` agrees with `get`: any mockable string key answers true, everything else asks the target.
+        has(fnTarget, key) {
+            if (key === MOCK_RESET) {
+                return true;
+            }
+            if (seedRecord !== undefined && seedProvides(seedRecord, key)) {
+                return true;
+            }
+            if (typeof key === "symbol" || UNMOCKED_KEYS.has(key)) {
+                return Reflect.has(fnTarget, key);
+            }
+            return true;
+        },
+        // Enumeration shows the interface's materialized members, not the spy backend's internals.
+        ownKeys(fnTarget) {
+            const keys = new Set();
+            if (seedRecord !== undefined) {
+                for (const key of Reflect.ownKeys(seedRecord)) {
+                    keys.add(key);
+                }
+            }
+            for (const key of cache.keys()) {
+                keys.add(key);
+            }
+            // Non-configurable target keys must be reported (proxy invariant); the rest stay hidden.
+            for (const key of Reflect.ownKeys(fnTarget)) {
+                const descriptor = Reflect.getOwnPropertyDescriptor(fnTarget, key);
+                if (descriptor !== undefined && descriptor.configurable === false) {
+                    keys.add(key);
+                }
+            }
+            return [...keys];
+        },
+        getOwnPropertyDescriptor(fnTarget, key) {
+            if (typeof key === "string" && (cache.has(key) || (seedRecord !== undefined && seedProvides(seedRecord, key)))) {
+                return {
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                    value: proxy[key],
+                };
+            }
+            return Reflect.getOwnPropertyDescriptor(fnTarget, key);
+        },
+        deleteProperty(fnTarget, key) {
+            if (typeof key === "string" && cache.delete(key)) {
+                return true;
+            }
+            return Reflect.deleteProperty(fnTarget, key);
+        },
+    });
+    self = proxy;
+    return proxy;
+}
+//# sourceMappingURL=auto-mock.js.map

package/dist/mocking/auto-mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-mock.js","sourceRoot":"","sources":["../../src/mocking/auto-mock.ts"],"names":[],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock-factory.d.ts","sourceRoot":"","sources":["../../src/mocking/mock-factory.ts"],"names":[],"mappings":"AAAA,uFAAuF;AAEvF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC;AAExE;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,SAAS,YAAY,GAAG,YAAY,IAAI,MAAM,OAAO,CAAC;AAErF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,GAAG,CAAqB,CAAC"}

package/dist/mocking/mock-factory.js

@@ -0,0 +1,7 @@
+/** The pluggable seam that decides which spy backend the auto-mocks are built from. */
+import { createSpy } from "#/mocking/spy";
+/**
+ * The default `MockFactory` — one built-in {@link Spy} per call, with no test-framework dependency.
+ */
+export const defaultMockFactory = () => createSpy();
+//# sourceMappingURL=mock-factory.js.map

package/dist/mocking/mock-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-factory.js","sourceRoot":"","sources":["../../src/mocking/mock-factory.ts"],"names":[],"mappings":"AAAA,uFAAuF;AAGvF,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAsB1C;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAqB,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC"}

package/dist/mocking/spy.d.ts

@@ -0,0 +1,39 @@
+/** The built-in zero-dependency spy the default mock factory hands out. */
+/**
+ * One recorded invocation's outcome — a returned value or a thrown error.
+ */
+export interface SpyResult {
+    readonly type: "return" | "throw";
+    readonly value: unknown;
+}
+/**
+ * The call log a spy exposes for assertions.
+ *
+ * @typeParam Args - The spy's argument tuple.
+ */
+export interface SpyState<Args extends ReadonlyArray<unknown>> {
+    readonly calls: ReadonlyArray<Args>;
+    readonly results: ReadonlyArray<SpyResult>;
+}
+/**
+ * The built-in zero-dependency spy: callable, records calls, and takes a return value or implementation.
+ *
+ * @remarks `Return` defaults to `any` so a spy drops into any typed method slot, exactly as Vitest's
+ * own mock type does — the package's one deliberate `any`.
+ */
+export interface Spy<Args extends ReadonlyArray<unknown> = ReadonlyArray<unknown>, Return = any> {
+    (...args: Args): Return;
+    /** The recorded calls and their outcomes. */
+    readonly mock: SpyState<Args>;
+    /** Sets a fixed value returned by every subsequent call. */
+    mockReturnValue(value: Return): this;
+    /** Replaces the spy's behaviour with `fn`, still recording each call. */
+    mockImplementation(fn: (...args: Args) => Return): this;
+    /** Clears the recorded calls and any configured return value or implementation. */
+    mockReset(): void;
+}
+/**
+ * Creates a fresh zero-dependency spy that records its calls and returns `undefined` until configured.
+ */
+export declare function createSpy(): Spy;
+//# sourceMappingURL=spy.d.ts.map

package/dist/mocking/spy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spy.d.ts","sourceRoot":"","sources":["../../src/mocking/spy.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC;IAC3D,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;CAC5C;AAGD;;;;;GAKG;AACH,MAAM,WAAW,GAAG,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAC7F,CAAC,GAAG,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC9B,4DAA4D;IAC5D,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,GAAG,IAAI,CAAC;IACxD,mFAAmF;IACnF,SAAS,IAAI,IAAI,CAAC;CACnB;AAGD;;GAEG;AACH,wBAAgB,SAAS,IAAI,GAAG,CAwC/B"}

package/dist/mocking/spy.js

@@ -0,0 +1,43 @@
+/** The built-in zero-dependency spy the default mock factory hands out. */
+/* oxlint-enable typescript/no-explicit-any */
+/**
+ * Creates a fresh zero-dependency spy that records its calls and returns `undefined` until configured.
+ */
+export function createSpy() {
+    const calls = [];
+    const results = [];
+    let implementation;
+    let returnValue;
+    const spy = Object.assign((...args) => {
+        calls.push(args);
+        try {
+            const value = implementation === undefined ? returnValue : implementation(...args);
+            results.push({ type: "return", value });
+            return value;
+        }
+        catch (error) {
+            results.push({ type: "throw", value: error });
+            throw error;
+        }
+    }, {
+        mock: { calls, results },
+        mockReturnValue(value) {
+            returnValue = value;
+            implementation = undefined;
+            return spy;
+        },
+        mockImplementation(fn) {
+            implementation = fn;
+            return spy;
+        },
+        // Cleared in place so `mock` stays one stable object across resets.
+        mockReset() {
+            calls.length = 0;
+            results.length = 0;
+            implementation = undefined;
+            returnValue = undefined;
+        },
+    });
+    return spy;
+}
+//# sourceMappingURL=spy.js.map

package/dist/mocking/spy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spy.js","sourceRoot":"","sources":["../../src/mocking/spy.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAsC3E,8CAA8C;AAE9C;;GAEG;AACH,MAAM,UAAU,SAAS;IACvB,MAAM,KAAK,GAAkC,EAAE,CAAC;IAChD,MAAM,OAAO,GAAqB,EAAE,CAAC;IACrC,IAAI,cAA0E,CAAC;IAC/E,IAAI,WAAoB,CAAC;IAEzB,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CACvB,CAAC,GAAG,IAA4B,EAAW,EAAE;QAC3C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;YACnF,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;YACxC,OAAO,KAAK,CAAC;QACf,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YAC9C,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC,EACD;QACE,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE;QACxB,eAAe,CAAC,KAAc;YAC5B,WAAW,GAAG,KAAK,CAAC;YACpB,cAAc,GAAG,SAAS,CAAC;YAC3B,OAAO,GAAG,CAAC;QACb,CAAC;QACD,kBAAkB,CAAC,EAAgD;YACjE,cAAc,GAAG,EAAE,CAAC;YACpB,OAAO,GAAG,CAAC;QACb,CAAC;QACD,oEAAoE;QACpE,SAAS;YACP,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;YACjB,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;YACnB,cAAc,GAAG,SAAS,CAAC;YAC3B,WAAW,GAAG,SAAS,CAAC;QAC1B,CAAC;KACF,CACK,CAAC;IAET,OAAO,GAAG,CAAC;AACb,CAAC"}

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

@@ -0,0 +1,83 @@
+/** 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";
+/**
+ * Options that configure a whole test-bed compile.
+ *
+ * @typeParam Backend - The spy type the mock factory produces; it flows into every `Mocked` member,
+ * `mocks.get`, and the `.stub` callback, so `() => vi.fn()` yields Vitest's own mock typing.
+ */
+export interface TestBedOptions<Backend extends MockFunction = Spy> {
+    /** Spy factory each auto-mock property is materialized with; defaults to the built-in spy. */
+    readonly mockFactory?: MockFactory<Backend> | undefined;
+    /** Reader the dependency scan and the compile container both consult; defaults to di's reader. */
+    readonly metadataReader?: MetadataReader | undefined;
+}
+/**
+ * The override step: choose how one named dependency is supplied instead of a plain auto-mock.
+ *
+ * @typeParam Dependency - The dependency's value type.
+ * @typeParam Owner - The builder the chain returns to.
+ * @typeParam Backend - The spy type the bed's mock factory produces.
+ */
+export interface MockOverrideBuilder<Dependency, Owner, Backend extends MockFunction = Spy> {
+    /**
+     * Supplies a fixed value for this dependency.
+     *
+     * @remarks The value is bound as-is and sealed: it has no mock surface, so `mocks.get` refuses
+     * it rather than hand it back mistyped — the test already holds the reference it passed in.
+     */
+    using(value: Dependency): Owner;
+    /**
+     * Supplies a partial stub, built from the active spy factory; unlisted members stay auto-mocked.
+     *
+     * @remarks The callback runs once per compile, so beds built from one builder never share spies.
+     */
+    stub(setup: (fn: MockFactory<Backend>) => DeepPartial<Dependency>): Owner;
+    /** Leaves the dependency unbound: an `optional()` slot resolves `undefined`, an `injectAll()` slot `[]`. */
+    absent(): Owner;
+    /** Supplies every element of an unconstrained `injectAll()` slot, in order. Sealed like `.using`. */
+    usingAll(values: ReadonlyArray<Dependency>): Owner;
+}
+/**
+ * What a builder's prepare step hands the compile template: the container and the bound mock entries.
+ */
+export interface PreparedBed {
+    readonly container: Container;
+    readonly mocks: ReadonlyMap<DependencyKey, ReadonlyArray<BoundMock>>;
+}
+/**
+ * The shared builder core: records overrides, resolves the reader and mock factory, and owns the
+ * compile template that disposes the container when a build fails.
+ *
+ * @remarks Fields are `protected` rather than `#` so the two concrete builders stay thin; nothing
+ * outside `test-bed/` extends this class.
+ *
+ * @typeParam Class - The class under test.
+ * @typeParam Backend - The spy type the bed's mock factory produces.
+ */
+export declare abstract class BedBuilder<Class, Backend extends MockFunction = Spy> {
+    #private;
+    protected readonly target: Constructor<Class>;
+    protected readonly reader: MetadataReader;
+    protected readonly mockFactory: MockFactory<Backend>;
+    protected readonly overrides: ReadonlyMap<DependencyKey, ReadonlyArray<SlottedOverride>>;
+    constructor(target: Constructor<Class>, options?: TestBedOptions<Backend>);
+    /**
+     * Replaces the auto-mock for one dependency with a hand-written stub or a concrete value.
+     *
+     * @remarks Pass `options` (a name or tags) to target one slot of a token bound several ways;
+     * without them the override covers every slot of the token that has no more specific override.
+     * Registering the same target twice replaces the earlier override wholesale.
+     */
+    mock<Dependency>(identifier: InjectionIdentifier<Dependency>, options?: InjectOptions): MockOverrideBuilder<Dependency, this, Backend>;
+    /** Resolves the unit inside a guard that disposes the container when any compile step throws. */
+    protected compileWith<Prepared extends PreparedBed, Bed>(prepare: () => Prepared, build: (unit: Class, prepared: Prepared) => Bed): Bed;
+    /** 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bed-builder.d.ts","sourceRoot":"","sources":["../../src/test-bed/bed-builder.ts"],"names":[],"mappings":"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"}