@c9up/helix 0.1.3 → 0.1.5

package/dist/runtime/expect.js

@@ -0,0 +1,121 @@
+/**
+ * `expect(value)` engine — chainable assertion API compatible with Vitest.
+ *
+ * Supports:
+ *   - All matchers in `./matchers.ts`
+ *   - `.not.<matcher>()` — inverts pass/fail
+ *   - `.resolves.<matcher>()` / `.rejects.<matcher>()` — async awaits on received
+ *   - All four combinations: `.resolves.not`, `.rejects.not`, `.not.resolves`, `.not.rejects`
+ */
+import { AssertionError } from "./assertion-error.js";
+import { matchers } from "./matchers.js";
+function evaluate(ctx, name, args) {
+    const matcher = matchers[name];
+    let result;
+    try {
+        result = matcher(ctx.received, ...args);
+    }
+    catch (err) {
+        // A matcher threw unexpectedly (e.g. a user-supplied constructor with
+        // a throwing `Symbol.hasInstance`). Surface it as a normal assertion
+        // failure so reporters can render it uniformly.
+        const why = err instanceof Error ? err.message : String(err);
+        throw new AssertionError({
+            message: `matcher ${name} threw: ${why}`,
+            actual: ctx.received,
+            expected: args.length === 1 ? args[0] : args,
+            operator: ctx.negate ? `not.${name}` : name,
+        });
+    }
+    const pass = ctx.negate ? !result.pass : result.pass;
+    if (pass)
+        return;
+    const prefix = ctx.negate ? "expected NOT: " : "";
+    throw new AssertionError({
+        message: `${prefix}${result.message()}`,
+        actual: ctx.received,
+        expected: args,
+        operator: ctx.negate ? `not.${name}` : name,
+    });
+}
+const matcherNames = Object.keys(matchers);
+function buildSync(received, negate) {
+    const api = {};
+    for (const name of matcherNames) {
+        const fn = (...args) => evaluate({ received, negate }, name, args);
+        Reflect.set(api, name, fn);
+    }
+    return api;
+}
+function buildAsync(received, mode, negate) {
+    const api = {};
+    for (const name of matcherNames) {
+        const fn = async (...args) => {
+            if (!received ||
+                typeof received.then !== "function") {
+                throw new AssertionError({
+                    message: `expected a Promise (for .${mode}), got ${typeof received}`,
+                    operator: `${mode}.${name}`,
+                });
+            }
+            let resolved;
+            let rejected;
+            let didReject = false;
+            try {
+                resolved = await received;
+            }
+            catch (err) {
+                rejected = err;
+                didReject = true;
+            }
+            if (mode === "resolves") {
+                if (didReject) {
+                    throw new AssertionError({
+                        message: `expected promise to resolve, but it rejected with ${String(rejected)}`,
+                        operator: `resolves.${name}`,
+                    });
+                }
+                evaluate({ received: resolved, negate }, name, args);
+                return;
+            }
+            if (!didReject) {
+                throw new AssertionError({
+                    message: `expected promise to reject, but it resolved with ${String(resolved)}`,
+                    operator: `rejects.${name}`,
+                });
+            }
+            // `.rejects.toThrow(...)` feeds the rejection into toThrow's
+            // function-scoped contract by wrapping it in a rethrowing thunk.
+            const target = name === "toThrow"
+                ? () => {
+                    throw rejected;
+                }
+                : rejected;
+            evaluate({ received: target, negate }, name, args);
+        };
+        Reflect.set(api, name, fn);
+    }
+    return api;
+}
+export function expect(received) {
+    const base = buildSync(received, false);
+    // `.not` returns a chain that negates every matcher. It also exposes
+    // `.resolves` / `.rejects` so `expect(p).not.resolves.toBe(x)` works, matching
+    // Vitest's full surface.
+    const notSync = Object.assign(buildSync(received, true), {
+        resolves: buildAsync(received, "resolves", true),
+        rejects: buildAsync(received, "rejects", true),
+    });
+    const resolves = Object.assign(buildAsync(received, "resolves", false), {
+        not: buildAsync(received, "resolves", true),
+    });
+    const rejects = Object.assign(buildAsync(received, "rejects", false), {
+        not: buildAsync(received, "rejects", true),
+    });
+    return Object.assign(base, {
+        not: notSync,
+        resolves,
+        rejects,
+    });
+}
+//# sourceMappingURL=expect.js.map

package/dist/runtime/expect.js.map

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

package/{src/runtime/index.ts → dist/runtime/index.d.ts}

@@ -5,7 +5,6 @@
  * get the full DSL. The runtime is orchestrator-agnostic: a Node child
  * process, a Bun worker, or a Rust-spawned worker all load the same module.
  */
-
 export type { AssertionErrorInit } from "./assertion-error.js";
 export { AssertionError, isAssertionError } from "./assertion-error.js";
 export type { EqualsOptions } from "./equals.js";
@@ -13,38 +12,17 @@ export { equals, partialEquals } from "./equals.js";
 export type { Assertion } from "./expect.js";
 export { expect } from "./expect.js";
 export type { Hook, HookType } from "./lifecycle.js";
-export {
-	addHook,
-	afterAll,
-	afterEach,
-	beforeAll,
-	beforeEach,
-} from "./lifecycle.js";
+export { addHook, afterAll, afterEach, beforeAll, beforeEach, } from "./lifecycle.js";
 export type { MatcherName, MatcherResult, SpyLike } from "./matchers.js";
 export { matchers } from "./matchers.js";
-export type {
-	FileResult,
-	SerializedError,
-	SuiteResult,
-	TestResult,
-} from "./run.js";
+export type { FileResult, SerializedError, SuiteResult, TestResult, } from "./run.js";
 export { executeRoot } from "./run.js";
 export type { RunMode, SuiteNode, TestFn, TestNode } from "./suite.js";
-export {
-	describe,
-	getRoot,
-	it,
-	resetRoot,
-	test,
-} from "./suite.js";
+export { describe, getRoot, it, resetRoot, test, } from "./suite.js";
 export type { Vi } from "./vi/index.js";
 export { vi, withViContext } from "./vi/index.js";
-export type {
-	CreateSpyOptions,
-	MockCallResult,
-	MockInternals,
-	Spy,
-} from "./vi/spy.js";
+export type { CreateSpyOptions, MockCallResult, MockInternals, Spy, } from "./vi/spy.js";
 export type { SpyOnOptions } from "./vi/spyOn.js";
 export type { RunFileOptions } from "./worker.js";
 export { runTestFile } from "./worker.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EACN,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,GACV,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EACX,UAAU,EACV,eAAe,EACf,WAAW,EACX,UAAU,GACV,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACN,QAAQ,EACR,OAAO,EACP,EAAE,EACF,SAAS,EACT,IAAI,GACJ,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,EAAE,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAClD,YAAY,EACX,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,GAAG,GACH,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/runtime/index.js

@@ -0,0 +1,17 @@
+/**
+ * `@c9up/helix/runtime` — public surface of the Vitest-compatible test runtime.
+ *
+ * Test files can `import { describe, test, expect } from "@c9up/helix"` and
+ * get the full DSL. The runtime is orchestrator-agnostic: a Node child
+ * process, a Bun worker, or a Rust-spawned worker all load the same module.
+ */
+export { AssertionError, isAssertionError } from "./assertion-error.js";
+export { equals, partialEquals } from "./equals.js";
+export { expect } from "./expect.js";
+export { addHook, afterAll, afterEach, beforeAll, beforeEach, } from "./lifecycle.js";
+export { matchers } from "./matchers.js";
+export { executeRoot } from "./run.js";
+export { describe, getRoot, it, resetRoot, test, } from "./suite.js";
+export { vi, withViContext } from "./vi/index.js";
+export { runTestFile } from "./worker.js";
+//# sourceMappingURL=index.js.map

package/dist/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EACN,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,GACV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAOzC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,OAAO,EACN,QAAQ,EACR,OAAO,EACP,EAAE,EACF,SAAS,EACT,IAAI,GACJ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AASlD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/{src/runtime/lifecycle.ts → dist/runtime/lifecycle.d.ts}

@@ -6,12 +6,6 @@
  * stable import path for reporters/plugins that want hooks without the full
  * DSL surface.
  */
-
 export type { Hook, HookType } from "./suite.js";
-export {
-	addHook,
-	afterAll,
-	afterEach,
-	beforeAll,
-	beforeEach,
-} from "./suite.js";
+export { addHook, afterAll, afterEach, beforeAll, beforeEach, } from "./suite.js";
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/runtime/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/runtime/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EACN,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,GACV,MAAM,YAAY,CAAC"}

package/dist/runtime/lifecycle.js

@@ -0,0 +1,10 @@
+/**
+ * Public re-exports for lifecycle hooks.
+ *
+ * The actual registration lives in `./suite.ts` (hooks are attached to the
+ * currently-active suite on the collection stack). This module exists as a
+ * stable import path for reporters/plugins that want hooks without the full
+ * DSL surface.
+ */
+export { addHook, afterAll, afterEach, beforeAll, beforeEach, } from "./suite.js";
+//# sourceMappingURL=lifecycle.js.map

package/dist/runtime/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/runtime/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACN,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,GACV,MAAM,YAAY,CAAC"}

package/dist/runtime/matchers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Matcher signature. Returns `{ pass, message }`:
+ *   - `pass`: whether the assertion holds.
+ *   - `message`: diagnostic message for the failure path. Called lazily to
+ *     avoid formatting cost when the matcher passes.
+ */
+export interface MatcherResult {
+    pass: boolean;
+    message(): string;
+}
+export type Matcher<Args extends unknown[] = unknown[]> = (received: unknown, ...args: Args) => MatcherResult;
+export interface SpyLike {
+    __helixIsSpy: true;
+    calls: unknown[][];
+    callCount: number;
+}
+export declare const matchers: {
+    toBe(received: unknown, expected: unknown): MatcherResult;
+    toEqual(received: unknown, expected: unknown): MatcherResult;
+    toMatchObject(received: unknown, expected: unknown): MatcherResult;
+    toContain(received: unknown, item: unknown): MatcherResult;
+    toMatch(received: unknown, expected: RegExp | string): MatcherResult;
+    toHaveLength(received: unknown, length: number): MatcherResult;
+    toBeDefined(received: unknown): MatcherResult;
+    toBeUndefined(received: unknown): MatcherResult;
+    toBeNull(received: unknown): MatcherResult;
+    toBeInstanceOf(received: unknown, ctor: unknown): MatcherResult;
+    toBeGreaterThan(received: unknown, expected: number | bigint): MatcherResult;
+    toBeGreaterThanOrEqual(received: unknown, expected: number | bigint): MatcherResult;
+    toBeLessThan(received: unknown, expected: number | bigint): MatcherResult;
+    toBeLessThanOrEqual(received: unknown, expected: number | bigint): MatcherResult;
+    toBeTruthy(received: unknown): MatcherResult;
+    toBeFalsy(received: unknown): MatcherResult;
+    toBeNaN(received: unknown): MatcherResult;
+    toThrow(received: unknown, expected?: string | RegExp | Error | (new (...args: unknown[]) => Error)): MatcherResult;
+    toHaveBeenCalled(received: unknown): MatcherResult;
+    toHaveBeenCalledTimes(received: unknown, n: number): MatcherResult;
+    toHaveBeenCalledWith(received: unknown, ...expectedArgs: unknown[]): MatcherResult;
+    toHaveBeenCalledOnce(received: unknown): MatcherResult;
+};
+export type MatcherName = keyof typeof matchers;
+//# sourceMappingURL=matchers.d.ts.map

package/dist/runtime/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../src/runtime/matchers.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,IAAI,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,OAAO,CAAC,IAAI,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,IAAI,CACzD,QAAQ,EAAE,OAAO,EACjB,GAAG,IAAI,EAAE,IAAI,KACT,aAAa,CAAC;AAEnB,MAAM,WAAW,OAAO;IACvB,YAAY,EAAE,IAAI,CAAC;IACnB,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CAClB;AAuCD,eAAO,MAAM,QAAQ;mBACL,OAAO,YAAY,OAAO,GAAG,aAAa;sBASvC,OAAO,YAAY,OAAO,GAAG,aAAa;4BASpC,OAAO,YAAY,OAAO,GAAG,aAAa;wBAS9C,OAAO,QAAQ,OAAO,GAAG,aAAa;sBAyBxC,OAAO,YAAY,MAAM,GAAG,MAAM,GAAG,aAAa;2BAmB7C,OAAO,UAAU,MAAM,GAAG,aAAa;0BAYxC,OAAO,GAAG,aAAa;4BAOrB,OAAO,GAAG,aAAa;uBAO5B,OAAO,GAAG,aAAa;6BAOjB,OAAO,QAAQ,OAAO,GAAG,aAAa;8BA+BrC,OAAO,YAAY,MAAM,GAAG,MAAM,GAAG,aAAa;qCAcjE,OAAO,YACP,MAAM,GAAG,MAAM,GACvB,aAAa;2BAaO,OAAO,YAAY,MAAM,GAAG,MAAM,GAAG,aAAa;kCAc9D,OAAO,YACP,MAAM,GAAG,MAAM,GACvB,aAAa;yBAaK,OAAO,GAAG,aAAa;wBAOxB,OAAO,GAAG,aAAa;sBAOzB,OAAO,GAAG,aAAa;sBAQ9B,OAAO,aACN,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,GACtE,aAAa;+BA4CW,OAAO,GAAG,aAAa;oCAelB,OAAO,KAAK,MAAM,GAAG,aAAa;mCAgBvD,OAAO,mBACA,OAAO,EAAE,GACxB,aAAa;mCAkBe,OAAO,GAAG,aAAa;CActD,CAAC;AA+DF,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,QAAQ,CAAC"}

package/dist/runtime/matchers.js

@@ -0,0 +1,375 @@
+import { equals, partialEquals } from "./equals.js";
+function isSpy(value) {
+    // Spies are callable, so `typeof` can be "function" OR "object".
+    if (!value || (typeof value !== "object" && typeof value !== "function")) {
+        return false;
+    }
+    const v = value;
+    return (v.__helixIsSpy === true &&
+        Array.isArray(v.calls) &&
+        typeof v.callCount === "number");
+}
+function repr(value, maxLen = 200) {
+    try {
+        if (typeof value === "string") {
+            const s = JSON.stringify(value);
+            return s.length > maxLen ? `${s.slice(0, maxLen)}..."` : s;
+        }
+        if (typeof value === "function") {
+            const src = value.toString();
+            return src.length > 40 ? `${src.slice(0, 40)}...` : src;
+        }
+        if (value === undefined)
+            return "undefined";
+        if (value === null)
+            return "null";
+        if (typeof value === "bigint")
+            return `${value}n`;
+        if (typeof value === "object") {
+            const json = JSON.stringify(value);
+            if (json === undefined)
+                return String(value);
+            return json.length > maxLen ? `${json.slice(0, maxLen)}...` : json;
+        }
+        return String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export const matchers = {
+    toBe(received, expected) {
+        const pass = Object.is(received, expected);
+        return {
+            pass,
+            message: () => `expected ${repr(received)} to be ${repr(expected)} (strict equality)`,
+        };
+    },
+    toEqual(received, expected) {
+        const pass = equals(received, expected);
+        return {
+            pass,
+            message: () => `expected ${repr(received)} to deep-equal ${repr(expected)}`,
+        };
+    },
+    toMatchObject(received, expected) {
+        const pass = partialEquals(received, expected);
+        return {
+            pass,
+            message: () => `expected ${repr(received)} to match subset ${repr(expected)}`,
+        };
+    },
+    toContain(received, item) {
+        let pass = false;
+        if (typeof received === "string" && typeof item === "string") {
+            pass = received.includes(item);
+        }
+        else if (Array.isArray(received)) {
+            // Deep equality so `.toContain({id:1})` works on arrays of objects.
+            pass = received.some((x) => equals(x, item));
+        }
+        else if (received instanceof Set) {
+            // Deep equality: consistent with the Array branch.
+            for (const v of received) {
+                if (equals(v, item)) {
+                    pass = true;
+                    break;
+                }
+            }
+        }
+        // NB: `toContain` intentionally does not support `Map` — its semantics
+        // (keys? values? entries?) are ambiguous. Users should use
+        // `expect([...map.keys()]).toContain(k)` explicitly.
+        return {
+            pass,
+            message: () => `expected ${repr(received)} to contain ${repr(item)}`,
+        };
+    },
+    toMatch(received, expected) {
+        if (typeof received !== "string") {
+            return {
+                pass: false,
+                message: () => `expected a string, got ${typeof received} (${repr(received)})`,
+            };
+        }
+        const pass = expected instanceof RegExp
+            ? expected.test(received)
+            : received.includes(expected);
+        return {
+            pass,
+            message: () => `expected "${received}" to match ${expected instanceof RegExp ? expected : `"${expected}"`}`,
+        };
+    },
+    toHaveLength(received, length) {
+        const actual = received && typeof received.length === "number"
+            ? received.length
+            : undefined;
+        return {
+            pass: actual === length,
+            message: () => `expected length ${length}, got ${actual === undefined ? "no .length" : actual} (value: ${repr(received)})`,
+        };
+    },
+    toBeDefined(received) {
+        return {
+            pass: received !== undefined,
+            message: () => `expected value to be defined, got undefined`,
+        };
+    },
+    toBeUndefined(received) {
+        return {
+            pass: received === undefined,
+            message: () => `expected value to be undefined, got ${repr(received)}`,
+        };
+    },
+    toBeNull(received) {
+        return {
+            pass: received === null,
+            message: () => `expected null, got ${repr(received)}`,
+        };
+    },
+    toBeInstanceOf(received, ctor) {
+        if (typeof ctor !== "function") {
+            return {
+                pass: false,
+                message: () => `expected a constructor, got ${typeof ctor}`,
+            };
+        }
+        // Arrow functions and bound functions without `prototype` are not
+        // constructible; `x instanceof arrowFn` throws TypeError. Reject
+        // upfront with a clean AssertionError instead of leaking the raw error.
+        const ctorFn = ctor;
+        if (ctorFn.prototype === undefined) {
+            return {
+                pass: false,
+                message: () => `expected a constructor (function with a prototype), got ${ctorFn.name ?? "anonymous"} (arrow / bound fn?)`,
+            };
+        }
+        let pass = false;
+        try {
+            pass = received instanceof ctor;
+        }
+        catch {
+            pass = false;
+        }
+        return {
+            pass,
+            message: () => `expected ${repr(received)} to be instance of ${ctorFn.name ?? "anonymous"}`,
+        };
+    },
+    toBeGreaterThan(received, expected) {
+        if (typeof received !== "number" && typeof received !== "bigint") {
+            return {
+                pass: false,
+                message: () => `expected a number or bigint, got ${typeof received}`,
+            };
+        }
+        return {
+            pass: compareGt(received, expected),
+            message: () => `expected ${received} to be > ${expected}`,
+        };
+    },
+    toBeGreaterThanOrEqual(received, expected) {
+        if (typeof received !== "number" && typeof received !== "bigint") {
+            return {
+                pass: false,
+                message: () => `expected a number or bigint, got ${typeof received}`,
+            };
+        }
+        return {
+            pass: compareGte(received, expected),
+            message: () => `expected ${received} to be >= ${expected}`,
+        };
+    },
+    toBeLessThan(received, expected) {
+        if (typeof received !== "number" && typeof received !== "bigint") {
+            return {
+                pass: false,
+                message: () => `expected a number or bigint, got ${typeof received}`,
+            };
+        }
+        return {
+            pass: compareLt(received, expected),
+            message: () => `expected ${received} to be < ${expected}`,
+        };
+    },
+    toBeLessThanOrEqual(received, expected) {
+        if (typeof received !== "number" && typeof received !== "bigint") {
+            return {
+                pass: false,
+                message: () => `expected a number or bigint, got ${typeof received}`,
+            };
+        }
+        return {
+            pass: compareLte(received, expected),
+            message: () => `expected ${received} to be <= ${expected}`,
+        };
+    },
+    toBeTruthy(received) {
+        return {
+            pass: Boolean(received),
+            message: () => `expected ${repr(received)} to be truthy`,
+        };
+    },
+    toBeFalsy(received) {
+        return {
+            pass: !received,
+            message: () => `expected ${repr(received)} to be falsy`,
+        };
+    },
+    toBeNaN(received) {
+        return {
+            pass: typeof received === "number" && Number.isNaN(received),
+            message: () => `expected ${repr(received)} to be NaN`,
+        };
+    },
+    toThrow(received, expected) {
+        if (typeof received !== "function") {
+            return {
+                pass: false,
+                message: () => `expected a function, got ${typeof received}`,
+            };
+        }
+        let error;
+        let returned;
+        try {
+            returned = received();
+        }
+        catch (err) {
+            error = err;
+        }
+        if (error === undefined &&
+            returned &&
+            typeof returned.then === "function") {
+            // Swallow the rejection so it doesn't become an unhandledRejection.
+            returned.catch(() => { });
+            return {
+                pass: false,
+                message: () => `expected function to throw synchronously, but it returned a Promise — use \`expect(fn()).rejects.toThrow(...)\` for async`,
+            };
+        }
+        if (error === undefined) {
+            return {
+                pass: false,
+                message: () => `expected function to throw, but it returned normally`,
+            };
+        }
+        if (expected === undefined) {
+            return { pass: true, message: () => `` };
+        }
+        const pass = matchThrownError(error, expected);
+        return {
+            pass,
+            message: () => `expected function to throw matching ${reprExpected(expected)}, got ${repr(error)}`,
+        };
+    },
+    toHaveBeenCalled(received) {
+        if (!isSpy(received)) {
+            return {
+                pass: false,
+                message: () => `toHaveBeenCalled requires a spy (from vi.fn/vi.spyOn); got ${repr(received)}`,
+            };
+        }
+        return {
+            pass: received.callCount > 0,
+            message: () => `expected spy to have been called at least once, but it wasn't`,
+        };
+    },
+    toHaveBeenCalledTimes(received, n) {
+        if (!isSpy(received)) {
+            return {
+                pass: false,
+                message: () => `toHaveBeenCalledTimes requires a spy; got ${repr(received)}`,
+            };
+        }
+        return {
+            pass: received.callCount === n,
+            message: () => `expected spy to be called ${n} times, got ${received.callCount}`,
+        };
+    },
+    toHaveBeenCalledWith(received, ...expectedArgs) {
+        if (!isSpy(received)) {
+            return {
+                pass: false,
+                message: () => `toHaveBeenCalledWith requires a spy; got ${repr(received)}`,
+            };
+        }
+        const pass = received.calls.some((actualArgs) => equals(actualArgs, expectedArgs));
+        return {
+            pass,
+            message: () => `expected spy to have been called with ${repr(expectedArgs)}\nActual calls: ${repr(received.calls)}`,
+        };
+    },
+    toHaveBeenCalledOnce(received) {
+        if (!isSpy(received)) {
+            return {
+                pass: false,
+                message: () => `toHaveBeenCalledOnce requires a spy; got ${repr(received)}`,
+            };
+        }
+        return {
+            pass: received.callCount === 1,
+            message: () => `expected spy to have been called exactly once, got ${received.callCount} calls`,
+        };
+    },
+};
+/**
+ * Cross-type numeric comparison: JS's `>` / `>=` operators accept mixed
+ * `number` and `bigint` operands, but TypeScript refuses the union. These
+ * helpers narrow through typeof so the comparison is fully typed.
+ */
+function compareGt(a, b) {
+    if (typeof a === "number" && typeof b === "number")
+        return a > b;
+    if (typeof a === "bigint" && typeof b === "bigint")
+        return a > b;
+    // Mixed number/bigint — JS's `>` operator accepts it at runtime. Coerce
+    // both sides to a common `number` view for the comparison; BigInt values
+    // outside Number range lose precision only when larger than 2^53, which
+    // is acceptable for ordering.
+    return Number(a) > Number(b);
+}
+function compareGte(a, b) {
+    if (typeof a === "number" && typeof b === "number")
+        return a >= b;
+    if (typeof a === "bigint" && typeof b === "bigint")
+        return a >= b;
+    return Number(a) >= Number(b);
+}
+function compareLt(a, b) {
+    if (typeof a === "number" && typeof b === "number")
+        return a < b;
+    if (typeof a === "bigint" && typeof b === "bigint")
+        return a < b;
+    return Number(a) < Number(b);
+}
+function compareLte(a, b) {
+    if (typeof a === "number" && typeof b === "number")
+        return a <= b;
+    if (typeof a === "bigint" && typeof b === "bigint")
+        return a <= b;
+    return Number(a) <= Number(b);
+}
+function matchThrownError(error, expected) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (typeof expected === "string")
+        return msg.includes(expected);
+    if (expected instanceof RegExp)
+        return expected.test(msg);
+    if (expected instanceof Error) {
+        return (error instanceof Error &&
+            msg === expected.message &&
+            Object.getPrototypeOf(error) === Object.getPrototypeOf(expected));
+    }
+    // Ctor.
+    return error instanceof expected;
+}
+function reprExpected(expected) {
+    if (typeof expected === "string")
+        return `"${expected}"`;
+    if (expected instanceof RegExp)
+        return String(expected);
+    if (expected instanceof Error)
+        return `${expected.constructor.name}("${expected.message}")`;
+    return expected.name ?? "anonymous";
+}
+//# sourceMappingURL=matchers.js.map