@zudojs/testing 1.1.0 → 1.1.2

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,8 +67,20 @@ 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.
+- `createStub()` hands back the same no-op for a given property every time,
+  so `stub.handler === stub.handler` and a register/unregister pair written
+  against a stub actually unregisters.
+- `InMemoryTestStorage.set(key, value, 0)` means "already expired", not "no
+  expiry"; only an omitted TTL never expires.
 - `cleanup.dispose()` rejects with an `AggregateError` when any cleanup fails,
   after running them all.
 - `mockResolvedValue` and `mockRejectedValue` return promises; `results` stays

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,50 +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}`,
-            };
-        }
-        // Keys are matched by identity first and structurally second, so a
-        // Map keyed by objects compares by value like everything else here.
-        const unmatched = [...actual.keys()];
-        for (const [key, value] of expected) {
-            const actualKey = actual.has(key)
-                ? key
-                : findStructuralMatch(unmatched, key, seen);
-            if (actualKey === NO_MATCH) {
-                return { path, reason: `missing key ${describeValue(key)}` };
-            }
-            unmatched.splice(unmatched.indexOf(actualKey), 1);
-            const found = diff(actual.get(actualKey), 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}`,
-            };
-        }
-        // `Set.has` is identity-based, so two Sets holding equal but distinct
-        // objects compared unequal. Each expected entry is matched against a
-        // still-unmatched actual entry structurally instead.
-        const unmatched = [...actual];
-        for (const entry of expected) {
-            const match = actual.has(entry)
-                ? entry
-                : findStructuralMatch(unmatched, entry, seen);
-            if (match === NO_MATCH) {
-                return { path, reason: `missing item ${describeValue(entry)}` };
-            }
-            unmatched.splice(unmatched.indexOf(match), 1);
-        }
-        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);
@@ -161,21 +132,6 @@ function diff(actual, expected, path, seen) {
     }
     return undefined;
 }
-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(candidates, expected, seen) {
-    for (const candidate of candidates) {
-        if (diff(candidate, expected, "", new Map(seen)) === undefined) {
-            return candidate;
-        }
-    }
-    return NO_MATCH;
-}
 /**
  * Find the first structural difference between two values.
  *

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.
  *

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/mocking/stub.core.js

@@ -44,6 +44,10 @@ const NON_CALLABLE_KEYS = new Set([
  * ```
  */
 export function createStub(overrides = {}) {
+    // One no-op per property key, kept for the life of the stub. Handing out a
+    // fresh closure per access would make `stub.handler !== stub.handler`, so a
+    // register/unregister pair written against a stub could never match.
+    const noops = new Map();
     return new Proxy({}, {
         get(_target, prop, _receiver) {
             // `hasOwn`, not `in`: `in` walks the prototype chain, so `toString`,
@@ -55,7 +59,12 @@ export function createStub(overrides = {}) {
                 return undefined;
             if (typeof prop === "symbol")
                 return undefined;
-            return (..._args) => undefined;
+            const existing = noops.get(prop);
+            if (existing)
+                return existing;
+            const noop = (..._args) => undefined;
+            noops.set(prop, noop);
+            return noop;
         },
         has(_target, prop) {
             return !NON_CALLABLE_KEYS.has(prop);

package/dist/spyLogger/spyLogger.context.js

@@ -3,7 +3,7 @@
  *
  * @module spyLogger/spyLogger.context
  */
-import { deepEqual } from "../assertions/deepEqual.core.js";
+import { deepEqual } from "../assertions/deepEqual/deepEqual.core.js";
 /** Merges two logger contexts, preserving the nested shape. */
 export function mergeLoggerContext(base, next) {
     if (!base)

package/dist/testSerialization/serializationAssertions.core.js

@@ -4,8 +4,8 @@
  * Helpers for testing serialization round-trips and type preservation.
  */
 import { JSONSerializer } from "@zudojs/serialization";
-import { findDifference } from "../assertions/deepEqual.core.js";
-import { describeValue } from "../assertions/deepEqual.describe.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.

package/dist/testStorage/testStorageMemory.core.d.ts

@@ -22,7 +22,13 @@ export declare class InMemoryTestStorage {
      * test needs to distinguish.
      */
     get<T = unknown>(key: string): T | null;
-    /** Set a value with optional TTL in milliseconds. */
+    /**
+     * Set a value with optional TTL in milliseconds.
+     *
+     * Only an omitted (or `undefined`) TTL means "never expires". A TTL of `0`
+     * is a real deadline of now, so the entry is already expired on the next
+     * read — a cache test writing `0` to mean "already stale" gets that.
+     */
     set(key: string, value: unknown, ttlMs?: number): void;
     /** Delete a value by key. Returns true if deleted. */
     delete(key: string): boolean;

package/dist/testStorage/testStorageMemory.core.js

@@ -36,9 +36,15 @@ export class InMemoryTestStorage {
             return null;
         return (entry.value ?? null);
     }
-    /** Set a value with optional TTL in milliseconds. */
+    /**
+     * Set a value with optional TTL in milliseconds.
+     *
+     * Only an omitted (or `undefined`) TTL means "never expires". A TTL of `0`
+     * is a real deadline of now, so the entry is already expired on the next
+     * read — a cache test writing `0` to mean "already stale" gets that.
+     */
     set(key, value, ttlMs) {
-        const expiresAt = ttlMs ? new Date(Date.now() + ttlMs) : null;
+        const expiresAt = ttlMs === undefined ? null : new Date(Date.now() + ttlMs);
         this.store.set(key, { value, expiresAt });
     }
     /** Delete a value by key. Returns true if deleted. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/testing",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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.1",
-    "@zudojs/constants": "1.0.1",
-    "@zudojs/container": "1.1.0",
-    "@zudojs/errors": "1.0.1",
-    "@zudojs/events": "1.0.1",
-    "@zudojs/http": "1.1.0",
-    "@zudojs/logger": "1.1.0",
-    "@zudojs/messaging": "1.0.1",
-    "@zudojs/middleware": "1.0.1",
-    "@zudojs/queue": "1.1.0",
-    "@zudojs/security": "1.0.1",
-    "@zudojs/serialization": "1.0.1",
-    "@zudojs/storage": "1.1.0",
-    "@zudojs/types": "1.0.0",
-    "@zudojs/validation": "1.0.1"
+    "@zudojs/config": "1.2.0",
+    "@zudojs/constants": "1.1.1",
+    "@zudojs/container": "1.1.2",
+    "@zudojs/errors": "1.2.0",
+    "@zudojs/events": "1.2.0",
+    "@zudojs/http": "1.3.0",
+    "@zudojs/logger": "1.3.0",
+    "@zudojs/messaging": "1.1.0",
+    "@zudojs/middleware": "1.0.3",
+    "@zudojs/queue": "1.3.0",
+    "@zudojs/security": "1.2.0",
+    "@zudojs/serialization": "1.1.1",
+    "@zudojs/storage": "1.1.2",
+    "@zudojs/types": "1.1.1"
   },
   "devDependencies": {
     "typescript": "7.0.2",