@zudojs/testing 1.0.0 → 1.1.1

package/README.md

@@ -2,6 +2,12 @@
 
 Test helpers, fixtures, mocks, and assertions for Zudojs applications.
 
+<!-- zudo-docs:start -->
+
+**Documentation:** [zudojs.oyinlola.site/docs/packages-testing](https://zudojs.oyinlola.site/docs/packages-testing) · **For AI agents:** [Markdown version](https://zudojs.oyinlola.site/docs/packages-testing.md), [llms.txt](https://zudojs.oyinlola.site/llms.txt)
+
+<!-- zudo-docs:end -->
+
 ## Installation
 
 ```bash
@@ -61,13 +67,26 @@ assertResponseBody(response, { id: "u_1", roles: new Set(["admin"]) });
 - Assertions compare structurally, not by `JSON.stringify`. `Map`, `Set`,
   `Date`, `BigInt`, `undefined` values and key order are all handled, and a
   circular value reports a mismatch instead of throwing a `TypeError`.
+- Types are compared too: two objects must share a prototype (a class
+  instance never equals a plain object or an instance of another class;
+  `{}` and `Object.create(null)` count as the same), Errors must match on
+  `name`, `message` and `cause`, boxed primitives on their value, and typed
+  arrays on their constructor. Distinct Promises, WeakMaps and WeakSets are
+  never equal. A serializer that turns an Error into `{}` fails
+  `assertSerializesCorrectly`.
 - `createStub()` answers `then` with `undefined`, so awaiting a stub — or
   returning one from an async factory — resolves rather than hanging.
 - `cleanup.dispose()` rejects with an `AggregateError` when any cleanup fails,
   after running them all.
 - `mockResolvedValue` and `mockRejectedValue` return promises; `results` stays
-  aligned index-for-index with `calls`.
+  aligned index-for-index with `calls`, even when the implementation throws
+  (the slot holds `undefined` and the thrown value lands in `errors`).
 - Spies forward their receiver, so a method reading `this` still works.
+- `assertThrows` is for synchronous code. Handing it an async function throws
+  "use assertRejects" instead of a misleading "did not throw", and the
+  rejection is handled rather than leaked.
+- `findByMetadata` and the structural assertions compare `Set` members and
+  `Map` keys by value, so `new Set([{ id: 1 }])` matches `new Set([{ id: 1 }])`.
 
 ## Use Cases
 

package/dist/assertions/deepEqual/deepEqual.collections.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @zudojs/testing — Map and Set comparison for the structural walk.
+ *
+ * `Map.has`/`Set.has` are identity-based, so collections holding equal but
+ * distinct objects would compare unequal. Each expected entry is matched
+ * against a still-unmatched actual entry: by identity when that entry is
+ * still unmatched, structurally otherwise. The identity shortcut only applies
+ * to entries not yet consumed; taking it for a consumed entry made
+ * `indexOf` return -1 and `splice(-1, 1)` drop an unrelated entry.
+ *
+ * @module assertions/deepEqual.collections
+ */
+import type { Difference } from "./deepEqual.describe.js";
+/** The recursive walker, passed in to avoid a module cycle. */
+export type DiffWalker = (actual: unknown, expected: unknown, path: string, seen: Map<object, object>) => Difference | undefined;
+/**
+ * Compares two Maps. A key matched structurally prefers the actual key whose
+ * value also matches, and falls back to a key-only match so the value
+ * difference is what gets reported.
+ */
+export declare function diffMap(actual: Map<unknown, unknown>, expected: Map<unknown, unknown>, path: string, seen: Map<object, object>, walk: DiffWalker): Difference | undefined;
+/** Compares two Sets, matching each expected item to one unmatched actual item. */
+export declare function diffSet(actual: Set<unknown>, expected: Set<unknown>, path: string, seen: Map<object, object>, walk: DiffWalker): Difference | undefined;
+//# sourceMappingURL=deepEqual.collections.d.ts.map

package/dist/assertions/deepEqual/deepEqual.collections.js

@@ -0,0 +1,81 @@
+/**
+ * @zudojs/testing — Map and Set comparison for the structural walk.
+ *
+ * `Map.has`/`Set.has` are identity-based, so collections holding equal but
+ * distinct objects would compare unequal. Each expected entry is matched
+ * against a still-unmatched actual entry: by identity when that entry is
+ * still unmatched, structurally otherwise. The identity shortcut only applies
+ * to entries not yet consumed; taking it for a consumed entry made
+ * `indexOf` return -1 and `splice(-1, 1)` drop an unrelated entry.
+ *
+ * @module assertions/deepEqual.collections
+ */
+import { describeValue } from "./deepEqual.describe.js";
+const NO_MATCH = Symbol("deepEqual.noMatch");
+/**
+ * Finds a candidate structurally equal to `expected`. Each probe walks a
+ * copy of `seen`: the cycle guard records a pair as "assumed equal" before
+ * comparing it, and a probe that fails must not leave that assumption
+ * behind for the next candidate.
+ */
+function findStructuralMatch(walk, candidates, expected, seen, accept = () => true) {
+    for (const candidate of candidates) {
+        if (walk(candidate, expected, "", new Map(seen)) === undefined &&
+            accept(candidate)) {
+            return candidate;
+        }
+    }
+    return NO_MATCH;
+}
+/**
+ * Compares two Maps. A key matched structurally prefers the actual key whose
+ * value also matches, and falls back to a key-only match so the value
+ * difference is what gets reported.
+ */
+export function diffMap(actual, expected, path, seen, walk) {
+    if (actual.size !== expected.size) {
+        return {
+            path,
+            reason: `expected ${expected.size} entries, received ${actual.size}`,
+        };
+    }
+    const unmatched = [...actual.keys()];
+    for (const [key, value] of expected) {
+        let actualKey = key;
+        if (!unmatched.includes(key)) {
+            actualKey = findStructuralMatch(walk, unmatched, key, seen, (candidate) => walk(actual.get(candidate), value, "", new Map(seen)) === undefined);
+            if (actualKey === NO_MATCH) {
+                actualKey = findStructuralMatch(walk, unmatched, key, seen);
+            }
+        }
+        if (actualKey === NO_MATCH) {
+            return { path, reason: `missing key ${describeValue(key)}` };
+        }
+        unmatched.splice(unmatched.indexOf(actualKey), 1);
+        const found = walk(actual.get(actualKey), value, `${path}[${describeValue(key)}]`, seen);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** Compares two Sets, matching each expected item to one unmatched actual item. */
+export function diffSet(actual, expected, path, seen, walk) {
+    if (actual.size !== expected.size) {
+        return {
+            path,
+            reason: `expected ${expected.size} items, received ${actual.size}`,
+        };
+    }
+    const unmatched = [...actual];
+    for (const entry of expected) {
+        const match = unmatched.includes(entry)
+            ? entry
+            : findStructuralMatch(walk, unmatched, entry, seen);
+        if (match === NO_MATCH) {
+            return { path, reason: `missing item ${describeValue(entry)}` };
+        }
+        unmatched.splice(unmatched.indexOf(match), 1);
+    }
+    return undefined;
+}
+//# sourceMappingURL=deepEqual.collections.js.map

package/dist/assertions/{deepEqual.core.js → deepEqual/deepEqual.core.js}

@@ -11,6 +11,8 @@
  * @module assertions/deepEqual
  */
 import { describeValue } from "./deepEqual.describe.js";
+import { diffMap, diffSet } from "./deepEqual.collections.js";
+import { compareIdentity, errorCauses } from "./deepEqual.identity.js";
 /** The constructor-level kind of a value, used to reject cross-type matches. */
 function kindOf(value) {
     if (value === null)
@@ -60,12 +62,21 @@ function diff(actual, expected, path, seen) {
             reason: `expected ${describeValue(expected)}, received ${describeValue(actual)}`,
         };
     }
+    const mismatch = compareIdentity(actual, expected);
+    if (mismatch)
+        return { path, reason: mismatch };
     // Guard against cycles: a pair already being compared is assumed equal
     // until proven otherwise elsewhere in the walk.
     const previous = seen.get(actual);
     if (previous === expected)
         return undefined;
     seen.set(actual, expected);
+    const causes = errorCauses(actual, expected);
+    if (causes) {
+        const found = diff(causes.actual, causes.expected, `${path}.cause`, seen);
+        if (found)
+            return found;
+    }
     if (Array.isArray(actual) && Array.isArray(expected)) {
         if (actual.length !== expected.length) {
             return {
@@ -81,35 +92,10 @@ function diff(actual, expected, path, seen) {
         return undefined;
     }
     if (actual instanceof Map && expected instanceof Map) {
-        if (actual.size !== expected.size) {
-            return {
-                path,
-                reason: `expected ${expected.size} entries, received ${actual.size}`,
-            };
-        }
-        for (const [key, value] of expected) {
-            if (!actual.has(key)) {
-                return { path, reason: `missing key ${describeValue(key)}` };
-            }
-            const found = diff(actual.get(key), value, `${path}[${describeValue(key)}]`, seen);
-            if (found)
-                return found;
-        }
-        return undefined;
+        return diffMap(actual, expected, path, seen, diff);
     }
     if (actual instanceof Set && expected instanceof Set) {
-        if (actual.size !== expected.size) {
-            return {
-                path,
-                reason: `expected ${expected.size} items, received ${actual.size}`,
-            };
-        }
-        for (const entry of expected) {
-            if (!actual.has(entry)) {
-                return { path, reason: `missing item ${describeValue(entry)}` };
-            }
-        }
-        return undefined;
+        return diffSet(actual, expected, path, seen, diff);
     }
     if (ArrayBuffer.isView(actual) && ArrayBuffer.isView(expected)) {
         const a = new Uint8Array(actual.buffer, actual.byteOffset, actual.byteLength);

package/dist/assertions/deepEqual/deepEqual.identity.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @zudojs/testing — Identity checks that run before the structural walk.
+ *
+ * The structural walk compares own enumerable keys. That alone treats every
+ * Error as `{}` (`message`, `name` and `stack` are not enumerable), a class
+ * instance as a plain object, `new Number(1)` as `new Number(2)`, and a
+ * `Uint8Array` as any typed array with the same bytes. These checks reject
+ * those pairs first, so an assertion built on `deepEqual` can fail when the
+ * value lost its type or its payload.
+ *
+ * @module assertions/deepEqual.identity
+ */
+/** A mismatch reason, or undefined when the pair passes this check. */
+export type IdentityMismatch = string | undefined;
+/**
+ * Compares the parts of two objects that are invisible to a key walk:
+ * prototype, boxed value, Error name/message/cause, typed-array constructor,
+ * and the unobservable contents of Promises and weak collections.
+ *
+ * @param actual - The observed object.
+ * @param expected - The object it should equal.
+ * @returns A mismatch reason, or undefined when the pair may be walked.
+ */
+export declare function compareIdentity(actual: object, expected: object): IdentityMismatch;
+/**
+ * The Error `cause`, when either side has one. `cause` is an own
+ * non-enumerable property, so the key walk never reaches it.
+ */
+export declare function errorCauses(actual: object, expected: object): {
+    readonly actual: unknown;
+    readonly expected: unknown;
+} | undefined;
+//# sourceMappingURL=deepEqual.identity.d.ts.map

package/dist/assertions/deepEqual/deepEqual.identity.js

@@ -0,0 +1,101 @@
+/**
+ * @zudojs/testing — Identity checks that run before the structural walk.
+ *
+ * The structural walk compares own enumerable keys. That alone treats every
+ * Error as `{}` (`message`, `name` and `stack` are not enumerable), a class
+ * instance as a plain object, `new Number(1)` as `new Number(2)`, and a
+ * `Uint8Array` as any typed array with the same bytes. These checks reject
+ * those pairs first, so an assertion built on `deepEqual` can fail when the
+ * value lost its type or its payload.
+ *
+ * @module assertions/deepEqual.identity
+ */
+import { describeValue } from "./deepEqual.describe.js";
+/** Whether a prototype marks a plain record (`{}` or `Object.create(null)`). */
+function isPlainPrototype(proto) {
+    return proto === null || proto === Object.prototype;
+}
+/** A readable name for the prototype of a value. */
+function prototypeName(value) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null)
+        return "null-prototype object";
+    const ctor = proto.constructor;
+    return ctor?.name ? ctor.name : "anonymous prototype";
+}
+/**
+ * Boxed primitives (`new Number(1)`, `Object(1n)`) carry their value in an
+ * internal slot, not in an own key. Returns the unboxed value, or a sentinel
+ * when `value` is not boxed.
+ */
+function unbox(value) {
+    const tag = Object.prototype.toString.call(value);
+    switch (tag) {
+        case "[object Number]":
+        case "[object String]":
+        case "[object Boolean]":
+        case "[object BigInt]":
+        case "[object Symbol]":
+            return {
+                boxed: true,
+                value: value.valueOf(),
+            };
+        default:
+            return { boxed: false };
+    }
+}
+/** Values whose contents cannot be observed, so only identity can make them equal. */
+function isOpaque(value) {
+    return (value instanceof Promise ||
+        value instanceof WeakMap ||
+        value instanceof WeakSet ||
+        (typeof WeakRef !== "undefined" && value instanceof WeakRef));
+}
+/**
+ * Compares the parts of two objects that are invisible to a key walk:
+ * prototype, boxed value, Error name/message/cause, typed-array constructor,
+ * and the unobservable contents of Promises and weak collections.
+ *
+ * @param actual - The observed object.
+ * @param expected - The object it should equal.
+ * @returns A mismatch reason, or undefined when the pair may be walked.
+ */
+export function compareIdentity(actual, expected) {
+    const actualProto = Object.getPrototypeOf(actual);
+    const expectedProto = Object.getPrototypeOf(expected);
+    const bothPlain = isPlainPrototype(actualProto) && isPlainPrototype(expectedProto);
+    if (!bothPlain && actualProto !== expectedProto) {
+        return `expected instance of ${prototypeName(expected)}, received ${prototypeName(actual)}`;
+    }
+    if (isOpaque(expected)) {
+        return `expected the same ${prototypeName(expected)} instance, received a different one`;
+    }
+    const actualBox = unbox(actual);
+    const expectedBox = unbox(expected);
+    if (actualBox.boxed || expectedBox.boxed) {
+        if (!Object.is(actualBox.value, expectedBox.value)) {
+            return `expected boxed ${describeValue(expectedBox.value)}, received boxed ${describeValue(actualBox.value)}`;
+        }
+    }
+    if (actual instanceof Error && expected instanceof Error) {
+        if (actual.name !== expected.name) {
+            return `expected error name ${describeValue(expected.name)}, received ${describeValue(actual.name)}`;
+        }
+        if (actual.message !== expected.message) {
+            return `expected error message ${describeValue(expected.message)}, received ${describeValue(actual.message)}`;
+        }
+    }
+    return undefined;
+}
+/**
+ * The Error `cause`, when either side has one. `cause` is an own
+ * non-enumerable property, so the key walk never reaches it.
+ */
+export function errorCauses(actual, expected) {
+    if (!(actual instanceof Error) || !(expected instanceof Error))
+        return undefined;
+    if (!("cause" in actual) && !("cause" in expected))
+        return undefined;
+    return { actual: actual.cause, expected: expected.cause };
+}
+//# sourceMappingURL=deepEqual.identity.js.map

package/dist/assertions/deepEqual/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @zudojs/testing — Structural equality barrel.
+ *
+ * `deepEqual`/`findDifference` compare values structurally, including Maps,
+ * Sets, typed arrays, Errors, boxed primitives and class instances (by
+ * prototype). `describeValue` renders values for assertion messages.
+ *
+ * @module assertions/deepEqual
+ */
+export { deepEqual, findDifference } from "./deepEqual.core.js";
+export { describeValue } from "./deepEqual.describe.js";
+export type { Difference } from "./deepEqual.describe.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/assertions/deepEqual/index.js

@@ -0,0 +1,12 @@
+/**
+ * @zudojs/testing — Structural equality barrel.
+ *
+ * `deepEqual`/`findDifference` compare values structurally, including Maps,
+ * Sets, typed arrays, Errors, boxed primitives and class instances (by
+ * prototype). `describeValue` renders values for assertion messages.
+ *
+ * @module assertions/deepEqual
+ */
+export { deepEqual, findDifference } from "./deepEqual.core.js";
+export { describeValue } from "./deepEqual.describe.js";
+//# sourceMappingURL=index.js.map

package/dist/assertions/errorAssertions.core.js

@@ -3,8 +3,8 @@
  *
  * Assert errors, error types, and error messages.
  */
-import { findDifference } from "./deepEqual.core.js";
-import { describeValue } from "./deepEqual.describe.js";
+import { findDifference } from "./deepEqual/deepEqual.core.js";
+import { describeValue } from "./deepEqual/deepEqual.describe.js";
 /**
  * Asserts that a function throws an error.
  *
@@ -13,8 +13,9 @@ import { describeValue } from "./deepEqual.describe.js";
  * @returns The thrown error.
  */
 export function assertThrows(fn, expectedMessage) {
+    let returned;
     try {
-        fn();
+        returned = fn();
     }
     catch (error) {
         if (expectedMessage !== undefined) {
@@ -25,8 +26,21 @@ export function assertThrows(fn, expectedMessage) {
         }
         return error instanceof Error ? error : new Error(String(error));
     }
+    if (isThenable(returned)) {
+        // An async function never throws synchronously; its failure is a
+        // rejection. Reporting "did not throw" was misleading, and the
+        // rejected promise nobody awaited surfaced as an unhandled rejection
+        // blamed on whichever test happened to be running.
+        void returned.then(undefined, () => undefined);
+        throw new Error("assertThrows received a function that returned a promise; use assertRejects for async functions.");
+    }
     throw new Error("Expected function to throw, but it did not.");
 }
+function isThenable(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value.then === "function");
+}
 /**
  * Asserts that an async function rejects.
  *

package/dist/assertions/eventAssertions.core.js

@@ -3,7 +3,7 @@
  *
  * Assert events, event types, and event payloads.
  */
-import { findDifference } from "./deepEqual.core.js";
+import { findDifference } from "./deepEqual/deepEqual.core.js";
 /**
  * Asserts that an event has a specific type.
  *

package/dist/assertions/httpAssertions.core.js

@@ -3,8 +3,8 @@
  *
  * Assert HTTP responses, status codes, headers, and bodies.
  */
-import { findDifference } from "./deepEqual.core.js";
-import { describeValue } from "./deepEqual.describe.js";
+import { findDifference } from "./deepEqual/deepEqual.core.js";
+import { describeValue } from "./deepEqual/deepEqual.describe.js";
 /**
  * Asserts that a response has a specific status code.
  *

package/dist/assertions/index.d.ts

@@ -4,7 +4,6 @@
 export { assertBadRequest, assertCreated, assertNoContent, assertNotFound, assertOK, assertResponseBody, assertResponseBodyContains, assertResponseHeader, assertResponseStatus, assertServerError, } from "./httpAssertions.core.js";
 export { assertEventNotPublished, assertEventPayload, assertEventPublished, assertEventType, assertMessageDispatched, assertMessageNotDispatched, assertRecordedEventType, } from "./eventAssertions.core.js";
 export { assertErrorCode, assertErrorMetadata, assertErrorType, assertRejects, assertThrows, } from "./errorAssertions.core.js";
-export { deepEqual, findDifference } from "./deepEqual.core.js";
-export { describeValue } from "./deepEqual.describe.js";
-export type { Difference } from "./deepEqual.describe.js";
+export { deepEqual, describeValue, findDifference } from "./deepEqual/index.js";
+export type { Difference } from "./deepEqual/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/assertions/index.js

@@ -4,6 +4,5 @@
 export { assertBadRequest, assertCreated, assertNoContent, assertNotFound, assertOK, assertResponseBody, assertResponseBodyContains, assertResponseHeader, assertResponseStatus, assertServerError, } from "./httpAssertions.core.js";
 export { assertEventNotPublished, assertEventPayload, assertEventPublished, assertEventType, assertMessageDispatched, assertMessageNotDispatched, assertRecordedEventType, } from "./eventAssertions.core.js";
 export { assertErrorCode, assertErrorMetadata, assertErrorType, assertRejects, assertThrows, } from "./errorAssertions.core.js";
-export { deepEqual, findDifference } from "./deepEqual.core.js";
-export { describeValue } from "./deepEqual.describe.js";
+export { deepEqual, describeValue, findDifference } from "./deepEqual/index.js";
 //# sourceMappingURL=index.js.map

package/dist/cleanupManager/cleanupManager.core.js

@@ -15,6 +15,7 @@ export function createCleanupManager(options = {}) {
     const entries = [];
     let nextId = 0;
     let disposed = false;
+    let inFlight;
     const register = (fn, label = `cleanup-${nextId}`) => {
         if (disposed) {
             throw new Error("Cannot register cleanup after manager has been disposed.");
@@ -25,11 +26,7 @@ export function createCleanupManager(options = {}) {
             fn,
         });
     };
-    const dispose = async () => {
-        if (disposed) {
-            return;
-        }
-        disposed = true;
+    const runCleanups = async () => {
         const errors = [];
         const reversed = [...entries].reverse();
         for (const entry of reversed) {
@@ -49,6 +46,23 @@ export function createCleanupManager(options = {}) {
                 .join(", ")}`);
         }
     };
+    /**
+     * Runs the cleanups once. A second call made while the first is still
+     * running shares its promise, so nobody is told "disposed" before the
+     * resources are actually released; a call after completion resolves
+     * immediately.
+     */
+    const dispose = () => {
+        if (inFlight)
+            return inFlight;
+        if (disposed)
+            return Promise.resolve();
+        disposed = true;
+        inFlight = runCleanups().finally(() => {
+            inFlight = undefined;
+        });
+        return inFlight;
+    };
     return {
         get disposed() {
             return disposed;

package/dist/mocking/mockFn.core.d.ts

@@ -9,8 +9,14 @@
 export interface MockFn<TArgs extends readonly unknown[] = unknown[], TResult = unknown> {
     (...args: TArgs): TResult;
     readonly calls: readonly TArgs[];
-    /** Result of each call, aligned index-for-index with {@link calls}. */
+    /**
+     * Result of each call, aligned index-for-index with {@link calls}. A
+     * call whose implementation threw occupies its slot with `undefined`;
+     * the thrown value is in {@link errors}.
+     */
     readonly results: readonly TResult[];
+    /** Values thrown by the implementation, in call order. */
+    readonly errors: readonly unknown[];
     readonly invoked: boolean;
     readonly callCount: number;
     mockReturnValue: (value: TResult) => void;

package/dist/mocking/mockFn.core.js

@@ -23,6 +23,7 @@
 export function createMockFn(defaultReturnValue) {
     const calls = [];
     const results = [];
+    const errors = [];
     const initialMode = arguments.length > 0
         ? { kind: "value", value: defaultReturnValue }
         : { kind: "none" };
@@ -50,7 +51,17 @@ export function createMockFn(defaultReturnValue) {
     };
     const mock = ((...args) => {
         calls.push(args);
-        const result = produce(args);
+        let result;
+        try {
+            result = produce(args);
+        }
+        catch (error) {
+            // Keep `results` aligned with `calls` even when the implementation
+            // throws; otherwise every later result shifts one index left.
+            results.push(undefined);
+            errors.push(error);
+            throw error;
+        }
         results.push(result);
         return result;
     });
@@ -62,6 +73,10 @@ export function createMockFn(defaultReturnValue) {
         get: () => results,
         enumerable: true,
     });
+    Object.defineProperty(mock, "errors", {
+        get: () => errors,
+        enumerable: true,
+    });
     Object.defineProperty(mock, "invoked", {
         get: () => calls.length > 0,
         enumerable: true,
@@ -85,11 +100,13 @@ export function createMockFn(defaultReturnValue) {
     mock.mockReset = () => {
         calls.length = 0;
         results.length = 0;
+        errors.length = 0;
         mode = initialMode;
     };
     mock.mockClear = () => {
         calls.length = 0;
         results.length = 0;
+        errors.length = 0;
     };
     return mock;
 }

package/dist/spyLogger/spyLogger.context.d.ts

@@ -14,6 +14,14 @@ export declare function mergeLoggerContext(base: LoggerContext | undefined, next
  * top level, the way a real transport would render it.
  */
 export declare function mergeContext(context: LoggerContext | undefined, metadata: LogMetadata | undefined): LogMetadata | undefined;
-/** Structural comparison, so object metadata can actually be matched. */
+/**
+ * Structural comparison, so object metadata can actually be matched.
+ *
+ * Uses the same walker as the assertions. The previous
+ * `JSON.stringify` comparison matched any two `Map`s or `Set`s (both
+ * render as `{}`), dropped `undefined` values, and treated key order as
+ * significant, so `findByMetadata` could both match what it should not
+ * and miss what it should find.
+ */
 export declare function deepMatches(actual: unknown, expected: unknown): boolean;
 //# sourceMappingURL=spyLogger.context.d.ts.map

package/dist/spyLogger/spyLogger.context.js

@@ -3,6 +3,7 @@
  *
  * @module spyLogger/spyLogger.context
  */
+import { deepEqual } from "../assertions/deepEqual/deepEqual.core.js";
 /** Merges two logger contexts, preserving the nested shape. */
 export function mergeLoggerContext(base, next) {
     if (!base)
@@ -28,14 +29,16 @@ export function mergeContext(context, metadata) {
         ...metadata,
     };
 }
-/** Structural comparison, so object metadata can actually be matched. */
+/**
+ * Structural comparison, so object metadata can actually be matched.
+ *
+ * Uses the same walker as the assertions. The previous
+ * `JSON.stringify` comparison matched any two `Map`s or `Set`s (both
+ * render as `{}`), dropped `undefined` values, and treated key order as
+ * significant, so `findByMetadata` could both match what it should not
+ * and miss what it should find.
+ */
 export function deepMatches(actual, expected) {
-    if (Object.is(actual, expected))
-        return true;
-    if (typeof actual !== "object" || typeof expected !== "object")
-        return false;
-    if (actual === null || expected === null)
-        return false;
-    return JSON.stringify(actual) === JSON.stringify(expected);
+    return deepEqual(actual, expected);
 }
 //# sourceMappingURL=spyLogger.context.js.map

package/dist/spyLogger/spyLogger.recording.js

@@ -59,10 +59,21 @@ export function createRecordingLogger(recorder, derived, initialLevel, initially
         log: (logLevel, message, options) => {
             record("log", logLevel, message, options?.metadata);
         },
-        child: (options) => createRecordingLogger(recorder, {
-            name: `${derived.name}.${options?.name ?? "child"}`,
-            ...(derived.context ? { context: derived.context } : {}),
-        }, level, enabled),
+        // A real child logger merges `options.metadata` into every entry it
+        // writes and may lower its own level; the spy mirrors both so a test
+        // can assert on `logger.child({ metadata: { module } })` output.
+        child: (options) => {
+            const context = options?.metadata
+                ? mergeLoggerContext(derived.context, {
+                    identifiers: {},
+                    metadata: options.metadata,
+                })
+                : derived.context;
+            return createRecordingLogger(recorder, {
+                name: `${derived.name}.${options?.name ?? "child"}`,
+                ...(context ? { context } : {}),
+            }, options?.level ?? level, enabled);
+        },
         withContext: (context) => createRecordingLogger(recorder, {
             name: derived.name,
             context: mergeLoggerContext(derived.context, context),

package/dist/testClock/testClock.core.js

@@ -53,6 +53,11 @@ export function createTestClock(initialTime) {
             (duration.minutes ?? 0) * 60_000 +
             (duration.hours ?? 0) * 3_600_000 +
             (duration.days ?? 0) * 86_400_000;
+        // Validated like `advance`: a NaN or Infinity component silently turned
+        // the clock into `Invalid Date` and every later assertion on it lied.
+        if (!Number.isFinite(ms)) {
+            throw new TypeError(`Cannot add ${JSON.stringify(duration)} to the clock: the duration is not finite.`);
+        }
         currentTime += ms;
     };
     const reset = () => {

package/dist/testSerialization/serializationAssertions.core.js

@@ -4,7 +4,8 @@
  * Helpers for testing serialization round-trips and type preservation.
  */
 import { JSONSerializer } from "@zudojs/serialization";
-import { findDifference } from "../assertions/deepEqual.core.js";
+import { findDifference } from "../assertions/deepEqual/deepEqual.core.js";
+import { describeValue } from "../assertions/deepEqual/deepEqual.describe.js";
 const defaultSerializer = new JSONSerializer();
 /**
  * Assert that a value round-trips through serialization correctly.
@@ -66,7 +67,11 @@ export function assertTypePreservesRoundTrip(value, checker, description) {
     const json = serializer.serialize(value, { preserveTypes: true });
     const restored = serializer.deserialize(json, { preserveTypes: true });
     if (!checker(restored)) {
-        throw new Error(`Type preservation failed for ${description}: ${JSON.stringify(value)} → ${JSON.stringify(restored)}`);
+        // Rendered with `describeValue`, not `JSON.stringify`: the values this
+        // helper exists for (BigInt, Map, Set, circular graphs) are exactly the
+        // ones `JSON.stringify` refuses, so the failure used to surface as a
+        // TypeError from the message itself rather than as the assertion.
+        throw new Error(`Type preservation failed for ${description}: ${describeValue(value)} → ${describeValue(restored)}`);
     }
 }
 //# sourceMappingURL=serializationAssertions.core.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/testing",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Test helpers, fixtures, mocks, and utilities for testing Zudojs applications.",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,21 +19,20 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/config": "1.0.0",
-    "@zudojs/constants": "1.0.0",
-    "@zudojs/container": "1.0.0",
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/events": "1.0.0",
-    "@zudojs/http": "1.0.0",
-    "@zudojs/logger": "1.0.0",
-    "@zudojs/messaging": "1.0.0",
-    "@zudojs/middleware": "1.0.0",
-    "@zudojs/queue": "1.0.0",
-    "@zudojs/security": "1.0.0",
-    "@zudojs/serialization": "1.0.0",
-    "@zudojs/storage": "1.0.0",
-    "@zudojs/types": "1.0.0",
-    "@zudojs/validation": "1.0.0"
+    "@zudojs/config": "1.1.0",
+    "@zudojs/constants": "1.1.0",
+    "@zudojs/container": "1.1.1",
+    "@zudojs/errors": "1.1.0",
+    "@zudojs/events": "1.1.0",
+    "@zudojs/http": "1.2.0",
+    "@zudojs/logger": "1.2.0",
+    "@zudojs/messaging": "1.0.2",
+    "@zudojs/middleware": "1.0.2",
+    "@zudojs/queue": "1.2.0",
+    "@zudojs/security": "1.1.0",
+    "@zudojs/serialization": "1.1.0",
+    "@zudojs/storage": "1.1.1",
+    "@zudojs/types": "1.1.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",
@@ -43,6 +42,10 @@
     "node": ">=24.0.0"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },