@augment-vir/assert 30.8.4 → 31.0.1

package/dist/assertions/keys.js

@@ -1,24 +1,6 @@
 import { stringify, } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { createCheck } from '../guard-types/check-function.js';
-import { autoGuard } from '../guard-types/guard-override.js';
-function isKeyOf(key, parent, failureMessage) {
-    try {
-        hasKey(parent, key);
-    }
-    catch {
-        throw new AssertionError(`'${String(key)}' is not a key of '${stringify(parent)}'.`, failureMessage);
-    }
-}
-function isNotKeyOf(key, parent, failureMessage) {
-    try {
-        isKeyOf(key, parent);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`'${String(key)}' is a key of '${stringify(parent)}'.`, failureMessage);
-}
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
 const hasKeyAttempts = [
     (object, key) => {
         return key in object;
@@ -28,10 +10,8 @@ const hasKeyAttempts = [
         return key in object.constructor.prototype;
     },
 ];
-/** Check if an object has the given property. */
-function hasKey(parent, key, failureMessage) {
-    const message = `'${stringify(parent)}' does not have key '${String(key)}'.`;
-    const doesHaveKey = hasKeyAttempts.some((attemptCallback) => {
+function hasKey(parent, key) {
+    return hasKeyAttempts.some((attemptCallback) => {
         try {
             return attemptCallback(parent, key);
         }
@@ -39,40 +19,152 @@ function hasKey(parent, key, failureMessage) {
             return false;
         }
     });
-    if (!doesHaveKey) {
-        throw new AssertionError(message, failureMessage);
-    }
-}
-function lacksKey(parent, key, failureMessage) {
-    try {
-        hasKey(parent, key);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`'${stringify(parent)}' has key '${String(key)}'.`, failureMessage);
-}
-const checkHasKey = createCheck(hasKey);
-/** Check if an object has all the given properties. */
-function hasKeys(parent, keys, failureMessage) {
-    const missingKeys = keys.filter((key) => !checkHasKey(parent, key));
-    if (missingKeys.length) {
-        throw new AssertionError(`'${stringify(parent)}' does not have keys '${missingKeys.join(',')}'.`, failureMessage);
-    }
-}
-function lacksKeys(parent, keys, failureMessage) {
-    const existingKeys = keys.filter((key) => checkHasKey(parent, key));
-    if (existingKeys.length) {
-        throw new AssertionError(`'${stringify(parent)}' does not lack keys '${existingKeys.join(',')}'.`, failureMessage);
-    }
 }
 const assertions = {
-    isKeyOf,
-    isNotKeyOf,
-    hasKey,
-    lacksKey,
-    hasKeys,
-    lacksKeys,
+    /**
+     * Asserts that a key is contained within a parent value.
+     *
+     * Type guards the key.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isKeyof('a', {a: 0, b: 1}); // passes
+     * assert.isKeyof('c', {a: 0, b: 1}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the key is not in the parent.
+     * @see
+     * - {@link assert.isNotKeyOf} : the opposite assertion.
+     */
+    isKeyOf(key, parent, failureMessage) {
+        if (!hasKey(parent, key)) {
+            throw new AssertionError(`'${String(key)}' is not a key of '${stringify(parent)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a key is _not_ contained within a parent value.
+     *
+     * Type guards the key.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotKeyOf('a', {a: 0, b: 1}); // fails
+     * assert.isNotKeyOf('c', {a: 0, b: 1}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the key is in the parent.
+     * @see
+     * - {@link assert.isKeyOf} : the opposite assertion.
+     */
+    isNotKeyOf(key, parent, failureMessage) {
+        if (hasKey(parent, key)) {
+            throw new AssertionError(`'${String(key)}' is a key of '${stringify(parent)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a parent value has the key.
+     *
+     * Type guards the parent value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.hasKey({a: 0, b: 1}, 'a'); // passes
+     * assert.hasKey({a: 0, b: 1}, 'c'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent does not have the key.
+     * @see
+     * - {@link assert.lacksKey} : the opposite assertion.
+     * - {@link assert.hasKeys} : the multi-key assertion.
+     */
+    hasKey(parent, key, failureMessage) {
+        if (!hasKey(parent, key)) {
+            throw new AssertionError(`'${stringify(parent)}' does not have key '${String(key)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a parent value does not have the key.
+     *
+     * Type guards the parent value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.lacksKey({a: 0, b: 1}, 'a'); // fails
+     * assert.lacksKey({a: 0, b: 1}, 'c'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent has the key.
+     * @see
+     * - {@link assert.hasKey} : the opposite assertion.
+     * - {@link assert.lacksKeys} : the multi-key assertion.
+     */
+    lacksKey(parent, key, failureMessage) {
+        if (hasKey(parent, key)) {
+            throw new AssertionError(`'${stringify(parent)}' has key '${String(key)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a parent value has all the keys.
+     *
+     * Type guards the parent value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.hasKeys({a: 0, b: 1}, ['a', 'b']); // passes
+     * assert.hasKeys({a: 0, b: 1}, ['b', 'c']); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent does not have all the keys.
+     * @see
+     * - {@link assert.lacksKeys} : the opposite assertion.
+     * - {@link assert.hasKey} : the single-key assertion.
+     */
+    hasKeys(parent, keys, failureMessage) {
+        const missingKeys = keys.filter((key) => !hasKey(parent, key));
+        if (missingKeys.length) {
+            throw new AssertionError(`'${stringify(parent)}' does not have keys '${missingKeys.join(',')}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a parent value none of the keys.
+     *
+     * Type guards the parent value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.lacksKeys({a: 0, b: 1}, ['b', 'c']); // fails
+     * assert.lacksKeys({a: 0, b: 1}, ['c', 'd']); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent has any of the keys.
+     * @see
+     * - {@link assert.hasKeys} : the opposite assertion.
+     * - {@link assert.lacksKey} : the single-key assertion.
+     */
+    lacksKeys(parent, keys, failureMessage) {
+        const existingKeys = keys.filter((key) => hasKey(parent, key));
+        if (existingKeys.length) {
+            throw new AssertionError(`'${stringify(parent)}' does not lack keys '${existingKeys.join(',')}'.`, failureMessage);
+        }
+    },
 };
 export const keyGuards = {
     assert: assertions,
@@ -94,7 +186,9 @@ export const keyGuards = {
          * @see
          * - {@link check.isNotKeyOf} : the opposite check.
          */
-        isKeyOf: autoGuard(),
+        isKeyOf(key, parent) {
+            return hasKey(parent, key);
+        },
         /**
          * Checks that a key is _not_ contained within a parent value.
          *
@@ -112,7 +206,9 @@ export const keyGuards = {
          * @see
          * - {@link check.isKeyOf} : the opposite check.
          */
-        isNotKeyOf: autoGuard(),
+        isNotKeyOf(key, parent) {
+            return !hasKey(parent, key);
+        },
         /**
          * Checks that a parent value has the key.
          *
@@ -131,7 +227,7 @@ export const keyGuards = {
          * - {@link check.lacksKey} : the opposite check.
          * - {@link check.hasKeys} : the multi-key check.
          */
-        hasKey: autoGuard(),
+        hasKey,
         /**
          * Checks that a parent value does not have the key.
          *
@@ -150,7 +246,9 @@ export const keyGuards = {
          * - {@link check.hasKey} : the opposite check.
          * - {@link check.lacksKeys} : the multi-key check.
          */
-        lacksKey: autoGuard(),
+        lacksKey(parent, key) {
+            return !hasKey(parent, key);
+        },
         /**
          * Checks that a parent value has all the keys.
          *
@@ -161,21 +259,17 @@ export const keyGuards = {
          * ```ts
          * import {check} from '@augment-vir/assert';
          *
-         * check.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // returns `true`
-         * check.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `false`
+         * check.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `true`
+         * check.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
          * ```
          *
          * @see
          * - {@link check.lacksKeys} : the opposite check.
          * - {@link check.hasKey} : the single-key check.
          */
-        hasKeys: autoGuard(),
+        hasKeys(parent, keys) {
+            return keys.every((key) => hasKey(parent, key));
+        },
         /**
          * Checks that a parent value none of the keys.
          *
@@ -186,21 +280,17 @@ export const keyGuards = {
          * ```ts
          * import {check} from '@augment-vir/assert';
          *
-         * check.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `false`
-         * check.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // returns `true`
+         * check.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `false`
+         * check.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `true`
          * ```
          *
          * @see
          * - {@link check.hasKeys} : the opposite check.
          * - {@link check.lacksKey} : the single-key check.
          */
-        lacksKeys: autoGuard(),
+        lacksKeys(parent, keys) {
+            return keys.every((key) => !hasKey(parent, key));
+        },
     },
     assertWrap: {
         /**
@@ -223,7 +313,12 @@ export const keyGuards = {
          * @see
          * - {@link assertWrap.isNotKeyOf} : the opposite assertion.
          */
-        isKeyOf: autoGuard(),
+        isKeyOf(key, parent, failureMessage) {
+            if (!hasKey(parent, key)) {
+                throw new AssertionError(`'${String(key)}' is not a key of '${stringify(parent)}'.`, failureMessage);
+            }
+            return key;
+        },
         /**
          * Asserts that a key is _not_ contained within a parent value. Returns the key if the
          * assertion passes.
@@ -244,7 +339,12 @@ export const keyGuards = {
          * @see
          * - {@link assertWrap.isKeyOf} : the opposite assertion.
          */
-        isNotKeyOf: autoGuard(),
+        isNotKeyOf(key, parent, failureMessage) {
+            if (hasKey(parent, key)) {
+                throw new AssertionError(`'${String(key)}' is a key of '${stringify(parent)}'.`, failureMessage);
+            }
+            return key;
+        },
         /**
          * Asserts that a parent value has the key. Returns the parent if the assertion passes.
          *
@@ -265,7 +365,12 @@ export const keyGuards = {
          * - {@link assertWrap.lacksKey} : the opposite assertion.
          * - {@link assertWrap.hasKeys} : the multi-key assertion.
          */
-        hasKey: autoGuard(),
+        hasKey(parent, key, failureMessage) {
+            if (!hasKey(parent, key)) {
+                throw new AssertionError(`'${stringify(parent)}' does not have key '${String(key)}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that a parent value does not have the key. Returns the parent if the assertion
          * passes.
@@ -287,7 +392,12 @@ export const keyGuards = {
          * - {@link assertWrap.hasKey} : the opposite assertion.
          * - {@link assertWrap.lacksKeys} : the multi-key assertion.
          */
-        lacksKey: autoGuard(),
+        lacksKey(parent, key, failureMessage) {
+            if (hasKey(parent, key)) {
+                throw new AssertionError(`'${stringify(parent)}' has key '${String(key)}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that a parent value has all the keys. Returns the parent if the assertion passes.
          *
@@ -298,14 +408,8 @@ export const keyGuards = {
          * ```ts
          * import {assertWrap} from '@augment-vir/assert';
          *
-         * assertWrap.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // returns `{a: 0, b: 1}`
-         * assertWrap.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // throws an error
+         * assertWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
+         * assertWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
          * ```
          *
          * @returns The parent if it has all the keys.
@@ -314,7 +418,13 @@ export const keyGuards = {
          * - {@link assertWrap.lacksKeys} : the opposite assertion.
          * - {@link assertWrap.hasKey} : the single-key assertion.
          */
-        hasKeys: autoGuard(),
+        hasKeys(parent, keys, failureMessage) {
+            const missingKeys = keys.filter((key) => !hasKey(parent, key));
+            if (missingKeys.length) {
+                throw new AssertionError(`'${stringify(parent)}' does not have keys '${missingKeys.join(',')}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that a parent value none of the keys. Returns the parent if the assertion passes.
          *
@@ -325,14 +435,8 @@ export const keyGuards = {
          * ```ts
          * import {assertWrap} from '@augment-vir/assert';
          *
-         * assertWrap.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // throws an error
-         * assertWrap.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // returns `{a: 0, b: 1}`
+         * assertWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // throws an error
+         * assertWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
          * ```
          *
          * @returns The parent if it does not have any of the keys.
@@ -341,7 +445,13 @@ export const keyGuards = {
          * - {@link assertWrap.hasKeys} : the opposite assertion.
          * - {@link assertWrap.lacksKey} : the single-key assertion.
          */
-        lacksKeys: autoGuard(),
+        lacksKeys(parent, keys, failureMessage) {
+            const existingKeys = keys.filter((key) => hasKey(parent, key));
+            if (existingKeys.length) {
+                throw new AssertionError(`'${stringify(parent)}' does not lack keys '${existingKeys.join(',')}'.`, failureMessage);
+            }
+            return parent;
+        },
     },
     checkWrap: {
         /**
@@ -363,7 +473,14 @@ export const keyGuards = {
          * @see
          * - {@link checkWrap.isNotKeyOf} : the opposite check.
          */
-        isKeyOf: autoGuard(),
+        isKeyOf(key, parent) {
+            if (hasKey(parent, key)) {
+                return key;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a key is _not_ contained within a parent value. Returns the key if the check
          * passes, otherwise `undefined`.
@@ -383,7 +500,14 @@ export const keyGuards = {
          * @see
          * - {@link checkWrap.isKeyOf} : the opposite check.
          */
-        isNotKeyOf: autoGuard(),
+        isNotKeyOf(key, parent) {
+            if (hasKey(parent, key)) {
+                return undefined;
+            }
+            else {
+                return key;
+            }
+        },
         /**
          * Checks that a parent value has the key. Returns the parent value if the check passes,
          * otherwise `undefined`.
@@ -404,7 +528,14 @@ export const keyGuards = {
          * - {@link checkWrap.lacksKey} : the opposite check.
          * - {@link checkWrap.hasKeys} : the multi-key check.
          */
-        hasKey: autoGuard(),
+        hasKey(parent, key) {
+            if (hasKey(parent, key)) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a parent value does not have the key. Returns the parent value if the check
          * passes, otherwise `undefined`.
@@ -425,7 +556,14 @@ export const keyGuards = {
          * - {@link checkWrap.hasKey} : the opposite check.
          * - {@link checkWrap.lacksKeys} : the multi-key check.
          */
-        lacksKey: autoGuard(),
+        lacksKey(parent, key) {
+            if (hasKey(parent, key)) {
+                return undefined;
+            }
+            else {
+                return parent;
+            }
+        },
         /**
          * Checks that a parent value has all the keys. Returns the parent value if the check
          * passes, otherwise `undefined`.
@@ -437,14 +575,8 @@ export const keyGuards = {
          * ```ts
          * import {checkWrap} from '@augment-vir/assert';
          *
-         * checkWrap.hasKeys({a: 0, b: 1}, [
-         *     'a',
-         *     'b',
-         * ]); // returns `{a: 0, b: 1}`
-         * checkWrap.hasKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `undefined`
+         * checkWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
+         * checkWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
          * ```
          *
          * @returns The parent value if the check passes, otherwise `undefined`.
@@ -452,7 +584,14 @@ export const keyGuards = {
          * - {@link checkWrap.lacksKeys} : the opposite check.
          * - {@link checkWrap.hasKey} : the single-key check.
          */
-        hasKeys: autoGuard(),
+        hasKeys(parent, keys) {
+            if (keys.every((key) => hasKey(parent, key))) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a parent value none of the keys. Returns the parent value if the check
          * passes, otherwise `undefined`.
@@ -464,14 +603,8 @@ export const keyGuards = {
          * ```ts
          * import {checkWrap} from '@augment-vir/assert';
          *
-         * checkWrap.lacksKeys({a: 0, b: 1}, [
-         *     'b',
-         *     'c',
-         * ]); // returns `undefined`
-         * checkWrap.lacksKeys({a: 0, b: 1}, [
-         *     'c',
-         *     'd',
-         * ]); // returns `{a: 0, b: 1}`
+         * checkWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
+         * checkWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
          * ```
          *
          * @returns The parent value if the check passes, otherwise `undefined`.
@@ -479,7 +612,14 @@ export const keyGuards = {
          * - {@link checkWrap.hasKeys} : the opposite check.
          * - {@link checkWrap.lacksKey} : the single-key check.
          */
-        lacksKeys: autoGuard(),
+        lacksKeys(parent, keys) {
+            if (keys.every((key) => !hasKey(parent, key))) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -503,7 +643,7 @@ export const keyGuards = {
          * @see
          * - {@link waitUntil.isNotKeyOf} : the opposite assertion.
          */
-        isKeyOf: autoGuard(),
+        isKeyOf: createWaitUntil(assertions.isKeyOf),
         /**
          * Repeatedly calls a callback until its output is a key that is _not_ contained within the
          * first, parent value. Once the callback output passes, it is returned. If the attempts
@@ -525,7 +665,7 @@ export const keyGuards = {
          * @see
          * - {@link waitUntil.isNotKeyOf} : the opposite assertion.
          */
-        isNotKeyOf: autoGuard(),
+        isNotKeyOf: createWaitUntil(assertions.isNotKeyOf),
         /**
          * Repeatedly calls a callback until its output is a parent value that has the first, key
          * input. Once the callback output passes, it is returned. If the attempts time out, an
@@ -552,7 +692,7 @@ export const keyGuards = {
          * - {@link waitUntil.lacksKey} : the opposite assertion.
          * - {@link waitUntil.hasKeys} : the multi-key assertion.
          */
-        hasKey: autoGuard(),
+        hasKey: createWaitUntil(assertions.hasKey),
         /**
          * Repeatedly calls a callback until its output is a parent value that does not have the
          * first, key input. Once the callback output passes, it is returned. If the attempts time
@@ -579,7 +719,7 @@ export const keyGuards = {
          * - {@link waitUntil.hasKey} : the opposite assertion.
          * - {@link waitUntil.lacksKeys} : the multi-key assertion.
          */
-        lacksKey: autoGuard(),
+        lacksKey: createWaitUntil(assertions.lacksKey),
         /**
          * Repeatedly calls a callback until its output is a parent value that has all of the first,
          * keys input. Once the callback output passes, it is returned. If the attempts time out, an
@@ -592,24 +732,12 @@ export const keyGuards = {
          * ```ts
          * import {waitUntil} from '@augment-vir/assert';
          *
-         * await waitUntil.hasKeys(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // returns `{a: 0, b: 1}`
-         * await waitUntil.hasKeys(
-         *     [
-         *         'b',
-         *         'c',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // throws an error
+         * await waitUntil.hasKeys(['a', 'b'], () => {
+         *     return {a: 0, b: 1};
+         * }); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasKeys(['b', 'c'], () => {
+         *     return {a: 0, b: 1};
+         * }); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -618,7 +746,7 @@ export const keyGuards = {
          * - {@link waitUntil.lacksKeys} : the opposite assertion.
          * - {@link waitUntil.hasKey} : the single-key assertion.
          */
-        hasKeys: autoGuard(),
+        hasKeys: createWaitUntil(assertions.hasKeys),
         /**
          * Repeatedly calls a callback until its output is a parent value that does not have any of
          * the first, keys input. Once the callback output passes, it is returned. If the attempts
@@ -631,24 +759,12 @@ export const keyGuards = {
          * ```ts
          * import {waitUntil} from '@augment-vir/assert';
          *
-         * await waitUntil.hasKeys(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // throws an error
-         * await waitUntil.hasKeys(
-         *     [
-         *         'b',
-         *         'c',
-         *     ],
-         *     () => {
-         *         return {a: 0, b: 1};
-         *     },
-         * ); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasKeys(['a', 'b'], () => {
+         *     return {a: 0, b: 1};
+         * }); // throws an error
+         * await waitUntil.hasKeys(['b', 'c'], () => {
+         *     return {a: 0, b: 1};
+         * }); // returns `{a: 0, b: 1}`
          * ```
          *
          * @returns The callback output once it passes.
@@ -657,6 +773,6 @@ export const keyGuards = {
          * - {@link waitUntil.hasKeys} : the opposite assertion.
          * - {@link waitUntil.lacksKey} : the single-key assertion.
          */
-        lacksKeys: autoGuard(),
+        lacksKeys: createWaitUntil(assertions.lacksKeys),
     },
 };