bupkis 0.7.2 → 0.9.0

package/dist/esm/assertion/slotify.d.ts

@@ -7,17 +7,5 @@
  *
  * @packageDocumentation
  */
-import type { AssertionParts, AssertionSlots } from './assertion-types.js';
-/**
- * Builds slots out of assertion parts.
- *
- * @remarks
- * This function converts {@link AssertionParts} into {@link AssertionSlots} by
- * processing string literals and Zod schemas, registering metadata for runtime
- * introspection, and handling validation constraints such as preventing "not "
- * prefixes in string literal parts.
- * @param parts Assertion parts
- * @returns Slots
- */
-export declare const slotify: <const Parts extends AssertionParts>(parts: Parts) => AssertionSlots<Parts>;
+export {};
 //# sourceMappingURL=slotify.d.ts.map

package/dist/esm/assertion/slotify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slotify.d.ts","sourceRoot":"","sources":["../../../src/assertion/slotify.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAW3E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,GAAI,KAAK,CAAC,KAAK,SAAS,cAAc,EACxD,OAAO,KAAK,KACX,cAAc,CAAC,KAAK,CAoDiB,CAAC"}
+{"version":3,"file":"slotify.d.ts","sourceRoot":"","sources":["../../../src/assertion/slotify.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/esm/assertion/slotify.js

@@ -11,7 +11,7 @@ import { inspect } from 'util';
 import { z } from 'zod/v4';
 import { kStringLiteral } from '../constant.js';
 import { AssertionImplementationError } from '../error.js';
-import { isPhraseLiteral, isPhraseLiteralChoice, isZodType, } from '../guards.js';
+import { isPhrase, isPhraseLiteral, isPhraseLiteralChoice, isZodType, } from '../guards.js';
 import { BupkisRegistry } from '../metadata.js';
 /**
  * Builds slots out of assertion parts.
@@ -21,37 +21,36 @@ import { BupkisRegistry } from '../metadata.js';
  * processing string literals and Zod schemas, registering metadata for runtime
  * introspection, and handling validation constraints such as preventing "not "
  * prefixes in string literal parts.
+ * @function
  * @param parts Assertion parts
  * @returns Slots
+ * @internal
  */
 export const slotify = (parts) => parts.flatMap((part, index) => {
     const result = [];
-    if (index === 0 && (isPhraseLiteralChoice(part) || isPhraseLiteral(part))) {
+    if (index === 0 && isPhrase(part)) {
         result.push(z.unknown().describe('subject'));
     }
     if (isPhraseLiteralChoice(part)) {
         if (part.some((p) => p.startsWith('not '))) {
-            throw new AssertionImplementationError(`PhraseLiteralChoice at parts[${index}] must not include phrases starting with "not ": ${inspect(part)}`);
+            throw new AssertionImplementationError(`PhraseLiteralChoice at parts[${index}] must not include phrases starting with "not "; refactor to be a positive assertion: ${inspect(part)}`);
         }
-        result.push(z
-            .literal(part)
-            .brand('string-literal')
-            .register(BupkisRegistry, {
-            [kStringLiteral]: true,
-            values: part,
-        }));
+        result.push(createPhraseLiteralChoiceSchema(part));
     }
     else if (isPhraseLiteral(part)) {
         if (part.startsWith('not ')) {
             throw new AssertionImplementationError(`PhraseLiteral at parts[${index}] must not start with "not ": ${inspect(part)}`);
         }
-        result.push(z
-            .literal(part)
-            .brand('string-literal')
-            .register(BupkisRegistry, {
-            [kStringLiteral]: true,
-            value: part,
-        }));
+        result.push(createPhraseLiteralSchema(part));
+    }
+    else if (typeof part === 'string' && part === 'and') {
+        // Special case: "and" is allowed when followed by a ZodType (for conjunctify)
+        if (index + 1 >= parts.length || !isZodType(parts[index + 1])) {
+            throw new AssertionImplementationError(`"and" at parts[${index}] must be followed by a Zod schema but was followed by ${index + 1 >= parts.length
+                ? 'nothing'
+                : `${inspect(parts[index + 1])} (${typeof parts[index + 1]})`}`);
+        }
+        result.push(createPhraseLiteralSchema(part));
     }
     else {
         if (!isZodType(part)) {
@@ -61,4 +60,38 @@ export const slotify = (parts) => parts.flatMap((part, index) => {
     }
     return result;
 });
+/**
+ * Creates a schema for a choice of phrase literals
+ *
+ * This schema is a branded literal schema to differentiate regular strings from
+ * phrases.
+ *
+ * @function
+ * @param part Phrase literal choice (tuple of strings)
+ * @returns Schema
+ */
+const createPhraseLiteralChoiceSchema = (part) => z
+    .literal(part)
+    .brand('string-literal')
+    .register(BupkisRegistry, {
+    [kStringLiteral]: true,
+    values: part,
+});
+/**
+ * Creates a schema for a single phrase literal
+ *
+ * This schema is a branded literal schema to differentiate regular strings from
+ * phrases.
+ *
+ * @function
+ * @param part Phrase literal (string)
+ * @returns Schema
+ */
+const createPhraseLiteralSchema = (part) => z
+    .literal(part)
+    .brand('string-literal')
+    .register(BupkisRegistry, {
+    [kStringLiteral]: true,
+    value: part,
+});
 //# sourceMappingURL=slotify.js.map

package/dist/esm/assertion/slotify.js.map

@@ -1 +1 @@
-{"version":3,"file":"slotify.js","sourceRoot":"","sources":["../../../src/assertion/slotify.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,KAAY,EACW,EAAE,CACzB,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;IAC5B,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QAC1E,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;QAChC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,4BAA4B,CACpC,gCAAgC,KAAK,oDAAoD,OAAO,CAC9F,IAAI,CACL,EAAE,CACJ,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CACT,CAAC;aACE,OAAO,CAAC,IAAI,CAAC;aACb,KAAK,CAAC,gBAAgB,CAAC;aACvB,QAAQ,CAAC,cAAc,EAAE;YACxB,CAAC,cAAc,CAAC,EAAE,IAAI;YACtB,MAAM,EAAE,IAAI;SACb,CAAC,CACL,CAAC;IACJ,CAAC;SAAM,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,4BAA4B,CACpC,0BAA0B,KAAK,iCAAiC,OAAO,CACrE,IAAI,CACL,EAAE,CACJ,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CACT,CAAC;aACE,OAAO,CAAC,IAAI,CAAC;aACb,KAAK,CAAC,gBAAgB,CAAC;aACvB,QAAQ,CAAC,cAAc,EAAE;YACxB,CAAC,cAAc,CAAC,EAAE,IAAI;YACtB,KAAK,EAAE,IAAI;SACZ,CAAC,CACL,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,4BAA4B,CACpC,0EAA0E,KAAK,kBAAkB,OAAO,CACtG,IAAI,CACL,KAAK,OAAO,IAAI,GAAG,CACrB,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAqC,CAAC"}
+{"version":3,"file":"slotify.js","sourceRoot":"","sources":["../../../src/assertion/slotify.ts"],"names":[],"mappings":"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"}

package/dist/esm/bootstrap.d.ts

@@ -120,15 +120,35 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
 }, import("zod/v4/core").$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
     actual: unknown;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => false | {
-    actual: {};
-    expected: import("./types.js").Constructor;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => {
+    actual: unknown;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => {
+    actual: unknown;
+    expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => boolean, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: any) => import("zod/v4").ZodError<unknown> | {
-    actual: never;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expected?: never;
+    message?: never;
+}, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: any) => {
+    actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod/v4").ZodString], (subject: string, expected: string) => {
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expected?: never;
+    message?: never;
+}, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod/v4").ZodString], (subject: string, expected: string) => {
     actual: string;
     expected: string;
     message: string;
@@ -149,11 +169,7 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
     actual: boolean;
     expected: boolean;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, "to have enumerable property", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>], (subject: unknown, key: string | number | symbol) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>]>, 
+} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, "to have enumerable property", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod/v4").ZodCustom<unknown, unknown>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>]>, 
 /**
  * The main asynchronous assertion function which can execute only built-in
  * assertions.
@@ -177,22 +193,74 @@ expectAsync: ExpectAsync<readonly [import("./types.js").AssertionFunctionAsync<r
     actual: string;
     expected: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying"], import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<import("zod/v4").ZodError<unknown> | {
+} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<{
     actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying"], import("zod/v4").ZodAny], (subject: PromiseLike<unknown>, param: any) => Promise<import("zod/v4").ZodError<unknown> | {
+    expected?: never;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+    expect?: never;
+} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<{
     actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodAny], (promise: PromiseLike<unknown>, param: any) => Promise<import("zod/v4").ZodError<any> | {
-    actual: unknown;
+    expected?: never;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+    expect?: never;
+} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying"], import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<{
+    actual: string;
+    expect: string;
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying"], import("zod/v4").ZodAny], (subject: PromiseLike<unknown>, param: any) => Promise<{
+    actual: string;
+    expect: string;
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodAny], (promise: PromiseLike<unknown>, param: any) => Promise<{
+    actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<import("zod/v4").ZodError<any> | {
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<{
     actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodAny]>]>;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodAny]>]>;
 export { expect, expectAsync };
 //# sourceMappingURL=bootstrap.d.ts.map

package/dist/esm/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;;;;;;GAMG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;;GAMG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oWACN,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;AAyB3D,QAAA;AACE;;;;;;GAMG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;;GAMG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wVACN,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}

package/dist/esm/bootstrap.js

@@ -12,6 +12,7 @@ import { createUse } from './use.js';
  * Factory function that creates both synchronous and asynchronous assertion
  * engines.
  *
+ * @function
  * @returns Object containing {@link expect} and {@link expectAsync} functions
  * @internal
  */

package/dist/esm/bootstrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,SAAS,GAAG,GAGhB,EAAE;IACF,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,CACvC,cAAc,EACd,eAAe,CAChB,CAAC,CAAC,GAAG,cAAc,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC;IAE3C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;AAExB,MAAM;AACJ;;;;;;GAMG;AACH,MAAM;AACN;;;;;;GAMG;AACH,WAAW,GACZ,GAAG,GAAG,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,SAAS,GAAG,GAGhB,EAAE;IACF,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,CACvC,cAAc,EACd,eAAe,CAChB,CAAC,CAAC,GAAG,cAAc,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC;IAE3C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;AAExB,MAAM;AACJ;;;;;;GAMG;AACH,MAAM;AACN;;;;;;GAMG;AACH,WAAW,GACZ,GAAG,GAAG,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}

package/dist/esm/diff.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Diff utilities for generating rich assertion failure output.
+ *
+ * This module provides utilities for extracting meaningful actual/expected
+ * values from Zod validation errors and generating high-quality diff output
+ * using `jest-diff` for assertion failures.
+ *
+ * @packageDocumentation
+ * @see {@link https://npm.im/jest-diff | jest-diff}
+ */
+import type { DiffOptions } from 'jest-diff';
+import type { z } from 'zod/v4';
+export type { DiffOptions };
+/**
+ * Result of extracting diff values from a `ZodError`
+ */
+export interface DiffValues {
+    /** The actual value that was validated */
+    actual: unknown;
+    /** The expected value (corrected version) */
+    expected: unknown;
+}
+/**
+ * Extracts actual and expected values from a `ZodError` for meaningful diffs.
+ *
+ * @function
+ * @param zodError The `ZodError` to extract values from
+ * @param subject The original subject that failed validation
+ * @returns Object with actual and expected values for diff
+ */
+export declare const extractDiffValues: (zodError: z.ZodError, subject: unknown) => DiffValues;
+/**
+ * Generates a rich diff string using jest-diff for assertion failures.
+ *
+ * @function
+ * @param expected The expected value
+ * @param actual The actual value
+ * @param options Configuration options for diff generation
+ * @returns A formatted diff string, or null if values are identical
+ */
+export declare const generateDiff: (expected: unknown, actual: unknown, options?: DiffOptions) => null | string;
+/**
+ * Checks if two values should generate a meaningful diff.
+ *
+ * @function
+ * @param actual The actual value
+ * @param expected The expected value
+ * @returns True if a diff should be generated, false otherwise
+ */
+export declare const shouldGenerateDiff: (actual: unknown, expected: unknown) => boolean;
+//# sourceMappingURL=diff.d.ts.map

package/dist/esm/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAGhC,YAAY,EAAE,WAAW,EAAE,CAAC;AAO5B;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,OAAO,CAAC;IAChB,6CAA6C;IAC7C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,CAAC,CAAC,QAAQ,EACpB,SAAS,OAAO,KACf,UA4GF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,OAAO,EACjB,QAAQ,OAAO,EACf,UAAS,WAAgB,KACxB,IAAI,GAAG,MAYT,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,OAAO,EACf,UAAU,OAAO,KAChB,OACoE,CAAC"}