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

package/dist/client-files.js

@@ -0,0 +1,186 @@
+import { clientFileKeyExport } from "./client-file-key.js";
+import { movesItsLinks } from "./styles.js";
+import { builtHostModuleUrl, hostModulePrefix } from "@kasperpeulen/vitest-plugin-rsc/internal/host-module";
+import { normalizePath, parseAstAsync } from "vite";
+import path from "node:path";
+import { hasDirective } from "@vitejs/plugin-rsc/transforms";
+import { testFileReferencesPlugin, testFilesPlugin } from "@kasperpeulen/vitest-plugin-rsc/internal/test-file-references";
+//#region src/client-files.ts
+const parsedFile = /\.(?:tsx|ts|mts|jsx|js|mjs)$/;
+const languageOf = (file) => file.endsWith(".tsx") ? "tsx" : file.endsWith("ts") ? "ts" : "jsx";
+const versionQuery = /^\?v=[\w.-]+$/;
+/**
+* The file that a module of Vite is, by its id: the id, without the version
+* a dev server adds for a dependency. Nothing for an id with another query.
+*/
+function fileOfModule(id) {
+	const query = id.indexOf("?");
+	if (query === -1) return id;
+	return versionQuery.test(id.slice(query)) ? id.slice(0, query) : void 0;
+}
+/**
+* The client reference of a module of the rsc layer, in Vite RSC's map of
+* them. With a dev server, Vite RSC has a module in `node_modules` there by
+* its file, without the version, unless the page imports it by the name of
+* its package.
+*/
+function clientReferenceOfModule(references, id) {
+	const reference = references[id];
+	if (reference) return reference;
+	const file = fileOfModule(id);
+	return file === void 0 ? void 0 : references[file];
+}
+/**
+* What the module of the rsc layer for a file with `"use client"` starts
+* with, in front of the reference module, which has none of the code of the
+* file: the export `clientFileKeyExport` with the file's reference key, by
+* which `loadClientModule()` tells the module, see client-file-key.ts. For a
+* file of the host, `load`, also the line that loads the file in the browser
+* layer by that key, see client-graph.ts. With a dev server the key is the
+* URL of the file in the browser layer. In a build it is a hash.
+*/
+function clientFileCode({ referenceKey }, load) {
+	const key = `export const ${clientFileKeyExport} = ${JSON.stringify(referenceKey)}; `;
+	if (!load) return key;
+	return `import { loadClientFile as __vitestPluginRscLoadClientFile } from ${JSON.stringify(load.internal)}; ` + key + `await __vitestPluginRscLoadClientFile(${JSON.stringify(referenceKey)}); `;
+}
+/** What `renderServer()` throws in a file with `"use client"`. */
+const renderServerError = "vitest-plugin-rsc: renderServer() renders on the server, and this test file has \"use client\": it is client code, which cannot render server code. Render a Client Component with `render()` of vitest-browser-react or of @testing-library/react, or test a connected component with renderServer() in a test file without \"use client\".";
+/** What the page imports for a module of the host: see ../host-module.ts. */
+function hostModuleCode(target, testingLibrary) {
+	if (target === testingLibrary.specifier) return `import * as module from ${JSON.stringify(testingLibrary.file)};\nexport default {\n  ...module,\n  async renderServer() {\n    throw new Error(${JSON.stringify(renderServerError)});\n  },\n};\n`;
+	return `import * as module from ${JSON.stringify(target)};\nexport default module;\n`;
+}
+/**
+* Three plugins. One that says which modules are Vitest's files, which Vite
+* RSC makes a reference of last. Before Vite RSC: the modules of the page
+* for the browser layer, the error for a file with `"use client"` that mocks
+* a module, before Vite RSC drops the code of the file, and with a dev
+* server the change of the file's module in the rsc layer for a change of
+* what the file imports in the browser layer. After Vite RSC, which made the file a
+* reference: the line in front of that module, with the file's reference
+* key, which for a file of the host loads the file in the browser layer by
+* that key. Not a file without the directive: a test file without it renders
+* with `renderServer()`, in a page with a graph of its own.
+*/
+function clientFiles(options) {
+	const { rsc, browser } = options.environments;
+	const { testingLibrary, clientComponents, internal, isHostFile, isTestFile, isHostPackage } = options;
+	const { clientReferenceOf } = options;
+	const hostFileOf = (id) => {
+		const file = fileOfModule(id);
+		if (file === void 0 || !isHostFile(file)) return;
+		return file;
+	};
+	return [
+		{
+			name: testFilesPlugin,
+			api: { isModuleOfTestFile: (id) => {
+				const file = fileOfModule(id);
+				return file !== void 0 && isTestFile(file);
+			} }
+		},
+		{
+			name: "vitest-plugin-rsc:next-client-files",
+			enforce: "pre",
+			resolveId: {
+				order: "pre",
+				handler(source, importer) {
+					if (source.startsWith(hostModulePrefix)) return source;
+					if (this.environment.name !== browser) return;
+					const { root } = this.environment.config;
+					if (!importer || importer === path.posix.join(normalizePath(root), "index.html")) return;
+					const entry = source === testingLibrary.specifier || source === clientComponents;
+					if (isHostPackage(source) || entry) return this.environment.mode === "build" ? {
+						id: builtHostModuleUrl(source),
+						external: "absolute"
+					} : hostModulePrefix + source;
+				}
+			},
+			load(id) {
+				if (!id.startsWith(hostModulePrefix)) return;
+				const target = id.slice(hostModulePrefix.length);
+				if (this.environment.name !== rsc) return "export {};";
+				return hostModuleCode(target, testingLibrary);
+			},
+			async transform(code, id) {
+				if (this.environment.name !== rsc || !code.includes("use client")) return;
+				const file = hostFileOf(id);
+				if (!file || !parsedFile.test(file)) return;
+				const ast = await parseAstAsync(code, { lang: languageOf(file) });
+				if (!hasDirective(ast.body, "use client")) return;
+				const mocking = findMocking(ast);
+				if (mocking) this.error(`vitest-plugin-rsc: ${file} calls ${mocking}(), which a file with "use client" cannot: it runs in the browser layer, and Vitest's mocker replaces the modules of the rsc layer. Mock in a setup file or a test file without the directive, or pass a mock as a prop.`);
+			},
+			hotUpdate: {
+				order: "pre",
+				handler({ file, modules, server }) {
+					if (this.environment.name !== rsc) return;
+					const changed = server.environments[browser]?.moduleGraph.getModulesByFile(file);
+					if (!changed) return;
+					const config = this.environment.getTopLevelConfig();
+					const updated = new Set(modules);
+					for (const hostFile of hostFilesImporting(changed, isHostFile)) for (const node of this.environment.moduleGraph.getModulesByFile(hostFile) ?? []) if (node.id && clientReferenceOf(node.id, config)) updated.add(node);
+					if (updated.size > modules.length) return [...updated];
+				}
+			}
+		},
+		{
+			name: "vitest-plugin-rsc:next-load-client-files",
+			enforce: "post",
+			configResolved({ plugins }) {
+				const names = plugins.map(({ name }) => name);
+				if (names.indexOf(testFileReferencesPlugin) > names.indexOf("vitest-plugin-rsc:next-load-client-files")) throw new Error("vitest-plugin-rsc: vitestPluginNext() needs vitestPluginRSC() before it in the plugins.");
+			},
+			transform(code, id) {
+				if (this.environment.name !== rsc) return;
+				const config = this.environment.getTopLevelConfig();
+				const reference = clientReferenceOf(id, config);
+				if (!reference) return;
+				return {
+					code: clientFileCode(reference, hostFileOf(id) ? { internal } : void 0) + code,
+					map: null
+				};
+			}
+		}
+	];
+}
+/**
+* The files of the host among `modules` and the modules that import them in
+* a module graph, also through other modules. Not through a stylesheet whose
+* links move to the version of now (`movesItsLinks()`).
+*/
+function hostFilesImporting(modules, isHostFile) {
+	const files = /* @__PURE__ */ new Set();
+	const seen = new Set(modules);
+	for (const node of seen) {
+		if (movesItsLinks(node)) continue;
+		if (node.file && isHostFile(node.file)) files.add(node.file);
+		for (const importer of node.importers) seen.add(importer);
+	}
+	return files;
+}
+const mockingCall = /^(?:vi|vitest)\.(?:mock|unmock|doMock|doUnmock|hoisted)$/;
+/** The first call of the AST to a function of Vitest that mocks a module, like `vi.mock`. */
+function findMocking(node) {
+	if (Array.isArray(node)) {
+		for (const child of node) {
+			const found = findMocking(child);
+			if (found) return found;
+		}
+		return;
+	}
+	if (typeof node !== "object" || node === null) return;
+	const { type, callee } = node;
+	if (type === "CallExpression" && callee?.type === "MemberExpression" && !callee.computed && callee.object?.type === "Identifier" && callee.property?.type === "Identifier") {
+		const name = `${callee.object.name}.${callee.property.name}`;
+		if (mockingCall.test(name)) return name;
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent" || typeof value !== "object") continue;
+		const found = findMocking(value);
+		if (found) return found;
+	}
+}
+//#endregion
+export { clientFileCode, clientFiles, clientReferenceOfModule, fileOfModule, findMocking, hostModuleCode, renderServerError };

package/dist/client-graph.d.ts

@@ -0,0 +1,94 @@
+import { StylesheetVersions } from "./stylesheet-versions.js";
+
+//#region src/client-graph.d.ts
+/**
+ * Evaluates a file of the host with `"use client"` in the module graph of
+ * the browser layer: the file with the reference key `key`, which with a dev
+ * server is its URL in that layer. The module of the rsc layer for the file
+ * calls this before its own code runs, as Vitest evaluates what a file
+ * imports before it. So a test file with the directive registers its tests
+ * with Vitest, which imports the file in the rsc layer, and a setup file
+ * with it its hooks.
+ *
+ * Once for each version of the file, as the browser evaluates a module
+ * once: a second import of the file gets the evaluation of the first, or
+ * its error. A change of the file, or of a module that it imports, is a new
+ * version of it, which evaluates the file again, and so is
+ * `forgetClientFiles()`, which the plugin's setup file calls before every
+ * test file, as Vitest evaluates a setup file and a test file again for
+ * each. What the file imports, once for the graph until it changes, as the
+ * browser does for what Vitest evaluates in the tab.
+ */
+declare function loadClientFile(key: string): Promise<void>;
+/**
+ * The module that the host imported, as the host uses it. For a file of the
+ * host with `"use client"`, which the rsc layer has as a client reference
+ * module, the file's own exports from the browser layer: the evaluation the
+ * graph has when the host first asks for the module, the one that the
+ * module's line loaded unless the graph evaluated the file again since. The
+ * same object for the same module, every time. Such a module has the export
+ * `clientFileKeyExport`, which the plugin put in front of it, and that alone
+ * tells it: other exports, like one that a plugin of the host adds, change
+ * nothing. Any other module as it is. Links nothing: a host that uses the
+ * file links its stylesheets with `linkStylesheetsOf()`.
+ *
+ * Rejects for the client reference module of a file that is not the host's,
+ * which nothing evaluated in the browser layer.
+ */
+declare function loadClientModule<T extends object>(module: T): Promise<T>;
+/**
+ * Links the stylesheets of files of the host that the host uses, like a
+ * framework that renders a component of one, or one that renders as it
+ * loads: what each imports, in the browser layer for a file with
+ * `"use client"`, in their order, as they are now. The files as for
+ * `hostFiles` of `renderServer()`: absolute, or from the root of the
+ * project. Resolves once the stylesheets have loaded.
+ *
+ * The use ends as `signal` aborts, and without one at `cleanup()`, which ends
+ * every use: a stylesheet goes once no use holds it. An aborted signal links
+ * nothing, and a use whose signal aborts rejects at once with the signal's
+ * reason, as `renderServer()` does: also while it asks for the stylesheets,
+ * whose answer then links nothing.
+ */
+declare function linkStylesheetsOf(hostFiles: string[], {
+  signal
+}?: {
+  signal?: AbortSignal;
+}): Promise<void>;
+/**
+ * Moves the stylesheets that the files of the host linked to the versions of
+ * now, after a change of their CSS: see stylesheet-versions.ts.
+ */
+declare function moveGraphLinks(versions: StylesheetVersions): void;
+/**
+ * Unlinks the stylesheets of the files of the host, which ends every use of
+ * them: `cleanup()` calls this, once it has left the page.
+ */
+declare function unlinkStylesheets(): void;
+/**
+ * Forgets what the files of the host did in the tab: with a dev server the
+ * graph evaluates each again the next time it loads, also one that failed,
+ * and the stylesheets they linked go. The plugin's setup file calls this
+ * before every test file, under Vitest. The graph keeps what the files
+ * import, and a module whose line ran before still gets the evaluation it
+ * loaded.
+ */
+declare function forgetClientFiles(): void;
+/**
+ * Whether the graph evaluated `file`, a file of the host, as one with
+ * `"use client"` since `forgetClientFiles()`, with a dev server. Under Vitest
+ * that tells a test file with the directive, once Vitest has collected it.
+ */
+declare function loadedAsClientFile(file: string): boolean;
+/**
+ * What a Server Action calls while no page of the app is open. A Server
+ * Action that a component of the browser layer calls goes through
+ * `callServer()` of Vite RSC, which calls the global `__viteRscCallServer`.
+ * A page sets Next's own, which posts to that page (client.tsx). A client
+ * file has no page, and the router of a page that was left would never
+ * answer. So this one is there from the start, and again once a page is left
+ * (`leavePage()` in page.ts).
+ */
+declare function callServerWithoutPage(id: string): Promise<never>;
+//#endregion
+export { callServerWithoutPage, forgetClientFiles, linkStylesheetsOf, loadClientFile, loadClientModule, loadedAsClientFile, moveGraphLinks, unlinkStylesheets };

package/dist/client-graph.js

@@ -0,0 +1,266 @@
+import { loadsNothing, registry } from "./registry.js";
+import { builtFileKey, builtHostFileStylesheetsOf, graphStylesheetAttribute, stylesheetOfUrl, stylesheetsChangedEvent, stylesheetsEvent } from "./styles-shared.js";
+import { buildDirectory, builtFiles } from "./built-files.js";
+import { clientFileKeyExport } from "./client-file-key.js";
+import { moveLink, stylesheetVersions } from "./stylesheet-versions.js";
+import { askDevServer, checkFetchedModules, createEnvironmentRunner, environmentModule, forgetHeardVersions, takeChangedModules, versionsOfAnswers } from "@kasperpeulen/vitest-plugin-rsc/internal/utils";
+import { clientReferencesId } from "@kasperpeulen/vitest-plugin-rsc/internal/built-layers";
+import { isHostModule } from "@kasperpeulen/vitest-plugin-rsc/internal/host-module";
+//#region src/client-graph.ts
+const environment = "react_client";
+let graph;
+const linked = /* @__PURE__ */ new Map();
+const keyOf = (href) => stylesheetOfUrl(href) ?? href;
+let cleanups = 0;
+const evaluations = /* @__PURE__ */ new Map();
+const imported = /* @__PURE__ */ new Set();
+const evaluationOf = /* @__PURE__ */ new WeakMap();
+const isDependency = ({ id, file }) => isHostModule(id) || (file ?? id).includes("/node_modules/");
+const browserRequire = (id) => registry.loadBrowserModule?.(id) ?? loadsNothing();
+/**
+* Evaluates a file of the host with `"use client"` in the module graph of
+* the browser layer: the file with the reference key `key`, which with a dev
+* server is its URL in that layer. The module of the rsc layer for the file
+* calls this before its own code runs, as Vitest evaluates what a file
+* imports before it. So a test file with the directive registers its tests
+* with Vitest, which imports the file in the rsc layer, and a setup file
+* with it its hooks.
+*
+* Once for each version of the file, as the browser evaluates a module
+* once: a second import of the file gets the evaluation of the first, or
+* its error. A change of the file, or of a module that it imports, is a new
+* version of it, which evaluates the file again, and so is
+* `forgetClientFiles()`, which the plugin's setup file calls before every
+* test file, as Vitest evaluates a setup file and a test file again for
+* each. What the file imports, once for the graph until it changes, as the
+* browser does for what Vitest evaluates in the tab.
+*/
+async function loadClientFile(key) {
+	if (buildDirectory) {
+		graph ??= createEnvironmentRunner(environment);
+		const load = (await graph.import(environmentModule(environment, clientReferencesId))).default[key];
+		if (!load) throw new Error(`vitest-plugin-rsc: the build has no client reference "${key}"`);
+		registry.browserRequire = browserRequire;
+		evaluations.set(key, await load());
+		return;
+	}
+	graph ??= createEnvironmentRunner(environment, { sourcemaps: true });
+	const caughtUp = catchingUp.then(() => catchUp(graph));
+	catchingUp = caughtUp.catch(() => {});
+	await caughtUp;
+	registry.browserRequire = browserRequire;
+	imported.add(key);
+	evaluations.set(key, await graph.import(key));
+}
+let catchingUp = Promise.resolve();
+async function catchUp(graph) {
+	forgetHeardVersions();
+	await checkFetchedModules();
+	const { evaluatedModules } = graph;
+	const changed = /* @__PURE__ */ new Set();
+	const add = (id) => {
+		const node = evaluatedModules.getModuleById(id);
+		if (node && !isDependency(node)) changed.add(node);
+	};
+	for (const id of await takeChangedModules(graph)) add(id);
+	for (const node of changed) node.importers.forEach(add);
+	for (const node of changed) evaluatedModules.invalidateModule(node);
+}
+/**
+* The module that the host imported, as the host uses it. For a file of the
+* host with `"use client"`, which the rsc layer has as a client reference
+* module, the file's own exports from the browser layer: the evaluation the
+* graph has when the host first asks for the module, the one that the
+* module's line loaded unless the graph evaluated the file again since. The
+* same object for the same module, every time. Such a module has the export
+* `clientFileKeyExport`, which the plugin put in front of it, and that alone
+* tells it: other exports, like one that a plugin of the host adds, change
+* nothing. Any other module as it is. Links nothing: a host that uses the
+* file links its stylesheets with `linkStylesheetsOf()`.
+*
+* Rejects for the client reference module of a file that is not the host's,
+* which nothing evaluated in the browser layer.
+*/
+async function loadClientModule(module) {
+	const key = Reflect.get(module, clientFileKeyExport);
+	if (typeof key !== "string") return module;
+	let exports = evaluationOf.get(module);
+	if (!exports) {
+		exports = evaluations.get(key);
+		if (!exports) throw new Error(`vitest-plugin-rsc: ${key} has "use client" and is not a file of the host, so nothing loaded it in the browser layer for loadClientModule(). ${key} is the reference key that Vite RSC gives the file: its URL with a dev server, and in a static build a hash of the file. The files of the host are the ones that host.files of vitestPluginNext() matches.`);
+		evaluationOf.set(module, exports);
+	}
+	return exports;
+}
+/**
+* Links the stylesheets of files of the host that the host uses, like a
+* framework that renders a component of one, or one that renders as it
+* loads: what each imports, in the browser layer for a file with
+* `"use client"`, in their order, as they are now. The files as for
+* `hostFiles` of `renderServer()`: absolute, or from the root of the
+* project. Resolves once the stylesheets have loaded.
+*
+* The use ends as `signal` aborts, and without one at `cleanup()`, which ends
+* every use: a stylesheet goes once no use holds it. An aborted signal links
+* nothing, and a use whose signal aborts rejects at once with the signal's
+* reason, as `renderServer()` does: also while it asks for the stylesheets,
+* whose answer then links nothing.
+*/
+async function linkStylesheetsOf(hostFiles, { signal } = {}) {
+	signal?.throwIfAborted();
+	const cleanupsBefore = cleanups;
+	let held = [];
+	const use = (async () => {
+		const urls = await stylesheetsOfHostFiles(hostFiles);
+		if (signal?.aborted || cleanups !== cleanupsBefore) return;
+		held = urls.map(hold);
+		await Promise.all(held.map((stylesheet) => stylesheet.loaded));
+	})();
+	if (!signal) return use;
+	const ended = new Promise((_, reject) => signal.addEventListener("abort", () => {
+		held.forEach(release);
+		reject(signal.reason);
+	}, { once: true }));
+	return Promise.race([use, ended]);
+}
+const hostStylesheets = /* @__PURE__ */ new Map();
+let hostStylesheetsOf;
+async function stylesheetsOfHostFiles(hostFiles) {
+	if (hostFiles.length === 0) return [];
+	const versions = await versionsOfAnswers();
+	if (versions !== hostStylesheetsOf) {
+		hostStylesheets.clear();
+		hostStylesheetsOf = versions;
+	}
+	const key = hostFiles.join("\n");
+	let answer = hostStylesheets.get(key);
+	if (!answer) {
+		const asked = stylesheetsOfHostFilesUncached(hostFiles);
+		hostStylesheets.set(key, answer = asked);
+		asked.catch(() => hostStylesheets.get(key) === asked && hostStylesheets.delete(key));
+	}
+	return answer;
+}
+async function stylesheetsOfHostFilesUncached(hostFiles) {
+	if (!buildDirectory) return askDevServer(stylesheetsEvent, { hostFiles });
+	const built = await builtFiles();
+	const keys = Object.keys(built.hostFiles);
+	const urls = hostFiles.flatMap((file) => {
+		const key = builtFileKey(file, keys);
+		return key === void 0 ? [] : builtHostFileStylesheetsOf(built, key, buildDirectory);
+	});
+	return [...new Set(urls)];
+}
+function hold(href) {
+	const known = linked.get(keyOf(href));
+	if (known) {
+		known.uses++;
+		if (known.href !== href) move(known, href);
+		return known;
+	}
+	const link = Object.assign(document.createElement("link"), {
+		rel: "stylesheet",
+		href
+	});
+	link.setAttribute(graphStylesheetAttribute, "");
+	const stylesheet = {
+		href,
+		link,
+		uses: 1,
+		...loading(link)
+	};
+	linked.set(keyOf(href), stylesheet);
+	document.head.append(link);
+	return stylesheet;
+}
+function loading(link) {
+	let settle;
+	return {
+		loaded: new Promise((resolve) => {
+			settle = () => resolve();
+			link.addEventListener("load", settle, { once: true });
+			link.addEventListener("error", settle, { once: true });
+		}),
+		settle
+	};
+}
+function move(stylesheet, href) {
+	const link = moveLink(stylesheet.link, href);
+	stylesheet.href = href;
+	if (link === stylesheet.link) return;
+	stylesheet.settle();
+	stylesheet.previous = stylesheet.link;
+	stylesheet.link = link;
+	Object.assign(stylesheet, loading(link));
+}
+/**
+* Moves the stylesheets that the files of the host linked to the versions of
+* now, after a change of their CSS: see stylesheet-versions.ts.
+*/
+function moveGraphLinks(versions) {
+	for (const [key, stylesheet] of linked) {
+		const href = versions.get(key);
+		if (href !== void 0 && href !== stylesheet.href) move(stylesheet, href);
+	}
+}
+import.meta.hot?.on(stylesheetsChangedEvent, (urls) => moveGraphLinks(stylesheetVersions(urls)));
+function release(stylesheet) {
+	if (linked.get(keyOf(stylesheet.href)) !== stylesheet) return;
+	if (--stylesheet.uses === 0) unlink(stylesheet);
+}
+function unlink(stylesheet) {
+	for (const link of [stylesheet.link, stylesheet.previous]) {
+		link?.remove();
+		link?.removeAttribute(graphStylesheetAttribute);
+	}
+	linked.delete(keyOf(stylesheet.href));
+	stylesheet.settle();
+}
+/**
+* Unlinks the stylesheets of the files of the host, which ends every use of
+* them: `cleanup()` calls this, once it has left the page.
+*/
+function unlinkStylesheets() {
+	cleanups++;
+	for (const stylesheet of linked.values()) unlink(stylesheet);
+}
+/**
+* Forgets what the files of the host did in the tab: with a dev server the
+* graph evaluates each again the next time it loads, also one that failed,
+* and the stylesheets they linked go. The plugin's setup file calls this
+* before every test file, under Vitest. The graph keeps what the files
+* import, and a module whose line ran before still gets the evaluation it
+* loaded.
+*/
+function forgetClientFiles() {
+	for (const url of imported) {
+		const own = graph?.evaluatedModules.getModuleByUrl(url);
+		if (own) graph?.evaluatedModules.invalidateModule(own);
+	}
+	imported.clear();
+	unlinkStylesheets();
+}
+/**
+* Whether the graph evaluated `file`, a file of the host, as one with
+* `"use client"` since `forgetClientFiles()`, with a dev server. Under Vitest
+* that tells a test file with the directive, once Vitest has collected it.
+*/
+function loadedAsClientFile(file) {
+	return [...graph?.evaluatedModules.getModulesByFile(file) ?? []].some((module) => imported.has(module.url));
+}
+/**
+* What a Server Action calls while no page of the app is open. A Server
+* Action that a component of the browser layer calls goes through
+* `callServer()` of Vite RSC, which calls the global `__viteRscCallServer`.
+* A page sets Next's own, which posts to that page (client.tsx). A client
+* file has no page, and the router of a page that was left would never
+* answer. So this one is there from the start, and again once a page is left
+* (`leavePage()` in page.ts).
+*/
+async function callServerWithoutPage(id) {
+	const name = id.split("#").at(-1);
+	throw new Error(`vitest-plugin-rsc: a component called the Server Action ${name}, and no page of the app is open to post it to. A Server Action needs Next's app, which a file with "use client" does not render in, like a test file with the directive: render the component with renderServer(), from a file without "use client".`);
+}
+globalThis.__viteRscCallServer = callServerWithoutPage;
+//#endregion
+export { callServerWithoutPage, forgetClientFiles, linkStylesheetsOf, loadClientFile, loadClientModule, loadedAsClientFile, moveGraphLinks, unlinkStylesheets };

package/dist/client-modules.d.ts

@@ -0,0 +1,10 @@
+//#region src/client-modules.d.ts
+/**
+ * Has the layer load its Client Components with a loader of its own.
+ * Returns how to forget the loader of the browser layer, which keeps the
+ * modules that it loaded: the layer then has none, as before its first
+ * page, unless another page's has come since.
+ */
+declare function registerModuleLoader(layer: "ssr" | "browser", ready?: Promise<void>): () => void;
+//#endregion
+export { registerModuleLoader };

package/dist/client-modules.js

@@ -0,0 +1,43 @@
+import { registry } from "./registry.js";
+import clientReferences from "virtual:vitest-plugin-rsc/client-references";
+//#region src/client-modules.ts
+function importModule(id) {
+	if (!clientReferences) return import(
+		/* @vite-ignore */
+		id
+);
+	const load = clientReferences[id];
+	if (!load) return Promise.reject(/* @__PURE__ */ new Error(`vitest-plugin-rsc: the build has no Client Component "${id}"`));
+	return load();
+}
+function createModuleLoader(ready) {
+	const modules = /* @__PURE__ */ new Map();
+	return (id) => {
+		id = id.split("$$cache=")[0];
+		let loading = modules.get(id);
+		if (!loading) {
+			const load = () => importModule(id);
+			modules.set(id, loading = ready ? ready.then(load) : load());
+		}
+		return loading;
+	};
+}
+/**
+* Has the layer load its Client Components with a loader of its own.
+* Returns how to forget the loader of the browser layer, which keeps the
+* modules that it loaded: the layer then has none, as before its first
+* page, unless another page's has come since.
+*/
+function registerModuleLoader(layer, ready) {
+	const loader = createModuleLoader(ready);
+	if (layer === "ssr") {
+		registry.loadSsrModule = loader;
+		return () => {};
+	}
+	registry.loadBrowserModule = loader;
+	return () => {
+		if (registry.loadBrowserModule === loader) delete registry.loadBrowserModule;
+	};
+}
+//#endregion
+export { registerModuleLoader };

package/dist/client.d.ts

@@ -0,0 +1,42 @@
+import { callServer } from "./compat/browser/client.js";
+import { NodeOnPage } from "./node-on-page.js";
+
+//#region src/client.d.ts
+declare global {
+  var __viteRscCallServer: typeof callServer;
+  var __NEXT_HYDRATED_CB: (() => void) | undefined;
+}
+/**
+ * Hydrates the document, or with a `container`, the node of a test in it.
+ * Resolves once it has, with how to leave the page. Calls `loaded` once Next's
+ * client has loaded, before a module of the app has. A page of a node tells
+ * `nodeOnPage` what it does with the node: see node-rendered.tsx. The errors
+ * that React reports on the root of the app go in `errors`, in order, but
+ * for those of Next's control flow.
+ *
+ * Rejects once `signal` aborts, when the page is left before it has hydrated.
+ * What it started is gone by then: the root, and the listeners React added.
+ * A root that Next would create after that renders nothing.
+ */
+declare function start(loaded: () => void, container: Element | undefined, signal: AbortSignal, nodeOnPage: NodeOnPage | undefined, errors: unknown[], keep?: boolean): Promise<StartedApp>;
+/** How to leave the page that `start()` or `renderAgain()` opened, and its app. */
+type StartedApp = {
+  /** Leaves the page. For a kept app, its root stays, with nothing in it. */unmount(): void; /** Leaves the app: its root goes, and the listeners React added for it. */
+  leaveApp(): void;
+};
+/**
+ * Renders the page in the document into the root of the app that `start()`
+ * kept, in place of the page before it: what Next's entry does as the page
+ * loads, without the entry, from the Flight payload in the document. The
+ * modules of the app stay, and so does its root, so this is no page load:
+ * its Flight payload is decoded, the router gets a state of its own from it,
+ * and a tree with a key of its own mounts.
+ * Resolves as `start()` does, once it has rendered.
+ *
+ * What the modules of the app keep stays from the page before: Next's caches
+ * of its router are emptied, but the state of a module of the app, or of a
+ * package, is still there.
+ */
+declare function renderAgain(signal: AbortSignal, errors: unknown[], flight?: Uint8Array): Promise<StartedApp>;
+//#endregion
+export { StartedApp, renderAgain, start };