@unrift/core 0.2.1 → 0.4.0

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);
+}

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

@@ -0,0 +1,54 @@
+/**
+ * File system mocking - `mock.fs()`.
+ *
+ * Backed by `memfs` today (private implementation detail behind the
+ * `FakeFsBackend` interface). The plan is to swap memfs for a hand-rolled
+ * package later; consumers of this module should only depend on the public
+ * `FakeFsHandle` surface, not on memfs types directly.
+ *
+ * Interception is layered on Tier A module mocking - `mock.doMock` is
+ * called for `node:fs` and `node:fs/promises`, so the fake takes effect
+ * when test code does `await import("node:fs")` or `await import("node:fs/promises")`.
+ * Static `import { readFileSync } from "node:fs"` is NOT intercepted in
+ * Tier A (planned for Tier B). See the docs page for the explicit limit
+ * list and workarounds.
+ */
+/**
+ * `Volume.fromJSON()` accepts a path-to-content map. `null` represents an
+ * empty directory; strings are file contents.
+ */
+export type FakeFsState = Record<string, string | null>;
+/** Public handle returned by `mock.fs()`. */
+export interface FakeFsHandle {
+    /** Dump the current state as a path-to-content map. */
+    toJSON(): FakeFsState;
+    /** Replace the current state with the given map. */
+    fromJSON(state: FakeFsState): void;
+    /** Read a file's contents, or null if it doesn't exist. */
+    read(path: string): string | null;
+    /** Write a file, creating parent directories as needed. */
+    write(path: string, content: string): void;
+    /** Check whether a path exists in the fake fs. */
+    exists(path: string): boolean;
+    /** Delete a file. Returns true if something was removed. */
+    delete(path: string): boolean;
+    /** List entries in a directory. Returns an empty array if missing. */
+    list(dir: string): string[];
+    /**
+     * Unpatch node:fs and node:fs/promises for this handle's interception.
+     * Idempotent, and a no-op if a later mock.fs() call has already superseded
+     * this handle - so holding an old handle for snapshotting can't tear down
+     * the current volume's interception.
+     */
+    restore(): void;
+}
+/**
+ * Install an in-memory file system as `node:fs` and `node:fs/promises`
+ * for the duration of the test. Subsequent `await import("node:fs")`
+ * calls return the fake.
+ *
+ * Calling `mock.fs()` while a fake is already installed swaps in a fresh
+ * volume - the previous handle's references stop receiving updates.
+ */
+export declare function fs(initial?: FakeFsState): FakeFsHandle;
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/mock/fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;AAqFxD,6CAA6C;AAC7C,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,MAAM,IAAI,WAAW,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,2DAA2D;IAC3D,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAClC,2DAA2D;IAC3D,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,kDAAkD;IAClD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,4DAA4D;IAC5D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,sEAAsE;IACtE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAeD;;;;;;;GAOG;AACH,wBAAgB,EAAE,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,YAAY,CAkCtD"}

package/dist/esm/mock/fs.js

@@ -0,0 +1,125 @@
+/**
+ * File system mocking - `mock.fs()`.
+ *
+ * Backed by `memfs` today (private implementation detail behind the
+ * `FakeFsBackend` interface). The plan is to swap memfs for a hand-rolled
+ * package later; consumers of this module should only depend on the public
+ * `FakeFsHandle` surface, not on memfs types directly.
+ *
+ * Interception is layered on Tier A module mocking - `mock.doMock` is
+ * called for `node:fs` and `node:fs/promises`, so the fake takes effect
+ * when test code does `await import("node:fs")` or `await import("node:fs/promises")`.
+ * Static `import { readFileSync } from "node:fs"` is NOT intercepted in
+ * Tier A (planned for Tier B). See the docs page for the explicit limit
+ * list and workarounds.
+ */
+import { Volume, createFsFromVolume } from "memfs";
+import { doMock, unmock } from "./module.js";
+import { activeRestorers } from "./spy.js";
+/**
+ * The current implementation factory. Swap this single line when replacing
+ * memfs with a hand-rolled backend - no other code changes needed.
+ */
+function createBackend(initial) {
+    const vol = Volume.fromJSON(initial ?? {});
+    const fsExports = createFsFromVolume(vol);
+    // memfs's createFsFromVolume returns the fs surface; .promises is on it.
+    const fsPromisesExports = fsExports
+        .promises;
+    return {
+        fsExports,
+        fsPromisesExports,
+        toJSON: () => vol.toJSON(),
+        fromJSON: (state) => {
+            vol.reset();
+            vol.fromJSON(state);
+        },
+        readFile: (path) => {
+            try {
+                return vol.readFileSync(path, "utf8");
+            }
+            catch {
+                return null;
+            }
+        },
+        writeFile: (path, content) => {
+            // memfs throws if the parent directory doesn't exist; create it for
+            // ergonomic test code.
+            const lastSlash = path.lastIndexOf("/");
+            if (lastSlash > 0) {
+                vol.mkdirSync(path.slice(0, lastSlash), { recursive: true });
+            }
+            vol.writeFileSync(path, content);
+        },
+        exists: (path) => vol.existsSync(path),
+        remove: (path) => {
+            try {
+                vol.unlinkSync(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        list: (dir) => {
+            try {
+                return vol.readdirSync(dir);
+            }
+            catch {
+                return [];
+            }
+        },
+    };
+}
+// Process-global singleton: only one fake fs interception is active at a time.
+// Safe under sequential per-file execution + afterEach(restoreAll); parallel
+// per-file execution (see ISSUES.md) would need per-worker isolation.
+let activeBackend;
+const restoreFakeFs = () => {
+    if (!activeBackend)
+        return;
+    unmock("node:fs");
+    unmock("node:fs/promises");
+    activeBackend = undefined;
+    activeRestorers.delete(restoreFakeFs);
+};
+/**
+ * Install an in-memory file system as `node:fs` and `node:fs/promises`
+ * for the duration of the test. Subsequent `await import("node:fs")`
+ * calls return the fake.
+ *
+ * Calling `mock.fs()` while a fake is already installed swaps in a fresh
+ * volume - the previous handle's references stop receiving updates.
+ */
+export function fs(initial) {
+    // Tear down any existing fake before installing the new one so the
+    // module-mocking registrations don't stack.
+    if (activeBackend) {
+        unmock("node:fs");
+        unmock("node:fs/promises");
+    }
+    const backend = createBackend(initial);
+    activeBackend = backend;
+    doMock("node:fs", () => backend.fsExports);
+    doMock("node:fs/promises", () => backend.fsPromisesExports);
+    activeRestorers.add(restoreFakeFs);
+    const handle = {
+        toJSON: () => backend.toJSON(),
+        fromJSON: (state) => backend.fromJSON(state),
+        read: (path) => backend.readFile(path),
+        write: (path, content) => backend.writeFile(path, content),
+        exists: (path) => backend.exists(path),
+        delete: (path) => backend.remove(path),
+        list: (dir) => backend.list(dir),
+        // Only tear down the interception if THIS handle still owns it. A later
+        // mock.fs() call orphans this handle - its volume lives on for snapshot
+        // inspection, but restoring it must not rip out the newer volume's
+        // interception. On an orphaned handle this is a no-op (also makes restore
+        // idempotent: a second call finds activeBackend already cleared).
+        restore: () => {
+            if (activeBackend === backend)
+                restoreFakeFs();
+        },
+    };
+    return handle;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * `mock` namespace - single entry point for all mocking utilities.
+ *
+ * Both forms are supported:
+ *   import { mock } from "unrift";
+ *   mock.fn();
+ *   mock.spyOn(obj, "method");
+ *
+ *   import { spy, spyOn } from "unrift";
+ *   spy();
+ *
+ * They produce identical objects.
+ */
+import { spy, spyOn, isSpy, clearAllMocks, resetAllMocks, restoreAllMocks } from "./spy";
+import { mockObject, mockClass } from "./auto";
+import { stub, mockGlobal } from "./stub";
+import { mockFetch, mockFetchOnce } from "./fetch";
+import { useFakeTimers, useRealTimers, advanceTimersByTime, advanceTimersByTimeAsync, runAllTimers, runAllTimersAsync, runOnlyPendingTimers, runOnlyPendingTimersAsync, getTimerCount, setSystemTime, getRealSystemTime } from "./timers";
+import { doMock, unmock, listMockedSpecs, fromModule } from "./module";
+import { fs as mockFs } from "./fs";
+export { 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, };
+export type { Spy, MockState, MockResult, AnyFn } from "./spy";
+export type { MockFetch, FetchMatcher, MockResponseInit, MockFetchResponse, } from "./fetch";
+export type { UseFakeTimersOptions, FakeableApi } from "./timers";
+export type { LoaderMessage } from "./module";
+export type { FakeFsHandle, FakeFsState } from "./fs";
+/**
+ * Unified mock namespace. Mirrors Jest / Vitest naming so existing test
+ * code reads naturally:
+ *
+ *   mock.fn(impl?)            // spy()
+ *   mock.spyOn(obj, key)
+ *   mock.object(obj)          // auto-spy every method
+ *   mock.class(Ctor)          // auto-spy every method on instances
+ *   mock.global(key, value)   // stub on globalThis
+ *   mock.stub(target, key, value)
+ *   mock.clearAll()
+ *   mock.resetAll()
+ *   mock.restoreAll()
+ */
+export declare const mock: {
+    readonly fn: typeof spy;
+    readonly spyOn: typeof spyOn;
+    readonly object: typeof mockObject;
+    readonly class: typeof mockClass;
+    readonly global: typeof mockGlobal;
+    readonly stub: typeof stub;
+    readonly fetch: import("./fetch").MockFetch;
+    readonly fetchOnce: typeof mockFetchOnce;
+    readonly useFakeTimers: typeof useFakeTimers;
+    readonly useRealTimers: typeof useRealTimers;
+    readonly advanceTimersByTime: typeof advanceTimersByTime;
+    readonly advanceTimersByTimeAsync: typeof advanceTimersByTimeAsync;
+    readonly runAllTimers: typeof runAllTimers;
+    readonly runAllTimersAsync: typeof runAllTimersAsync;
+    readonly runOnlyPendingTimers: typeof runOnlyPendingTimers;
+    readonly runOnlyPendingTimersAsync: typeof runOnlyPendingTimersAsync;
+    readonly getTimerCount: typeof getTimerCount;
+    readonly setSystemTime: typeof setSystemTime;
+    readonly getRealSystemTime: typeof getRealSystemTime;
+    readonly doMock: typeof doMock;
+    readonly unmock: typeof unmock;
+    readonly fromModule: typeof fromModule;
+    readonly listMockedSpecs: typeof listMockedSpecs;
+    readonly fs: typeof mockFs;
+    readonly clearAll: typeof clearAllMocks;
+    readonly resetAll: typeof resetAllMocks;
+    readonly restoreAll: typeof restoreAllMocks;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mock/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,GAAG,EACH,KAAK,EACL,KAAK,EACL,aAAa,EACb,aAAa,EACb,eAAe,EAChB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EACL,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,aAAa,EACb,aAAa,EACb,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACvE,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,MAAM,CAAC;AAEpC,OAAO,EACL,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,CAAC;AAEF,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC/D,YAAY,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAClE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCP,CAAC"}

package/dist/esm/mock/index.js

@@ -0,0 +1,70 @@
+/**
+ * `mock` namespace - single entry point for all mocking utilities.
+ *
+ * Both forms are supported:
+ *   import { mock } from "unrift";
+ *   mock.fn();
+ *   mock.spyOn(obj, "method");
+ *
+ *   import { spy, spyOn } from "unrift";
+ *   spy();
+ *
+ * They produce identical objects.
+ */
+import { spy, spyOn, isSpy, clearAllMocks, resetAllMocks, restoreAllMocks, } from "./spy.js";
+import { mockObject, mockClass } from "./auto.js";
+import { stub, mockGlobal } from "./stub.js";
+import { mockFetch, mockFetchOnce } from "./fetch.js";
+import { useFakeTimers, useRealTimers, advanceTimersByTime, advanceTimersByTimeAsync, runAllTimers, runAllTimersAsync, runOnlyPendingTimers, runOnlyPendingTimersAsync, getTimerCount, setSystemTime, getRealSystemTime, } from "./timers.js";
+import { doMock, unmock, listMockedSpecs, fromModule } from "./module.js";
+import { fs as mockFs } from "./fs.js";
+export { 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, };
+/**
+ * Unified mock namespace. Mirrors Jest / Vitest naming so existing test
+ * code reads naturally:
+ *
+ *   mock.fn(impl?)            // spy()
+ *   mock.spyOn(obj, key)
+ *   mock.object(obj)          // auto-spy every method
+ *   mock.class(Ctor)          // auto-spy every method on instances
+ *   mock.global(key, value)   // stub on globalThis
+ *   mock.stub(target, key, value)
+ *   mock.clearAll()
+ *   mock.resetAll()
+ *   mock.restoreAll()
+ */
+export const mock = {
+    fn: spy,
+    spyOn,
+    object: mockObject,
+    class: mockClass,
+    global: mockGlobal,
+    stub,
+    fetch: mockFetch,
+    fetchOnce: mockFetchOnce,
+    useFakeTimers,
+    useRealTimers,
+    advanceTimersByTime,
+    advanceTimersByTimeAsync,
+    runAllTimers,
+    runAllTimersAsync,
+    runOnlyPendingTimers,
+    runOnlyPendingTimersAsync,
+    getTimerCount,
+    setSystemTime,
+    getRealSystemTime,
+    // Tier A module mocking - dynamic imports of external specs only.
+    // The hoisted `mock.module(spec, factory)` for static imports is
+    // planned for Tier B and intentionally not exposed yet.
+    doMock,
+    unmock,
+    fromModule,
+    listMockedSpecs,
+    // File system mocking - backed by memfs, layered on Tier A module
+    // mocking. Works with `await import("node:fs")`; static imports of
+    // node:fs are not intercepted yet (planned for Tier B).
+    fs: mockFs,
+    clearAll: clearAllMocks,
+    resetAll: resetAllMocks,
+    restoreAll: restoreAllMocks,
+};