@augment-vir/assert 31.0.0 → 31.1.0

package/dist/assertions/boundary.js

@@ -1,15 +1,14 @@
 import { stringify } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuard } from '../guard-types/guard-override.js';
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
 function endsWith(parent, child, failureMessage) {
-    const message = `${stringify(parent)} does not end with ${stringify(child)}}`;
     if (typeof parent === 'string') {
         if (!parent.endsWith(child)) {
-            throw new AssertionError(message, failureMessage);
+            throw new AssertionError(`${stringify(parent)} does not end with ${stringify(child)}}`, failureMessage);
         }
     }
     else if (parent[parent.length - 1] !== child) {
-        throw new AssertionError(message, failureMessage);
+        throw new AssertionError(`${stringify(parent)} does not end with ${stringify(child)}}`, failureMessage);
     }
 }
 function boundaryCheck() {
@@ -37,42 +36,127 @@ function boundaryWaitUntil() {
      */
 }
 function endsWithout(parent, child, failureMessage) {
-    const message = `${stringify(parent)} ends with ${stringify(child)}}`;
     if (typeof parent === 'string') {
         if (parent.endsWith(child)) {
-            throw new AssertionError(message, failureMessage);
+            throw new AssertionError(`${stringify(parent)} ends with ${stringify(child)}}`, failureMessage);
         }
     }
     else if (parent[parent.length - 1] === child) {
-        throw new AssertionError(message, failureMessage);
+        throw new AssertionError(`${stringify(parent)} ends with ${stringify(child)}}`, failureMessage);
     }
 }
 function startsWith(parent, child, failureMessage) {
-    const message = `${stringify(parent)} does not start with ${stringify(child)}}`;
     if (typeof parent === 'string') {
         if (!parent.startsWith(child)) {
-            throw new AssertionError(message, failureMessage);
+            throw new AssertionError(`${stringify(parent)} does not start with ${stringify(child)}}`, failureMessage);
         }
     }
     else if (parent[0] !== child) {
-        throw new AssertionError(message, failureMessage);
+        throw new AssertionError(`${stringify(parent)} does not start with ${stringify(child)}}`, failureMessage);
     }
 }
 function startsWithout(parent, child, failureMessage) {
-    const message = `${stringify(parent)} starts with ${stringify(child)}}`;
     if (typeof parent === 'string') {
         if (parent.startsWith(child)) {
-            throw new AssertionError(message, failureMessage);
+            throw new AssertionError(`${stringify(parent)} starts with ${stringify(child)}}`, failureMessage);
         }
     }
     else if (parent[0] === child) {
-        throw new AssertionError(message, failureMessage);
+        throw new AssertionError(`${stringify(parent)} starts with ${stringify(child)}}`, failureMessage);
     }
 }
 const assertions = {
+    /**
+     * Asserts that a parent string or array ends with a specific child. This uses reference
+     * equality when the parent is an array.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.endsWith('ab', 'b'); // passes
+     * assert.endsWith('ab', 'a'); // fails
+     * assert.endsWith(['a', 'b'], 'b'); // passes
+     * assert.endsWith(['a', 'b'], 'a'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent does not end with the child.
+     * @see
+     * - {@link assert.endsWithout} : the opposite assertion.
+     * - {@link assert.startsWith} : assertion on the other end.
+     */
     endsWith,
+    /**
+     * Asserts that a parent string or array does _not_ end with a specific child. This uses
+     * reference equality when the parent is an array.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.endsWithout('ab', 'b'); // fails
+     * assert.endsWithout('ab', 'a'); // passes
+     * assert.endsWithout(['a', 'b'], 'b'); // fails
+     * assert.endsWithout(['a', 'b'], 'a'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent ends with the child.
+     * @see
+     * - {@link assert.endsWith} : the opposite assertion.
+     * - {@link assert.startsWithout} : assertion on the other end.
+     */
     endsWithout,
+    /**
+     * Asserts that a parent string or array starts with a specific child. This uses reference
+     * equality when the parent is an array.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.startsWith('ab', 'b'); // fails
+     * assert.startsWith('ab', 'a'); // passes
+     * assert.startsWith(['a', 'b'], 'b'); // fails
+     * assert.startsWith(['a', 'b'], 'a'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent does not start with the child.
+     * @see
+     * - {@link assert.startsWithout} : the opposite assertion.
+     * - {@link assert.endsWith} : assertion on the other end.
+     */
     startsWith,
+    /**
+     * Asserts that a parent string or array starts with a specific child. This uses reference
+     * equality when the parent is an array.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.startsWith('ab', 'b'); // passes
+     * assert.startsWith('ab', 'a'); // fails
+     * assert.startsWith(['a', 'b'], 'b'); // passes
+     * assert.startsWith(['a', 'b'], 'a'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the parent does start with the child.
+     * @see
+     * - {@link assert.startsWithout} : the opposite assertion.
+     * - {@link assert.endsWith} : assertion on the other end.
+     */
     startsWithout,
 };
 export const boundaryGuards = {
@@ -91,27 +175,20 @@ export const boundaryGuards = {
          *
          * check.endsWith('ab', 'b'); // returns `true`
          * check.endsWith('ab', 'a'); // returns `false`
-         * check.endsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `true`
-         * check.endsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `false`
+         * check.endsWith(['a', 'b'], 'b'); // returns `true`
+         * check.endsWith(['a', 'b'], 'a'); // returns `false`
          * ```
          *
          * @see
          * - {@link check.endsWithout} : the opposite check.
          * - {@link check.startsWith} : check on the other end.
          */
-        endsWith: autoGuard(),
+        endsWith: ((parent, child) => {
+            if (typeof parent === 'string') {
+                return parent.endsWith(child);
+            }
+            return parent[parent.length - 1] === child;
+        }),
         /**
          * Checks that a parent string or array does _not_ end with a specific child. This uses
          * reference equality when the parent is an array.
@@ -125,27 +202,20 @@ export const boundaryGuards = {
          *
          * check.endsWithout('ab', 'b'); // returns `false`
          * check.endsWithout('ab', 'a'); // returns `true`
-         * check.endsWithout(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `false`
-         * check.endsWithout(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `true`
+         * check.endsWithout(['a', 'b'], 'b'); // returns `false`
+         * check.endsWithout(['a', 'b'], 'a'); // returns `true`
          * ```
          *
          * @see
          * - {@link check.endsWith} : the opposite check.
          * - {@link check.startsWithout} : check on the other end.
          */
-        endsWithout: autoGuard(),
+        endsWithout: ((parent, child) => {
+            if (typeof parent === 'string') {
+                return !parent.endsWith(child);
+            }
+            return parent[parent.length - 1] !== child;
+        }),
         /**
          * Checks that a parent string or array starts with a specific child. This uses reference
          * equality when the parent is an array.
@@ -159,27 +229,20 @@ export const boundaryGuards = {
          *
          * check.startsWith('ab', 'b'); // returns `false`
          * check.startsWith('ab', 'a'); // returns `true`
-         * check.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `false`
-         * check.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `true`
+         * check.startsWith(['a', 'b'], 'b'); // returns `false`
+         * check.startsWith(['a', 'b'], 'a'); // returns `true`
          * ```
          *
          * @see
          * - {@link check.startsWithout} : the opposite check.
          * - {@link check.endsWith} : check on the other end.
          */
-        startsWith: autoGuard(),
+        startsWith: ((parent, child) => {
+            if (typeof parent === 'string') {
+                return parent.startsWith(child);
+            }
+            return parent[0] === child;
+        }),
         /**
          * Checks that a parent string or array starts with a specific child. This uses reference
          * equality when the parent is an array.
@@ -193,27 +256,20 @@ export const boundaryGuards = {
          *
          * check.startsWith('ab', 'b'); // returns `false`
          * check.startsWith('ab', 'a'); // returns `true`
-         * check.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `false`
-         * check.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `true`
+         * check.startsWith(['a', 'b'], 'b'); // returns `false`
+         * check.startsWith(['a', 'b'], 'a'); // returns `true`
          * ```
          *
          * @see
          * - {@link check.startsWithout} : the opposite check.
          * - {@link check.endsWith} : check on the other end.
          */
-        startsWithout: autoGuard(),
+        startsWithout: ((parent, child) => {
+            if (typeof parent === 'string') {
+                return !parent.startsWith(child);
+            }
+            return parent[0] !== child;
+        }),
     },
     assertWrap: {
         /**
@@ -229,20 +285,8 @@ export const boundaryGuards = {
          *
          * assertWrap.endsWith('ab', 'b'); // returns `'ab'`
          * assertWrap.endsWith('ab', 'a'); // throws an error
-         * assertWrap.endsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `['a', 'b']`
-         * assertWrap.endsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // throws an error
+         * assertWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
+         * assertWrap.endsWith(['a', 'b'], 'a'); // throws an error
          * ```
          *
          * @returns The parent value if it does end with the child.
@@ -251,7 +295,17 @@ export const boundaryGuards = {
          * - {@link assertWrap.endsWithout} : the opposite assertion.
          * - {@link assertWrap.startsWith} : assertion on the other end.
          */
-        endsWith: autoGuard(),
+        endsWith: ((parent, child, failureMessage) => {
+            if (typeof parent === 'string') {
+                if (!parent.endsWith(child)) {
+                    throw new AssertionError(`${stringify(parent)} does not end with ${stringify(child)}}`, failureMessage);
+                }
+            }
+            else if (parent[parent.length - 1] !== child) {
+                throw new AssertionError(`${stringify(parent)} does not end with ${stringify(child)}}`, failureMessage);
+            }
+            return parent;
+        }),
         /**
          * Asserts that a parent string or array does _not_ end with a specific child. This uses
          * reference equality when the parent is an array. Returns the parent if the assertion
@@ -266,20 +320,8 @@ export const boundaryGuards = {
          *
          * assertWrap.endsWithout('ab', 'b'); // throws an error
          * assertWrap.endsWithout('ab', 'a'); // returns `'ab'`
-         * assertWrap.endsWithout(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // throws an error
-         * assertWrap.endsWithout(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `['a', 'b']`
+         * assertWrap.endsWithout(['a', 'b'], 'b'); // throws an error
+         * assertWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
          * ```
          *
          * @returns The parent value if it does not end with the child.
@@ -288,7 +330,17 @@ export const boundaryGuards = {
          * - {@link assertWrap.endsWith} : the opposite assertion.
          * - {@link assertWrap.startsWithout} : assertion on the other end.
          */
-        endsWithout: autoGuard(),
+        endsWithout: ((parent, child, failureMessage) => {
+            if (typeof parent === 'string') {
+                if (parent.endsWith(child)) {
+                    throw new AssertionError(`${stringify(parent)} ends with ${stringify(child)}}`, failureMessage);
+                }
+            }
+            else if (parent[parent.length - 1] === child) {
+                throw new AssertionError(`${stringify(parent)} ends with ${stringify(child)}}`, failureMessage);
+            }
+            return parent;
+        }),
         /**
          * Checks that a parent string or array starts with a specific child. This uses reference
          * equality when the parent is an array. Returns the parent if the assertion passes.
@@ -302,20 +354,8 @@ export const boundaryGuards = {
          *
          * assertWrap.startsWith('ab', 'b'); // throws an error
          * assertWrap.startsWith('ab', 'a'); // returns `'ab'`
-         * assertWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // throws an error
-         * assertWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `['a', 'b']`
+         * assertWrap.startsWith(['a', 'b'], 'b'); // throws an error
+         * assertWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
          * ```
          *
          * @returns The parent value if it starts with the child.
@@ -324,7 +364,17 @@ export const boundaryGuards = {
          * - {@link assertWrap.startsWithout} : the opposite assertion.
          * - {@link assertWrap.endsWith} : assertion on the other end.
          */
-        startsWith: autoGuard(),
+        startsWith: ((parent, child, failureMessage) => {
+            if (typeof parent === 'string') {
+                if (!parent.startsWith(child)) {
+                    throw new AssertionError(`${stringify(parent)} does not start with ${stringify(child)}}`, failureMessage);
+                }
+            }
+            else if (parent[0] !== child) {
+                throw new AssertionError(`${stringify(parent)} does not start with ${stringify(child)}}`, failureMessage);
+            }
+            return parent;
+        }),
         /**
          * Asserts that a parent string or array starts with a specific child. This uses reference
          * equality when the parent is an array. Returns the parent if the assertion passes.
@@ -338,20 +388,8 @@ export const boundaryGuards = {
          *
          * assertWrap.startsWith('ab', 'b'); // returns `'ab'`
          * assertWrap.startsWith('ab', 'a'); // throws an error
-         * assertWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `['a', 'b']`
-         * assertWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // throws an error
+         * assertWrap.startsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
+         * assertWrap.startsWith(['a', 'b'], 'a'); // throws an error
          * ```
          *
          * @returns The parent value if it does not start with the child.
@@ -360,7 +398,17 @@ export const boundaryGuards = {
          * - {@link assertWrap.startsWithout} : the opposite assertion.
          * - {@link assertWrap.endsWith} : assertion on the other end.
          */
-        startsWithout: autoGuard(),
+        startsWithout: ((parent, child, failureMessage) => {
+            if (typeof parent === 'string') {
+                if (parent.startsWith(child)) {
+                    throw new AssertionError(`${stringify(parent)} starts with ${stringify(child)}}`, failureMessage);
+                }
+            }
+            else if (parent[0] === child) {
+                throw new AssertionError(`${stringify(parent)} starts with ${stringify(child)}}`, failureMessage);
+            }
+            return parent;
+        }),
     },
     checkWrap: {
         /**
@@ -377,20 +425,8 @@ export const boundaryGuards = {
          *
          * checkWrap.endsWith('ab', 'b'); // returns `'ab'`
          * checkWrap.endsWith('ab', 'a'); // returns `undefined`
-         * checkWrap.endsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `['a', 'b']`
-         * checkWrap.endsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `undefined`
+         * checkWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
+         * checkWrap.endsWith(['a', 'b'], 'a'); // returns `undefined`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -398,7 +434,22 @@ export const boundaryGuards = {
          * - {@link checkWrap.endsWithout} : the opposite check.
          * - {@link checkWrap.startsWith} : check on the other end.
          */
-        endsWith: autoGuard(),
+        endsWith: ((parent, child) => {
+            if (typeof parent === 'string') {
+                if (parent.endsWith(child)) {
+                    return parent;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            if (parent[parent.length - 1] === child) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        }),
         /**
          * Checks that a parent string or array does _not_ end with a specific child. This uses
          * reference equality when the parent is an array. Returns the value if the check passes,
@@ -413,20 +464,8 @@ export const boundaryGuards = {
          *
          * checkWrap.endsWithout('ab', 'b'); // returns `undefined`
          * checkWrap.endsWithout('ab', 'a'); // returns `'ab'`
-         * checkWrap.endsWithout(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `undefined`
-         * checkWrap.endsWithout(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `['a', 'b']`
+         * checkWrap.endsWithout(['a', 'b'], 'b'); // returns `undefined`
+         * checkWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -434,7 +473,22 @@ export const boundaryGuards = {
          * - {@link checkWrap.endsWith} : the opposite check.
          * - {@link checkWrap.startsWithout} : check on the other end.
          */
-        endsWithout: autoGuard(),
+        endsWithout: ((parent, child) => {
+            if (typeof parent === 'string') {
+                if (parent.endsWith(child)) {
+                    return undefined;
+                }
+                else {
+                    return parent;
+                }
+            }
+            if (parent[parent.length - 1] === child) {
+                return undefined;
+            }
+            else {
+                return parent;
+            }
+        }),
         /**
          * Checks that a parent string or array starts with a specific child. This uses reference
          * equality when the parent is an array. Returns the value if the check passes, otherwise
@@ -449,20 +503,8 @@ export const boundaryGuards = {
          *
          * checkWrap.startsWith('ab', 'b'); // returns `undefined`
          * checkWrap.startsWith('ab', 'a'); // returns `'ab'`
-         * checkWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `undefined`
-         * checkWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `['a', 'b']`
+         * checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
+         * checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -470,7 +512,22 @@ export const boundaryGuards = {
          * - {@link checkWrap.startsWithout} : the opposite check.
          * - {@link checkWrap.endsWith} : check on the other end.
          */
-        startsWith: autoGuard(),
+        startsWith: ((parent, child) => {
+            if (typeof parent === 'string') {
+                if (parent.startsWith(child)) {
+                    return parent;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            if (parent[0] === child) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        }),
         /**
          * Checks that a parent string or array starts with a specific child. This uses reference
          * equality when the parent is an array. Returns the value if the check passes, otherwise
@@ -485,20 +542,8 @@ export const boundaryGuards = {
          *
          * checkWrap.startsWith('ab', 'b'); // returns `undefined`
          * checkWrap.startsWith('ab', 'a'); // returns `'ab'`
-         * checkWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'b',
-         * ); // returns `undefined`
-         * checkWrap.startsWith(
-         *     [
-         *         'a',
-         *         'b',
-         *     ],
-         *     'a',
-         * ); // returns `['a', 'b']`
+         * checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
+         * checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -506,7 +551,22 @@ export const boundaryGuards = {
          * - {@link checkWrap.startsWithout} : the opposite check.
          * - {@link checkWrap.endsWith} : check on the other end.
          */
-        startsWithout: autoGuard(),
+        startsWithout: ((parent, child) => {
+            if (typeof parent === 'string') {
+                if (parent.startsWith(child)) {
+                    return undefined;
+                }
+                else {
+                    return parent;
+                }
+            }
+            if (parent[0] === child) {
+                return undefined;
+            }
+            else {
+                return parent;
+            }
+        }),
     },
     waitUntil: {
         /**
@@ -523,14 +583,8 @@ export const boundaryGuards = {
          *
          * await waitUntil.endsWith('b', () => 'ab'); // returns `'ab'`
          * await waitUntil.endsWith('a', () => 'ab'); // throws an error
-         * await waitUntil.endsWith('b', () => [
-         *     'a',
-         *     'b',
-         * ]); // returns `['a', 'b']`
-         * await waitUntil.endsWith('a', () => [
-         *     'a',
-         *     'b',
-         * ]); // throws an error
+         * await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
+         * await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -539,7 +593,7 @@ export const boundaryGuards = {
          * - {@link waitUntil.endsWithout} : the opposite assertion.
          * - {@link waitUntil.startsWith} : assertion on the other end.
          */
-        endsWith: autoGuard(),
+        endsWith: createWaitUntil(assertions.endsWith),
         /**
          * Repeatedly calls a callback until its output string or array does not end with the first
          * input child value. This uses reference equality when the parent is an array. Once the
@@ -554,14 +608,8 @@ export const boundaryGuards = {
          *
          * await waitUntil.endsWith('b', () => 'ab'); // throws an error
          * await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
-         * await waitUntil.endsWith('b', () => [
-         *     'a',
-         *     'b',
-         * ]); // throws an error
-         * await waitUntil.endsWith('a', () => [
-         *     'a',
-         *     'b',
-         * ]); // returns `['a', 'b']`
+         * await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
+         * await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
          * ```
          *
          * @returns The callback output once it passes.
@@ -570,7 +618,7 @@ export const boundaryGuards = {
          * - {@link waitUntil.endsWith} : the opposite assertion.
          * - {@link waitUntil.startsWithout} : assertion on the other end.
          */
-        endsWithout: autoGuard(),
+        endsWithout: createWaitUntil(assertions.endsWithout),
         /**
          * Repeatedly calls a callback until its output string or array starts with the first input
          * child value. This uses reference equality when the parent is an array. Once the callback
@@ -585,14 +633,8 @@ export const boundaryGuards = {
          *
          * await waitUntil.endsWith('b', () => 'ab'); // throws an error
          * await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
-         * await waitUntil.endsWith('b', () => [
-         *     'a',
-         *     'b',
-         * ]); // throws an error
-         * await waitUntil.endsWith('a', () => [
-         *     'a',
-         *     'b',
-         * ]); // returns `['a', 'b']`
+         * await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
+         * await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
          * ```
          *
          * @returns The callback output once it passes.
@@ -601,7 +643,7 @@ export const boundaryGuards = {
          * - {@link waitUntil.startsWithout} : the opposite assertion.
          * - {@link waitUntil.endsWith} : assertion on the other end.
          */
-        startsWith: autoGuard(),
+        startsWith: createWaitUntil(assertions.startsWith),
         /**
          * Repeatedly calls a callback until its output string or array does not start with the
          * first input child value. This uses reference equality when the parent is an array. Once
@@ -615,14 +657,8 @@ export const boundaryGuards = {
          * ```ts
          * await waitUntil.endsWith('b', () => 'ab'); // returns `'ab'`
          * await waitUntil.endsWith('a', () => 'ab'); // throws an error
-         * await waitUntil.endsWith('b', () => [
-         *     'a',
-         *     'b',
-         * ]); // returns `['a', 'b']`
-         * await waitUntil.endsWith('a', () => [
-         *     'a',
-         *     'b',
-         * ]); // throws an error
+         * await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
+         * await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -631,6 +667,6 @@ export const boundaryGuards = {
          * - {@link waitUntil.startsWith} : the opposite assertion.
          * - {@link waitUntil.endsWithout} : assertion on the other end.
          */
-        startsWithout: autoGuard(),
+        startsWithout: createWaitUntil(assertions.startsWithout),
     },
 };