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

package/dist/route-lookup.d.ts

@@ -0,0 +1,34 @@
+import { NextProject, NextRoute } from "./project.js";
+import { Plugin } from "vite";
+
+//#region src/route-lookup.d.ts
+/** A request the code makes: its URL, a placeholder for each expression of a template. */
+type RouteRequest = {
+  url: string; /** Whether it renders the route's files, which the node of a test does not. */
+  route: boolean; /** Whether the middleware gets it. */
+  proxy: boolean;
+};
+/** What a placeholder of a template literal stands for in `RouteRequest.url`. */
+declare const placeholder = "\0";
+/**
+ * The requests that the calls of `renderServer()` and `handleRequest()` of
+ * `specifier` make in `code`, a module of JavaScript. `"every"` where a call
+ * or its URL is not read off the code. Nothing for code that calls neither.
+ */
+declare function requestsOf(code: string, specifier: string): Promise<RouteRequest[] | "every">;
+/** The routes a request can get, by its URL: every route where that is not known. */
+declare function routesOf(project: Pick<NextProject, "routes" | "routing" | "pageOf" | "middlewareFile">, {
+  url,
+  proxy
+}: Pick<RouteRequest, "url" | "proxy">): Promise<NextRoute[]>;
+type RouteLookupOptions = {
+  getProject: () => NextProject; /** What a test imports `renderServer()` and `handleRequest()` from. */
+  specifier: string;
+};
+/** The plugin that adds the routes a module opens to the map of Vitest's lookup. */
+declare function routeLookupPlugin({
+  getProject,
+  specifier
+}: RouteLookupOptions): Plugin;
+//#endregion
+export { RouteLookupOptions, RouteRequest, placeholder, requestsOf, routeLookupPlugin, routesOf };

package/dist/route-lookup.js

@@ -0,0 +1,207 @@
+import { walk } from "./commonjs.js";
+import { normalizePath, parseAstAsync } from "vite";
+import { lookupEnvironment, lookupServers } from "@kasperpeulen/vitest-plugin-rsc/internal/related-lookup";
+//#region src/route-lookup.ts
+/** What a placeholder of a template literal stands for in `RouteRequest.url`. */
+const placeholder = "\0";
+const opening = ["renderServer", "handleRequest"];
+/**
+* The requests that the calls of `renderServer()` and `handleRequest()` of
+* `specifier` make in `code`, a module of JavaScript. `"every"` where a call
+* or its URL is not read off the code. Nothing for code that calls neither.
+*/
+async function requestsOf(code, specifier) {
+	const ast = await parseAstAsync(code);
+	const functions = /* @__PURE__ */ new Map();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const statement of ast.body) {
+		if (statement.source?.value !== specifier) continue;
+		if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") return "every";
+		if (statement.type !== "ImportDeclaration") continue;
+		for (const imported of statement.specifiers) {
+			const local = imported.local.name;
+			if (imported.type === "ImportNamespaceSpecifier") namespaces.add(local);
+			if (imported.type !== "ImportSpecifier") continue;
+			const { name, value } = imported.imported;
+			const importedName = name ?? value;
+			if (importedName && opening.includes(importedName)) functions.set(local, importedName);
+		}
+	}
+	for (const [node] of walk(ast)) {
+		const source = node.type === "ImportExpression" && node.source;
+		if (source && source.type === "Literal" && source.value === specifier) return "every";
+	}
+	if (functions.size === 0 && namespaces.size === 0) return [];
+	const requests = [];
+	for (const [node, parent] of walk(ast)) {
+		if (node.type !== "Identifier" || !parent) continue;
+		const name = node.name;
+		if (parent.type === "MemberExpression" && parent.property === node && !parent.computed || parent.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand || parent.type === "ImportSpecifier" || parent.type === "ImportNamespaceSpecifier") continue;
+		let callee = node;
+		let opened = functions.get(name);
+		if (namespaces.has(name)) {
+			if (parent.type !== "MemberExpression" || parent.object !== node || parent.computed) return "every";
+			opened = parent.property.name;
+			if (!opening.includes(opened)) continue;
+			callee = parent;
+		}
+		if (!opened) continue;
+		const call = callee === node ? parent : parentOf(ast, callee);
+		if (call?.type !== "CallExpression" || call.callee !== callee) return "every";
+		const request = requestOf(opened, call.arguments);
+		if (!request) return "every";
+		requests.push(...request);
+	}
+	return requests;
+}
+function requestOf(name, args) {
+	const [first, second] = args;
+	if (name === "handleRequest") {
+		const url = first && urlOf(first);
+		return url === void 0 ? void 0 : [{
+			url,
+			route: true,
+			proxy: true
+		}];
+	}
+	if (first === void 0 || first.type === "ObjectExpression") {
+		const options = first && optionsOf(first);
+		if (first && !options) return;
+		const url = options?.url ? urlOf(options.url) : "/";
+		if (url === void 0) return;
+		return [{
+			url,
+			route: true,
+			proxy: options?.proxy === void 0 || isOn(options.proxy)
+		}];
+	}
+	if (!isElement(first)) return;
+	if (second === void 0) return [];
+	const options = optionsOf(second);
+	if (!options) return;
+	const url = options.url ? urlOf(options.url) : "/";
+	if (url === void 0) return;
+	const route = options.layouts !== void 0 && isOn(options.layouts);
+	const proxy = options.proxy !== void 0 && isOn(options.proxy);
+	return route || proxy ? [{
+		url,
+		route,
+		proxy
+	}] : [];
+}
+function optionsOf(node) {
+	if (node.type !== "ObjectExpression") return;
+	const options = {};
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) return;
+		const key = property.key;
+		const name = key.name ?? key.value;
+		if (typeof name !== "string") return;
+		options[name] = property.value;
+	}
+	return options;
+}
+function isElement(node) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	const name = callee.type === "Identifier" ? callee.name : callee.type === "MemberExpression" && !callee.computed ? callee.property.name : void 0;
+	return name !== void 0 && /^(?:_?jsxs?|_?jsxDEV|createElement)$/.test(name);
+}
+const isOn = (node) => !(node.type === "Literal" && node.value === false) && !(node.type === "Identifier" && node.name === "undefined");
+function urlOf(node) {
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type !== "TemplateLiteral") return;
+	const quasis = node.quasis;
+	if (quasis.some(({ value }) => value.cooked === null)) return;
+	return quasis.map(({ value }) => value.cooked).join("\0");
+}
+function parentOf(ast, child) {
+	for (const [node, parent] of walk(ast)) if (node === child) return parent;
+}
+/** The routes a request can get, by its URL: every route where that is not known. */
+async function routesOf(project, { url, proxy }) {
+	const { routes, routing } = project;
+	const pagesOf = async (target) => new Set(await Promise.all([project.pageOf(target, { proxy: false }), ...proxy ? [project.pageOf(target, { proxy: true })] : []]));
+	const orNotFound = (found) => found.length > 0 ? found : proxy && project.middlewareFile ? routes : routes.filter((route) => route.page === "/_not-found/page");
+	if (!url.includes("\0")) {
+		const pages = await pagesOf(new URL(url, "http://localhost"));
+		return orNotFound(routes.filter((route) => pages.has(route.page)));
+	}
+	let pathname = url.split(/[?#]/)[0].replace(/^[a-z][a-z\d+.-]*:\/\/[^/]*/i, "");
+	if (pathname.startsWith("\0")) {
+		const slash = pathname.indexOf("/");
+		if (slash === -1) return routes;
+		pathname = pathname.slice(slash);
+	}
+	if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+	const sample = await pagesOf(new URL(pathname.replaceAll("\0", "-x-"), "http://localhost"));
+	if (routing.basePath && pathname.startsWith(routing.basePath)) pathname = pathname.slice(routing.basePath.length);
+	const parts = segmentsOf(pathname);
+	const found = routes.filter((route) => sample.has(route.page) || matches(parts, segmentsOf(route.pathname)));
+	return found.length > 0 ? found : routes;
+}
+const segmentsOf = (pathname) => pathname.split("/").filter(Boolean);
+const isCatchAll = (segment) => /^\[\[?\.\.\./.test(segment);
+const isOptional = (segment) => segment.startsWith("[[...");
+const isDynamic = (segment) => segment.startsWith("[");
+function matches(url, route) {
+	const [part, ...restOfUrl] = url;
+	const [segment, ...restOfRoute] = route;
+	if (part === void 0) return route.every(isOptional);
+	if (segment === void 0) return false;
+	if (restOfUrl.length === 0 && part !== "\0" && part.endsWith("\0")) {
+		if (isDynamic(segment)) return true;
+		return patternOf(part).test(segment);
+	}
+	if (isCatchAll(segment)) return matches(restOfUrl, route) || matches(restOfUrl, restOfRoute) || isOptional(segment) && matches(url, restOfRoute);
+	if (isDynamic(segment)) return matches(restOfUrl, restOfRoute);
+	return patternOf(part).test(segment) && matches(restOfUrl, restOfRoute);
+}
+const patternOf = (part) => new RegExp(`^${part.split("\0").map((text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+/** The plugin that adds the routes a module opens to the map of Vitest's lookup. */
+function routeLookupPlugin({ getProject, specifier }) {
+	const servers = lookupServers();
+	const filesOf = /* @__PURE__ */ new WeakMap();
+	const filesOfRoute = (project, route) => {
+		if (!filesOf.has(project)) filesOf.set(project, /* @__PURE__ */ new Map());
+		const files = filesOf.get(project);
+		if (!files.has(route)) files.set(route, project.loadRouteEntry(route).then(({ watchFiles }) => watchFiles.map(normalizePath).filter((file) => !file.includes("/node_modules/"))));
+		return files.get(route);
+	};
+	const routesOfRequests = async (project, requests) => {
+		if (requests === "every") return project.routes;
+		try {
+			const opened = requests.filter(({ route }) => route);
+			return (await Promise.all(opened.map((request) => routesOf(project, request)))).flat();
+		} catch {
+			return project.routes;
+		}
+	};
+	return {
+		name: "vitest-plugin-rsc:next-route-lookup",
+		enforce: "post",
+		configureVitest({ project, defineCacheKeyGenerator }) {
+			if (!servers.add(project)) return;
+			defineCacheKeyGenerator(({ environment, sourceCode }) => environment.name === lookupEnvironment && sourceCode.includes(specifier) ? false : void 0);
+		},
+		async transform(code, id) {
+			if (!servers.inLookup(this)) return;
+			if (!code.includes(specifier) || id.includes("/node_modules/")) return;
+			const requests = await requestsOf(code, specifier);
+			if (requests !== "every" && requests.length === 0) return;
+			const project = getProject();
+			const routes = await routesOfRequests(project, requests);
+			const files = new Set((await Promise.all(routes.map((route) => filesOfRoute(project, route)))).flat());
+			const proxy = requests === "every" || requests.some((request) => request.proxy);
+			if (project.middlewareFile && proxy) files.add(normalizePath(project.middlewareFile));
+			files.delete(normalizePath(id.split("?")[0]));
+			if (files.size === 0) return;
+			return {
+				code: `${code}\nvoid (() => [${[...files].sort().map((file) => `import(${JSON.stringify(file)})`).join(", ")}]);\n`,
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+export { placeholder, requestsOf, routeLookupPlugin, routesOf };

package/dist/routes-ahead-shared.d.ts

@@ -0,0 +1,17 @@
+//#region src/routes-ahead-shared.d.ts
+/**
+ * Where the page tells the dev server of a test file that starts in it, and
+ * of a route it opened, over the websocket of the page (`askDevServer()` in
+ * ../utils.ts), with a `RoutesAheadNews`.
+ */
+declare const routesAheadEvent = "vitest-plugin-rsc:next-routes-ahead";
+/**
+ * A test file that starts in a tab, or a route that one opened, by the name
+ * of its modules. The file is absolute, as Vitest names it.
+ */
+type RoutesAheadNews = {
+  testFile: string;
+  opened?: string;
+};
+//#endregion
+export { RoutesAheadNews, routesAheadEvent };

package/dist/routes-ahead-shared.js

@@ -0,0 +1,9 @@
+//#region src/routes-ahead-shared.ts
+/**
+* Where the page tells the dev server of a test file that starts in it, and
+* of a route it opened, over the websocket of the page (`askDevServer()` in
+* ../utils.ts), with a `RoutesAheadNews`.
+*/
+const routesAheadEvent = "vitest-plugin-rsc:next-routes-ahead";
+//#endregion
+export { routesAheadEvent };

package/dist/routes-ahead.d.ts

@@ -0,0 +1,10 @@
+import { Plugin, ViteDevServer } from "vite";
+
+//#region src/routes-ahead.d.ts
+type RoutesAheadOptions = {
+  /** The root of the project, under whose `node_modules/.cache/` the routes are kept. */root(): string; /** Has the dev server compile a route, by the name of its modules: see `compileRoute()` in styles.ts. */
+  compile(vite: ViteDevServer, entry: string): Promise<unknown>;
+};
+declare function routesAheadPlugin(options: RoutesAheadOptions): Plugin;
+//#endregion
+export { RoutesAheadOptions, routesAheadPlugin };

package/dist/routes-ahead.js

@@ -0,0 +1,54 @@
+import { routesAheadEvent } from "./routes-ahead-shared.js";
+import { normalizePath } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import { answerPage } from "@kasperpeulen/vitest-plugin-rsc/internal/page-bridge";
+//#region src/routes-ahead.ts
+const cacheFile = "node_modules/.cache/vitest-plugin-rsc/routes-ahead-1.json";
+function routesAheadPlugin(options) {
+	let kept;
+	const opened = /* @__PURE__ */ new Map();
+	function read() {
+		if (kept) return kept;
+		try {
+			const { files } = JSON.parse(fs.readFileSync(path.join(options.root(), cacheFile), "utf8"));
+			kept = new Map(Object.entries(files));
+		} catch {
+			kept = /* @__PURE__ */ new Map();
+		}
+		return kept;
+	}
+	function write(routes) {
+		const file = path.join(options.root(), cacheFile);
+		try {
+			fs.mkdirSync(path.dirname(file), { recursive: true });
+			const written = `${file}.${process.pid}`;
+			fs.writeFileSync(written, JSON.stringify({ files: Object.fromEntries(routes) }));
+			fs.renameSync(written, file);
+		} catch {}
+	}
+	return {
+		name: "vitest-plugin-rsc:next-routes-ahead",
+		configureServer(vite) {
+			answerPage(vite, routesAheadEvent, async ({ testFile, opened: entry }) => {
+				const file = normalizePath(path.relative(options.root(), testFile));
+				const routes = read();
+				if (entry === void 0) {
+					for (const ahead of routes.get(file) ?? []) await options.compile(vite, ahead).catch(() => {});
+					return null;
+				}
+				const now = opened.get(file) ?? [];
+				opened.set(file, now);
+				if (now.includes(entry)) return null;
+				now.push(entry);
+				const before = routes.get(file);
+				if (before?.length === now.length && before.every((route, i) => route === now[i])) return null;
+				routes.set(file, [...now]);
+				write(routes);
+				return null;
+			});
+		}
+	};
+}
+//#endregion
+export { routesAheadPlugin };

package/dist/rsc.d.ts

@@ -0,0 +1,19 @@
+//#region src/rsc.d.ts
+/** The page module of the route of a node: see `loadNodeEntry()` in project/entries.ts. */
+declare function loadComponent(): Promise<{
+  default: () => unknown;
+}>;
+declare global {
+  var __vite_rsc_require__: (id: string) => Promise<unknown>;
+}
+/**
+ * Next's `__next_app__.require`: the module loader of the server bundle, which
+ * holds the modules of both server layers. React's Flight codec calls it for a
+ * reference in a payload, and Next calls it for the module of a Server Action.
+ *
+ * Like webpack's, it returns the same promise for the same id: React keeps the
+ * state of a module on that promise.
+ */
+declare function requireModule(id: string): Promise<unknown>;
+//#endregion
+export { loadComponent, requireModule };

package/dist/rsc.js

@@ -0,0 +1,171 @@
+import { actionModulePrefix, registry } from "./registry.js";
+import { builtStylesheetsOf, stylesheetsEvent } from "./styles-shared.js";
+import { buildDirectory, builtFiles } from "./built-files.js";
+import { preloadPage } from "./document.js";
+import { NoFallbackError } from "./compat/rsc/handlers.js";
+import { nextConfig, speedFeatures } from "virtual:vitest-plugin-rsc/next-manifest";
+import { askDevServer, versionsOfAnswers } from "@kasperpeulen/vitest-plugin-rsc/internal/utils";
+import { createElement } from "react";
+import { NodeRendered } from "@kasperpeulen/vitest-plugin-nextjs/node-rendered";
+import { createServerManifest } from "@vitejs/plugin-rsc/core/rsc";
+import * as ReactServer from "@vitejs/plugin-rsc/react/rsc";
+import { prerender } from "@vitejs/plugin-rsc/react/rsc/static";
+import * as FlightServer from "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge";
+import appPages from "virtual:vitest-plugin-rsc/next-app-pages";
+import loadMiddleware from "virtual:vitest-plugin-rsc/next-middleware";
+import routeHandlers from "virtual:vitest-plugin-rsc/next-route-handlers";
+import serverReferences from "virtual:vitest-plugin-rsc/server-references";
+//#region src/rsc.ts
+ReactServer.setRequireModule({ load: (id) => {
+	if (!serverReferences) return __vite_rsc_raw_import__(id);
+	const load = serverReferences[id];
+	if (!load) return Promise.reject(/* @__PURE__ */ new Error(`vitest-plugin-rsc: the build has no Server Action module "${id}"`));
+	return load();
+} });
+registry.speedFeatures = speedFeatures;
+registry.flightServer = {
+	renderToReadableStream: (model, _clientModules, options) => ReactServer.renderToReadableStream(model, options),
+	decodeReply: (body, _serverModules, options) => ReactServer.decodeReply(body, options),
+	decodeReplyFromAsyncIterable: (body, _serverModules, options) => FlightServer.decodeReplyFromAsyncIterable(body, createServerManifest(), options),
+	decodeAction: (body) => ReactServer.decodeAction(body),
+	decodeFormState: (result, body) => ReactServer.decodeFormState(result, body),
+	createTemporaryReferenceSet: ReactServer.createTemporaryReferenceSet,
+	registerServerReference: ReactServer.registerServerReference,
+	registerClientReference: ReactServer.registerClientReference,
+	createClientModuleProxy: FlightServer.createClientModuleProxy
+};
+registry.flightServer.decodeReplyFromBusboy = (busboy, _serverModules, options) => new Promise((resolve, reject) => {
+	const form = new FormData();
+	busboy.on("field", (name, value) => form.append(name, value));
+	busboy.on("file", (name, file, info) => {
+		const chunks = [];
+		file.on("data", (chunk) => chunks.push(new Uint8Array(chunk)));
+		file.on("end", () => form.append(name, new File(chunks, info.filename, { type: info.mimeType })));
+	});
+	busboy.on("error", reject);
+	busboy.on("finish", () => resolve(ReactServer.decodeReply(form, options)));
+});
+registry.flightStatic = { prerender: (model, _clientModules, options) => prerender(model, options) };
+registry.flightClient = {
+	createFromReadableStream: (stream, { serverConsumerManifest: _, ...options } = {}) => ReactServer.createFromReadableStream(stream, options),
+	encodeReply: ReactServer.encodeReply,
+	createTemporaryReferenceSet: ReactServer.createClientTemporaryReferenceSet
+};
+function withServerCache(entry) {
+	const { routeModule } = entry;
+	if (routeModule) routeModule.getIncrementalCache = async () => globalThis.__incrementalCache;
+	return entry;
+}
+registry.loadAppPage = async (page) => {
+	const load = appPages[page];
+	if (!load) throw new Error(`vitest-plugin-rsc: unknown Next.js app page ${page}`);
+	return registry.appPages[page] ??= withServerCache(await load());
+};
+const directory = buildDirectory;
+if (directory) {
+	builtFiles().catch(() => {});
+	const warned = /* @__PURE__ */ new Set();
+	const missing = (file) => {
+		if (warned.has(file)) return;
+		warned.add(file);
+		console.warn(`vitest-plugin-rsc: the files that render a node, \`hostFiles\` of renderServer(), name ${file}, which the static build has no stylesheets for: it is no file of the host that the rsc layer built. In a build the files of the host are what \`host.files\` of vitestPluginNext() matches, named from the root of the project. The stylesheets it imports are not linked.`);
+	};
+	registry.loadStylesheets = async (entry, _inline, files) => builtStylesheetsOf(await builtFiles(), entry, directory, files, missing);
+	const linksAtPath = process.env.NODE_ENV === "production" && !nextConfig.deploymentId;
+	const encoded = (path) => path.split("/").map(encodeURIComponent).join("/");
+	registry.preloadRoute = async (entry, files, signal) => {
+		const built = await builtFiles().catch(() => void 0);
+		if (!built || signal?.aborted) return;
+		const linked = Object.values(builtStylesheetsOf(built, entry, directory, files)).flat();
+		preloadPage({
+			stylesheets: linksAtPath ? linked.map(({ path }) => new URL(`${nextConfig.assetPrefix}/_next/${encoded(path)}`, location.href).href) : [],
+			crossOrigin: nextConfig.crossOrigin || void 0,
+			modules: (built.modules[entry] ?? []).map((index) => new URL(built.chunks[index], directory).href)
+		});
+	};
+} else {
+	const stylesheets = /* @__PURE__ */ new Map();
+	let stylesheetsOf;
+	registry.loadStylesheets = async (entry, inline, files) => {
+		registry.routeOpened?.(entry);
+		const versions = await versionsOfAnswers();
+		if (versions !== stylesheetsOf) {
+			stylesheets.clear();
+			stylesheetsOf = versions;
+		}
+		const key = JSON.stringify([
+			entry,
+			inline,
+			files
+		]);
+		let answer = stylesheets.get(key);
+		if (!answer) {
+			const asked = askDevServer(stylesheetsEvent, {
+				entry,
+				inline,
+				files
+			});
+			stylesheets.set(key, answer = asked);
+			asked.catch(() => stylesheets.get(key) === asked && stylesheets.delete(key));
+		}
+		return answer;
+	};
+	registry.preloadRoute = async () => {};
+}
+/** The page module of the route of a node: see `loadNodeEntry()` in project/entries.ts. */
+async function loadComponent() {
+	return { default: function Component() {
+		const node = (registry.openedByRequest.getStore() ?? registry.opened)?.node;
+		if (!node) throw new Error("vitest-plugin-rsc: the node of the test is gone");
+		const { ui, version } = node;
+		return version === void 0 ? ui : createElement(NodeRendered, { version }, ui);
+	} };
+}
+const loadRouteHandler = async (page) => {
+	const load = routeHandlers[page];
+	if (!load) throw new Error(`vitest-plugin-rsc: unknown Next.js route handler ${page}`);
+	return withServerCache(await load());
+};
+registry.loadRouteHandler = async (page) => (await loadRouteHandler(page)).handler;
+registry.prerenderVerdict = async ({ kind, page, pathname }) => {
+	const { prerenderVerdictOf } = await import("virtual:vitest-plugin-rsc/next-prerender");
+	return prerenderVerdictOf(kind === "route" ? await loadRouteHandler(page) : await registry.loadAppPage(page), pathname, kind);
+};
+registry.isNoFallbackError = (error) => error instanceof NoFallbackError;
+registry.loadMiddleware = async () => {
+	if (!loadMiddleware) throw new Error("vitest-plugin-rsc: the app has no middleware");
+	return (await loadMiddleware()).handler;
+};
+const modules = /* @__PURE__ */ new Map();
+/**
+* Next's `__next_app__.require`: the module loader of the server bundle, which
+* holds the modules of both server layers. React's Flight codec calls it for a
+* reference in a payload, and Next calls it for the module of a Server Action.
+*
+* Like webpack's, it returns the same promise for the same id: React keeps the
+* state of a module on that promise.
+*/
+function requireModule(id) {
+	let loading = modules.get(id);
+	if (!loading) modules.set(id, loading = loadModule(id));
+	return loading;
+}
+registry.ownServerAction = import("./server-action.js").then(({ runInServerActionOfTest }) => Reflect.get(runInServerActionOfTest, "$$id"));
+registry.hasServerAction = async (id) => {
+	if (!id.includes("#")) return false;
+	try {
+		return (await requireModule(actionModulePrefix + id))[id]?.$$typeof === Symbol.for("react.server.reference");
+	} catch {
+		return true;
+	}
+};
+async function loadModule(id) {
+	if (id.startsWith("action:")) {
+		const actionId = id.slice(actionModulePrefix.length);
+		return { [actionId]: await ReactServer.loadServerAction(actionId) };
+	}
+	if (id.startsWith("$$server:")) return globalThis.__vite_rsc_require__(id);
+	return registry.loadSsrModule(id);
+}
+//#endregion
+export { loadComponent, requireModule };

package/dist/server-action.d.ts

@@ -0,0 +1,9 @@
+//#region src/server-action.d.ts
+/**
+ * The Server Action that `runInServerAction()` calls: it runs the function the
+ * test handed over. The test and the server share their modules, so that is
+ * the test's own function, inside the request of the action.
+ */
+declare function runInServerActionOfTest(key: number): Promise<void>;
+//#endregion
+export { runInServerActionOfTest };

package/dist/server-action.js

@@ -0,0 +1,15 @@
+"use server";
+import { registry } from "./registry.js";
+//#region src/server-action.ts
+/**
+* The Server Action that `runInServerAction()` calls: it runs the function the
+* test handed over. The test and the server share their modules, so that is
+* the test's own function, inside the request of the action.
+*/
+async function runInServerActionOfTest(key) {
+	const action = registry.serverActions.get(key);
+	if (!action) throw new Error("vitest-plugin-rsc: no function to run as a Server Action");
+	await action();
+}
+//#endregion
+export { runInServerActionOfTest };