@unrift/core 0.3.0 → 0.4.0

package/bin/unrift.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 "use strict";
 
-// Run the real CLI
+// Run the real CLI. The CLI installs the module-mock loader itself
+// (see src/mock/register-loader.ts), so this bin stays a thin entry point.
 await import("../dist/esm/cli.js");

package/dist/esm/cli.js

@@ -2,8 +2,13 @@
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { registerModuleLoader } from "./mock/register-loader.js";
 import { runTestsCLI, watchTestsCLI } from "./runner.js";
 import { safeRegExp } from "./utils/helpers.js";
+// Install the module-mock loader before any test file is imported. Both the
+// core bin and the unrift wrapper bin run this CLI, so this is the single
+// place module mocking is bootstrapped.
+registerModuleLoader();
 const __cliDir = dirname(fileURLToPath(import.meta.url));
 function readVersion() {
     // Walk up from current file to find package.json (works from both src/ and dist/esm/)

package/dist/esm/expect.d.ts

@@ -28,6 +28,18 @@ export interface Matchers<T> {
     toBeFinite(): void | Promise<void>;
     toMatchObject(expected: Record<string, unknown>): void | Promise<void>;
     toHaveProperty(path: string | readonly string[], value?: unknown): void | Promise<void>;
+    toHaveBeenCalled(): void | Promise<void>;
+    toHaveBeenCalledTimes(expected: number): void | Promise<void>;
+    toHaveBeenCalledWith(...args: unknown[]): void | Promise<void>;
+    toHaveBeenLastCalledWith(...args: unknown[]): void | Promise<void>;
+    toHaveBeenNthCalledWith(n: number, ...args: unknown[]): void | Promise<void>;
+    toHaveReturned(): void | Promise<void>;
+    toHaveReturnedTimes(expected: number): void | Promise<void>;
+    toHaveReturnedWith(expected: unknown): void | Promise<void>;
+    toHaveLastReturnedWith(expected: unknown): void | Promise<void>;
+    toHaveNthReturnedWith(n: number, expected: unknown): void | Promise<void>;
+    toHaveFetched(urlOrMatcher: string | RegExp | ((req: Request) => boolean)): void | Promise<void>;
+    toHaveFetchedTimes(expected: number): void | Promise<void>;
     readonly not: Matchers<T>;
     readonly resolves: Matchers<Awaited<T>>;
     readonly rejects: Matchers<unknown>;

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

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

package/dist/esm/index.d.ts

@@ -6,4 +6,6 @@ export type { Matchers, ExpectInterface } from "./expect";
 export type { MatcherContext, MatcherFn, MatcherMap, Promisable, } from "./types";
 export { runEngine } from "./run";
 export type { RunEngineResult } from "./run";
+export { mock, spy, spyOn, isSpy, mockObject, mockClass, stub, mockGlobal, mockFetch, mockFetchOnce, useFakeTimers, useRealTimers, advanceTimersByTime, advanceTimersByTimeAsync, runAllTimers, runAllTimersAsync, runOnlyPendingTimers, runOnlyPendingTimersAsync, getTimerCount, setSystemTime, getRealSystemTime, doMock, unmock, listMockedSpecs, fromModule, mockFs, clearAllMocks, resetAllMocks, restoreAllMocks, } from "./mock/index";
+export type { Spy, MockState, MockResult, MockFetch, FetchMatcher, MockResponseInit, MockFetchResponse, UseFakeTimersOptions, FakeableApi, LoaderMessage, FakeFsHandle, FakeFsState, } from "./mock/index";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAElD,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC1D,YAAY,EACV,cAAc,EACd,SAAS,EACT,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClC,YAAY,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAElD,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC1D,YAAY,EACV,cAAc,EACd,SAAS,EACT,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClC,YAAY,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAG7C,OAAO,EACL,IAAI,EACJ,GAAG,EACH,KAAK,EACL,KAAK,EACL,UAAU,EACV,SAAS,EACT,IAAI,EACJ,UAAU,EACV,SAAS,EACT,aAAa,EACb,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,MAAM,EACN,MAAM,EACN,eAAe,EACf,UAAU,EACV,MAAM,EACN,aAAa,EACb,aAAa,EACb,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,GAAG,EACH,SAAS,EACT,UAAU,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,YAAY,EACZ,WAAW,GACZ,MAAM,cAAc,CAAC"}

package/dist/esm/index.js

@@ -3,3 +3,5 @@ export { defineConfig } from "./utils/defineConfig.js";
 export { describe, it, test } from "./interface.js";
 export { expect, extendMatchers } from "./expect.js";
 export { runEngine } from "./run.js";
+// Mocking suite
+export { mock, spy, spyOn, isSpy, mockObject, mockClass, stub, mockGlobal, mockFetch, mockFetchOnce, useFakeTimers, useRealTimers, advanceTimersByTime, advanceTimersByTimeAsync, runAllTimers, runAllTimersAsync, runOnlyPendingTimers, runOnlyPendingTimersAsync, getTimerCount, setSystemTime, getRealSystemTime, doMock, unmock, listMockedSpecs, fromModule, mockFs, clearAllMocks, resetAllMocks, restoreAllMocks, } from "./mock/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../src/matchers.ts"],"names":[],"mappings":"AA8DA,wBAAgB,sBAAsB,SAMrC;AAED,wBAAgB,aAAa,SAE5B"}
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../src/matchers.ts"],"names":[],"mappings":"AAyGA,wBAAgB,sBAAsB,SAMrC;AAED,wBAAgB,aAAa,SAE5B"}

package/dist/esm/matchers.js

@@ -1,8 +1,41 @@
 import { expect } from "./expect.js";
+import { isSpy } from "./mock/spy.js";
+import { isFetchMock } from "./mock/fetch.js";
 import { deepEqual } from "./utils/deepEqual.js";
 import { looseEqual } from "./utils/looseEqual.js";
+import { regexTest } from "./utils/helpers.js";
 import { toThrow } from "./utils/toThrow.js";
 let matchersRegistered = false;
+function ensureSpy(received, matcherName) {
+    if (!isSpy(received)) {
+        throw new Error(`${matcherName}() requires a spy or mock function (created via spy() or spyOn()), ` +
+            `but received ${typeof received === "object" ? Object.prototype.toString.call(received) : typeof received}`);
+    }
+}
+function ensureFetchMock(received, matcherName) {
+    if (!isFetchMock(received)) {
+        throw new Error(`${matcherName}() requires \`mock.fetch\` as the received value, ` +
+            `but received ${typeof received === "object" ? Object.prototype.toString.call(received) : typeof received}`);
+    }
+}
+function matchesFetchTarget(req, target) {
+    if (typeof target === "string")
+        return req.url === target;
+    if (target instanceof RegExp)
+        return regexTest(target, req.url);
+    if (typeof target === "function")
+        return Boolean(target(req));
+    return false;
+}
+function argsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!looseEqual(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
 function partialMatch(received, expected) {
     if (expected === null || typeof expected !== "object") {
         return looseEqual(received, expected);
@@ -163,7 +196,7 @@ function registerCoreMatchers() {
             }
             const pass = typeof expected === "string"
                 ? received.includes(expected)
-                : expected.test(received);
+                : regexTest(expected, received);
             if (this.isNot ? pass : !pass)
                 throw new Error(this.diff(received, expected));
         },
@@ -219,6 +252,133 @@ function registerCoreMatchers() {
                 throw new Error(this.diff(received, expected));
             }
         },
+        toHaveBeenCalled(received) {
+            ensureSpy(received, "toHaveBeenCalled");
+            const pass = received.mock.calls.length > 0;
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(`${received.getMockName()} called ${received.mock.calls.length} time(s)`, "to have been called"));
+            }
+        },
+        toHaveBeenCalledTimes(received, expected) {
+            ensureSpy(received, "toHaveBeenCalledTimes");
+            if (typeof expected !== "number" || !Number.isFinite(expected)) {
+                throw new Error(this.diff(expected, "toHaveBeenCalledTimes() requires a finite number"));
+            }
+            const actual = received.mock.calls.length;
+            const pass = actual === expected;
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(actual, expected));
+            }
+        },
+        toHaveBeenCalledWith(received, ...expectedArgs) {
+            ensureSpy(received, "toHaveBeenCalledWith");
+            const pass = received.mock.calls.some((call) => argsEqual(call, expectedArgs));
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(received.mock.calls, expectedArgs));
+            }
+        },
+        toHaveBeenLastCalledWith(received, ...expectedArgs) {
+            ensureSpy(received, "toHaveBeenLastCalledWith");
+            const last = received.mock.lastCall;
+            const pass = last !== undefined && argsEqual(last, expectedArgs);
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(last ?? "no calls", expectedArgs));
+            }
+        },
+        toHaveBeenNthCalledWith(received, n, ...expectedArgs) {
+            ensureSpy(received, "toHaveBeenNthCalledWith");
+            if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+                throw new Error(this.diff(n, "toHaveBeenNthCalledWith() requires a 1-indexed integer"));
+            }
+            const call = received.mock.calls[n - 1];
+            const pass = call !== undefined && argsEqual(call, expectedArgs);
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(call ?? `call #${n} not found`, expectedArgs));
+            }
+        },
+        toHaveReturned(received) {
+            ensureSpy(received, "toHaveReturned");
+            const pass = received.mock.results.some((r) => r.type === "return");
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(`${received.mock.results.length} result(s)`, "at least one successful return"));
+            }
+        },
+        toHaveReturnedTimes(received, expected) {
+            ensureSpy(received, "toHaveReturnedTimes");
+            if (typeof expected !== "number" || !Number.isFinite(expected)) {
+                throw new Error(this.diff(expected, "toHaveReturnedTimes() requires a finite number"));
+            }
+            const actual = received.mock.results.filter((r) => r.type === "return").length;
+            const pass = actual === expected;
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(actual, expected));
+            }
+        },
+        toHaveReturnedWith(received, expected) {
+            ensureSpy(received, "toHaveReturnedWith");
+            const pass = received.mock.results.some((r) => r.type === "return" && looseEqual(r.value, expected));
+            if (this.isNot ? pass : !pass) {
+                const returnValues = received.mock.results
+                    .filter((r) => r.type === "return")
+                    .map((r) => r.value);
+                throw new Error(this.diff(returnValues, expected));
+            }
+        },
+        toHaveLastReturnedWith(received, expected) {
+            ensureSpy(received, "toHaveLastReturnedWith");
+            const results = received.mock.results;
+            const last = results[results.length - 1];
+            const pass = last !== undefined &&
+                last.type === "return" &&
+                looseEqual(last.value, expected);
+            if (this.isNot ? pass : !pass) {
+                if (last === undefined) {
+                    throw new Error(this.diff("no calls", expected));
+                }
+                if (last.type === "throw") {
+                    throw new Error(this.diff("last call threw", expected));
+                }
+                throw new Error(this.diff(last.value, expected));
+            }
+        },
+        toHaveNthReturnedWith(received, n, expected) {
+            ensureSpy(received, "toHaveNthReturnedWith");
+            if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+                throw new Error(this.diff(n, "toHaveNthReturnedWith() requires a 1-indexed integer"));
+            }
+            const result = received.mock.results[n - 1];
+            const pass = result !== undefined &&
+                result.type === "return" &&
+                looseEqual(result.value, expected);
+            if (this.isNot ? pass : !pass) {
+                if (result === undefined) {
+                    throw new Error(this.diff(`call #${n} not found`, expected));
+                }
+                if (result.type === "throw") {
+                    throw new Error(this.diff(`call #${n} threw`, expected));
+                }
+                throw new Error(this.diff(result.value, expected));
+            }
+        },
+        toHaveFetched(received, target) {
+            ensureFetchMock(received, "toHaveFetched");
+            const pass = received.calls.some((req) => matchesFetchTarget(req, target));
+            if (this.isNot ? pass : !pass) {
+                const urls = received.calls.map((r) => `${r.method} ${r.url}`);
+                throw new Error(this.diff(urls, target));
+            }
+        },
+        toHaveFetchedTimes(received, expected) {
+            ensureFetchMock(received, "toHaveFetchedTimes");
+            if (typeof expected !== "number" || !Number.isFinite(expected)) {
+                throw new Error(this.diff(expected, "toHaveFetchedTimes() requires a finite number"));
+            }
+            const actual = received.calls.length;
+            const pass = actual === expected;
+            if (this.isNot ? pass : !pass) {
+                throw new Error(this.diff(actual, expected));
+            }
+        },
         toHaveProperty(received, path, ...rest) {
             if (received === null || typeof received !== "object") {
                 throw new Error(this.diff(received, "expected an object for toHaveProperty()"));

package/dist/esm/mock/auto.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Auto-mocking helpers: `mock.object` and `mock.class`.
+ *
+ * Both walk own + prototype methods and replace each function with a spy.
+ * Restoration uses the same registry as `spyOn`, so `mock.restoreAll()`
+ * cleans up auto mocks too.
+ */
+/**
+ * Replace every method on `obj` (own + inherited, excluding Object.prototype)
+ * with a spy. Returns the same reference, mutated in place.
+ *
+ * Cleanup happens via `mock.restoreAll()` - auto-mock spies share the same
+ * restorer registry as `spyOn`.
+ */
+export declare function mockObject<T extends object>(obj: T): T;
+/**
+ * Wrap a constructor so every instance is auto-mocked, and so static
+ * methods on the constructor itself are spied too. Returns a Proxy that
+ * is `instanceof`-compatible with the original.
+ *
+ * Instance methods are spied as OWN properties on each instance (shadowing
+ * the prototype), NOT by mutating the shared prototype. This keeps call
+ * state per-instance (a.run and b.run are separate spies) and leaves the
+ * class prototype untouched - nothing to restore, nothing to leak.
+ */
+export declare function mockClass<T extends new (...args: any[]) => any>(Ctor: T): T;
+//# sourceMappingURL=auto.d.ts.map

package/dist/esm/mock/auto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto.d.ts","sourceRoot":"","sources":["../../../src/mock/auto.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+CH;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAatD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAEvB,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACrC,IAAI,EAAE,CAAC,GAAG,CAAC,CA8BZ"}

package/dist/esm/mock/auto.js

@@ -0,0 +1,108 @@
+/**
+ * Auto-mocking helpers: `mock.object` and `mock.class`.
+ *
+ * Both walk own + prototype methods and replace each function with a spy.
+ * Restoration uses the same registry as `spyOn`, so `mock.restoreAll()`
+ * cleans up auto mocks too.
+ */
+import { spy, spyOn } from "./spy.js";
+/**
+ * Walks the chain from `target` up to (but not including) the built in
+ * `Object.prototype` and `Function.prototype`, yielding every own method
+ * key encountered. Spying on built in prototypes (`apply`, `call`, etc.)
+ * would recurse into the spy machinery itself.
+ */
+function* enumerableMethodKeys(target) {
+    const seen = new Set();
+    let current = target;
+    while (current &&
+        current !== Object.prototype &&
+        current !== Function.prototype) {
+        for (const key of Reflect.ownKeys(current)) {
+            if (seen.has(key))
+                continue;
+            // Skip the `constructor` property, replacing it would break
+            // `instance.constructor` checks and is rarely what callers want.
+            if (key === "constructor")
+                continue;
+            // Built in `Function` properties on a constructor we don't want to
+            // wrap (length / name are non-writable; prototype is structural).
+            if (key === "length" || key === "name" || key === "prototype")
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (!descriptor)
+                continue;
+            // Skip getters/setters: spyOn would invoke the getter to read the
+            // current value, which can have side effects. Track separately.
+            if (descriptor.get || descriptor.set)
+                continue;
+            if (typeof descriptor.value !== "function")
+                continue;
+            if (descriptor.configurable === false)
+                continue;
+            seen.add(key);
+            yield { host: current, key };
+        }
+        current = Object.getPrototypeOf(current);
+    }
+}
+/**
+ * Replace every method on `obj` (own + inherited, excluding Object.prototype)
+ * with a spy. Returns the same reference, mutated in place.
+ *
+ * Cleanup happens via `mock.restoreAll()` - auto-mock spies share the same
+ * restorer registry as `spyOn`.
+ */
+export function mockObject(obj) {
+    for (const { host, key } of enumerableMethodKeys(obj)) {
+        try {
+            spyOn(host, key);
+        }
+        catch {
+            /** Non-configurable properties (e.g. some built ins), skip silently.
+             * Test code targeting these would fail clearly when the spy methods
+             * aren't found. We don't want auto mock to throw on the first such key.
+             */
+        }
+    }
+    return obj;
+}
+/**
+ * Wrap a constructor so every instance is auto-mocked, and so static
+ * methods on the constructor itself are spied too. Returns a Proxy that
+ * is `instanceof`-compatible with the original.
+ *
+ * Instance methods are spied as OWN properties on each instance (shadowing
+ * the prototype), NOT by mutating the shared prototype. This keeps call
+ * state per-instance (a.run and b.run are separate spies) and leaves the
+ * class prototype untouched - nothing to restore, nothing to leak.
+ */
+export function mockClass(Ctor) {
+    // Spy static methods on the constructor itself (mutates Ctor in place;
+    // statics are own properties of Ctor, so spyOn restores them normally).
+    mockObject(Ctor);
+    return new Proxy(Ctor, {
+        construct(target, args, newTarget) {
+            const instance = Reflect.construct(target, args, newTarget);
+            for (const { host, key } of enumerableMethodKeys(instance)) {
+                if (host === instance) {
+                    // Own method (assigned in the constructor): spy in place.
+                    spyOn(instance, key);
+                }
+                else {
+                    // Inherited method: shadow it with an own-property spy that passes
+                    // through to the prototype implementation. The prototype itself is
+                    // never modified.
+                    const protoMethod = host[key];
+                    Object.defineProperty(instance, key, {
+                        value: spy(protoMethod),
+                        writable: true,
+                        configurable: true,
+                        enumerable: false,
+                    });
+                }
+            }
+            return instance;
+        },
+    });
+}

package/dist/esm/mock/fetch.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `mock.fetch` - stub `globalThis.fetch` for HTTP testing.
+ *
+ * Handlers are matched against requests in registration order; the first
+ * matching handler wins. `mock.fetchOnce()` registers a single-use handler
+ * that's consumed after its first match.
+ *
+ * Restoration:
+ *   - `mock.fetch.restore()` un-patches global fetch and clears handlers
+ *   - `mock.restoreAll()` does the same as part of bulk cleanup
+ */
+/** Brand applied to `mock.fetch` so matchers can verify their received value. */
+export declare const FETCH_MOCK_BRAND: unique symbol;
+/**
+ * Derive WebFetch helper types from the runtime constructors so we don't
+ * have to widen the project's `lib` config to include `dom` types. These
+ * match what the platform actually accepts.
+ */
+type HeadersInitLike = ConstructorParameters<typeof Headers>[0];
+type BodyInitLike = ConstructorParameters<typeof Response>[0];
+/** What can be passed as the first argument to `mock.fetch(matcher, ...)`. */
+export type FetchMatcher = string | RegExp | ((req: Request) => boolean | Promise<boolean>);
+export interface MockResponseInit {
+    status?: number;
+    statusText?: string;
+    headers?: HeadersInitLike;
+    body?: BodyInitLike | null;
+    json?: unknown;
+}
+export type MockFetchResponse = Response | MockResponseInit | ((req: Request) => Response | MockResponseInit | Promise<Response | MockResponseInit>);
+/**
+ * Public surface for `mock.fetch`. Callable to register a handler, with
+ * attached helpers for inspection and cleanup.
+ */
+export interface MockFetch {
+    (matcher: FetchMatcher, response: MockFetchResponse): void;
+    once(matcher: FetchMatcher, response: MockFetchResponse): void;
+    readonly calls: Request[];
+    reset(): void;
+    restore(): void;
+    readonly [FETCH_MOCK_BRAND]: true;
+}
+export declare function isFetchMock(value: unknown): value is MockFetch;
+export declare const mockFetch: MockFetch;
+export declare function mockFetchOnce(matcher: FetchMatcher, response: MockFetchResponse): void;
+export {};
+//# sourceMappingURL=fetch.d.ts.map

package/dist/esm/mock/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/mock/fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAuC,CAAC;AAE9E;;;;GAIG;AACH,KAAK,eAAe,GAAG,qBAAqB,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAChE,KAAK,YAAY,GAAG,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAG9D,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,MAAM,GACN,CAAC,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;AAGnD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,IAAI,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAGD,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,gBAAgB,GAChB,CAAC,CACC,GAAG,EAAE,OAAO,KACT,QAAQ,GAAG,gBAAgB,GAAG,OAAO,CAAC,QAAQ,GAAG,gBAAgB,CAAC,CAAC,CAAC;AAuI7E;;;GAGG;AACH,MAAM,WAAW,SAAS;IAExB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAE3D,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAE/D,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC;IAE1B,KAAK,IAAI,IAAI,CAAC;IAEd,OAAO,IAAI,IAAI,CAAC;IAEhB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC;CACnC;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAK9D;AA2BD,eAAO,MAAM,SAAS,EAAE,SAAyB,CAAC;AAElD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAEN"}

package/dist/esm/mock/fetch.js

@@ -0,0 +1,149 @@
+/**
+ * `mock.fetch` - stub `globalThis.fetch` for HTTP testing.
+ *
+ * Handlers are matched against requests in registration order; the first
+ * matching handler wins. `mock.fetchOnce()` registers a single-use handler
+ * that's consumed after its first match.
+ *
+ * Restoration:
+ *   - `mock.fetch.restore()` un-patches global fetch and clears handlers
+ *   - `mock.restoreAll()` does the same as part of bulk cleanup
+ */
+import { activeRestorers } from "./spy.js";
+import { regexTest } from "../utils/helpers.js";
+/** Brand applied to `mock.fetch` so matchers can verify their received value. */
+export const FETCH_MOCK_BRAND = Symbol.for("unrift.fetchMock");
+// Process-global singleton state. Correct because unrift runs spec files
+// sequentially in one process and afterEach(restoreAll) resets between tests.
+// Parallel per-file execution (see ISSUES.md) would need per-worker isolation.
+const handlers = [];
+const calls = [];
+let originalFetch;
+// Whether globalThis had a `fetch` at install time. If it didn't (older Node,
+// custom runtimes), restore must DELETE our patch rather than leave it - the
+// original state was "fetch is absent", and `originalFetch` being undefined
+// must not be mistaken for "nothing to restore".
+let fetchWasDefined = false;
+let installed = false;
+function urlOf(req) {
+    return req.url;
+}
+async function matches(handler, req) {
+    if (handler.consumed)
+        return false;
+    const m = handler.matcher;
+    if (typeof m === "string")
+        return urlOf(req) === m;
+    if (m instanceof RegExp)
+        return regexTest(m, urlOf(req));
+    if (typeof m === "function")
+        return Boolean(await m(req));
+    return false;
+}
+async function buildResponse(spec, req) {
+    let resolved;
+    if (typeof spec === "function") {
+        resolved = await spec(req);
+    }
+    else {
+        resolved = spec;
+    }
+    if (resolved instanceof Response)
+        return resolved;
+    const init = resolved;
+    let body = init.body;
+    const headers = new Headers(init.headers);
+    if (init.json !== undefined) {
+        body = JSON.stringify(init.json);
+        if (!headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+        }
+    }
+    return new Response(body ?? null, {
+        status: init.status ?? 200,
+        statusText: init.statusText,
+        headers,
+    });
+}
+function patchedFetch(input, init) {
+    /**
+     * Normalize all call shapes - `fetch(url)`, `fetch(url, init)`,
+     * `fetch(new Request(...))`, `fetch(new Request(...), init)` into a
+     * single Request object that handlers can introspect.
+     */
+    const req = input instanceof Request
+        ? new Request(input, init)
+        : new Request(input, init);
+    calls.push(req);
+    return (async () => {
+        for (const handler of handlers) {
+            if (await matches(handler, req)) {
+                if (handler.once)
+                    handler.consumed = true;
+                return buildResponse(handler.response, req);
+            }
+        }
+        throw new Error(`No mock.fetch handler matched: ${req.method} ${req.url}`);
+    })();
+}
+function install() {
+    if (installed)
+        return;
+    installed = true;
+    // `in` checks presence without triggering Node's lazy fetch getter.
+    fetchWasDefined = "fetch" in globalThis;
+    originalFetch = globalThis.fetch;
+    globalThis.fetch = patchedFetch;
+    activeRestorers.add(restoreFetch);
+}
+function restoreFetch() {
+    if (!installed)
+        return;
+    installed = false;
+    if (fetchWasDefined) {
+        globalThis.fetch = originalFetch;
+    }
+    else {
+        // fetch didn't exist before we patched it - remove our patch so the
+        // environment reads `undefined` again, rather than leaking the stale mock.
+        delete globalThis.fetch;
+    }
+    originalFetch = undefined;
+    fetchWasDefined = false;
+    handlers.length = 0;
+    calls.length = 0;
+    activeRestorers.delete(restoreFetch);
+}
+function register(matcher, response, once) {
+    install();
+    handlers.push({ matcher, response, once, consumed: false });
+}
+// Type guard used by toHaveFetched / toHaveFetchedTimes matchers.
+export function isFetchMock(value) {
+    return (typeof value === "function" &&
+        value[FETCH_MOCK_BRAND] === true);
+}
+const mockFetchImpl = ((matcher, response) => register(matcher, response, false));
+mockFetchImpl.once = (matcher, response) => register(matcher, response, true);
+mockFetchImpl.reset = () => {
+    handlers.length = 0;
+    calls.length = 0;
+};
+mockFetchImpl.restore = restoreFetch;
+Object.defineProperty(mockFetchImpl, "calls", {
+    // Return a snapshot copy, not the internal array, so callers can't mutate
+    // recorded state (e.g. push/splice) and corrupt later assertions.
+    get: () => calls.slice(),
+    enumerable: true,
+    configurable: false,
+});
+Object.defineProperty(mockFetchImpl, FETCH_MOCK_BRAND, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+});
+export const mockFetch = mockFetchImpl;
+export function mockFetchOnce(matcher, response) {
+    mockFetch.once(matcher, response);
+}