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

package/dist/plugin.js

@@ -0,0 +1,1006 @@
+import { registryGlobal } from "./registry-global.js";
+import { nextBuilds, nextProductionPlugin } from "./build.js";
+import { codeFile, createCompilePlugin, createDependencyCompilePlugin, createScanCompilePlugin } from "./compile.js";
+import { builtHostFileOf, changesInPlace, createStyles } from "./styles.js";
+import { clientFiles, clientReferenceOfModule } from "./client-files.js";
+import { createCommonJsPlugin } from "./commonjs.js";
+import { esmRequirePlugin } from "./esm-require.js";
+import { fastCryptoModule, fastCryptoModuleOf, fastCryptoSetup } from "./fast-crypto.js";
+import { flightBridge } from "./flight.js";
+import { resolveSpeedFeatures } from "./mode.js";
+import { browserMapping, isNativeNodeModule, isNodeModule, nativeRequirePlugin, nodeModuleOf } from "./node-builtins.js";
+import { devAssetPrefix, prerenderImports, runtimeImports as runtimeImports$1, serverReferenceInfo } from "./compat/paths.js";
+import { createNodePlatform, instrumentationPlugin } from "./node-platform.js";
+import { notFoundPagePlugin, returnToHostScript, topLevelHost } from "./not-found-page.js";
+import { optimizerCacheKey } from "./optimizer-cache-key.js";
+import "./own-package.js";
+import { pageTimersDefine, pageTimersPlugin } from "./page-timers.js";
+import { createPathsPlugin } from "./paths.js";
+import { nextPatches } from "./compat/patches.js";
+import { describeEnv, envFilesOf } from "./project/env.js";
+import { moduleFileAt } from "./project/context.js";
+import { loadNextProject } from "./project.js";
+import { compileServerCode, createServerCode } from "./server-code.js";
+import { createUseCachePlugin, useCacheModule } from "./use-cache.js";
+import { routeLookupPlugin } from "./route-lookup.js";
+import { routesAheadPlugin } from "./routes-ahead.js";
+import { nextStaticBuild, withPathsFromRoot } from "./static-build.js";
+import { assertVitestVersion } from "./vitest-version.js";
+import { createFilter, defaultServerMainFields, normalizePath, parseAst, parseAstAsync, send, transformWithOxc } from "vite";
+import path from "node:path";
+import { hasDirective, transformDirectiveProxyExport } from "@vitejs/plugin-rsc/transforms";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import { getPluginApi } from "@vitejs/plugin-rsc/plugin";
+import { fileURLToPath } from "node:url";
+import { isOwnFile, ownPackageNames } from "@kasperpeulen/vitest-plugin-rsc/internal/own-packages";
+import "@kasperpeulen/vitest-plugin-rsc/internal/compile-cache";
+import { escapePath } from "tinyglobby";
+import { isTestServer, servesPageInNode } from "@kasperpeulen/vitest-plugin-rsc/internal/page-in-node";
+import { createRunnerEnvironmentPlugins } from "@kasperpeulen/vitest-plugin-rsc/internal/runner-environment";
+//#region src/plugin.ts
+const environmentOf = {
+	rsc: "client",
+	ssr: "next_ssr",
+	browser: "react_client"
+};
+const layers = Object.keys(environmentOf);
+const registry = `globalThis.${registryGlobal}`;
+const fileEntry = (file) => escapePath(normalizePath(file));
+const ruleExtensionsOf = (project) => (project.config.pageExtensions ?? []).filter((extension) => !codeFile.test(`.${extension}`) && project.webpackRuleOf(path.join(project.appDir, `page.${extension}`), "rsc"));
+const appEntriesOf = (project) => `${fileEntry(project.appDir)}/**/*.{${[
+	"js",
+	"jsx",
+	"ts",
+	"tsx",
+	...ruleExtensionsOf(project)
+].join(",")}}`;
+const manifestId = "virtual:vitest-plugin-rsc/next-manifest";
+const virtual = (name) => `virtual:vitest-plugin-rsc/next-${name}`;
+const routeEntryPrefix = virtual("route/");
+const routeLists = {
+	page: virtual("app-pages"),
+	route: virtual("route-handlers")
+};
+const routeKinds = Object.keys(routeLists);
+const middlewareId = virtual("middleware");
+const middlewareEntryId = virtual("middleware-entry");
+const metadataPrefix = virtual("metadata/");
+const envId = virtual("env");
+const cacheHandlersId = virtual("cache-handlers");
+const rootParamsId = virtual("root-params");
+const prerenderId = virtual("prerender");
+const nextRouting = "@next/routing";
+const entryOf = (route) => route.component ?? route.page;
+const isRouteModule = (id) => id.startsWith(routeEntryPrefix) || routeKinds.some((kind) => id === routeLists[kind]);
+function importedByRoute(module) {
+	const seen = /* @__PURE__ */ new Set([module]);
+	for (const node of seen) {
+		if (changesInPlace(node)) continue;
+		for (const importer of node.importers) {
+			const id = importer.id?.startsWith("\0") ? importer.id.slice(1) : void 0;
+			if (id !== void 0 && (isRouteModule(id) || id === middlewareId || id === middlewareEntryId)) return true;
+			seen.add(importer);
+		}
+	}
+	return false;
+}
+const hmrBoundary = (entries) => `import.meta.hot?.accept([${entries.join(", ")}]);\n`;
+const bridgePrefix = "\0vitest-plugin-rsc/next-bridge/";
+const emptyModuleId = "\0vitest-plugin-rsc/next-empty";
+const emptyModule = "const empty = {};\nexport default empty;\n";
+const vendoredFlight = (entry) => `@vitejs/plugin-rsc/vendor/react-server-dom/${entry}`;
+const ownFile = (name) => normalizePath(fileURLToPath(new URL(`./${name}${path.extname(import.meta.url)}`, import.meta.url)));
+const setupFile = ownFile("setup-browser");
+const nodeSetupFile = ownFile("setup-node");
+const testingLibrary = {
+	specifier: "@kasperpeulen/vitest-plugin-nextjs/testing-library",
+	file: ownFile("index")
+};
+const testerHtml = fileURLToPath(new URL("./tester.html", import.meta.url));
+const serverReferenceInfoShim = `
+import * as original from ${JSON.stringify(serverReferenceInfo)};
+export * from ${JSON.stringify(serverReferenceInfo)};
+const isNextId = (id) => id.length === original.SERVER_REFERENCE_ID_LENGTH && /^[0-9a-f]+$/i.test(id);
+export function mightBeServerReferenceId(id) {
+  return typeof id === "string" && (original.mightBeServerReferenceId(id) || id.includes("#"));
+}
+export function extractInfoFromServerReferenceId(id) {
+  return isNextId(id)
+    ? original.extractInfoFromServerReferenceId(id)
+    : { type: "server-action", usedArgs: [true, true, true, true, true, true], hasRestArgs: true };
+}
+`;
+const devAssetPrefixShim = `export const assetPrefix = "";\n`;
+const nodePlatform = createNodePlatform(registry, bridgePrefix);
+const saidOfNext = /* @__PURE__ */ new Set();
+const fastCryptoPrefix = `${bridgePrefix}fast-crypto/`;
+const fastCryptoSetupId = "virtual:vitest-plugin-rsc/next-fast-crypto";
+function createLayerResolver(getProject, layer, fastCrypto, nodeModules) {
+	let aliases;
+	const normalized = /* @__PURE__ */ new Map();
+	function nextFile(specifier) {
+		return moduleFileAt(path.join(getProject().nextDir, specifier.slice(5)));
+	}
+	function toSpecifier(file) {
+		return `next/${path.relative(getProject().nextDir, file).split(path.sep).join("/")}`;
+	}
+	function getAliases() {
+		if (aliases) return aliases;
+		const { nextDir } = getProject();
+		const table = { ...getProject().aliases[layer] };
+		const flightDir = path.posix.dirname(table["react-server-dom-webpack/server$"]);
+		for (const entry of [
+			"server.edge",
+			"static.edge",
+			"client.edge",
+			"client.browser"
+		]) table[`${vendoredFlight(entry)}$`] = `${flightDir}/${entry}`;
+		aliases = Object.entries(table).flatMap(([key, target]) => {
+			if (/^next\/dist\/\w+$/.test(key)) return [];
+			let exact = key.endsWith("$");
+			key = key.replace(/\$$/, "");
+			if (path.isAbsolute(key) && !path.relative(nextDir, key).startsWith("..")) {
+				key = toSpecifier(key);
+				exact = true;
+				if (/^next\/[\w-]+\.js$/.test(key)) return [{
+					key,
+					exact,
+					target
+				}, {
+					key: key.slice(0, -3),
+					exact,
+					target
+				}];
+			}
+			return [{
+				key,
+				exact,
+				target
+			}];
+		});
+		return aliases;
+	}
+	function applyAlias(source) {
+		for (const { key, exact, target } of getAliases()) {
+			if (source !== key && (exact || !source.startsWith(`${key}/`))) continue;
+			const aliased = target && target + source.slice(key.length);
+			if (aliased && source !== key && aliased.startsWith("next/") && !nextFile(aliased)) continue;
+			return aliased;
+		}
+	}
+	function isDependencyOfNext(target) {
+		return path.isAbsolute(target) && normalizePath(target).includes("/node_modules/") && path.relative(getProject().nextDir, target).startsWith("..");
+	}
+	function bridgeOf(source) {
+		if (layer === "rsc") {
+			const flight = /^react-server-dom-webpack\/(server|static|client)(\.edge)?$/.exec(source);
+			if (flight) return `${bridgePrefix}flight-${flight[1]}`;
+		}
+		if (source === "next/dist/esm/shared/lib/server-reference-info.js") return `${bridgePrefix}server-reference-info`;
+		if (devAssetPrefix.test(source)) return `${bridgePrefix}dev-asset-prefix`;
+		if (layer === "rsc" && /^next\/dist\/(esm\/)?server\/route-modules\/app-page\/module\.compiled(\.js)?$/.test(source)) return `${bridgePrefix}ssr-app-page-module`;
+		if (layer !== "browser") return nodePlatform.moduleOf(source);
+	}
+	/**
+	* Where a specifier leads in this layer: another specifier, a bridge module
+	* (`\0...`), or `false` for a module the layer leaves empty. For the app's
+	* code, `ofApp`, with the entries Next's own files do not get, like React's
+	* `react-dom/server` for Node.js in the ssr layer (project/layers.ts).
+	*/
+	function normalize(source, ofApp = false) {
+		const appTarget = ofApp ? getProject().appAliases[layer][`${source}$`] : void 0;
+		if (appTarget !== void 0) return normalize(appTarget);
+		const cached = normalized.get(source);
+		if (cached !== void 0) return cached;
+		const own = layer !== "browser" ? nodeModuleOf(source, nodeModules()) : void 0;
+		if (own) {
+			normalized.set(source, own);
+			return own;
+		}
+		let current = source;
+		for (let i = 0; i < 10 && current; i++) {
+			const bridge = bridgeOf(current);
+			if (bridge) {
+				current = bridge;
+				break;
+			}
+			const commonJs = current.replace(/^next\/dist\/esm\//, "next/dist/");
+			let next = applyAlias(current) ?? applyAlias(commonJs);
+			if (next === void 0 && current.startsWith("next/")) {
+				const file = nextFile(commonJs.replace(/^next\/dist\/(?!compiled\/)/, "next/dist/esm/")) ?? nextFile(commonJs);
+				if (file) next = toSpecifier(file);
+			}
+			if (next === void 0 || next === current) break;
+			current = next;
+		}
+		normalized.set(source, current);
+		return current;
+	}
+	/**
+	* The name this layer pre-bundles an entry of `optimizeDeps.include` under:
+	* the specifier `plugin()` resolves it to, or none for a module the layer
+	* leaves empty, bridges, or imports by its file.
+	*/
+	function preBundledName(entry) {
+		const source = entry.slice(entry.lastIndexOf(">") + 1).trim();
+		const target = normalize(source, true);
+		if (target === false || target.startsWith("\0") || isNodeModule(target) || layer !== "browser" && isNativeNodeModule(target)) return;
+		if (isDependencyOfNext(target)) return entry;
+		if (path.isAbsolute(target)) return;
+		return target === source ? entry : target;
+	}
+	function plugin() {
+		return {
+			name: `vitest-plugin-rsc:next-resolve:${layer}`,
+			enforce: "pre",
+			async resolveId(source, importer, options) {
+				if (source.startsWith(bridgePrefix) || source === emptyModuleId) return source;
+				if (source.startsWith("\0")) return;
+				if (layer !== "browser" && fastCrypto() && !importer?.startsWith(fastCryptoPrefix)) {
+					const name = fastCryptoModuleOf(source);
+					const native = nodeModules() === "native";
+					if (name && (name !== "node-crypto" || native || browserMapping(source, importer) === void 0)) return fastCryptoPrefix + name;
+				}
+				if (importer === `${bridgePrefix}server-reference-info`) return nextFile(serverReferenceInfo);
+				if (source === nextRouting) {
+					if (!importer || !isOwnFile(importer)) return;
+					return this.resolve(source, path.join(getProject().root, "package.json"), {
+						...options,
+						skipSelf: true
+					});
+				}
+				let specifier = source;
+				if (source.startsWith(".") && importer) specifier = path.resolve(path.dirname(importer.split("?")[0]), source);
+				if (path.isAbsolute(specifier)) {
+					const relative = path.relative(getProject().nextDir, specifier.split("?")[0]);
+					if (relative.startsWith("..")) return;
+					specifier = `next/${relative.split(path.sep).join("/")}`;
+				}
+				const ofApp = !!importer && !normalizePath(importer).includes("/next/dist/");
+				const target = normalize(specifier, ofApp);
+				if (target === false) return emptyModuleId;
+				if (layer !== "browser" && isNativeNodeModule(target)) return {
+					id: target,
+					external: true
+				};
+				if (isNodeModule(target)) {
+					const mapping = browserMapping(source, importer);
+					if (mapping === false) return emptyModuleId;
+					if (mapping !== void 0) return;
+					if (!this.environment) return target;
+					return this.resolve(target, importer, {
+						...options,
+						skipSelf: true
+					});
+				}
+				if (target.startsWith("\0")) return target;
+				if (target === source) return;
+				if (specifier !== source && target === specifier && !nextFile(target)) return;
+				if (isDependencyOfNext(target) && importer && !importer.includes("/node_modules/")) return this.resolve(source, path.join(getProject().nextDir, "package.json"), {
+					...options,
+					skipSelf: true
+				});
+				if (this.environment?.mode === "build" && source === specifier && target.startsWith("next/") && !target.startsWith("next/dist/compiled/")) {
+					const file = nextFile(target);
+					if (file) return normalizePath(file);
+				}
+				const from = target.startsWith("next/") ? path.join(getProject().root, "package.json") : importer;
+				return this.resolve(target, from, {
+					...options,
+					skipSelf: true
+				});
+			},
+			load(id) {
+				if (id === emptyModuleId) return emptyModule;
+				if (!id.startsWith(bridgePrefix)) return;
+				const name = id.slice(31);
+				if (name === "server-reference-info") return serverReferenceInfoShim;
+				if (name === "dev-asset-prefix") return devAssetPrefixShim;
+				if (id.startsWith(fastCryptoPrefix)) return fastCryptoModule(id.slice(fastCryptoPrefix.length), nodeModuleOf("node:crypto", nodeModules()));
+				const { flightExports, version, newExports } = getProject();
+				const nodeModule = nodePlatform.load(name, newExports[name], version);
+				if (nodeModule) return nodeModule;
+				const entry = name.slice(7);
+				return flightBridge(entry, flightExports[entry], version, registry);
+			}
+		};
+	}
+	return {
+		normalize,
+		nextFile,
+		toSpecifier,
+		isDependencyOfNext,
+		preBundledName,
+		plugin
+	};
+}
+function nextClientBoundaryPlugin(getProject, resolver) {
+	return {
+		name: "vitest-plugin-rsc:next-client-boundary",
+		async transform(code, id) {
+			const file = normalizePath(id.split("?")[0]);
+			if (!file.startsWith(`${normalizePath(getProject().nextDir)}/`)) return;
+			if (!code.includes("use client")) return;
+			const specifier = resolver.toSpecifier(file);
+			const result = transformDirectiveProxyExport(await parseAstAsync(code), {
+				directive: "use client",
+				code,
+				runtime: (name) => `$$ReactServer.registerClientReference(() => { throw new Error(${JSON.stringify(`${specifier}#${name} is a Client Component and cannot be called on the server`)}) }, ${JSON.stringify(`/@id/${specifier}`)}, ${JSON.stringify(name)})`
+			});
+			if (!result) return;
+			result.output.prepend(`import * as $$ReactServer from ${JSON.stringify(vendoredFlight("server.edge"))};\n`);
+			return {
+				code: result.output.toString(),
+				map: null
+			};
+		}
+	};
+}
+function flightConsolePlugin() {
+	return {
+		name: "vitest-plugin-rsc:flight-console",
+		transform: {
+			filter: { id: /\/react-server-dom-webpack-server\.[^/]+\.development\.js$/ },
+			handler(code, id) {
+				const patched = code.replace(/function patchConsole\([^)]*\)\s*\{/, "$& return;");
+				if (patched === code) this.warn(`vitest-plugin-rsc: React's patchConsole() in ${id} is not turned off.`);
+				return {
+					code: patched,
+					map: null
+				};
+			}
+		}
+	};
+}
+function nextPatchesPlugin() {
+	const patches = nextPatches(registry);
+	return {
+		name: "vitest-plugin-rsc:next-patches",
+		transform: {
+			filter: { id: { include: patches.map(({ file }) => file) } },
+			handler(code, id) {
+				let patched = code;
+				for (const { file, lost, edits } of patches) {
+					if (!file.test(id)) continue;
+					for (const [find, replace] of edits) {
+						if (!patched.includes(find)) {
+							this.warn(`vitest-plugin-rsc: ${id} has no \`${find.trim()}\`: ${lost}.`);
+							continue;
+						}
+						patched = patched.replaceAll(find, () => replace);
+					}
+				}
+				return patched === code ? void 0 : {
+					code: patched,
+					map: null
+				};
+			}
+		}
+	};
+}
+function definesOf(project, layer) {
+	const { "process.env.NODE_ENV": _, ...defines } = project.defines[layer];
+	return {
+		...defines,
+		__dirname: "\"\"",
+		...layer === "browser" && {
+			__webpack_require__: `${registry}.browserRequire`,
+			"process.env.__NEXT_TEST_MODE": "true"
+		}
+	};
+}
+function findMetadataRequests(code) {
+	return [...code.matchAll(/["'](next-metadata-(?:image|route)-loader\?[^"']+)["']/g)].map((match) => match[1]);
+}
+/**
+* The files of the cache handlers that `next.config` names, which Next's
+* server loads before its first request (cache.ts): `cacheHandler`, and one
+* of `cacheHandlers` for each kind of `"use cache"` that has one. A path, or
+* a `file:` URL, as Next takes one. A relative path is of the project, as
+* Next's server resolves it.
+*/
+function cacheHandlerFilesOf(project) {
+	const { cacheHandler, cacheHandlers = {} } = project.config;
+	const fileOf = (file) => normalizePath(file.startsWith("file:") ? fileURLToPath(file) : path.resolve(project.root, file));
+	return {
+		cacheHandler: cacheHandler ? fileOf(cacheHandler) : void 0,
+		cacheHandlers: Object.fromEntries(Object.entries(cacheHandlers).flatMap(([kind, file]) => file ? [[kind, fileOf(file)]] : []))
+	};
+}
+/**
+* What the dependency optimizer of the ssr layer, which loads the cache
+* handlers, is to know of them before the first request. Vite's scan does not
+* follow the `import()` of a file that a virtual module makes from the
+* config. A file of Next, like its `default.external.js`, is a dependency:
+* the layer imports it by the specifier `toSpecifier()` gives it. Any other
+* file, of the app or of another package, is an entry of the scan, which
+* then finds what it imports.
+*/
+function cacheHandlerScan(project, toSpecifier) {
+	const { cacheHandler, cacheHandlers } = cacheHandlerFilesOf(project);
+	const files = [...new Set([cacheHandler ?? [], Object.values(cacheHandlers)].flat())];
+	const isOfNext = (file) => {
+		const relative = path.relative(project.nextDir, file);
+		return !relative.startsWith("..") && !path.isAbsolute(relative);
+	};
+	return {
+		include: files.filter(isOfNext).map(toSpecifier),
+		entries: files.filter((file) => !isOfNext(file)).map(fileEntry)
+	};
+}
+function findImports(code) {
+	return [...code.matchAll(/(?:\bfrom\s*|\bimport\s*\(?\s*|\brequire\s*\(\s*)(?:\/\*.*?\*\/\s*)?["']([^"'?!]+)["']/g)].map((match) => match[1]);
+}
+const clientBoundaryFiles = /* @__PURE__ */ new Map();
+function findClientBoundaries(nextDir, root, resolver) {
+	let files = clientBoundaryFiles.get(nextDir);
+	if (!files) {
+		files = scanClientBoundaries(nextDir, root);
+		clientBoundaryFiles.set(nextDir, files);
+	}
+	return files.map((file) => resolver.toSpecifier(file)).sort();
+}
+function scanClientBoundaries(nextDir, root) {
+	const scripts = fs.readdirSync(path.join(nextDir, "dist/esm"), {
+		recursive: true,
+		withFileTypes: true
+	}).flatMap((entry) => entry.isFile() && entry.name.endsWith(".js") ? [path.join(entry.parentPath, entry.name)] : []);
+	const key = createHash("sha256");
+	for (const file of scripts) {
+		const stats = fs.statSync(file, { throwIfNoEntry: false });
+		key.update(`${file}\0${stats?.size}\0${stats?.mtimeMs}\n`);
+	}
+	const cache = path.join(root, "node_modules/.cache/vitest-plugin-rsc/client-boundaries-1.json");
+	const digest = key.digest("hex");
+	try {
+		const cached = JSON.parse(fs.readFileSync(cache, "utf8"));
+		if (cached.key === digest) return cached.files;
+	} catch {}
+	const files = scripts.filter((file) => {
+		const code = fs.readFileSync(file, "utf8");
+		return code.includes("use client") && hasDirective(parseAst(code).body, "use client");
+	});
+	try {
+		fs.mkdirSync(path.dirname(cache), { recursive: true });
+		const written = `${cache}.${process.pid}`;
+		fs.writeFileSync(written, JSON.stringify({
+			key: digest,
+			files
+		}));
+		fs.renameSync(written, cache);
+	} catch {}
+	return files;
+}
+const react = [
+	"react",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"react/compiler-runtime"
+];
+const runtimeImports = {
+	rsc: [
+		...react,
+		"react-dom",
+		...runtimeImports$1.rsc,
+		vendoredFlight("server.edge"),
+		vendoredFlight("static.edge"),
+		vendoredFlight("client.edge")
+	],
+	ssr: [
+		...react,
+		"react-dom",
+		...runtimeImports$1.ssr,
+		vendoredFlight("client.edge"),
+		"next/navigation"
+	],
+	browser: [
+		...react,
+		"react-dom",
+		"react-dom/client",
+		...runtimeImports$1.browser,
+		"next/navigation",
+		vendoredFlight("client.browser")
+	]
+};
+function vitestPluginNext(options = {}) {
+	const chosen = resolveSpeedFeatures(options, process.env);
+	let speedFeatures = {
+		...chosen,
+		fastCrypto: false,
+		cacheDevServer: false
+	};
+	let nodeModules = "stand-ins";
+	let project;
+	let cssDifferences = [];
+	const serverCode = createServerCode(registry, options);
+	const getProject = () => project;
+	if (options.build !== void 0 && !nextBuilds.includes(options.build)) throw new Error(`vitest-plugin-rsc: \`build\` is "development" or "production", not ${JSON.stringify(options.build)}.`);
+	let build = options.build ?? "development";
+	let env;
+	let envLoad = Promise.resolve();
+	let server;
+	let cacheHandlerEntries = [];
+	let underVitest = false;
+	const pluginApis = /* @__PURE__ */ new WeakMap();
+	const clientReferenceOf = (id, config) => {
+		if (!pluginApis.has(config)) pluginApis.set(config, getPluginApi(config));
+		const references = pluginApis.get(config)?.manager.clientReferenceMetaMap;
+		return references && clientReferenceOfModule(references, id);
+	};
+	const hostPackagesPlugin = {
+		name: "vitest-plugin-rsc:next-host-packages",
+		resolveId: (source) => serverCode.isHostPackage(source) ? {
+			id: source,
+			external: true
+		} : void 0
+	};
+	const resolvers = Object.fromEntries(layers.map((layer) => [layer, createLayerResolver(getProject, layer, () => speedFeatures.fastCrypto, () => nodeModules)]));
+	let pageRoutes;
+	const styles = createStyles({
+		getProject,
+		environments: environmentOf,
+		isServerCode: (file) => serverCode.isServerCode(file, "rsc"),
+		isHostFile: serverCode.isHostFile,
+		isHostPackageFile: serverCode.isHostPackageFile,
+		pageRoutes() {
+			if (pageRoutes?.of !== project) {
+				const routes = [...project.routes, ...project.componentRoutes].flatMap((route) => route.kind === "page" ? [[entryOf(route), route]] : []);
+				pageRoutes = {
+					of: project,
+					routes: new Map(routes)
+				};
+			}
+			return pageRoutes.routes;
+		},
+		entryIdOf: (entry) => `\0${routeEntryPrefix}${[...project.routes, ...project.componentRoutes].findIndex((route) => route.kind === "page" && entryOf(route) === entry)}`,
+		lists: routeKinds.map((kind) => `\0${routeLists[kind]}`)
+	});
+	const generatedDefines = () => ({
+		...definesOf(project, "rsc"),
+		...build === "production" && { "process.env.NODE_ENV": "\"production\"" }
+	});
+	return [
+		{
+			name: "vitest-plugin-rsc:next-scan",
+			configureServer: {
+				order: "pre",
+				handler(server) {
+					const rsc = server.config.environments[environmentOf.rsc];
+					const input = rsc.input ?? rsc.build.rolldownOptions.input;
+					const inputFiles = typeof input === "string" ? [input] : Object.values(input ?? {});
+					const hostEntries = rsc.optimizeDeps.entries ?? (inputFiles.length > 0 ? inputFiles.map(fileEntry) : "**/*.html");
+					rsc.optimizeDeps.entries = [
+						...[hostEntries].flat(),
+						appEntriesOf(project),
+						...project.middlewareFile ? [fileEntry(project.middlewareFile)] : []
+					];
+					const ssr = server.config.environments[environmentOf.ssr];
+					const isOwnOrPackageFile = (entry) => {
+						const file = normalizePath(entry);
+						return file.includes("/node_modules/") || isOwnFile(file);
+					};
+					ssr.optimizeDeps.entries = [
+						...[ssr.optimizeDeps.entries ?? []].flat(),
+						...rsc.optimizeDeps.entries.filter((entry) => !isOwnOrPackageFile(entry)),
+						...cacheHandlerEntries
+					];
+				}
+			}
+		},
+		...createRunnerEnvironmentPlugins(environmentOf.ssr),
+		createPathsPlugin(getProject),
+		{
+			name: "vitest-plugin-rsc:next",
+			enforce: "pre",
+			async config(config, { command }) {
+				const isBuild = command === "build";
+				build = options.build ?? (isBuild ? "production" : "development");
+				const testRun = isTestServer(config, command);
+				speedFeatures = {
+					...chosen,
+					fastCrypto: chosen.fastCrypto && testRun,
+					cacheDevServer: chosen.cacheDevServer && testRun
+				};
+				const pageInNode = servesPageInNode(config, command);
+				nodeModules = pageInNode ? "native" : "stand-ins";
+				project = await loadNextProject(path.resolve(config.root ?? process.cwd()), void 0, {
+					build,
+					static: isBuild
+				});
+				serverCode.configure(project.root, pageInNode ? "native" : "compiled");
+				env = project.env;
+				if (isBuild) serverCode.addTestFiles(() => false);
+				const appPageEntries = await Promise.all([...project.routes, ...project.componentRoutes.slice(0, 1)].map((candidate) => project.loadRouteEntry(candidate)));
+				const metadataModules = await Promise.all([...new Set(appPageEntries.flatMap(({ code }) => findMetadataRequests(code)))].map((request) => project.loadMetadata(request)));
+				const entryImports = [
+					...appPageEntries.flatMap(({ code }) => findImports(code)),
+					...metadataModules.flatMap(({ code }) => findImports(code)),
+					...findImports(await project.loadMiddlewareEntry() ?? ""),
+					...findImports(await project.loadRootParams())
+				];
+				const cacheHandlers = cacheHandlerScan(project, resolvers.ssr.toSpecifier);
+				cacheHandlerEntries = cacheHandlers.entries;
+				const apiImports = (layer) => Object.entries(project.aliases[layer]).flatMap(([file, target]) => path.dirname(file) === project.nextDir && target && !file.endsWith("og.js") ? [target] : []);
+				const toInclude = (layer, sources) => [...new Set(sources.flatMap((source) => {
+					const target = resolvers[layer].normalize(source);
+					return target && target.startsWith("next/dist/") ? [target] : [];
+				}))];
+				const rscInclude = toInclude("rsc", [
+					...entryImports,
+					...apiImports("rsc"),
+					...runtimeImports.rsc,
+					...build === "production" ? prerenderImports : []
+				]);
+				const clientBoundaries = findClientBoundaries(project.nextDir, project.root, resolvers.rsc);
+				const include = {
+					rsc: [...rscInclude, nextRouting],
+					ssr: [...toInclude("ssr", [
+						...apiImports("ssr"),
+						...runtimeImports.ssr,
+						...clientBoundaries,
+						...cacheHandlers.include
+					]), nextRouting],
+					browser: toInclude("browser", [
+						...apiImports("browser"),
+						...runtimeImports.browser,
+						...clientBoundaries
+					])
+				};
+				const dependenciesOfNext = (layer) => Object.entries(project.aliases[layer]).flatMap(([key, target]) => key.endsWith("$") && target && resolvers[layer].isDependencyOfNext(target) ? [`next > ${key.slice(0, -1)}`] : []);
+				const ruleExtensions = ruleExtensionsOf(project).map((extension) => `.${extension}`);
+				const optimizeDeps = (layer) => ({
+					include: [
+						...include[layer],
+						...dependenciesOfNext(layer),
+						...project.webpackPackages[layer]
+					],
+					...ruleExtensions.length > 0 && { extensions: ruleExtensions },
+					rolldownOptions: {
+						plugins: [
+							...build === "production" ? [nextProductionPlugin(project.nextDir)] : [],
+							...layer !== "browser" && nodeModules === "native" ? [nativeRequirePlugin()] : [],
+							...layer === "browser" ? [hostPackagesPlugin] : [],
+							resolvers[layer].plugin(),
+							createDependencyCompilePlugin(getProject, layer, serverCode.isAppCode),
+							createScanCompilePlugin(getProject, layer, serverCode.isAppCode, async (source, importer) => (await server?.environments[environmentOf[layer]]?.pluginContainer.resolveId(source, importer))?.id),
+							...layer === "rsc" ? [nextClientBoundaryPlugin(getProject, resolvers.rsc)] : [],
+							flightConsolePlugin(),
+							nextPatchesPlugin(),
+							esmRequirePlugin(),
+							...layer === "browser" ? [] : [
+								instrumentationPlugin(),
+								...layer === "rsc" ? [serverCode.optimizerPlugin()] : [],
+								serverCode.asyncFunctionsOptimizerPlugin(layer)
+							]
+						],
+						shimMissingExports: true,
+						moduleTypes: { ".js": "jsx" },
+						transform: { define: {
+							...definesOf(project, layer),
+							...layer === "browser" ? pageTimersDefine : serverCode.optimizerDefine(layer),
+							...layer === "browser" ? serverCode.browserCacheKey : serverCode.cacheKey,
+							...optimizerCacheKey(project, layer),
+							__vitest_plugin_rsc_fast_crypto__: JSON.stringify(speedFeatures.fastCrypto)
+						} }
+					}
+				});
+				const css = await project.loadCssOptions();
+				cssDifferences = [...css.differences];
+				const cssOptions = { ...css.options };
+				if (config.css?.preprocessorOptions !== void 0 && cssOptions.preprocessorOptions) {
+					delete cssOptions.preprocessorOptions;
+					cssDifferences.push("`css.preprocessorOptions` of the Vitest config is used, not `sassOptions` of next.config");
+				}
+				if (config.css?.transformer === "lightningcss") {
+					delete cssOptions.postcss;
+					delete cssOptions.modules;
+					cssDifferences.push("`css.transformer` of the Vitest config compiles the CSS with Lightning CSS: not with Next's PostCSS plugins, its mode of a CSS module or its class names");
+				} else {
+					if (config.css?.postcss !== void 0) {
+						delete cssOptions.postcss;
+						cssDifferences.push("`css.postcss` of the Vitest config is used, not Next's PostCSS plugins, nor Next's mode of a CSS module");
+					}
+					if (config.css?.modules !== void 0) {
+						delete cssOptions.modules;
+						cssDifferences.push("`css.modules` of the Vitest config names the classes of a CSS module, not Next's rule");
+					}
+				}
+				const test = config.test ??= {};
+				test.setupFiles = [setupFile, ...[test.setupFiles ?? []].flat()];
+				(test.browser ??= {}).testerHtmlPath ??= testerHtml;
+				test.browser.dependencySourcemaps ??= false;
+				if (speedFeatures.watchDom) ((test.expect ??= {}).poll ??= {}).interval ??= 5;
+				const jsx = build === "production" && config.oxc !== false && typeof config.oxc?.jsx !== "string" ? { oxc: { jsx: { development: false } } } : {};
+				const nodeEnv = JSON.stringify(build);
+				const builtLayer = (layer) => isBuild && {
+					define: {
+						"process.env.NODE_ENV": nodeEnv,
+						"global.process.env.NODE_ENV": nodeEnv,
+						"globalThis.process.env.NODE_ENV": nodeEnv,
+						...layer === "browser" && { __vite_rsc_require__: `${registry}.browserRequire` }
+					},
+					build: { rolldownOptions: { shimMissingExports: true } }
+				};
+				return {
+					...jsx,
+					...speedFeatures.fastCrypto && { cacheDir: path.join(config.cacheDir || "node_modules/.vite", "fast-crypto") },
+					css: cssOptions,
+					environments: {
+						[environmentOf.rsc]: {
+							...builtLayer("rsc"),
+							optimizeDeps: optimizeDeps("rsc")
+						},
+						[environmentOf.ssr]: {
+							...builtLayer("ssr"),
+							consumer: "client",
+							resolve: {
+								conditions: [
+									...(config.resolve?.conditions ?? []).filter((condition) => condition === "vitest-plugin-rsc-source"),
+									"module",
+									pageInNode ? "node" : "browser",
+									"development|production"
+								],
+								...pageInNode && { mainFields: [...defaultServerMainFields] }
+							},
+							dev: {
+								moduleRunnerTransform: true,
+								...testRun && { warmup: [ownFile("ssr")] }
+							},
+							optimizeDeps: {
+								...optimizeDeps("ssr"),
+								exclude: [...ownPackageNames(), "@vitejs/plugin-rsc"]
+							}
+						},
+						[environmentOf.browser]: {
+							...builtLayer("browser"),
+							optimizeDeps: optimizeDeps("browser")
+						}
+					}
+				};
+			},
+			configureServer(vite) {
+				server = vite;
+				const mainApp = "static/chunks/main-app.js";
+				vite.middlewares.use((request, response, next) => {
+					const { pathname } = new URL(request.url ?? "/", "http://n");
+					if (pathname !== `${project.assetPath}${mainApp}`) return next();
+					send(request, response, "", "js", {
+						headers: vite.config.server.headers,
+						map: { mappings: "" }
+					});
+				});
+			},
+			configEnvironment: {
+				order: "post",
+				handler(name, config, { command }) {
+					const layer = layers.find((layer) => environmentOf[layer] === name);
+					if (!layer) return;
+					const optimizeDeps = config.optimizeDeps;
+					if (optimizeDeps?.include) optimizeDeps.include = [...new Set(optimizeDeps.include.flatMap((entry) => resolvers[layer].preBundledName(entry) ?? []))];
+					if (layer === "rsc" && nodeModules === "native" && config.resolve?.conditions) {
+						config.resolve.conditions = config.resolve.conditions.map((condition) => condition === "browser" ? "node" : condition);
+						config.resolve.mainFields = [...defaultServerMainFields];
+					}
+					if (command === "build") return { keepProcessEnv: true };
+				}
+			},
+			configResolved(config) {
+				config.logger.info(describeEnv(env, config.command === "build"));
+				for (const difference of [...cssDifferences, ...project.webpackDifferences]) config.logger.warnOnce(`vitest-plugin-rsc: ${difference}.`);
+				if (project.edgeRouteFiles.length > 0) config.logger.warnOnce(`vitest-plugin-rsc: Next.js has deprecated its edge runtime. These routes ask for it with \`export const runtime = "edge"\` and run on Node.js here, like the others: ${project.edgeRouteFiles.join(", ")}`);
+				const newExports = Object.values(project.newExports).flat();
+				const aboutNext = `vitest-plugin-rsc: next@${project.version} has exports that the plugin's stand-ins for its modules have not. Each throws when it is used: ` + newExports.map(({ name, module }) => `\`${name}\` of ${module}`).join(", ") + `. Use a version of @kasperpeulen/vitest-plugin-nextjs that supports next@${project.version}.`;
+				if (newExports.length > 0 && !saidOfNext.has(aboutNext)) {
+					saidOfNext.add(aboutNext);
+					config.logger.warn(aboutNext);
+				}
+				if (project.unmatchedRoutes.length > 0) config.logger.warnOnce("vitest-plugin-rsc: @next/routing does not find a dynamic route under a folder with a name that a URL percent-encodes. These routes get the not-found page: " + project.unmatchedRoutes.join(", "));
+			},
+			configureVitest({ vitest, project: testProject }) {
+				underVitest = true;
+				assertVitestVersion(vitest.version);
+				const test = testProject.config;
+				const isSetupFile = (file) => test.setupFiles.some((setupFile) => normalizePath(setupFile) === file);
+				const isIncluded = createFilter(test.include, test.exclude, { resolve: test.dir || test.root });
+				serverCode.addTestFiles((file) => isSetupFile(file) || isIncluded(file));
+				if (!test.browser.enabled) test.setupFiles = test.setupFiles.map((file) => normalizePath(file) === setupFile ? nodeSetupFile : file);
+			},
+			async hotUpdate({ file, modules }) {
+				if (underVitest) return;
+				if (envFilesOf(false).some((name) => normalizePath(path.join(project.root, name)) === file)) {
+					if (this.environment.name !== environmentOf.rsc) return [];
+					const loaded = envLoad.then(() => project.loadEnv());
+					envLoad = loaded.catch(() => {});
+					env = await loaded;
+					for (const environment of Object.values(server?.environments ?? {})) {
+						const envModule = environment.moduleGraph.getModuleById(`\0${envId}`);
+						if (envModule) environment.moduleGraph.invalidateModule(envModule);
+					}
+					this.environment.logger.info(`page reload ${path.relative(this.environment.config.root, file)} (vitest-plugin-rsc: an env file changed)`, { timestamp: true });
+					this.environment.hot.send({
+						type: "full-reload",
+						path: "*",
+						triggeredBy: file
+					});
+					return [];
+				}
+				if (this.environment.name !== environmentOf.rsc) return;
+				if (!modules.some(importedByRoute)) return;
+				this.environment.logger.info(`page reload ${path.relative(this.environment.config.root, file)} (vitest-plugin-rsc: a file of the app changed)`, { timestamp: true });
+				this.environment.hot.send({
+					type: "full-reload",
+					path: "*",
+					triggeredBy: file
+				});
+				return [];
+			},
+			resolveId(source) {
+				if (source === manifestId || source === envId || isRouteModule(source)) return `\0${source}`;
+				if (source === fastCryptoSetupId) return `\0${source}`;
+				if (source === middlewareId || source === middlewareEntryId) return `\0${source}`;
+				if (source === "virtual:vitest-plugin-rsc/next-use-cache" || source === cacheHandlersId) return `\0${source}`;
+				if (source === prerenderId) return `\0${source}`;
+				if (source === "next/root-params") return `\0${rootParamsId}`;
+				if (project.isMetadataRequest(source)) return `\0${metadataPrefix}${source}`;
+				if (source.endsWith(project.metadataImageMeta)) return source.slice(0, -project.metadataImageMeta.length);
+			},
+			async load(id) {
+				if (id.startsWith(`\0${metadataPrefix}`)) {
+					const { code, watchFiles } = await project.loadMetadata(id.slice(metadataPrefix.length + 1));
+					for (const file of watchFiles) this.addWatchFile(file);
+					return serverCode.compile(code, "next-metadata.js", generatedDefines());
+				}
+				if (id === `\0virtual:vitest-plugin-rsc/next-use-cache`) return useCacheModule(registry);
+				if (id === `\0${rootParamsId}`) return project.loadRootParams();
+				if (id === `\0${prerenderId}`) return build === "production" ? `export { prerenderVerdictOf } from ${JSON.stringify(ownFile("prerender-verdict"))};\n` : "export function prerenderVerdictOf() {\n  throw new Error('vitest-plugin-rsc: only `build: \"production\"` prerenders');\n}\n";
+				if (id === `\0${cacheHandlersId}`) {
+					const { cacheHandler, cacheHandlers } = cacheHandlerFilesOf(project);
+					const load = (file) => `() => import(${JSON.stringify(file)})`;
+					const kinds = Object.entries(cacheHandlers).map(([kind, file]) => `  ${JSON.stringify(kind)}: ${load(file)},`);
+					return `export const cacheHandler = ${cacheHandler ? load(cacheHandler) : "undefined"};\nexport const cacheHandlers = {\n${kinds.join("\n")}\n};\n`;
+				}
+				if (id === `\0${fastCryptoSetupId}`) return fastCryptoSetup(speedFeatures.fastCrypto);
+				if (id === `\0${envId}`) {
+					for (const name of env.files) this.addWatchFile(path.join(project.root, name));
+					return `export default ${JSON.stringify(env.values)};\n`;
+				}
+				if (id === `\0${manifestId}`) {
+					const routes = project.routes.map(({ kind, page, pathname }) => ({
+						kind,
+						page,
+						pathname
+					}));
+					return `export const routes = ${JSON.stringify([...routes, ...project.componentRoutes])};\nexport const nextConfig = ${JSON.stringify(this.environment.mode === "build" ? withPathsFromRoot(project.config, project.root) : project.config)};\nexport const routing = ${JSON.stringify(project.routing)};\nexport const routesManifest = ${JSON.stringify(project.routesManifest)};\nexport const preview = ${JSON.stringify(project.preview)};\nexport const build = ${JSON.stringify(build)};\nexport const speedFeatures = ${JSON.stringify(speedFeatures)};\n`;
+				}
+				const hasMiddleware = project.middlewareFile !== void 0 && this.environment.name === environmentOf.rsc;
+				if (id === `\0${middlewareId}`) {
+					if (!hasMiddleware) return "export default undefined;\n";
+					const entry = JSON.stringify(middlewareEntryId);
+					return `export default () => import(${entry});\n${hmrBoundary([entry])}`;
+				}
+				if (id === `\0${middlewareEntryId}`) {
+					const code = hasMiddleware && await project.loadMiddlewareEntry();
+					if (!code) return "export {};";
+					return serverCode.compile(code, "next-middleware-entry.js", generatedDefines());
+				}
+				if (!id.startsWith("\0") || !isRouteModule(id.slice(1))) return;
+				if (this.environment.name !== environmentOf.rsc) return "export default {};";
+				const routes = [...project.routes, ...project.componentRoutes];
+				const listed = routeKinds.find((kind) => id === `\0${routeLists[kind]}`);
+				if (listed) {
+					const entries = routes.flatMap((route, index) => route.kind === listed ? [{
+						name: JSON.stringify(entryOf(route)),
+						entry: JSON.stringify(routeEntryPrefix + index)
+					}] : []);
+					return `export default {\n${entries.map(({ name, entry }) => `  ${name}: () => import(${entry}),`).join("\n")}\n};\n${hmrBoundary(entries.map(({ entry }) => entry))}`;
+				}
+				const route = routes[Number(id.slice(routeEntryPrefix.length + 1))];
+				const entry = await project.loadRouteEntry(route);
+				for (const file of entry.watchFiles) this.addWatchFile(file);
+				return serverCode.compile(entry.code, `${id.replace(/\W+/g, "-")}.js`, generatedDefines());
+			}
+		},
+		{
+			name: "vitest-plugin-rsc:next-setup-files",
+			enforce: "post",
+			configureVitest({ project: testProject }) {
+				const test = testProject.config;
+				if (!test.browser.enabled) testProject.provide("vitest-plugin-rsc:setup-files", test.setupFiles);
+			}
+		},
+		...clientFiles({
+			environments: {
+				rsc: environmentOf.rsc,
+				browser: environmentOf.browser
+			},
+			testingLibrary,
+			clientComponents: "@kasperpeulen/vitest-plugin-nextjs/client-components",
+			internal: ownFile("internal"),
+			isHostFile: serverCode.isHostFile,
+			isTestFile: serverCode.isTestFile,
+			isHostPackage: serverCode.isHostPackage,
+			clientReferenceOf
+		}),
+		routeLookupPlugin({
+			getProject,
+			specifier: testingLibrary.specifier
+		}),
+		serverCode.plugin({
+			[environmentOf.rsc]: "rsc",
+			[environmentOf.ssr]: "ssr"
+		}),
+		pageTimersPlugin(environmentOf.browser, serverCode.isHostFile),
+		notFoundPagePlugin(environmentOf.rsc),
+		...styles.plugins,
+		routesAheadPlugin({
+			root: () => getProject().root,
+			compile: styles.compileRoute
+		}),
+		serverCode.asyncFunctionsPlugin(environmentOf.rsc),
+		createUseCachePlugin(getProject, (environment) => layers.find((layer) => environmentOf[layer] === environment), serverCode.isAppCode),
+		createCompilePlugin(getProject, (environment) => layers.find((layer) => environmentOf[layer] === environment), serverCode.isAppCode),
+		createCommonJsPlugin((environment) => layers.find((layer) => environmentOf[layer] === environment), serverCode.isAppCode, (source, layer) => layer !== "browser" && isNativeNodeModule(nodeModuleOf(source, nodeModules) ?? "")),
+		...layers.map((layer) => ({
+			...resolvers[layer].plugin(),
+			applyToEnvironment: (environment) => environment.name === environmentOf[layer]
+		})),
+		...layers.map((layer) => dependencyBuildPlugin(getProject, serverCode, layer)),
+		{
+			...flightConsolePlugin(),
+			apply: "build"
+		},
+		{
+			...nextPatchesPlugin(),
+			apply: "build"
+		},
+		{
+			...instrumentationPlugin(),
+			apply: "build"
+		},
+		nextStaticBuild({
+			environments: environmentOf,
+			entries: {
+				ssr: "@kasperpeulen/vitest-plugin-nextjs/ssr",
+				browser: "@kasperpeulen/vitest-plugin-nextjs/client"
+			},
+			emittedFiles: () => [...project.emittedFiles(), ...styles.builtFiles()],
+			rscModule: ownFile("rsc"),
+			isHostFile: (id) => builtHostFileOf(id, project.root, serverCode.isHostFile) !== void 0
+		})
+	];
+}
+function dependencyBuildPlugin(getProject, serverCode, layer) {
+	const compile = createDependencyCompilePlugin(getProject, layer, serverCode.isAppCode);
+	return {
+		name: `vitest-plugin-rsc:next-build-dependency:${layer}`,
+		apply: "build",
+		applyToEnvironment: (environment) => environment.name === environmentOf[layer],
+		async transform(code, id) {
+			const file = id.split("?")[0];
+			if (!normalizePath(file).includes("/node_modules/") || !/\.[cm]?js$/.test(file)) return;
+			const compiled = await compile.transform(code, file);
+			const isServerCode = layer !== "browser" && serverCode.isServerCode(file, layer);
+			const forStores = isServerCode ? serverCode.forStores(this, compiled?.code ?? code, file, layer) : void 0;
+			const source = forStores?.code ?? compiled?.code ?? code;
+			const kept = source === (compiled?.code ?? code) ? compiled : { code: source };
+			const define = Object.fromEntries(Object.entries(definesOf(getProject(), layer)).filter(([key]) => source.includes(key.replace(/^typeof /, ""))));
+			if (!isServerCode && Object.keys(define).length === 0) return kept;
+			try {
+				return (isServerCode ? await compileServerCode(source, file, registry, {
+					...define,
+					...forStores?.define
+				}) : await transformWithOxc(source, file, {
+					lang: "js",
+					define
+				})) ?? kept;
+			} catch (error) {
+				const reason = String(error instanceof Error ? error.message : error);
+				this.warn(`vitest-plugin-rsc: ${file} keeps the constants of Next's ${layer} layer, it does not parse as JavaScript. ${reason.replace(/\s+/g, " ")}`);
+				return kept;
+			}
+		}
+	};
+}
+//#endregion
+export { returnToHostScript, topLevelHost, vitestPluginNext };