@kasperpeulen/vitest-plugin-nextjs 0.0.0-alpha.0 → 0.1.0-alpha.0

package/dist/build-output.js

@@ -0,0 +1,216 @@
+import { actionModulePrefix, registry } from "./registry.js";
+import { RSC_SUFFIX, normalizePagePath } from "./compat/ssr/build-output.js";
+import { nextConfig, preview, routesManifest, routing } from "virtual:vitest-plugin-rsc/next-manifest";
+//#region src/build-output.ts
+const anyKey = (create) => new Proxy({}, {
+	get: (_, key) => typeof key === "string" ? create(key) : void 0,
+	has: () => true
+});
+const stylesheets = /* @__PURE__ */ new Map();
+const fontFiles = /* @__PURE__ */ new Map();
+function setStylesheets(of) {
+	for (const [file, entries] of Object.entries(of)) {
+		stylesheets.set(file, entries.map(({ path, content }) => content === void 0 ? {
+			path,
+			inlined: false
+		} : {
+			path,
+			inlined: true,
+			content
+		}));
+		const fonts = entries.flatMap((entry) => entry.fonts ?? []);
+		if (fonts.length === 0) fontFiles.delete(file);
+		else fontFiles.set(file, fonts.filter((font) => /\.p\.(?:woff|woff2|eot|ttf|otf)$/.test(font)));
+	}
+}
+const nextFontManifest = {
+	pages: {},
+	app: new Proxy({}, {
+		get: (_, key) => typeof key === "string" ? fontFiles.get(key) : void 0,
+		has: (_, key) => typeof key === "string" && fontFiles.has(key)
+	}),
+	appUsingSizeAdjust: false,
+	pagesUsingSizeAdjust: false
+};
+const clientReference = anyKey((id) => anyKey((name) => ({
+	id,
+	name,
+	chunks: [],
+	async: true
+})));
+const clientReferenceManifest = {
+	moduleLoading: {
+		prefix: "",
+		crossOrigin: null
+	},
+	clientModules: anyKey((id) => ({
+		id,
+		name: "*",
+		chunks: [],
+		async: true
+	})),
+	ssrModuleMapping: clientReference,
+	rscModuleMapping: clientReference,
+	entryCSSFiles: anyKey((file) => stylesheets.get(file) ?? []),
+	entryJSFiles: anyKey(() => [])
+};
+const buildManifest = {
+	polyfillFiles: [],
+	rootMainFiles: ["static/chunks/main-app.js"],
+	devFiles: [],
+	lowPriorityFiles: [],
+	pages: {}
+};
+let serverActions = {};
+function setServerActions(ids) {
+	serverActions = Object.fromEntries(Array.from(ids, (id) => [id, {
+		workers: anyKey(() => ({
+			moduleId: actionModulePrefix + id,
+			async: true
+		})),
+		layer: {}
+	}]));
+}
+let prerenderManifest = {
+	version: 4,
+	routes: {},
+	dynamicRoutes: {},
+	notFoundRoutes: [],
+	preview
+};
+/**
+* Lists what Next's build prerenders of a route, by its verdict: the entries
+* of the prerender manifest that Next's handler reads. With them the handler
+* prerenders a pathname at its first request, keeps it, and serves it from
+* then on, as `next start` serves what the build prerendered. Without the
+* `revalidate` the build writes: Next's cache reads it for a page the build
+* prerendered, and here every page is first prerendered by the handler,
+* which keeps the `revalidate` of the render with it.
+*/
+function recordRoute(route, verdict) {
+	if (!verdict) return;
+	const { pathname: srcRoute, kind } = route;
+	const dataRouteOf = (pathname) => kind === "page" ? `${normalizePagePath(pathname)}${RSC_SUFFIX}` : null;
+	for (const pathname of verdict.pathnames) prerenderManifest.routes[pathname] = {
+		srcRoute,
+		dataRoute: dataRouteOf(pathname)
+	};
+	if (verdict.fallback !== void 0) prerenderManifest = {
+		...prerenderManifest,
+		dynamicRoutes: {
+			...prerenderManifest.dynamicRoutes,
+			[srcRoute]: {
+				fallback: verdict.fallback,
+				dataRoute: dataRouteOf(srcRoute)
+			}
+		}
+	};
+}
+const built = /* @__PURE__ */ new Set();
+/** Forgets what the build kept, as the server's cache forgets its entries. */
+function forgetBuilt() {
+	built.clear();
+}
+/**
+* A page as the build keeps it, which Next's handler is about to keep for
+* `pathname`, at the first prerender of that pathname in this `generation`
+* of the cache. The build keeps a page of a parallel route's slot without a
+* status (`export/routes/app-page.js:126-141`), which `next start` serves
+* with 200: a page whose other slots have no page for its path renders the
+* not-found page there, which a page load shows, and a navigation, which
+* keeps the other slots as they are, does not. Next's handler would keep
+* the status of its render, 404, and Next's router takes a navigation that
+* answers 404 for a page load. So the entry gets 200, in place: the handler
+* answers the request of its prerender with the status of the entry it
+* keeps, and otherwise with the one its render set. `route` is the source
+* of the entry, the page, as Next's response cache hands it to the cache.
+*/
+function keptAsBuilt(pathname, value, { route }, generation) {
+	if (value?.kind !== "APP_PAGE" || !(pathname in prerenderManifest.routes)) return;
+	const key = `${generation}:${pathname}`;
+	if (built.has(key)) return;
+	built.add(key);
+	if (value.status !== void 0 && /\/@\w+/.test(route?.sourceRoute ?? "")) value.status = 200;
+}
+let hidden;
+/**
+* Hands Next's handler a manifest without `route` for `respond()`, the
+* response of a prefetch: Next reads the manifest as it starts a request.
+*/
+async function withoutRoute(route, respond) {
+	const before = hidden;
+	hidden = route.pathname;
+	try {
+		return await respond();
+	} finally {
+		hidden = before;
+	}
+}
+function currentPrerenderManifest() {
+	const route = hidden;
+	if (route === void 0 || !isPrerendered({
+		kind: "page",
+		page: "",
+		pathname: route
+	})) return prerenderManifest;
+	const { [route]: _, ...dynamicRoutes } = prerenderManifest.dynamicRoutes;
+	return {
+		...prerenderManifest,
+		routes: Object.fromEntries(Object.entries(prerenderManifest.routes).filter(([, entry]) => entry.srcRoute !== route)),
+		dynamicRoutes
+	};
+}
+/** Whether the build prerenders a route, or a pathname of it. */
+function isPrerendered(route) {
+	return route.pathname in prerenderManifest.dynamicRoutes || Object.values(prerenderManifest.routes).some((entry) => entry.srcRoute === route.pathname);
+}
+/**
+* Takes a route out of what the build prerenders: for a render that read the
+* request, which the build would have found as it prerendered the route.
+* All of its pathnames: of a route with `generateStaticParams`, the build
+* keeps those that did not read it, and here the others are not rendered yet.
+*/
+function demoteRoute(route) {
+	for (const [pathname, entry] of Object.entries(prerenderManifest.routes)) if (entry.srcRoute === route.pathname) delete prerenderManifest.routes[pathname];
+	if (route.pathname in prerenderManifest.dynamicRoutes) {
+		const { [route.pathname]: _, ...dynamicRoutes } = prerenderManifest.dynamicRoutes;
+		prerenderManifest = {
+			...prerenderManifest,
+			dynamicRoutes
+		};
+	}
+}
+const manifests = [
+	["routes-manifest.json", () => routesManifest],
+	["prerender-manifest.json", currentPrerenderManifest],
+	["preview-props.json", () => preview],
+	["fallback-build-manifest.json", () => ({})],
+	["build-manifest.json", () => buildManifest],
+	["next-font-manifest.json", () => nextFontManifest],
+	["_client-reference-manifest.js", () => ({ __RSC_MANIFEST: anyKey(() => clientReferenceManifest) })],
+	["server-reference-manifest.json", () => ({
+		node: serverActions,
+		edge: serverActions,
+		encryptionKey: ""
+	})],
+	["required-server-files.json", () => ({ config: nextConfig })],
+	["BUILD_ID", () => routing.buildId]
+];
+/** A file of `.next/`, by its path, as Next's `loadManifest()` reads it. */
+function loadManifest(file) {
+	return manifests.find(([suffix]) => file.endsWith(suffix))?.[1]();
+}
+const nodeRouteDistDir = ".next/vitest-plugin-rsc-node";
+const nothingPrerendered = {
+	...prerenderManifest,
+	routes: {},
+	dynamicRoutes: {}
+};
+registry.node = {
+	loadManifest,
+	evalManifest: loadManifest,
+	loadManifestFromRelativePath: ({ manifest, distDir }) => distDir === ".next/vitest-plugin-rsc-node" && manifest === "prerender-manifest.json" ? nothingPrerendered : loadManifest(manifest),
+	evalManifestFromRelativePath: ({ manifest }) => loadManifest(manifest)
+};
+//#endregion
+export { demoteRoute, forgetBuilt, isPrerendered, keptAsBuilt, loadManifest, nodeRouteDistDir, prerenderManifest, recordRoute, setServerActions, setStylesheets, withoutRoute };

package/dist/build.d.ts

@@ -0,0 +1,26 @@
+import { Rolldown } from "vite";
+
+//#region src/build.d.ts
+/**
+ * The code that Next's runtime and React run: their development code, as
+ * `next dev` runs it, or their production code, as `next start` runs it after
+ * `next build`. The app's own `process.env.NODE_ENV` is the same for both:
+ * see docs/internals/next-routes.md, "Development Or Production".
+ */
+type NextBuild = "development" | "production";
+declare const nextBuilds: readonly NextBuild[];
+/**
+ * Makes `process.env.NODE_ENV` `"production"` in the files of Next: its
+ * runtime and the copies of React, React DOM, the scheduler and the Flight
+ * codec that it ships, which every layer runs on. React's entry files then
+ * pick its production build by themselves. The files of the app and of its
+ * other packages keep the `NODE_ENV` they have. For the dependency optimizer,
+ * which pre-bundles all of Next.
+ *
+ * A define, not a text replacement: Next's files also have `process.env.NODE_ENV`
+ * in strings, and assign it. Its name is in the hash of the pre-bundled
+ * dependencies, which then are not the ones of the development build.
+ */
+declare function nextProductionPlugin(nextDir: string): Rolldown.Plugin;
+//#endregion
+export { NextBuild, nextBuilds, nextProductionPlugin };

package/dist/build.js

@@ -0,0 +1,39 @@
+import { normalizePath, transformWithOxc } from "vite";
+//#region src/build.ts
+const nextBuilds = ["development", "production"];
+/**
+* Makes `process.env.NODE_ENV` `"production"` in the files of Next: its
+* runtime and the copies of React, React DOM, the scheduler and the Flight
+* codec that it ships, which every layer runs on. React's entry files then
+* pick its production build by themselves. The files of the app and of its
+* other packages keep the `NODE_ENV` they have. For the dependency optimizer,
+* which pre-bundles all of Next.
+*
+* A define, not a text replacement: Next's files also have `process.env.NODE_ENV`
+* in strings, and assign it. Its name is in the hash of the pre-bundled
+* dependencies, which then are not the ones of the development build.
+*/
+function nextProductionPlugin(nextDir) {
+	const dist = `${normalizePath(nextDir)}/dist/`.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return {
+		name: "vitest-plugin-rsc:next-production",
+		transform: {
+			filter: {
+				id: new RegExp(`^${dist}.*\\.[cm]?js$`),
+				code: "process.env.NODE_ENV"
+			},
+			async handler(code, id) {
+				const { code: compiled, map } = await transformWithOxc(code, id, {
+					lang: "js",
+					define: { "process.env.NODE_ENV": "\"production\"" }
+				});
+				return {
+					code: compiled,
+					map
+				};
+			}
+		}
+	};
+}
+//#endregion
+export { nextBuilds, nextProductionPlugin };

package/dist/built-files.d.ts

@@ -0,0 +1,9 @@
+import { BuiltFiles } from "./styles-shared.js";
+
+//#region src/built-files.d.ts
+/** The URL of the directory of the build. Nothing with a dev server. */
+declare const buildDirectory: string | undefined;
+/** The files of the build. Only in a build, where `buildDirectory` is. */
+declare function builtFiles(): Promise<BuiltFiles>;
+//#endregion
+export { buildDirectory, builtFiles };

package/dist/built-files.js

@@ -0,0 +1,22 @@
+import { registry } from "./registry.js";
+import { builtFilesPath } from "./styles-shared.js";
+import builtLayers from "virtual:vitest-plugin-rsc/layers";
+//#region src/built-files.ts
+/** The URL of the directory of the build. Nothing with a dev server. */
+const buildDirectory = builtLayers && Object.values(builtLayers)[0]?.base;
+let built;
+/** The files of the build. Only in a build, where `buildDirectory` is. */
+function builtFiles() {
+	if (!built) {
+		built = load(new URL(builtFilesPath, buildDirectory).href);
+		built.catch(() => built = void 0);
+	}
+	return built;
+}
+async function load(url) {
+	const response = await registry.network(url, { cache: "no-cache" });
+	if (!response.ok) throw new Error(`vitest-plugin-rsc: ${url} answered ${response.status}: ${await response.text()}`);
+	return await response.json();
+}
+//#endregion
+export { buildDirectory, builtFiles };

package/dist/cache.d.ts

@@ -0,0 +1,44 @@
+import { IncrementalCache } from "./compat/ssr/cache.js";
+
+//#region src/cache.d.ts
+declare global {
+  var __incrementalCache: IncrementalCache | undefined;
+}
+/**
+ * The directory of the build on the server's disk, `.next/<generation>` in
+ * the host's directory of the server's files: `/.next/<generation>` in a
+ * browser.
+ */
+declare const buildDir: () => string;
+/**
+ * Loads the cache handlers that `next.config` names, as Next's server does
+ * before its first request: `cacheHandler`, the class of the handler of this
+ * cache, and `cacheHandlers`, the handler of each kind of `"use cache"`.
+ * Without them, Next's own handlers keep the entries in memory.
+ */
+declare function loadCacheHandlers(): Promise<void>;
+/**
+ * Puts the cache of the server back in the global Next reads it from. Next's
+ * route module leaves one of its own there. A request that was left can end
+ * long after its test: the cache is the one of now, not of that request.
+ */
+declare function restoreIncrementalCache(): void;
+/**
+ * Gives a request the cache of the server, with the options that
+ * `getIncrementalCache()` of Next's server passes. Without headers it is the
+ * cache between requests, for a test that calls a cached function itself.
+ */
+declare function shareIncrementalCache(headers?: Headers): void;
+/**
+ * Makes the server forget which tags were revalidated, and what it has
+ * cached: the entries are on the server's disk, which `cleanup()` empties
+ * after this. The generation keeps a cached function that was still running
+ * when its test ended from being found under its key. An app's own
+ * `cacheHandler` keeps the prerendered pages and route handlers where it
+ * does, under their pathnames: those are expired as `revalidatePath("/",
+ * "layout")` expires them, by the tag each of them has for the root layout.
+ * What the build prerenders stays: that is the app's code (build-output.ts).
+ */
+declare function resetCaches(): Promise<void>;
+//#endregion
+export { buildDir, loadCacheHandlers, resetCaches, restoreIncrementalCache, shareIncrementalCache };

package/dist/cache.js

@@ -0,0 +1,99 @@
+import { registry } from "./registry.js";
+import { forgetBuilt, keptAsBuilt, prerenderManifest } from "./build-output.js";
+import { IncrementalCache, NEXT_CACHE_IMPLICIT_TAG_ID, initializeCacheHandlers, nodeFs, registerCustomCacheHandlers, setCacheHandler, tagsManifest } from "./compat/ssr/cache.js";
+import { nextConfig, preview } from "virtual:vitest-plugin-rsc/next-manifest";
+import { cacheHandler, cacheHandlers } from "virtual:vitest-plugin-rsc/next-cache-handlers";
+//#region src/cache.ts
+let generation = 0;
+/**
+* The directory of the build on the server's disk, `.next/<generation>` in
+* the host's directory of the server's files: `/.next/<generation>` in a
+* browser.
+*/
+const buildDir = () => `${registry.serverDir()}/.next/${generation}`;
+registry.cacheGeneration = () => generation;
+registry.buildDir = buildDir;
+let current;
+let CurCacheHandler;
+let loading;
+const handlerOf = (module) => {
+	const handler = module.default || module;
+	return handler.default || handler;
+};
+/**
+* Loads the cache handlers that `next.config` names, as Next's server does
+* before its first request: `cacheHandler`, the class of the handler of this
+* cache, and `cacheHandlers`, the handler of each kind of `"use cache"`.
+* Without them, Next's own handlers keep the entries in memory.
+*/
+function loadCacheHandlers() {
+	loading ??= (async () => {
+		if (cacheHandler) CurCacheHandler = handlerOf(await cacheHandler());
+		initializeCacheHandlers(nextConfig.cacheMaxMemorySize);
+		await registerCustomCacheHandlers(async () => {
+			for (const [kind, load] of Object.entries(cacheHandlers)) setCacheHandler(kind, handlerOf(await load()));
+		});
+	})();
+	return loading;
+}
+/**
+* Puts the cache of the server back in the global Next reads it from. Next's
+* route module leaves one of its own there. A request that was left can end
+* long after its test: the cache is the one of now, not of that request.
+*/
+function restoreIncrementalCache() {
+	globalThis.__incrementalCache = current;
+}
+/**
+* Gives a request the cache of the server, with the options that
+* `getIncrementalCache()` of Next's server passes. Without headers it is the
+* cache between requests, for a test that calls a cached function itself.
+*/
+function shareIncrementalCache(headers = new registry.Headers()) {
+	const cache = new IncrementalCache({
+		fs: nodeFs,
+		serverDistDir: `${buildDir()}/server`,
+		dev: false,
+		minimalMode: false,
+		flushToDisk: true,
+		maxMemoryCacheSize: 0,
+		requestHeaders: Object.fromEntries(headers),
+		allowedRevalidateHeaderKeys: nextConfig.experimental.allowedRevalidateHeaderKeys,
+		fetchCacheKeyPrefix: `${nextConfig.experimental.fetchCacheKeyPrefix ?? ""}${generation}`,
+		previewProps: preview,
+		CurCacheHandler,
+		prerenderManifest
+	});
+	const set = cache.set.bind(cache);
+	cache.set = ((...args) => {
+		keptAsBuilt(args[0], args[1], args[2], generation);
+		return set(...args);
+	});
+	globalThis.__incrementalCache = current = cache;
+}
+/**
+* Makes the server forget which tags were revalidated, and what it has
+* cached: the entries are on the server's disk, which `cleanup()` empties
+* after this. The generation keeps a cached function that was still running
+* when its test ended from being found under its key. An app's own
+* `cacheHandler` keeps the prerendered pages and route handlers where it
+* does, under their pathnames: those are expired as `revalidatePath("/",
+* "layout")` expires them, by the tag each of them has for the root layout.
+* What the build prerenders stays: that is the app's code (build-output.ts).
+*/
+async function resetCaches() {
+	tagsManifest.clear();
+	forgetBuilt();
+	generation++;
+	shareIncrementalCache();
+	if (!CurCacheHandler || !hasPrerenders()) return;
+	const stored = realNow();
+	while (realNow() === stored) await new Promise((resolve) => nativeSetTimeout(resolve, 1));
+	await current.revalidateTag(`${NEXT_CACHE_IMPLICIT_TAG_ID}/layout`);
+}
+const realNow = Date.now.bind(Date);
+const nativeSetTimeout = globalThis.setTimeout;
+const hasPrerenders = () => Object.keys(prerenderManifest.routes).length > 0 || Object.keys(prerenderManifest.dynamicRoutes).length > 0;
+shareIncrementalCache();
+//#endregion
+export { buildDir, loadCacheHandlers, resetCaches, restoreIncrementalCache, shareIncrementalCache };

package/dist/client-components.d.ts

@@ -0,0 +1,3 @@
+import { linkStylesheetsOf, loadClientModule } from "./client-graph.js";
+import { keepHostDocument } from "./host-document.js";
+export { keepHostDocument, linkStylesheetsOf, loadClientModule };

package/dist/client-components.js

@@ -0,0 +1,4 @@
+import "./globals.js";
+import { linkStylesheetsOf, loadClientModule } from "./client-graph.js";
+import { keepHostDocument } from "./host-document.js";
+export { keepHostDocument, linkStylesheetsOf, loadClientModule };

package/dist/client-file-key.d.ts

@@ -0,0 +1,5 @@
+//#region src/client-file-key.d.ts
+/** The name of the export with the reference key of a file with `"use client"`. */
+declare const clientFileKeyExport = "__vitest_plugin_rsc_client_file__";
+//#endregion
+export { clientFileKeyExport };

package/dist/client-file-key.js

@@ -0,0 +1,5 @@
+//#region src/client-file-key.ts
+/** The name of the export with the reference key of a file with `"use client"`. */
+const clientFileKeyExport = "__vitest_plugin_rsc_client_file__";
+//#endregion
+export { clientFileKeyExport };

package/dist/client-files.d.ts

@@ -0,0 +1,83 @@
+import { Plugin, ResolvedConfig } from "vite";
+
+//#region src/client-files.d.ts
+/**
+ * The file that a module of Vite is, by its id: the id, without the version
+ * a dev server adds for a dependency. Nothing for an id with another query.
+ */
+declare function fileOfModule(id: string): string | undefined;
+/**
+ * The client reference of a module of the rsc layer, in Vite RSC's map of
+ * them. With a dev server, Vite RSC has a module in `node_modules` there by
+ * its file, without the version, unless the page imports it by the name of
+ * its package.
+ */
+declare function clientReferenceOfModule<Reference>(references: Record<string, Reference>, id: string): Reference | undefined;
+/**
+ * What Vite RSC made of a module of the rsc layer with `"use client"`: a
+ * client reference, with the file's reference key. With a dev server that is
+ * the URL of the file in the browser layer, in a build a hash of the file.
+ */
+type ClientReference = {
+  referenceKey: string;
+};
+type ClientFilesOptions = {
+  /** The Vite environment of the rsc layer, which the host shares, and of the browser layer. */environments: {
+    rsc: string;
+    browser: string;
+  }; /** `@kasperpeulen/vitest-plugin-nextjs/testing-library`, and the file it is. */
+  testingLibrary: {
+    specifier: string;
+    file: string;
+  }; /** `@kasperpeulen/vitest-plugin-nextjs/client-components`, the other entry of a host. */
+  clientComponents: string; /** The file of the plugin that loads a client file: internal.ts. */
+  internal: string;
+  /**
+   * Whether a file is the host's: a test file or a setup file of Vitest, or a
+   * file of another host, like a story.
+   */
+  isHostFile(file: string): boolean; /** Whether a file is a test file or a setup file of Vitest, not of another host. */
+  isTestFile(file: string): boolean; /** Whether an import is of a package of the host, by its name. */
+  isHostPackage(specifier: string): boolean;
+  /**
+   * The client reference that Vite RSC made of a module of the rsc layer, if
+   * it has `"use client"`: by the id of a module, else by its file, see
+   * `clientReferenceOfModule()`.
+   */
+  clientReferenceOf(id: string, config: ResolvedConfig): ClientReference | undefined;
+};
+/**
+ * What the module of the rsc layer for a file with `"use client"` starts
+ * with, in front of the reference module, which has none of the code of the
+ * file: the export `clientFileKeyExport` with the file's reference key, by
+ * which `loadClientModule()` tells the module, see client-file-key.ts. For a
+ * file of the host, `load`, also the line that loads the file in the browser
+ * layer by that key, see client-graph.ts. With a dev server the key is the
+ * URL of the file in the browser layer. In a build it is a hash.
+ */
+declare function clientFileCode({
+  referenceKey
+}: ClientReference, load?: {
+  internal: string;
+}): string;
+/** What `renderServer()` throws in a file with `"use client"`. */
+declare const renderServerError: string;
+/** What the page imports for a module of the host: see ../host-module.ts. */
+declare function hostModuleCode(target: string, testingLibrary: ClientFilesOptions["testingLibrary"]): string;
+/**
+ * Three plugins. One that says which modules are Vitest's files, which Vite
+ * RSC makes a reference of last. Before Vite RSC: the modules of the page
+ * for the browser layer, the error for a file with `"use client"` that mocks
+ * a module, before Vite RSC drops the code of the file, and with a dev
+ * server the change of the file's module in the rsc layer for a change of
+ * what the file imports in the browser layer. After Vite RSC, which made the file a
+ * reference: the line in front of that module, with the file's reference
+ * key, which for a file of the host loads the file in the browser layer by
+ * that key. Not a file without the directive: a test file without it renders
+ * with `renderServer()`, in a page with a graph of its own.
+ */
+declare function clientFiles(options: ClientFilesOptions): Plugin[];
+/** The first call of the AST to a function of Vitest that mocks a module, like `vi.mock`. */
+declare function findMocking(node: unknown): string | undefined;
+//#endregion
+export { ClientFilesOptions, ClientReference, clientFileCode, clientFiles, clientReferenceOfModule, fileOfModule, findMocking, hostModuleCode, renderServerError };