bupkis 0.3.0 → 0.4.0

package/dist/commonjs/bootstrap.d.ts

@@ -14,7 +14,7 @@ declare const
  *
  * @function
  */
-expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodMap<import("zod/v4").ZodAny, import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [import("zod/v4").ZodMap<import("zod/v4").ZodAny, import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodSet<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Set<any>, value: any) => boolean, readonly [import("zod/v4").ZodSet<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: any[], value: any) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have size", import("zod/v4").ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have length", import("zod/v4").ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be non-empty"], (subject: any[]) => {
+expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Map<unknown, unknown>, key: any) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Set<unknown>, value: any) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: any[], value: any) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have size", import("zod/v4").ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have length", import("zod/v4").ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be non-empty"], (subject: any[]) => {
     actual: number;
     expected: string;
     message: string;
@@ -123,25 +123,16 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to match", import("zod/v4").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to match">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], (_subject: {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to match", import("zod/v4").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to match">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodType<import("./types.js").SatisfyPatternValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>], (_subject: {
     [x: string]: unknown;
-}, shape: {
-    [x: string]: unknown;
-}) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+}, shape: import("./types.js").SatisfyPatternValue) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodType<import("./types.js").SatisfyPatternValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
     length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>], (_subject: unknown[] | [unknown, ...unknown[]] | {
-    [x: string]: unknown;
-    length: number;
-}, shape: unknown[] | [unknown, ...unknown[]] | {
+}, import("zod/v4/core").$loose>]>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodType<import("./types.js").SatisfyPatternValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>], (_subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
-    length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+}, shape: import("./types.js").SatisfyPatternValue) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
     length: import("zod/v4").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod/v4").ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
+}, import("zod/v4/core").$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodType<import("./types.js").SatisfyPatternValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod/v4").ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;

package/dist/commonjs/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAwB3D,QAAA;AACE;;;;;GAKG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;GAKG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2hBACN,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAwB3D,QAAA;AACE;;;;;GAKG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;GAKG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2hBACN,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}

package/dist/commonjs/constant.d.ts

@@ -8,5 +8,5 @@
  * @packageDocumentation
  * @internal
  */
-export {};
+export declare const kExpectIt: unique symbol;
 //# sourceMappingURL=constant.d.ts.map

package/dist/commonjs/constant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../src/constant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}
+{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../src/constant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAqCH,eAAO,MAAM,SAAS,EAAE,OAAO,MAAmC,CAAC"}

package/dist/commonjs/constant.js

@@ -10,7 +10,7 @@
  * @internal
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.kBupkisNegatedAssertionError = exports.kBupkisFailAssertionError = exports.kBupkisAssertionError = exports.kStringLiteral = void 0;
+exports.kExpectIt = exports.kBupkisNegatedAssertionError = exports.kBupkisFailAssertionError = exports.kBupkisAssertionError = exports.kStringLiteral = void 0;
 /**
  * Symbol flagging the value as a Bupkis-created string literal, which will be
  * omitted from the parameters to an `AssertionImpl`.
@@ -36,4 +36,5 @@ exports.kBupkisFailAssertionError = Symbol('bupkis-fail-error');
  * @internal
  */
 exports.kBupkisNegatedAssertionError = Symbol('bupkis-negated-error');
+exports.kExpectIt = Symbol('bupkis-expect-it');
 //# sourceMappingURL=constant.js.map

package/dist/commonjs/constant.js.map

@@ -1 +1 @@
-{"version":3,"file":"constant.js","sourceRoot":"","sources":["../../src/constant.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAEH;;;;;GAKG;AAEU,QAAA,cAAc,GAAkB,MAAM,CAAC,uBAAuB,CAAC,CAAC;AAE7E;;;;GAIG;AAEU,QAAA,qBAAqB,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAE3E;;;;GAIG;AACU,QAAA,yBAAyB,GACpC,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAE9B;;;;GAIG;AAEU,QAAA,4BAA4B,GAAkB,MAAM,CAC/D,sBAAsB,CACvB,CAAC"}
+{"version":3,"file":"constant.js","sourceRoot":"","sources":["../../src/constant.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAEH;;;;;GAKG;AAEU,QAAA,cAAc,GAAkB,MAAM,CAAC,uBAAuB,CAAC,CAAC;AAE7E;;;;GAIG;AAEU,QAAA,qBAAqB,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAE3E;;;;GAIG;AACU,QAAA,yBAAyB,GACpC,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAE9B;;;;GAIG;AAEU,QAAA,4BAA4B,GAAkB,MAAM,CAC/D,sBAAsB,CACvB,CAAC;AAEW,QAAA,SAAS,GAAkB,MAAM,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/commonjs/guards.d.ts

@@ -17,7 +17,7 @@
  */
 import { type Primitive } from 'type-fest';
 import { z } from 'zod/v4';
-import type { Constructor, ZodTypeMap } from './types.js';
+import type { Constructor, ExpectItExecutor, ZodTypeMap } from './types.js';
 /**
  * Returns `true` if the given value looks like a Zod v4 schema, determined by
  * the presence of an internal {@link z.core.$ZodTypeDef} field.
@@ -113,6 +113,79 @@ export declare const isNonNullObject: (value: unknown) => value is object;
  * @returns `true` if the value is null or not an object, `false` otherwise
  */
 export declare const isNullOrNonObject: (value: unknown) => value is null | Primitive;
+/**
+ * Generic type guard for instanceof checks.
+ *
+ * This function provides a type-safe way to check if a value is an instance of
+ * a given constructor, with proper type narrowing for TypeScript. It combines
+ * the null/object check with instanceof to ensure the value is a valid object
+ * before performing the instance check.
+ *
+ * @example
+ *
+ * ```typescript
+ * const obj = new Date();
+ * if (isA(obj, Date)) {
+ *   // obj is now typed as Date
+ *   console.log(obj.getTime());
+ * }
+ * ```
+ *
+ * @template T - The constructor type to check against
+ * @param value - Value to test
+ * @param ctor - Constructor function to check instanceof
+ * @returns `true` if the value is an instance of the constructor, `false`
+ *   otherwise
+ */
 export declare const isA: <T extends Constructor>(value: unknown, ctor: T) => value is InstanceType<T>;
+/**
+ * Type guard for Error instances.
+ *
+ * This function checks if a value is an instance of the Error class or any of
+ * its subclasses. It's useful for error handling and type narrowing when
+ * working with unknown values that might be errors.
+ *
+ * @example
+ *
+ * ```typescript
+ * try {
+ *   throw new TypeError('Something went wrong');
+ * } catch (err) {
+ *   if (isError(err)) {
+ *     // err is now typed as Error
+ *     console.log(err.message);
+ *   }
+ * }
+ * ```
+ *
+ * @param value - Value to test
+ * @returns `true` if the value is an Error instance, `false` otherwise
+ */
 export declare const isError: (value: unknown) => value is Error;
+/**
+ * Type guard for {@link ExpectItExecutor} functions.
+ *
+ * This function checks if a value is an {@link ExpectItExecutor} function
+ * created by {@link bupkis!expect.it | expect.it()}. {@link ExpectItExecutor}
+ * functions are special functions that contain assertion logic and are marked
+ * with an internal symbol for identification. They are used in nested
+ * assertions within "to satisfy" patterns and other complex assertion
+ * scenarios.
+ *
+ * @example
+ *
+ * ```typescript
+ * const executor = expect.it('to be a string');
+ * if (isExpectItExecutor(executor)) {
+ *   // executor is now typed as ExpectItExecutor
+ *   // Can be used in satisfaction patterns
+ * }
+ * ```
+ *
+ * @template Subject - The subject type that the executor function operates on
+ * @param value - Value to test
+ * @returns `true` if the value is an ExpectItExecutor function, `false`
+ *   otherwise
+ */
+export declare const isExpectItExecutor: <Subject extends z.ZodType = z.ZodUnknown>(value: unknown) => value is ExpectItExecutor<Subject>;
 //# sourceMappingURL=guards.d.ts.map

package/dist/commonjs/guards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAO3B,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,UAAU,EAClD,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,CAAC,GACN,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAC1B;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,OAAO,CAAC;AAkB9D;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,MAAM,CAEpE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,CAAC,UAC5B,CAAC;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CACb,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,OAAO,KAAG,EAAE,IAAI,WAYnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OACxB,CAAC;AAE7B;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAC5C,CAAC;AA6B9B;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACxB,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACb,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,IAAI,GAAG,SACtB,CAAC;AAyB9C,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,WAAW,EACvC,OAAO,OAAO,EACd,MAAM,CAAC,KACN,KAAK,IAAI,YAAY,CAAC,CAAC,CAEzB,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,KAA0B,CAAC"}
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAO3B,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI5E;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,UAAU,EAClD,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,CAAC,GACN,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAC1B;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,OAAO,CAAC;AAkB9D;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,MAAM,CAEpE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,CAAC,UAC5B,CAAC;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CACb,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,OAAO,KAAG,EAAE,IAAI,WAYnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OACxB,CAAC;AAE7B;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAC5C,CAAC;AA6B9B;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACxB,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACb,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,IAAI,GAAG,SACtB,CAAC;AAyB9C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,WAAW,EACvC,OAAO,OAAO,EACd,MAAM,CAAC,KACN,KAAK,IAAI,YAAY,CAAC,CAAC,CAEzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,KAA0B,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,UAAU,EACzE,OAAO,OAAO,KACb,KAAK,IAAI,gBAAgB,CAAC,OAAO,CAEnC,CAAC"}

package/dist/commonjs/guards.js

@@ -17,9 +17,10 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isError = exports.isA = exports.isPhraseLiteral = exports.isPhraseLiteralChoice = exports.isNullOrNonObject = exports.isNonNullObject = exports.isString = exports.isAssertionFailure = exports.isFunction = exports.isBoolean = exports.isConstructible = exports.isPromiseLike = exports.isZodPromise = exports.isObject = void 0;
+exports.isExpectItExecutor = exports.isError = exports.isA = exports.isPhraseLiteral = exports.isPhraseLiteralChoice = exports.isNullOrNonObject = exports.isNonNullObject = exports.isString = exports.isAssertionFailure = exports.isFunction = exports.isBoolean = exports.isConstructible = exports.isPromiseLike = exports.isZodPromise = exports.isObject = void 0;
 exports.isZodType = isZodType;
 const v4_1 = require("zod/v4");
+const constant_js_1 = require("./constant.js");
 function isZodType(value, type) {
     const isValid = (0, exports.isObject)(value) &&
         'def' in value &&
@@ -170,10 +171,86 @@ exports.isPhraseLiteralChoice = isPhraseLiteralChoice;
  */
 const isPhraseLiteral = (value) => (0, exports.isString)(value) && !value.startsWith('not ');
 exports.isPhraseLiteral = isPhraseLiteral;
+/**
+ * Generic type guard for instanceof checks.
+ *
+ * This function provides a type-safe way to check if a value is an instance of
+ * a given constructor, with proper type narrowing for TypeScript. It combines
+ * the null/object check with instanceof to ensure the value is a valid object
+ * before performing the instance check.
+ *
+ * @example
+ *
+ * ```typescript
+ * const obj = new Date();
+ * if (isA(obj, Date)) {
+ *   // obj is now typed as Date
+ *   console.log(obj.getTime());
+ * }
+ * ```
+ *
+ * @template T - The constructor type to check against
+ * @param value - Value to test
+ * @param ctor - Constructor function to check instanceof
+ * @returns `true` if the value is an instance of the constructor, `false`
+ *   otherwise
+ */
 const isA = (value, ctor) => {
     return (0, exports.isNonNullObject)(value) && value instanceof ctor;
 };
 exports.isA = isA;
+/**
+ * Type guard for Error instances.
+ *
+ * This function checks if a value is an instance of the Error class or any of
+ * its subclasses. It's useful for error handling and type narrowing when
+ * working with unknown values that might be errors.
+ *
+ * @example
+ *
+ * ```typescript
+ * try {
+ *   throw new TypeError('Something went wrong');
+ * } catch (err) {
+ *   if (isError(err)) {
+ *     // err is now typed as Error
+ *     console.log(err.message);
+ *   }
+ * }
+ * ```
+ *
+ * @param value - Value to test
+ * @returns `true` if the value is an Error instance, `false` otherwise
+ */
 const isError = (value) => (0, exports.isA)(value, Error);
 exports.isError = isError;
+/**
+ * Type guard for {@link ExpectItExecutor} functions.
+ *
+ * This function checks if a value is an {@link ExpectItExecutor} function
+ * created by {@link bupkis!expect.it | expect.it()}. {@link ExpectItExecutor}
+ * functions are special functions that contain assertion logic and are marked
+ * with an internal symbol for identification. They are used in nested
+ * assertions within "to satisfy" patterns and other complex assertion
+ * scenarios.
+ *
+ * @example
+ *
+ * ```typescript
+ * const executor = expect.it('to be a string');
+ * if (isExpectItExecutor(executor)) {
+ *   // executor is now typed as ExpectItExecutor
+ *   // Can be used in satisfaction patterns
+ * }
+ * ```
+ *
+ * @template Subject - The subject type that the executor function operates on
+ * @param value - Value to test
+ * @returns `true` if the value is an ExpectItExecutor function, `false`
+ *   otherwise
+ */
+const isExpectItExecutor = (value) => {
+    return (0, exports.isFunction)(value) && constant_js_1.kExpectIt in value && value[constant_js_1.kExpectIt] === true;
+};
+exports.isExpectItExecutor = isExpectItExecutor;
 //# sourceMappingURL=guards.js.map

package/dist/commonjs/guards.js.map

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

package/dist/commonjs/index.d.ts

@@ -37,7 +37,7 @@ export { z };
 /**
  * @primaryExport
  */
-export type { Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, FailFn, UseFn, ZodTypeMap, } from './types.js';
+export type { Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, ExpectIt, ExpectItExecutor, FailFn, UseFn, ZodTypeMap, } from './types.js';
 export { createAssertion, createAsyncAssertion, fail, use };
 declare const 
 /**
@@ -69,7 +69,7 @@ fail: import("./types.js").FailFn,
  *
  * @function
  */
-use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodAny, z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [z.ZodMap<z.ZodAny, z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: Set<any>, value: any) => boolean, readonly [z.ZodSet<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: any[], value: any) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to be non-empty"], (subject: any[]) => {
+use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: Map<unknown, unknown>, key: any) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: Set<unknown>, value: any) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: any[], value: any) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to be non-empty"], (subject: any[]) => {
     actual: number;
     expected: string;
     message: string;
@@ -178,25 +178,16 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, readonly ["to satisfy", "to be like"], z.ZodObject<{}, z.core.$loose>], (_subject: {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, readonly ["to satisfy", "to be like"], z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>], (_subject: {
     [x: string]: unknown;
-}, shape: {
-    [x: string]: unknown;
-}) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
-    length: z.ZodNumber;
-}, z.core.$loose>]>, readonly ["to satisfy", "to be like"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+}, shape: import("./types.js").SatisfyPatternValue) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>], (_subject: unknown[] | [unknown, ...unknown[]] | {
-    [x: string]: unknown;
-    length: number;
-}, shape: unknown[] | [unknown, ...unknown[]] | {
+}, z.core.$loose>]>, readonly ["to satisfy", "to be like"], z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>], (_subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
-    length: z.ZodNumber;
-}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+}, shape: import("./types.js").SatisfyPatternValue) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
+}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;

package/dist/commonjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,MAAM,EACN,KAAK,EACL,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;icAEgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,MAAM,EACN,KAAK,EACL,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;icAEgB,CAAC"}

package/dist/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,+BAA2B;AAuBlB,kFAvBA,MAAC,OAuBA;AArBV,iDAA6D;AAC7D,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAE5B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AAkCvB,MAAM;AACJ;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAjCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,+BAA2B;AAuBlB,kFAvBA,MAAC,OAuBA;AArBV,iDAA6D;AAC7D,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAE5B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AAoCvB,MAAM;AACJ;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAjCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}

package/dist/commonjs/schema.d.ts

@@ -32,9 +32,9 @@
  * @packageDocumentation
  */
 import { z } from 'zod/v4';
-import { type Constructor, type MutableOrReadonly } from './types.js';
+import { type Constructor, type MutableOrReadonly, type SatisfyPatternValue } from './types.js';
 /**
- * A Zod schema that validates JavaScript classes or constructor functions.
+ * A Zod schema that validates JavaScript constructible functions.
  *
  * This schema validates values that can be used as constructors, including ES6
  * classes, traditional constructor functions, and built-in constructors. It
@@ -43,24 +43,24 @@ import { type Constructor, type MutableOrReadonly } from './types.js';
  *
  * @privateRemarks
  * The schema is registered in the {@link BupkisRegistry} with the name
- * `ClassSchema` for later reference and type checking purposes.
+ * `ConstructibleSchema` for later reference and type checking purposes.
  * @example
  *
  * ```typescript
  * class MyClass {}
  * function MyConstructor() {}
  *
- * ClassSchema.parse(MyClass); // ✓ Valid
- * ClassSchema.parse(MyConstructor); // ✓ Valid
- * ClassSchema.parse(Array); // ✓ Valid
- * ClassSchema.parse(Date); // ✓ Valid
- * ClassSchema.parse(() => {}); // ✗ Throws validation error
- * ClassSchema.parse({}); // ✗ Throws validation error
+ * ConstructibleSchema.parse(MyClass); // ✓ Valid
+ * ConstructibleSchema.parse(MyConstructor); // ✓ Valid
+ * ConstructibleSchema.parse(Array); // ✓ Valid
+ * ConstructibleSchema.parse(Date); // ✓ Valid
+ * ConstructibleSchema.parse(() => {}); // ✗ Throws validation error
+ * ConstructibleSchema.parse({}); // ✗ Throws validation error
  * ```
  *
  * @group Schema
  */
-export declare const ClassSchema: z.ZodCustom<Constructor, Constructor>;
+export declare const ConstructibleSchema: z.ZodCustom<Constructor, Constructor>;
 /**
  * A Zod schema that validates any JavaScript function.
  *
@@ -413,4 +413,60 @@ export declare const ArrayLikeSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodUnkno
  * @group Schema
  */
 export declare const RegExpSchema: z.ZodCustom<RegExp, RegExp>;
+/**
+ * A recursive Zod schema that validates values allowed in "to satisfy"
+ * assertion patterns.
+ *
+ * This schema defines the allowed structure for patterns used with "to satisfy"
+ * and "to be like" assertions. It supports a recursive structure that can
+ * contain:
+ *
+ * - **Primitive values**: strings, numbers, booleans, null, undefined, bigint,
+ *   symbols
+ * - **Regular expressions**: for pattern matching against string values
+ * - **ExpectItExecutor functions**: nested assertions created via `expect.it()`
+ * - **Objects**: with properties that recursively follow this same pattern
+ * - **Arrays**: with elements that recursively follow this same pattern
+ *
+ * The schema handles the special semantics required for "to satisfy"
+ * assertions:
+ *
+ * - RegExp values are used for pattern testing rather than exact matching
+ * - ExpectItExecutor functions are executed as nested assertions
+ * - Objects and arrays can contain any combination of the above recursively
+ *
+ * @privateRemarks
+ * Uses `z.lazy()` to handle recursive object and array structures without
+ * causing infinite recursion during schema definition. The schema is registered
+ * in the `BupkisRegistry` for reference and type checking.
+ * @example
+ *
+ * ```typescript
+ * // Primitive values
+ * SatisfyPatternSchema.parse('hello'); // ✓ Valid
+ * SatisfyPatternSchema.parse(42); // ✓ Valid
+ * SatisfyPatternSchema.parse(true); // ✓ Valid
+ *
+ * // Regular expressions for pattern matching
+ * SatisfyPatternSchema.parse(/test/); // ✓ Valid
+ *
+ * // ExpectItExecutor functions
+ * SatisfyPatternSchema.parse(expect.it('to be a string')); // ✓ Valid
+ *
+ * // Complex nested structures
+ * SatisfyPatternSchema.parse({
+ *   name: expect.it('to be a string'),
+ *   email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+ *   age: expect.it('to be greater than', 0),
+ *   tags: [expect.it('to be a string')],
+ * }); // ✓ Valid
+ *
+ * // Invalid values
+ * SatisfyPatternSchema.parse(new Date()); // ✗ Invalid (not supported type)
+ * SatisfyPatternSchema.parse(() => {}); // ✗ Invalid (regular function, not ExpectItExecutor)
+ * ```
+ *
+ * @group Schema
+ */
+export declare const SatisfyPatternSchema: z.ZodType<SatisfyPatternValue>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/commonjs/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAU3B,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,WAAW,uCAGU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,wBACP,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAMzD,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,8DAG4B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,yDAK4B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,2DAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,yCAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,gBAAgB,yEAKmC,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yEAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,mBAAmB,wBAnNZ,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAuNA,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,YAAY,4BAOrB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,WAAW,yBAKsB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,oHAWsB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;mBASxB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY,6BAGsB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAW3B,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACzB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,mBAAmB,uCAGK,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,wBACP,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAMzD,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,8DAG4B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,yDAK4B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,2DAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,yCAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,gBAAgB,yEAKmC,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yEAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,mBAAmB,wBAnNZ,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAuNA,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,YAAY,4BAOrB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,WAAW,yBAKsB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,oHAWsB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;mBASxB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY,6BAGsB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAwBH,CAAC"}