bupkis 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.1.2](https://github.com/boneskull/bupkis/compare/bupkis-v0.1.1...bupkis-v0.1.2) (2025-09-09)
+
+
+### Bug Fixes
+
+* **util:** isConstructable handles Symbol and BigInt properly ([c13747a](https://github.com/boneskull/bupkis/commit/c13747aa57b5806c38389c1d8347a2966cb17f22))
+
+## [0.1.1](https://github.com/boneskull/bupkis/compare/bupkis-v0.1.0...bupkis-v0.1.1) (2025-09-09)
+
+
+### Bug Fixes
+
+* actually build before publish ([996c28e](https://github.com/boneskull/bupkis/commit/996c28e223ce488d07ea0b7633829ff25d510be3))
+
 ## [0.1.0](https://github.com/boneskull/bupkis/compare/bupkis-v0.0.2...bupkis-v0.1.0) (2025-09-08)
 
 

package/dist/commonjs/api.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Contains the main API types
+ *
+ * @packageDocumentation
+ */
+import type { TupleToUnion, UnionToIntersection } from 'type-fest';
+import type { AnyAsyncAssertion, AnyAsyncAssertions, AnySyncAssertion, AnySyncAssertions, BuiltinAsyncAssertions, BuiltinSyncAssertions } from './assertion/assertion-types.js';
+import type { createAssertion, createAsyncAssertion } from './assertion/create.js';
+import { type InferredExpectSlots, type MutableOrReadonly, type UseFn } from './types.js';
+/**
+ * Base set of properties included in both {@link Expect} and {@link ExpectAsync}.
+ */
+export interface BaseExpect {
+    /**
+     * Creates a new synchronous assertion.
+     */
+    createAssertion: typeof createAssertion;
+    /**
+     * Creates a new asynchronous assertion.
+     */
+    createAsyncAssertion: typeof createAsyncAssertion;
+    /**
+     * Fails immediately with optional `reason`.
+     *
+     * @param reason Reason for failure
+     * @throws {AssertionError}
+     */
+    fail(this: void, reason?: string): never;
+}
+/**
+ * The main synchronous assertion function.
+ *
+ * Contains properties in {@link ExpectSyncProps}.
+ *
+ * @template T All synchronous assertions available
+ * @template U All asynchronous assertions available; for use in
+ *   {@link ExpectSyncProps.use}
+ * @useDeclaredType
+ * @see {@link expect}
+ */
+export type Expect<T extends AnySyncAssertions = BuiltinSyncAssertions, U extends AnyAsyncAssertions = BuiltinAsyncAssertions> = ExpectFunction<T> & ExpectSyncProps<T, U>;
+/**
+ * The main asynchronous assertion function.
+ *
+ * Contains properties in {@link ExpectSyncProps}.
+ *
+ * @useDeclaredType
+ * @see {@link expectAsync}
+ */
+export type ExpectAsync<T extends AnyAsyncAssertions = BuiltinAsyncAssertions, U extends AnySyncAssertions = BuiltinSyncAssertions> = ExpectAsyncFunction<T> & ExpectAsyncProps<T, U>;
+/**
+ * All function overloads for `expectAsync()`; part of {@link ExpectAsync}.
+ */
+export type ExpectAsyncFunction<T extends AnyAsyncAssertions = BuiltinAsyncAssertions> = UnionToIntersection<TupleToUnion<{
+    [K in keyof T]: T[K] extends AnyAsyncAssertion ? (...args: MutableOrReadonly<InferredExpectSlots<T[K]['parts']>>) => Promise<void> : never;
+}>>;
+/**
+ * Properties available on `expectAsync()`; part of {@link ExpectAsync}.
+ */
+export interface ExpectAsyncProps<T extends AnyAsyncAssertions, U extends AnySyncAssertions> extends BaseExpect {
+    /**
+     * Tuple of all assertions available in this `expect()`.
+     */
+    assertions: T;
+    /**
+     * Function to add more assertions to this `expect()`, returning a new
+     * `expect()` and `expectAsync()` pair with the combined assertions.
+     */
+    use: UseFn<U, T>;
+}
+/**
+ * All function overloads for `expect()`; part of {@link Expect}.
+ *
+ * @useDeclaredType
+ */
+export type ExpectFunction<T extends AnySyncAssertions = BuiltinSyncAssertions> = UnionToIntersection<TupleToUnion<{
+    [K in keyof T]: T[K] extends AnySyncAssertion ? (...args: MutableOrReadonly<InferredExpectSlots<T[K]['parts']>>) => void : never;
+}>>;
+/**
+ * Properties for `expect()`; part of {@link Expect}.
+ */
+export interface ExpectSyncProps<T extends AnySyncAssertions, U extends AnyAsyncAssertions> extends BaseExpect {
+    /**
+     * Tuple of all assertions available in this `expect()`.
+     */
+    assertions: T;
+    /**
+     * Function to add more assertions to this `expect()`, returning a new
+     * `expect()` and `expectAsync()` pair with the combined assertions.
+     */
+    use: UseFn<T, U>;
+}
+//# sourceMappingURL=api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEnE,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,KAAK,EACX,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,eAAe,EAAE,OAAO,eAAe,CAAC;IACxC;;OAEG;IACH,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC1C;AAED;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,MAAM,CAChB,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,EACnD,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,IACnD,cAAc,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE9C;;;;;;;GAOG;AAEH,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,EACrD,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,IACjD,mBAAmB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEpD;;GAEG;AAEH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,kBAAkB,GAAG,sBAAsB,IACnD,mBAAmB,CACrB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,iBAAiB,GAC1C,CACE,GAAG,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAC3D,OAAO,CAAC,IAAI,CAAC,GAClB,KAAK;CACV,CAAC,CACH,CAAC;AAEF;;GAEG;AAEH,MAAM,WAAW,gBAAgB,CAC/B,CAAC,SAAS,kBAAkB,EAC5B,CAAC,SAAS,iBAAiB,CAC3B,SAAQ,UAAU;IAClB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC;IACd;;;OAGG;IACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,iBAAiB,GAAG,qBAAqB,IACjD,mBAAmB,CACrB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,gBAAgB,GACzC,CAAC,GAAG,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,GACxE,KAAK;CACV,CAAC,CACH,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe,CAC9B,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,kBAAkB,CAC5B,SAAQ,UAAU;IAClB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC;IAEd;;;OAGG;IACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB"}

package/dist/commonjs/api.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Contains the main API types
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.js.map

package/dist/commonjs/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/dist/commonjs/assertion/assertion-async.d.ts

@@ -0,0 +1,45 @@
+import { type AssertionAsync, type AssertionFunctionAsync, type AssertionImplAsync, type AssertionImplFnAsync, type AssertionImplSchemaAsync, type AssertionParts, type AssertionSchemaAsync, type AssertionSlots, type ParsedResult, type ParsedValues } from './assertion-types.js';
+import { BupkisAssertion } from './assertion.js';
+export declare abstract class BupkisAssertionAsync<Parts extends AssertionParts, Impl extends AssertionImplAsync<Parts>, Slots extends AssertionSlots<Parts>> extends BupkisAssertion<Parts, Impl, Slots> implements AssertionAsync<Parts, Impl, Slots> {
+    abstract executeAsync(parsedValues: ParsedValues<Parts>, args: unknown[], stackStartFn: (...args: any[]) => any, parseResult?: ParsedResult<Parts>): Promise<void>;
+    parseValuesAsync<Args extends readonly unknown[]>(args: Args): Promise<ParsedResult<Parts>>;
+}
+/**
+ * An assertion implemented as a Zod schema.
+ *
+ * Async schemas are supported via {@link expectAsync}.
+ */
+/**
+ * Optimized schema assertion that performs subject validation during
+ * parseValues() to eliminate double parsing for simple schema-based
+ * assertions.
+ *
+ * This class implements Option 2 from the z.function() analysis - it caches the
+ * subject validation result during argument parsing and reuses it during
+ * execution, eliminating the double parsing overhead.
+ */
+export declare class BupkisAssertionFunctionAsync<Parts extends AssertionParts, Impl extends AssertionImplFnAsync<Parts>, Slots extends AssertionSlots<Parts>> extends BupkisAssertionAsync<Parts, Impl, Slots> implements AssertionFunctionAsync<Parts, Impl, Slots> {
+    executeAsync(parsedValues: ParsedValues<Parts>, args: unknown[], stackStartFn: (...args: any[]) => any, _parseResult?: ParsedResult<Parts>): Promise<void>;
+}
+/**
+ * A class representing an assertion implemented as a function.
+ *
+ * This function may:
+ *
+ * 1. Return a `boolean` indicating pass/fail.
+ * 2. Return a `ZodType` which will be used to validate the subject.
+ * 3. Return a `Promise` resolving to either of the above (when called via
+ *    {@link expectAsync})
+ * 4. Throw a {@link AssertionError}; when called via {@link expectAsync}, reject
+ *    with an {@link AssertionError}
+ */
+export declare class BupkisAssertionSchemaAsync<Parts extends AssertionParts, Impl extends AssertionImplSchemaAsync<Parts>, Slots extends AssertionSlots<Parts>> extends BupkisAssertionAsync<Parts, Impl, Slots> implements AssertionSchemaAsync<Parts, Impl, Slots> {
+    executeAsync(parsedValues: ParsedValues<Parts>, _args: unknown[], stackStartFn: (...args: any[]) => any, _parseResult?: ParsedResult<Parts>): Promise<void>;
+    /**
+     * Determines if this assertion can be optimized (simple single-subject
+     * schema). Only simple assertions like ['to be a string'] with z.string()
+     * qualify.
+     */
+    private isSimpleSchemaAssertion;
+}
+//# sourceMappingURL=assertion-async.d.ts.map

package/dist/commonjs/assertion/assertion-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-async.d.ts","sourceRoot":"","sources":["../../../src/assertion/assertion-async.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,8BAAsB,oBAAoB,CACtC,KAAK,SAAS,cAAc,EAC5B,IAAI,SAAS,kBAAkB,CAAC,KAAK,CAAC,EACtC,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,CAErC,SAAQ,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAC1C,YAAW,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAE7C,QAAQ,CAAC,YAAY,CACnB,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,WAAW,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC;IAEV,gBAAgB,CAAC,IAAI,SAAS,SAAS,OAAO,EAAE,EACpD,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;CA0ChC;AACD;;;;GAIG;AACH;;;;;;;;GAQG;AAEH,qBAAa,4BAA4B,CACrC,KAAK,SAAS,cAAc,EAC5B,IAAI,SAAS,oBAAoB,CAAC,KAAK,CAAC,EACxC,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,CAErC,SAAQ,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAC/C,YAAW,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAEtC,YAAY,CACzB,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,YAAY,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;CA8BjB;AAED;;;;;;;;;;;GAWG;AAEH,qBAAa,0BAA0B,CACnC,KAAK,SAAS,cAAc,EAC5B,IAAI,SAAS,wBAAwB,CAAC,KAAK,CAAC,EAC5C,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,CAErC,SAAQ,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAC/C,YAAW,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAEpC,YAAY,CACzB,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,KAAK,EAAE,OAAO,EAAE,EAChB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,YAAY,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;IAahB;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;CAehC"}

package/dist/commonjs/assertion/assertion-async.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BupkisAssertionSchemaAsync = exports.BupkisAssertionFunctionAsync = exports.BupkisAssertionAsync = void 0;
+const debug_1 = __importDefault(require("debug"));
+const util_1 = require("util");
+const v4_1 = __importDefault(require("zod/v4"));
+const constant_js_1 = require("../constant.js");
+const error_js_1 = require("../error.js");
+const guards_js_1 = require("../guards.js");
+const metadata_js_1 = require("../metadata.js");
+const assertion_js_1 = require("./assertion.js");
+const debug = (0, debug_1.default)('bupkis:assertion:async');
+class BupkisAssertionAsync extends assertion_js_1.BupkisAssertion {
+    async parseValuesAsync(args) {
+        const { slots } = this;
+        const parsedValues = [];
+        if (slots.length !== args.length) {
+            return {
+                success: false,
+            };
+        }
+        let exactMatch = true;
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            const arg = args[i];
+            const parsedLiteralResult = this.parseSlotForLiteral(slot, i, arg);
+            if (parsedLiteralResult === true) {
+                continue;
+            }
+            else if (parsedLiteralResult !== false) {
+                return parsedLiteralResult;
+            }
+            // unknown/any accept anything
+            // IMPORTANT: do not use a type guard here; it will break inference
+            if (slot.def.type === 'unknown' || slot.def.type === 'any') {
+                debug('Skipping unknown/any slot validation for arg', arg);
+                parsedValues.push(arg);
+                exactMatch = false;
+                continue;
+            }
+            const result = await slot.safeParseAsync(arg);
+            if (!result.success) {
+                return {
+                    success: false,
+                };
+            }
+            parsedValues.push(result.data);
+        }
+        return {
+            exactMatch,
+            parsedValues: parsedValues,
+            success: true,
+        };
+    }
+}
+exports.BupkisAssertionAsync = BupkisAssertionAsync;
+/**
+ * An assertion implemented as a Zod schema.
+ *
+ * Async schemas are supported via {@link expectAsync}.
+ */
+/**
+ * Optimized schema assertion that performs subject validation during
+ * parseValues() to eliminate double parsing for simple schema-based
+ * assertions.
+ *
+ * This class implements Option 2 from the z.function() analysis - it caches the
+ * subject validation result during argument parsing and reuses it during
+ * execution, eliminating the double parsing overhead.
+ */
+class BupkisAssertionFunctionAsync extends BupkisAssertionAsync {
+    async executeAsync(parsedValues, args, stackStartFn, _parseResult) {
+        const { impl } = this;
+        const result = await impl(...parsedValues);
+        if ((0, guards_js_1.isZodType)(result)) {
+            try {
+                await result.parseAsync(parsedValues[0]);
+            }
+            catch (error) {
+                if ((0, guards_js_1.isA)(error, v4_1.default.ZodError)) {
+                    throw this.translateZodError(stackStartFn, error, ...parsedValues);
+                }
+                throw error;
+            }
+        }
+        else if ((0, guards_js_1.isBoolean)(result)) {
+            if (!result) {
+                throw new error_js_1.AssertionError({
+                    message: `Assertion ${this} failed for arguments: ${(0, util_1.inspect)(args)}`,
+                });
+            }
+        }
+        else if ((0, guards_js_1.isAssertionFailure)(result)) {
+            throw new error_js_1.AssertionError({
+                actual: result.actual,
+                expected: result.expected,
+                message: result.message ?? `Assertion ${this} failed`,
+            });
+        }
+        else if (result) {
+            throw new TypeError(`Invalid return type from assertion ${this}; expected boolean, ZodType, or AssertionFailure`);
+        }
+    }
+}
+exports.BupkisAssertionFunctionAsync = BupkisAssertionFunctionAsync;
+/**
+ * A class representing an assertion implemented as a function.
+ *
+ * This function may:
+ *
+ * 1. Return a `boolean` indicating pass/fail.
+ * 2. Return a `ZodType` which will be used to validate the subject.
+ * 3. Return a `Promise` resolving to either of the above (when called via
+ *    {@link expectAsync})
+ * 4. Throw a {@link AssertionError}; when called via {@link expectAsync}, reject
+ *    with an {@link AssertionError}
+ */
+class BupkisAssertionSchemaAsync extends BupkisAssertionAsync {
+    async executeAsync(parsedValues, _args, stackStartFn, _parseResult) {
+        // For async, fall back to standard implementation for now
+        const [subject] = parsedValues;
+        try {
+            await this.impl.parseAsync(subject);
+        }
+        catch (error) {
+            if ((0, guards_js_1.isA)(error, v4_1.default.ZodError)) {
+                throw this.translateZodError(stackStartFn, error, ...parsedValues);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Determines if this assertion can be optimized (simple single-subject
+     * schema). Only simple assertions like ['to be a string'] with z.string()
+     * qualify.
+     */
+    isSimpleSchemaAssertion() {
+        // Only optimize if we have exactly one subject slot + string literal slots
+        // and no complex argument processing
+        const hasSubjectSlot = this.slots.length > 0 &&
+            (this.slots[0]?.def.type === 'unknown' ||
+                this.slots[0]?.def.type === 'any');
+        const allOtherSlotsAreLiterals = this.slots.slice(1).every((slot) => {
+            const meta = metadata_js_1.BupkisRegistry.get(slot) ?? {};
+            return constant_js_1.kStringLiteral in meta;
+        });
+        return hasSubjectSlot && allOtherSlotsAreLiterals;
+    }
+}
+exports.BupkisAssertionSchemaAsync = BupkisAssertionSchemaAsync;
+//# sourceMappingURL=assertion-async.js.map

package/dist/commonjs/assertion/assertion-async.js.map

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

package/dist/commonjs/assertion/assertion-sync.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Synchronous assertion subclasses.
+ *
+ * @packageDocumentation
+ * @see {@link AssertionFunctionSync} for function-based assertions
+ * @see {@link AssertionSchemaSync} for schema-based assertions
+ */
+import { type AssertionFunctionSync, type AssertionImplFnSync, type AssertionImplSchemaSync, type AssertionImplSync, type AssertionParts, type AssertionSchemaSync, type AssertionSlots, type AssertionSync, type ParsedResult, type ParsedValues } from './assertion-types.js';
+import { BupkisAssertion } from './assertion.js';
+/**
+ * Abstract class for synchronous assertions.
+ *
+ * Child classes are expected to implement {@link execute}.
+ */
+export declare abstract class BupkisAssertionSync<Parts extends AssertionParts, Impl extends AssertionImplSync<Parts>, Slots extends AssertionSlots<Parts>> extends BupkisAssertion<Parts, Impl, Slots> implements AssertionSync<Parts, Impl, Slots> {
+    /**
+     * Parses raw arguments synchronously against this `Assertion`'s Slots to
+     * determine if they match this `Assertion`.
+     *
+     * @param args Raw arguments provided to `expect()`
+     * @returns Result of parsing attempt
+     */
+    abstract execute(parsedValues: ParsedValues<Parts>, args: unknown[], stackStartFn: (...args: any[]) => any, parseResult?: ParsedResult<Parts>): void;
+    /**
+     * Parses raw arguments against the slots of this assertion to determine if
+     * this assertion should be executed against those arguments.
+     *
+     * For example, if an assertion wants the subject to be a `z.string()`, then
+     * this will validate that the first raw arg parses as a string. It will also
+     * validate Phrase Literals as well, such as "to be a string". If all slots
+     * match and none of the slots are "unknown" or "any", then `exactMatch` will
+     * be true.
+     *
+     * If any slot does not match, this returns `success: false`.
+     *
+     * @param args Raw arguments
+     * @returns Result of parsing attempt
+     */
+    parseValues<Args extends readonly unknown[]>(args: Args): ParsedResult<Parts>;
+}
+export declare class BupkisAssertionFunctionSync<Parts extends AssertionParts, Impl extends AssertionImplFnSync<Parts>, Slots extends AssertionSlots<Parts>> extends BupkisAssertionSync<Parts, Impl, Slots> implements AssertionFunctionSync<Parts, Impl, Slots> {
+    execute(parsedValues: ParsedValues<Parts>, args: unknown[], stackStartFn: (...args: any[]) => any, _parseResult?: ParsedResult<Parts>): void;
+}
+/**
+ * A class representing an assertion implemented as a function.
+ *
+ * This function may:
+ *
+ * 1. Return a `boolean` indicating pass/fail.
+ * 2. Return a `ZodType` which will be used to validate the subject.
+ * 3. Return a `Promise` resolving to either of the above (when called via
+ *    {@link expectAsync})
+ * 4. Throw a {@link AssertionError}; when called via {@link expectAsync}, reject
+ *    with an {@link AssertionError}
+ */
+export declare class BupkisAssertionSchemaSync<Parts extends AssertionParts, Impl extends AssertionImplSchemaSync<Parts>, Slots extends AssertionSlots<Parts>> extends BupkisAssertionSync<Parts, Impl, Slots> implements AssertionSchemaSync<Parts, Impl, Slots> {
+    execute(parsedValues: ParsedValues<Parts>, args: unknown[], stackStartFn: (...args: any[]) => any, parseResult?: ParsedResult<Parts>): void;
+    parseValues<Args extends readonly unknown[]>(args: Args): ParsedResult<Parts>;
+    /**
+     * Determines if this assertion can be optimized (simple single-subject
+     * schema). Only simple assertions like ['to be a string'] with z.string()
+     * qualify.
+     */
+    private isSimpleSchemaAssertion;
+}
+//# sourceMappingURL=assertion-sync.d.ts.map

package/dist/commonjs/assertion/assertion-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-sync.d.ts","sourceRoot":"","sources":["../../../src/assertion/assertion-sync.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgBH,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EAEjB,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIjD;;;;GAIG;AACH,8BAAsB,mBAAmB,CACrC,KAAK,SAAS,cAAc,EAC5B,IAAI,SAAS,iBAAiB,CAAC,KAAK,CAAC,EACrC,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,CAErC,SAAQ,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAC1C,YAAW,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAE5C;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CACd,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,WAAW,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GAChC,IAAI;IAEP;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,IAAI,SAAS,SAAS,OAAO,EAAE,EACzC,IAAI,EAAE,IAAI,GACT,YAAY,CAAC,KAAK,CAAC;CAkDvB;AAED,qBAAa,2BAA2B,CACpC,KAAK,SAAS,cAAc,EAC5B,IAAI,SAAS,mBAAmB,CAAC,KAAK,CAAC,EACvC,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,CAErC,SAAQ,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAC9C,YAAW,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAE3C,OAAO,CACd,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,YAAY,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GACjC,IAAI;CA2CR;AAED;;;;;;;;;;;GAWG;AAEH,qBAAa,yBAAyB,CAClC,KAAK,SAAS,cAAc,EAC5B,IAAI,SAAS,uBAAuB,CAAC,KAAK,CAAC,EAC3C,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,CAErC,SAAQ,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAC9C,YAAW,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;IAEzC,OAAO,CACd,YAAY,EAAE,YAAY,CAAC,KAAK,CAAC,EACjC,IAAI,EAAE,OAAO,EAAE,EACf,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,WAAW,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GAChC,IAAI;IA+BE,WAAW,CAAC,IAAI,SAAS,SAAS,OAAO,EAAE,EAClD,IAAI,EAAE,IAAI,GACT,YAAY,CAAC,KAAK,CAAC;IA8EtB;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;CAehC"}

package/dist/commonjs/assertion/assertion-sync.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Synchronous assertion subclasses.
+ *
+ * @packageDocumentation
+ * @see {@link AssertionFunctionSync} for function-based assertions
+ * @see {@link AssertionSchemaSync} for schema-based assertions
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BupkisAssertionSchemaSync = exports.BupkisAssertionFunctionSync = exports.BupkisAssertionSync = void 0;
+const debug_1 = __importDefault(require("debug"));
+const util_1 = require("util");
+const constant_js_1 = require("../constant.js");
+const error_js_1 = require("../error.js");
+const guards_js_1 = require("../guards.js");
+const metadata_js_1 = require("../metadata.js");
+const assertion_js_1 = require("./assertion.js");
+const debug = (0, debug_1.default)('bupkis:assertion:sync');
+/**
+ * Abstract class for synchronous assertions.
+ *
+ * Child classes are expected to implement {@link execute}.
+ */
+class BupkisAssertionSync extends assertion_js_1.BupkisAssertion {
+    /**
+     * Parses raw arguments against the slots of this assertion to determine if
+     * this assertion should be executed against those arguments.
+     *
+     * For example, if an assertion wants the subject to be a `z.string()`, then
+     * this will validate that the first raw arg parses as a string. It will also
+     * validate Phrase Literals as well, such as "to be a string". If all slots
+     * match and none of the slots are "unknown" or "any", then `exactMatch` will
+     * be true.
+     *
+     * If any slot does not match, this returns `success: false`.
+     *
+     * @param args Raw arguments
+     * @returns Result of parsing attempt
+     */
+    parseValues(args) {
+        const { slots } = this;
+        const parsedValues = [];
+        const mismatch = this.maybeParseValuesArgMismatch(args);
+        if (mismatch) {
+            return mismatch;
+        }
+        let exactMatch = true;
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            const arg = args[i];
+            const parsedLiteralResult = this.parseSlotForLiteral(slot, i, arg);
+            if (parsedLiteralResult === true) {
+                continue;
+            }
+            else if (parsedLiteralResult !== false) {
+                return parsedLiteralResult;
+            }
+            // unknown/any accept anything
+            // IMPORTANT: do not use a type guard here
+            if (slot.def.type === 'unknown' || slot.def.type === 'any') {
+                // debug('Skipping unknown/any slot validation for arg', arg);
+                parsedValues.push(arg);
+                exactMatch = false;
+                continue;
+            }
+            // low-effort check
+            if ((0, guards_js_1.isZodPromise)(slot)) {
+                throw new TypeError(`${this} expects a Promise for slot ${i}; use expectAsync() instead of expect()`);
+            }
+            const result = slot.safeParse(arg);
+            if (!result.success) {
+                return {
+                    success: false,
+                };
+            }
+            parsedValues.push(arg);
+        }
+        return {
+            exactMatch,
+            parsedValues: parsedValues,
+            success: true,
+        };
+    }
+}
+exports.BupkisAssertionSync = BupkisAssertionSync;
+class BupkisAssertionFunctionSync extends BupkisAssertionSync {
+    execute(parsedValues, args, stackStartFn, _parseResult) {
+        const result = this.impl.call(null, 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        ...parsedValues);
+        if ((0, guards_js_1.isPromiseLike)(result)) {
+            // Avoid unhandled promise rejection
+            Promise.resolve(result).catch((err) => {
+                debug(`Ate unhandled rejection from assertion %s: %O`, this, err);
+            });
+            throw new TypeError(`Assertion ${this} returned a Promise; use expectAsync() instead of expect()`);
+        }
+        if ((0, guards_js_1.isZodType)(result)) {
+            const zodResult = result.safeParse(parsedValues[0]);
+            if (!zodResult.success) {
+                throw this.translateZodError(stackStartFn, zodResult.error, ...parsedValues);
+            }
+        }
+        else if ((0, guards_js_1.isBoolean)(result)) {
+            if (!result) {
+                throw new error_js_1.AssertionError({
+                    message: `Assertion ${this} failed for arguments: ${(0, util_1.inspect)(args)}`,
+                });
+            }
+        }
+        else if ((0, guards_js_1.isAssertionFailure)(result)) {
+            throw new error_js_1.AssertionError({
+                actual: result.actual,
+                expected: result.expected,
+                message: result.message ?? `Assertion ${this} failed`,
+            });
+        }
+        else if (result) {
+            throw new TypeError(`Invalid return type from assertion ${this}; expected boolean, ZodType, or AssertionFailure`);
+        }
+    }
+}
+exports.BupkisAssertionFunctionSync = BupkisAssertionFunctionSync;
+/**
+ * A class representing an assertion implemented as a function.
+ *
+ * This function may:
+ *
+ * 1. Return a `boolean` indicating pass/fail.
+ * 2. Return a `ZodType` which will be used to validate the subject.
+ * 3. Return a `Promise` resolving to either of the above (when called via
+ *    {@link expectAsync})
+ * 4. Throw a {@link AssertionError}; when called via {@link expectAsync}, reject
+ *    with an {@link AssertionError}
+ */
+class BupkisAssertionSchemaSync extends BupkisAssertionSync {
+    execute(parsedValues, args, stackStartFn, parseResult) {
+        // Check if we have cached validation result from parseValues
+        const cachedValidation = parseResult?.success
+            ? parseResult.subjectValidationResult
+            : undefined;
+        if (cachedValidation) {
+            debug('Using cached subject validation result from parseValues for %s', this);
+            if (!cachedValidation.success) {
+                // Subject validation failed during parseValues, throw the cached error
+                throw this.translateZodError(stackStartFn, cachedValidation.error, ...parsedValues);
+            }
+            // Subject validation passed, nothing more to do
+            return;
+        }
+        // Fall back to standard validation if no cached result
+        const [subject] = parsedValues;
+        const result = this.impl.safeParse(subject);
+        if (!result.success) {
+            throw this.translateZodError(stackStartFn, result.error, ...parsedValues);
+        }
+    }
+    parseValues(args) {
+        const { slots } = this;
+        const parsedValues = [];
+        const mismatch = this.maybeParseValuesArgMismatch(args);
+        if (mismatch) {
+            return mismatch;
+        }
+        let exactMatch = true;
+        let subjectValidationResult;
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            const arg = args[i];
+            const parsedLiteralResult = this.parseSlotForLiteral(slot, i, arg);
+            if (parsedLiteralResult === true) {
+                continue;
+            }
+            else if (parsedLiteralResult !== false) {
+                return parsedLiteralResult;
+            }
+            // For the subject slot (first slot if it's unknown/any), try optimized validation
+            if (i === 0 &&
+                (slot.def.type === 'unknown' || slot.def.type === 'any') &&
+                this.isSimpleSchemaAssertion()) {
+                const result = this.impl.safeParse(arg);
+                if (result.success) {
+                    subjectValidationResult = { data: result.data, success: true };
+                    parsedValues.push(result.data); // Use validated data
+                }
+                else {
+                    subjectValidationResult = { error: result.error, success: false };
+                    parsedValues.push(arg); // Keep original for error reporting
+                }
+                exactMatch = false; // Subject was validated, so we know the exact type
+                continue;
+            }
+            // Standard slot processing for non-optimized cases
+            if (slot.def.type === 'unknown' || slot.def.type === 'any') {
+                debug('Skipping unknown/any slot validation for arg', arg);
+                parsedValues.push(arg);
+                exactMatch = false;
+                continue;
+            }
+            if ((0, guards_js_1.isZodPromise)(slot)) {
+                throw new TypeError(`${this} expects a Promise for slot ${i}; use expectAsync() instead of expect()`);
+            }
+            const result = slot.safeParse(arg);
+            if (!result.success) {
+                return {
+                    success: false,
+                };
+            }
+            parsedValues.push(arg);
+        }
+        const result = {
+            exactMatch,
+            parsedValues: parsedValues,
+            success: true,
+        };
+        // Add cached validation result if we performed optimization
+        if (subjectValidationResult) {
+            result.subjectValidationResult = subjectValidationResult;
+        }
+        return result;
+    }
+    /**
+     * Determines if this assertion can be optimized (simple single-subject
+     * schema). Only simple assertions like ['to be a string'] with z.string()
+     * qualify.
+     */
+    isSimpleSchemaAssertion() {
+        // Only optimize if we have exactly one subject slot + string literal slots
+        // and no complex argument processing
+        const hasSubjectSlot = this.slots.length > 0 &&
+            (this.slots[0]?.def.type === 'unknown' ||
+                this.slots[0]?.def.type === 'any');
+        const allOtherSlotsAreLiterals = this.slots.slice(1).every((slot) => {
+            const meta = metadata_js_1.BupkisRegistry.get(slot) ?? {};
+            return constant_js_1.kStringLiteral in meta;
+        });
+        return hasSubjectSlot && allOtherSlotsAreLiterals;
+    }
+}
+exports.BupkisAssertionSchemaSync = BupkisAssertionSchemaSync;
+//# sourceMappingURL=assertion-sync.js.map