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

package/dist/ssr.js

@@ -0,0 +1,480 @@
+import { openedAt, registry } from "./registry.js";
+import { actionIdsOf } from "./action-ids.js";
+import { incoming, middlewareResult, redirectStatus, resolve } from "./server-in-front.js";
+import { demoteRoute, isPrerendered, nodeRouteDistDir, prerenderManifest, recordRoute, setServerActions, setStylesheets, withoutRoute } from "./build-output.js";
+import { loadCacheHandlers, resetCaches, shareIncrementalCache } from "./cache.js";
+import { registerModuleLoader } from "./client-modules.js";
+import { countBailouts, handleRequest as handleRequest$1, isPrerenderBailout, writingOf } from "./node-server.js";
+import { NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_RSC_UNION_QUERY, RSC_HEADER, appPageModule, getIsPossibleServerAction, getRouteMatcher, getRouteRegex, isRSCRequestHeader, normalizeNextQueryParam } from "./compat/ssr/handler.js";
+import { getAccessFallbackHTTPStatus, getRedirectStatusCodeFromError, getURLFromRedirectError, isHTTPAccessFallbackError, isRedirectError } from "./compat/ssr/render-errors.js";
+import { build, routes, routing } from "virtual:vitest-plugin-rsc/next-manifest";
+//#region src/ssr.ts
+registry.ssr = appPageModule;
+registerModuleLoader("ssr");
+const routes$1 = new Map(routes.filter((route) => !route.component).map((route) => [route.page, route]));
+const componentRoutes = new Map(routes.filter((route) => route.component && !route.layouts).map((route) => [route.pathname, route]));
+const componentLayoutRoutes = new Map(routes.filter((route) => route.layouts).map((route) => [route.page, route]));
+const notFoundPage = "/_not-found/page";
+function appQuery(query) {
+	const result = Object.create(null);
+	for (const [name, value] of query) {
+		if (normalizeNextQueryParam(name) !== null) continue;
+		result[name] = name in result ? [result[name], value].flat() : value;
+	}
+	return result;
+}
+function searchOf(query) {
+	const search = new URLSearchParams();
+	for (const [name, value] of Object.entries(query)) {
+		if (name === NEXT_RSC_UNION_QUERY) continue;
+		for (const item of [value].flat()) search.append(name, item);
+	}
+	return search.toString();
+}
+const paramMatchers = /* @__PURE__ */ new Map();
+function paramsOf(route, pathname) {
+	let match = paramMatchers.get(route);
+	if (!match) {
+		const { re, groups } = getRouteRegex(route);
+		match = getRouteMatcher({
+			re: new RegExp(re.source, "i"),
+			groups
+		});
+		paramMatchers.set(route, match);
+	}
+	try {
+		return match(pathname) || void 0;
+	} catch {
+		return;
+	}
+}
+function withoutBasePath(pathname) {
+	const { basePath } = routing;
+	return basePath && pathname.startsWith(basePath) ? pathname.slice(basePath.length) || "/" : pathname;
+}
+const setTimeout = globalThis.setTimeout;
+const clearTimeout = globalThis.clearTimeout;
+const now = performance.now.bind(performance);
+let queue = Promise.resolve();
+let queued = 0;
+let requestQueued = Promise.withResolvers();
+const nextRequest = () => queued > 0 ? Promise.resolve() : requestQueued.promise;
+const rendering = /* @__PURE__ */ new Set();
+let generation = 0;
+const backgroundWorkTimeout = 1e3;
+const backgroundWork = /* @__PURE__ */ new Set();
+const unanswered = /* @__PURE__ */ new Map();
+const settleTimeout = 5e3;
+function streamOf(body) {
+	return new ReadableStream({ start(controller) {
+		if (body) controller.enqueue(body);
+		controller.close();
+	} });
+}
+function handleRequest(request, { nested = false, unrouted = "not-found", opened, pageLoad = false } = {}) {
+	if (nested) return untilAnswered(request, handle(request, unrouted, true, opened, pageLoad)).then(({ response }) => response);
+	const requested = generation;
+	queued++;
+	requestQueued.resolve();
+	const timing = registry.requestTimings && timingOf(request);
+	if (timing) registry.requestTimings.push(timing);
+	const result = queue.then(() => {
+		if (requested !== generation) throw new DOMException("The page was left before the server responded.", "AbortError");
+		queued--;
+		requestQueued = Promise.withResolvers();
+		if (timing) timing.started = performance.now();
+		const handled = untilAnswered(request, handle(request, unrouted, false, opened, pageLoad));
+		if (timing) handled.then(({ finished }) => {
+			timing.answered = performance.now();
+			const record = () => timing.finished = performance.now();
+			finished.then(record, record);
+		}, () => {});
+		return handled;
+	});
+	queue = result.then(({ finished }) => finished, () => {});
+	return result.then(({ response }) => response);
+}
+function timingOf(request) {
+	const { headers } = request;
+	const flight = headers.has("rsc") && (headers.has("next-router-state-tree") || headers.has("next-router-prefetch"));
+	const kind = headers.has("next-action") ? "action" : flight ? "flight" : "page";
+	return {
+		method: request.method,
+		url: request.url,
+		kind,
+		queued: performance.now()
+	};
+}
+function untilAnswered(request, handled) {
+	const settled = handled.then(() => {}, () => {});
+	unanswered.set(settled, `${request.method} ${new URL(request.url).pathname}`);
+	settled.then(() => unanswered.delete(settled));
+	return handled;
+}
+async function stopResponses(written) {
+	await Promise.race([written, new Promise((resolve) => setTimeout(resolve, 100))]);
+	for (const stop of rendering) stop();
+	rendering.clear();
+}
+async function untilDone(work, deadline) {
+	let done = true;
+	for (let waiting = [...work()]; waiting.length > 0 && done; waiting = [...work()]) {
+		let timeout;
+		done = await Promise.race([Promise.all(waiting).then(() => true), new Promise((resolve) => timeout = setTimeout(resolve, Math.max(0, deadline - now()), false))]);
+		clearTimeout(timeout);
+	}
+	return done;
+}
+/**
+* How Next's server answers the document of a page when an error fails the
+* render of its HTML before any of it is out, by the digest of the error, as
+* Next's renderer does in the `catch` of `renderToStream()` (app-render.js):
+* the status of a `notFound()`, `forbidden()` or `unauthorized()`, the 307 or
+* 308 of a `redirect()` and where it goes, without the app's `basePath`, and
+* 500 for any other error. For a page that the server renders no HTML of: see
+* `renderFailureOf()` in page.ts.
+*/
+function shellErrorAnswer(digest) {
+	const error = Object.assign(/* @__PURE__ */ new Error(), { digest });
+	if (isHTTPAccessFallbackError(error)) return { status: getAccessFallbackHTTPStatus(error) };
+	if (isRedirectError(error)) return {
+		status: getRedirectStatusCodeFromError(error),
+		location: getURLFromRedirectError(error)
+	};
+	return { status: 500 };
+}
+/**
+* Ends the requests the server is still handling, when a page is left.
+*
+* A request that has its answer is writing the body: a short wait, then a
+* stop. A test can end while a page streams, on data that will never come.
+*
+* A request that has no answer yet runs code of the app, like a Server Action
+* or a route handler, and nothing can stop that. So it is waited for, and
+* then for the body it writes. So is what requests do after their response,
+* like `after()`. What comes next is not to run while any of that still reads
+* or sets the stores of a request, which would be the ones of the requests
+* that come next. A request that is sent in the meantime waits for all of
+* that, and is dropped: it is one of the page that was left.
+*/
+async function settleRequests() {
+	generation++;
+	const written = queue;
+	const settled = Promise.withResolvers();
+	queue = settled.promise;
+	queued = 0;
+	const waited = requestQueued;
+	requestQueued = Promise.withResolvers();
+	const deadline = now() + settleTimeout;
+	try {
+		await stopResponses(written);
+		if (unanswered.size > 0) {
+			if (!await untilDone(() => unanswered.keys(), deadline)) {
+				console.warn(`vitest-plugin-rsc: the server was still handling ${[...unanswered.values()].join(", ")} ${settleTimeout / 1e3}s after the page was left. What comes next runs anyway. Until that request is done, its code and the requests that come next can read and set each other's cookies, headers and other values of a request.`);
+				unanswered.clear();
+			}
+			await stopResponses(new Promise(() => {}));
+		}
+		const worked = await untilDone(() => backgroundWork, deadline);
+		waited.resolve();
+		if (!worked) {
+			backgroundWork.clear();
+			console.warn(`vitest-plugin-rsc: \`after()\` or \`waitUntil()\` work of a request was still running ${settleTimeout / 1e3}s after a page was left. What comes next runs anyway, and that work may read the stores of the requests that come next.`);
+		}
+	} finally {
+		generation++;
+		queued = 0;
+		waited.resolve();
+		requestQueued.resolve();
+		requestQueued = Promise.withResolvers();
+		settled.resolve();
+	}
+}
+function nodeRouteFor(opened, matched) {
+	const node = opened?.node;
+	if (!node) return void 0;
+	if (!node.layouts) return componentRoutes.get(matched?.pathname ?? "/") ?? componentRoutes.get("/");
+	const withLayouts = componentLayoutRoutes.get(matched?.page ?? "");
+	if (!withLayouts) throw new Error(`vitest-plugin-rsc: \`layouts: true\` renders a node in place of the \`page\` file of its \`url\`, and the app has none for ${opened.pathname}.`);
+	return withLayouts;
+}
+const verdicts = /* @__PURE__ */ new Map();
+function verdictOf(route) {
+	let verdict = verdicts.get(route.page);
+	if (!verdict) {
+		const endScope = registry.enterRequestScope();
+		verdict = registry.prerenderVerdict(route).finally(endScope);
+		verdicts.set(route.page, verdict);
+		verdict.catch(() => verdicts.delete(route.page));
+	}
+	return verdict;
+}
+const recorded = /* @__PURE__ */ new Set();
+async function recordVerdict(route) {
+	const verdict = await verdictOf(route);
+	if (recorded.has(route.page)) return;
+	recorded.add(route.page);
+	recordRoute(route, verdict);
+}
+async function isUnlisted(route, pathname) {
+	if (recorded.has(route.page)) return prerenderManifest.dynamicRoutes[route.pathname]?.fallback === false && !(pathname in prerenderManifest.routes);
+	const verdict = await verdictOf(route);
+	return verdict?.fallback === false && !verdict.pathnames.includes(pathname);
+}
+async function prerenderFirst(route, scope, respond) {
+	if (!route || !isPrerendered(route)) return respond();
+	const endPrerender = scope.enterInner();
+	const bailouts = countBailouts();
+	try {
+		const response = await respond();
+		const bailedOut = bailouts() > 0;
+		if (response.status !== 500 || !bailedOut) return response;
+		await response.body?.cancel();
+	} catch (error) {
+		bailouts();
+		if (!isPrerenderBailout(error)) throw error;
+	}
+	endPrerender();
+	demoteRoute(route);
+	return respond();
+}
+async function serverActionsOf(request) {
+	const own = await registry.ownServerAction;
+	const ids = new Set(own ? [own] : []);
+	for (const id of await actionIdsOf(request)) if (await registry.hasServerAction(id)) ids.add(id);
+	return ids;
+}
+function enterScope(waited) {
+	const endScope = registry.enterRequestScope();
+	const background = [];
+	const waitUntil = (promise) => {
+		background.push(promise);
+		const work = promise.then(() => {}, () => {});
+		backgroundWork.add(work);
+		work.then(() => backgroundWork.delete(work));
+	};
+	const backgroundSettled = async () => {
+		for (let settled = 0; settled < background.length;) {
+			const waiting = background.slice(settled);
+			settled = background.length;
+			await Promise.allSettled(waiting);
+		}
+	};
+	const inner = [];
+	const enterInner = () => {
+		const endInner = registry.enterRequestScope();
+		inner.push(endInner);
+		return endInner;
+	};
+	const endAll = () => {
+		for (const endInner of inner) endInner();
+		endScope();
+	};
+	const end = async () => {
+		await Promise.race([backgroundSettled(), waited().then(() => new Promise((resolve) => setTimeout(resolve, backgroundWorkTimeout)))]);
+		endAll();
+	};
+	return {
+		waitUntil,
+		end,
+		endScope: endAll,
+		enterInner
+	};
+}
+async function handle(received, unrouted, nested, openedByRequest, pageLoad) {
+	const request = incoming(received);
+	const url = new URL(request.url);
+	const opened = openedByRequest === null ? void 0 : openedByRequest ?? openedAt(url);
+	const scope = enterScope(nested ? () => Promise.resolve() : nextRequest);
+	registry.openedByRequest.run(opened, () => {});
+	const context = { waitUntil: scope.waitUntil };
+	const endRequest = scope.end;
+	try {
+		let { body } = request;
+		let middlewareBody;
+		if (body instanceof ReadableStream) [middlewareBody, body] = body.tee();
+		else middlewareBody = streamOf(body);
+		let responded;
+		let { headers } = request;
+		const invokeMiddleware = async (target) => {
+			const middlewareScope = enterScope(() => Promise.resolve());
+			let response;
+			try {
+				response = await (await registry.loadMiddleware())({
+					...request,
+					url: target.url.href,
+					headers: target.headers,
+					body: target.requestBody
+				}, {
+					waitUntil: middlewareScope.waitUntil,
+					signal: request.signal
+				});
+			} catch (error) {
+				if (request.signal?.aborted) throw error;
+				console.error(error);
+				responded = new registry.Response("Internal Server Error", { status: 500 });
+				return { bodySent: true };
+			} finally {
+				await middlewareScope.end();
+			}
+			const result = middlewareResult(response, target.headers, target.url);
+			if (result.bodySent) responded = response;
+			else headers = result.requestHeaders ?? headers;
+			return result;
+		};
+		const proxy = opened?.proxy ?? true;
+		await loadCacheHandlers();
+		const resolved = await resolve(request, middlewareBody, invokeMiddleware, proxy);
+		shareIncrementalCache(headers);
+		const routedHeaders = resolved.resolvedHeaders ?? new registry.Headers();
+		if (responded) return finishWithBody(request, responded, endRequest);
+		const redirect = redirectStatus(resolved);
+		if (redirect !== void 0) return finishWithBody(request, new registry.Response(null, {
+			status: redirect,
+			headers: routedHeaders
+		}), endRequest);
+		if (resolved.externalRewrite) {
+			const hasBody = request.method !== "GET" && request.method !== "HEAD";
+			return finishWithBody(request, await registry.network(resolved.externalRewrite, {
+				method: request.method,
+				headers,
+				body: hasBody ? await new registry.Response(body).arrayBuffer() : void 0,
+				signal: request.signal
+			}), endRequest, routedHeaders);
+		}
+		const matched = routes$1.get(routing.outputs[resolved.resolvedPathname ?? ""] ?? "");
+		const component = nodeRouteFor(opened, matched);
+		if (!matched && !component && unrouted === "pass") return { finished: endRequest() };
+		const page = component?.page ?? matched?.page ?? notFoundPage;
+		const entry = component?.component ?? page;
+		const routed = {
+			...request,
+			headers,
+			body
+		};
+		const target = resolved.invocationTarget;
+		const query = target && appQuery(Object.entries(target.query));
+		const rewrittenPath = target !== void 0 && target.pathname !== url.pathname;
+		const rewrittenQuery = query !== void 0 && searchOf(query) !== searchOf(appQuery(url.searchParams));
+		const namesParam = [...url.searchParams.keys()].some((name) => normalizeNextQueryParam(name) !== null);
+		const requestMeta = {
+			params: target && matched?.pathname.includes("[") ? paramsOf(matched.pathname, withoutBasePath(target.pathname)) : void 0,
+			query: rewrittenPath || rewrittenQuery || namesParam ? query : void 0
+		};
+		if (target && query && isRSCRequestHeader(headers.get(RSC_HEADER) ?? void 0)) {
+			if (rewrittenPath) routedHeaders.set(NEXT_REWRITTEN_PATH_HEADER, withoutBasePath(target.pathname));
+			if (rewrittenQuery && !routedHeaders.has(NEXT_REWRITTEN_QUERY_HEADER)) routedHeaders.set(NEXT_REWRITTEN_QUERY_HEADER, searchOf(query));
+		}
+		const prerenders = build === "production" && !component && matched && matched.page !== notFoundPage ? matched : void 0;
+		const prefetch = prerenders?.kind === "page" && headers.get(NEXT_ROUTER_PREFETCH_HEADER) === "1" && isRSCRequestHeader(headers.get(RSC_HEADER) ?? void 0);
+		if (prerenders && !prefetch) await recordVerdict(prerenders);
+		if (prerenders && isPrerendered(prerenders) && request.method !== "GET" && request.method !== "HEAD" && !getIsPossibleServerAction({
+			method: request.method,
+			headers
+		})) return finishWithBody(request, new registry.Response("Method Not Allowed", {
+			status: 405,
+			headers: { allow: "GET, HEAD" }
+		}), endRequest, routedHeaders);
+		const renderPage = async (page, entry, meta = requestMeta) => {
+			setServerActions(await serverActionsOf(routed));
+			const inline = !isRSCRequestHeader(headers.get(RSC_HEADER) ?? void 0);
+			const files = component ? opened?.node?.files ?? [] : [];
+			if (pageLoad && inline) await registry.preloadRoute(entry, files, request.signal);
+			const [stylesheets, { handler, routeModule }] = await Promise.all([registry.loadStylesheets(entry, inline, files), registry.loadAppPage(entry)]);
+			setStylesheets(stylesheets);
+			if (component) routeModule.distDir = nodeRouteDistDir;
+			const statusCode = page === notFoundPage ? 404 : void 0;
+			const respond = () => handleRequest$1(routed, context, handler, meta, {
+				statusCode,
+				headers: routedHeaders
+			});
+			if (page === notFoundPage) return respond();
+			if (prefetch) return withoutRoute(prerenders, respond);
+			return prerenderFirst(prerenders, scope, respond);
+		};
+		const renderNotFound = async () => finishWithBody(request, await renderPage(notFoundPage, notFoundPage, {}), endRequest, cookiesOf(routedHeaders));
+		if (!component && matched?.kind === "route") {
+			const handler = await registry.loadRouteHandler(page);
+			let response;
+			try {
+				response = await prerenderFirst(prerenders, scope, () => handleRequest$1(routed, context, handler, requestMeta, { headers: routedHeaders }));
+			} catch (error) {
+				if (registry.isNoFallbackError(error)) return renderNotFound();
+				if (!prerenders || request.signal?.aborted) throw error;
+				response = new registry.Response(null, { status: 500 });
+			}
+			if (prerenders && !(response.status < 400 || response.status === 404)) demoteRoute(prerenders);
+			return finishWithBody(request, response, endRequest, cookiesOf(routedHeaders));
+		}
+		if (prefetch) {
+			const pathname = withoutBasePath(target?.pathname ?? url.pathname);
+			if (await isUnlisted(prerenders, pathname.length > 1 ? pathname.replace(/\/$/, "") : pathname)) return renderNotFound();
+		}
+		let response;
+		try {
+			response = await renderPage(page, entry);
+		} catch (error) {
+			if (page === notFoundPage || !registry.isNoFallbackError(error)) throw error;
+			return renderNotFound();
+		}
+		return finishWithBody(request, response, endRequest, cookiesOf(routedHeaders));
+	} catch (error) {
+		scope.endScope();
+		throw error;
+	}
+}
+function cookiesOf(headers) {
+	const cookies = new registry.Headers();
+	for (const cookie of headers.getSetCookie()) cookies.append("set-cookie", cookie);
+	return cookies;
+}
+function finishWithBody(request, response, onFinish, routedHeaders) {
+	let finished;
+	let body = null;
+	const writing = writingOf(response);
+	if (writing) {
+		rendering.add(writing.stop);
+		body = response.body;
+		finished = writing.written.finally(() => {
+			rendering.delete(writing.stop);
+			return onFinish();
+		});
+	} else if (response.body) {
+		const pipe = new TransformStream(void 0, void 0, { highWaterMark: Infinity });
+		const stopping = new AbortController();
+		const stop = () => stopping.abort();
+		rendering.add(stop);
+		body = pipe.readable;
+		const source = response.body;
+		finished = source.pipeTo(pipe.writable, {
+			signal: stopping.signal,
+			preventCancel: true
+		}).catch(() => source.cancel(new DOMException("The page was left before the server had sent it.", "AbortError"))).catch(() => {}).finally(() => {
+			rendering.delete(stop);
+			return onFinish();
+		});
+	} else finished = onFinish();
+	const adds = routedHeaders !== void 0 && !routedHeaders.keys().next().done;
+	if (writing && !adds && request.method !== "HEAD") return {
+		response,
+		finished
+	};
+	let { headers } = response;
+	if (routedHeaders) {
+		headers = new registry.Headers(routedHeaders);
+		response.headers.forEach((value, name) => {
+			if (name === "set-cookie") headers.append(name, value);
+			else headers.set(name, value);
+		});
+	}
+	return {
+		response: new registry.Response(request.method === "HEAD" ? null : body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		}),
+		finished
+	};
+}
+//#endregion
+export { handleRequest, resetCaches, settleRequests, shellErrorAnswer };

package/dist/static-build.d.ts

@@ -0,0 +1,36 @@
+import { Plugin } from "vite";
+
+//#region src/static-build.d.ts
+/**
+ * The `next.config` of the app as the layers of a static build have it: with
+ * each option that is a path of the machine as a path from the root of the
+ * project, like `next.config.ts` and `../..`. Next's build reads them, and its
+ * server reads none for a request but the cache handlers, which the plugin
+ * imports by a module of its own, which the build bundles. A build would
+ * otherwise have the directory it was built in, and differ from machine to
+ * machine.
+ *
+ * By the options, not by what a value looks like: `basePath: "/app"` of a
+ * project in `/app` is no path of the machine.
+ */
+declare function withPathsFromRoot<T>(config: T, root: string): T;
+type NextStaticBuildOptions = {
+  /** The Vite environment of each layer. */environments: {
+    rsc: string;
+    ssr: string;
+    browser: string;
+  }; /** What the page imports to start the layers that run through a module runner. */
+  entries: {
+    ssr: string;
+    browser: string;
+  }; /** The files Next's loaders made for the browser, by the path it asks for. */
+  emittedFiles(): {
+    pathname: string;
+    body: Uint8Array;
+  }[]; /** The plugin's module of the rsc layer, which renders the routes: rsc.ts. */
+  rscModule: string; /** Whether a module of the rsc layer's build is a file of the host. */
+  isHostFile(id: string): boolean;
+};
+declare function nextStaticBuild(options: NextStaticBuildOptions): Plugin;
+//#endregion
+export { NextStaticBuildOptions, nextStaticBuild, withPathsFromRoot };

package/dist/static-build.js

@@ -0,0 +1,92 @@
+import { normalizePath } from "vite";
+import path from "node:path";
+import { getPluginApi } from "@vitejs/plugin-rsc/plugin";
+import { withStaticBuild } from "@kasperpeulen/vitest-plugin-rsc/internal/static-build";
+//#region src/static-build.ts
+const configPaths = [
+	["configFile"],
+	["outputFileTracingRoot"],
+	["repoRoot"],
+	["turbopack", "root"],
+	["images", "loaderFile"],
+	["cacheHandler"],
+	["cacheHandlers", "*"],
+	["adapterPath"]
+];
+/**
+* The `next.config` of the app as the layers of a static build have it: with
+* each option that is a path of the machine as a path from the root of the
+* project, like `next.config.ts` and `../..`. Next's build reads them, and its
+* server reads none for a request but the cache handlers, which the plugin
+* imports by a module of its own, which the build bundles. A build would
+* otherwise have the directory it was built in, and differ from machine to
+* machine.
+*
+* By the options, not by what a value looks like: `basePath: "/app"` of a
+* project in `/app` is no path of the machine.
+*/
+function withPathsFromRoot(config, root) {
+	const copy = JSON.parse(JSON.stringify(config));
+	const relativize = (object, [key, ...rest]) => {
+		for (const name of key === "*" ? Object.keys(object) : [key]) {
+			const value = object[name];
+			if (rest.length > 0) {
+				if (value && typeof value === "object") relativize(value, rest);
+			} else if (typeof value === "string" && path.isAbsolute(value)) object[name] = normalizePath(path.relative(root, value)) || ".";
+		}
+	};
+	for (const keys of configPaths) relativize(copy, keys);
+	return copy;
+}
+function nextStaticBuild(options) {
+	const { rsc, ssr, browser } = options.environments;
+	let manager;
+	let reached;
+	return {
+		name: "vitest-plugin-rsc:next-static-build",
+		config(_config, { command }) {
+			if (command !== "build") return;
+			return withStaticBuild({
+				entries: {
+					[ssr]: options.entries.ssr,
+					[browser]: options.entries.browser
+				},
+				directives: ["use turbopack: no side effects"],
+				strictExecutionOrder: true,
+				files: options.emittedFiles,
+				clientReferences: { [ssr]: () => reached }
+			});
+		},
+		configResolved(resolved) {
+			if (resolved.command !== "build") return;
+			manager = getPluginApi(resolved)?.manager;
+			if (!resolved.plugins.some((plugin) => plugin.name === "vitest-plugin-rsc:static-build")) throw new Error("vitest-plugin-rsc: vitestPluginNext() needs vitestPluginRSC().");
+		},
+		buildEnd(error) {
+			if (error || this.environment.mode !== "build" || this.environment.name !== rsc) return;
+			if (!manager || manager.isScanBuild) return;
+			reached = void 0;
+			if (!this.getModuleInfo(options.rscModule)) return;
+			const references = manager.clientReferenceMetaMap;
+			const found = /* @__PURE__ */ new Set();
+			const queue = [...this.getModuleIds()].filter((id) => id === options.rscModule || options.isHostFile(id) && !references[id]);
+			const seen = new Set(queue);
+			for (const id of queue) {
+				const reference = references[id];
+				if (reference) {
+					found.add(reference.referenceKey);
+					continue;
+				}
+				const info = this.getModuleInfo(id);
+				for (const imported of [...info?.importedIds ?? [], ...info?.dynamicallyImportedIds ?? []]) {
+					if (seen.has(imported)) continue;
+					seen.add(imported);
+					queue.push(imported);
+				}
+			}
+			reached = found;
+		}
+	};
+}
+//#endregion
+export { nextStaticBuild, withPathsFromRoot };

package/dist/storage.d.ts

@@ -0,0 +1,31 @@
+//#region src/storage.d.ts
+/**
+ * The items of the page's `localStorage` and `sessionStorage`. One for each
+ * browser context of the app.
+ */
+declare class PageStorage {
+  readonly localStorage: Map<string, string>;
+  readonly sessionStorage: Map<string, string>;
+}
+/** The items of a storage, as a map has them: the page's, or the browser's. */
+type Items = {
+  get(key: string): string | undefined;
+  set(key: string, value: string): void;
+  delete(key: string): boolean;
+  has(key: string): boolean;
+  clear(): void;
+  keys(): Iterable<string>;
+  readonly size: number;
+};
+/** The items of a `Storage` of the browser's, as a map. */
+declare function itemsOfStorage(storage: Storage): Items;
+/**
+ * A `Storage` of the items that `items()` returns each time it is used. Its
+ * items are its properties too, as in a browser: `storage.theme`,
+ * `Object.keys(storage)` and `JSON.stringify(storage)` have them, and setting
+ * or deleting a property sets or removes an item. A name of `Storage`, like
+ * `key` or `length`, hides the item of that name.
+ */
+declare function storageOf(items: () => Items): Storage;
+//#endregion
+export { Items, PageStorage, itemsOfStorage, storageOf };