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

package/dist/server-code.d.ts

@@ -0,0 +1,176 @@
+import { NextLayer } from "./project.js";
+import { Plugin, transformWithOxc } from "vite";
+import * as _$magic_string0 from "magic-string";
+
+//#region src/server-code.d.ts
+type Compiled = Pick<Awaited<ReturnType<typeof transformWithOxc>>, "code" | "map">;
+/** Compiles JavaScript as server code. Returns nothing for code that stays as it is. */
+declare function compileServerCode(code: string, id: string, registry: string, define?: Record<string, string>): Promise<Compiled | undefined>;
+type ServerCodeOptions = {
+  /**
+   * Modules that have to know they run in a browser: glob patterns, relative
+   * to the project root. They keep the browser's `typeof window` and `fetch`,
+   * as the test files and setup files of the Vitest config do. List a helper of
+   * the tests, or a package they use on the page, that asks `typeof window`
+   * before it works on the page.
+   *
+   * Files are matched by their real path, which for a package is seldom
+   * `node_modules/<name>` under the root. So start a pattern for one with `**`.
+   *
+   * @example ["test/**", "**\/node_modules/@testing-library/**"]
+   */
+  browserModules?: string | RegExp | (string | RegExp)[];
+  /**
+   * What runs the app, when that is not Vitest. Under Vitest the plugin knows
+   * the host's files from its config, the test files and the setup files, and
+   * its packages, `vitest` and `@vitest/*`. Another host says here what is its
+   * own. A file of the host is not server code: it keeps the browser's
+   * `typeof window` and `fetch`, and Next's compiler does not run on
+   * it. With `"use client"` it is a module of the browser layer. A package of
+   * the host is the one instance the page has, also in the browser layer.
+   */
+  host?: {
+    /**
+     * The files of the host, like the ones it renders: glob patterns,
+     * relative to the project root. What a test file is to Vitest.
+     *
+     * @example ["host/**", "src/**\/*.demo.tsx"]
+     */
+    files?: string | RegExp | (string | RegExp)[];
+    /**
+     * The packages of the host, by name. A name that ends in `/*` is every
+     * package of that scope the project has, or every module under that path
+     * of a package, like `host-kit/internal/*`. A module of a package, like
+     * `host-kit/test`, is the page's own, and the package's other modules
+     * are not, but the files of the whole package are the host's runtime in
+     * the rsc layer. What they depend on is the host's too, but for this
+     * plugin and what it depends on, which a framework of the host can
+     * depend on.
+     *
+     * Not something the plugin can read off the files: a file of the host
+     * with `"use client"` imports `react` and `host-kit/test` the same way,
+     * and the first has to be the browser layer's React, where the second
+     * has to be the page's own module, whose spies the host shows. What
+     * `vitest` is to a test file. The same list keeps the host's runtime
+     * the browser's in the rsc layer, where every other package is server
+     * code.
+     *
+     * A package of the list that the browser layer imports only from inside
+     * another package reaches the rsc layer through the page, which no scan
+     * of Vite's reads: list it in `optimizeDeps.include` too, or Vite
+     * pre-bundles it as the first page loads.
+     *
+     * @example ["host-kit/test", "host-kit/preview"]
+     */
+    packages?: string[];
+  };
+};
+type Warns = {
+  warn(message: string): void;
+};
+/**
+ * How the server carries the stores of `AsyncLocalStorage` across an `await`
+ * and from one step of a render to the next: `compiled`, in a browser, which
+ * carries nothing, so the async functions of the server and React's Flight
+ * server are compiled to (async-local-storage-transform.ts); or `native`, in
+ * a worker of Node.js, whose `AsyncLocalStorage` is Node's own (the package's
+ * `async-hooks` under the `node` condition), which needs none of it.
+ */
+type AsyncContext = "compiled" | "native";
+declare function createServerCode(registry: string, options?: ServerCodeOptions): {
+  isServerCode: (file: string, layer: NextLayer) => boolean;
+  isHostFile: (file: string) => boolean;
+  isHostPackageFile: (file: string) => boolean;
+  isTestFile: (file: string) => boolean;
+  /**
+   * Whether an import is of a package of the host, by its name: `vitest`,
+   * `vitest/browser`, `@vitest/spy`. Not what such a package depends on.
+   */
+  isHostPackage(specifier: string): boolean;
+  /**
+   * Whether a source file is code of the app in a layer: what Next's build
+   * compiles. Not in the rsc layer: what is the browser's there, the test
+   * files and the `browserModules`. And in no layer a file of the host,
+   * which with `"use client"` is a module of the browser layer: it is the
+   * host's to compile, as any test file of Vitest, with Vite's own
+   * transforms and the host's config, not with Next's.
+   */
+  isAppCode(file: string, layer: NextLayer): boolean; /** For the `define` of the optimizer of a server layer, which Vite keys its cache on. */
+  readonly cacheKey: {
+    __vitest_plugin_rsc_browser_modules__: string;
+    __vitest_plugin_rsc_modules_with_stores__: string;
+    __vitest_plugin_rsc_async_context__: string;
+  };
+  /**
+   * The same for the browser layer, which pre-bundles the packages of the
+   * host as the page's own: Vite does not key its cache on the plugins of
+   * the optimizer.
+   */
+  browserCacheKey: {
+    __vitest_plugin_rsc_host_packages__: string;
+  }; /** For a module this plugin generates, with the constants of its layer. */
+  compile: (code: string, id: string, define: Record<string, string>) => Promise<string>;
+  /**
+   * Call once the root of the project is known, and where the server runs:
+   * see `AsyncContext`.
+   */
+  configure(root: string, carried?: AsyncContext): void; /** Call with what a Vitest config says is a test file or a setup file. */
+  addTestFiles(matches: (file: string) => boolean): void;
+  /**
+   * What a dependency of a server layer needs on top of `compileServerCode()`
+   * to keep its stores across an `await` and a render, for a static build,
+   * which has no optimizer: see `optimizerDefine()`, `optimizerPlugin()` and
+   * `asyncFunctionsOptimizerPlugin()`.
+   */
+  forStores(context: Warns, code: string, id: string, layer: NextLayer): {
+    code: string;
+    define: {
+      queueMicrotask: string;
+    };
+  } | {
+    code: string;
+    define: {};
+  };
+  /**
+   * For the dependency optimizer of a layer: what the bundler replaces in
+   * every module of the pre-bundle, by its `transform.define`, natively and
+   * in parallel. In the ssr layer every dependency is server code
+   * (`isServerCode()`), and of this plugin's own files the pre-bundle has
+   * only its stand-ins of the modules of Node.js and of `fastCrypto`: those
+   * take the server's timers too, as Node's own modules do. The bundler
+   * also reaches a dependency in TypeScript or JSX, which oxc does not take
+   * as JavaScript. The rsc layer pre-bundles the host's packages with the
+   * app's, so there it is `optimizerPlugin()`, file by file.
+   */
+  optimizerDefine(layer: NextLayer): Record<string, string>;
+  /**
+   * For the dependency optimizer of the rsc layer: its pre-bundled
+   * dependencies that are server code.
+   */
+  optimizerPlugin(): {
+    name: string;
+    transform(this: {
+      warn(message: string): void;
+    }, code: string, id: string): Promise<Compiled | undefined>;
+  };
+  /**
+   * The async functions that have to read, after an `await`, a store Next
+   * entered for them, or left for them with `exit()`: see
+   * async-local-storage-transform.ts. For the dependency optimizer of a
+   * server layer, the modules of Next's server in `nextModulesWithStores`
+   * that are that layer's. The bundler hands it each file of a dependency
+   * it pre-bundles, by its path, so a module inside the bundle of
+   * `app-page/module` is one.
+   */
+  asyncFunctionsOptimizerPlugin(layer: NextLayer): {
+    name: string;
+    transform(this: Warns, code: string, id: string): {
+      code: string;
+      map: _$magic_string0.SourceMap;
+    } | undefined;
+  }; /** And the source files of the app in the `rsc` layer, by the name of its environment. */
+  asyncFunctionsPlugin(environment: string): Plugin; /** For the source files of the server layers, by the name of their environment. */
+  plugin(environments: Record<string, NextLayer>): Plugin;
+};
+//#endregion
+export { AsyncContext, ServerCodeOptions, compileServerCode, createServerCode };

package/dist/server-code.js

@@ -0,0 +1,357 @@
+import { nextModulesWithStores, vendoredFlightServer, withStoresFiles } from "./compat/paths.js";
+import "./own-package.js";
+import { createFilter, normalizePath, transformWithOxc } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { isOwnFile } from "@kasperpeulen/vitest-plugin-rsc/internal/own-packages";
+import { transformAsyncFunctions } from "@kasperpeulen/vitest-plugin-rsc/internal/async-local-storage-transform";
+//#region src/server-code.ts
+/** Globals of a browser that a server does not have. */
+const browserGlobals = [
+	"window",
+	"document",
+	"location",
+	"localStorage",
+	"sessionStorage"
+];
+/** Globals a server has too, but its own. */
+const serverGlobals = [
+	"Request",
+	"Response",
+	"fetch",
+	"setImmediate",
+	"clearImmediate",
+	"setTimeout",
+	"clearTimeout"
+];
+const mentionsServerGlobal = new RegExp(`\\b(?:${serverGlobals.join("|")})\\b`);
+const mentionsTypeof = /\btypeof\b/;
+const mentionsBrowserGlobal = new RegExp(`\\b(?:${browserGlobals.join("|")})\\b`);
+const serverGlobalsOf = (registry) => Object.fromEntries(serverGlobals.flatMap((name) => [[name, `${registry}.${name}`], [`globalThis.${name}`, `${registry}.${name}`]]));
+const browserTypeofs = Object.fromEntries(browserGlobals.map((name) => [`typeof ${name}`, "\"undefined\""]));
+/** Compiles JavaScript as server code. Returns nothing for code that stays as it is. */
+async function compileServerCode(code, id, registry, define = {}) {
+	const defines = {
+		...define,
+		...mentionsServerGlobal.test(code) && serverGlobalsOf(registry),
+		...mentionsTypeof.test(code) && mentionsBrowserGlobal.test(code) && browserTypeofs
+	};
+	if (Object.keys(defines).length === 0) return;
+	return transformWithOxc(code, id, {
+		lang: "js",
+		define: defines
+	});
+}
+function* nodeModulesOf(from) {
+	for (let dir = from;; dir = path.dirname(dir)) {
+		yield path.join(dir, "node_modules");
+		if (dir === path.dirname(dir)) return;
+	}
+}
+function findPackage(name, from) {
+	for (const nodeModules of nodeModulesOf(from)) {
+		const candidate = path.join(nodeModules, name);
+		if (fs.existsSync(path.join(candidate, "package.json"))) return fs.realpathSync(candidate);
+	}
+}
+function dependenciesOf(dir) {
+	const file = path.join(dir, "package.json");
+	if (!fs.existsSync(file)) return [];
+	const { dependencies = {} } = JSON.parse(fs.readFileSync(file, "utf8"));
+	return Object.keys(dependencies);
+}
+function ownPackageDir() {
+	let dir = path.dirname(fileURLToPath(import.meta.url));
+	while (!fs.existsSync(path.join(dir, "package.json")) && dir !== path.dirname(dir)) dir = path.dirname(dir);
+	return fs.realpathSync(dir);
+}
+function ownPackageDirs() {
+	const own = ownPackageDir();
+	const core = findPackage("@kasperpeulen/vitest-plugin-rsc", own);
+	const dirs = [own, ...core ? [core] : []];
+	const dependencies = dirs.flatMap((dir) => dependenciesOf(dir).map((name) => findPackage(name, dir)));
+	return /* @__PURE__ */ new Set([...dirs, ...dependencies.filter((found) => found !== void 0)]);
+}
+function findPackagesWithDependencies(names, root) {
+	const dirs = /* @__PURE__ */ new Set();
+	const named = new Set(names);
+	const appDirs = new Set(dependenciesOf(root).map((name) => findPackage(name, root)).filter((dir) => dir !== void 0));
+	const own = ownPackageDirs();
+	const visit = (name, from) => {
+		const dir = findPackage(name, from);
+		if (!dir || own.has(dir) || dirs.has(normalizePath(dir))) return;
+		if (!named.has(name) && appDirs.has(dir)) return;
+		dirs.add(normalizePath(dir));
+		for (const dependency of dependenciesOf(dir)) visit(dependency, dir);
+	};
+	for (const name of named) visit(name, root);
+	return dirs;
+}
+const hostPackages = (packages) => [
+	"vitest",
+	"@vitest/*",
+	...packages
+];
+const packageNameOf = (specifier) => /^(?:@[^/]+\/)?[^/]+/.exec(specifier)[0];
+function* hostPackageNames(root, packages) {
+	for (const name of ["vite", ...hostPackages(packages)]) {
+		if (!/^@[^/]+\/\*$/.test(name)) {
+			yield packageNameOf(name);
+			continue;
+		}
+		const scope = name.slice(0, -2);
+		for (const nodeModules of nodeModulesOf(root)) {
+			const dir = path.join(nodeModules, scope);
+			if (fs.existsSync(dir)) for (const child of fs.readdirSync(dir)) yield `${scope}/${child}`;
+		}
+	}
+}
+function packageDirOf(file) {
+	return /^.*\/node_modules\/(?:@[^/]+\/)?[^/]+(?=\/)/.exec(file)?.[0];
+}
+const name = "vitest-plugin-rsc:next-server-code";
+const asyncFunctionsName = "vitest-plugin-rsc:next-async-functions";
+function nextModulesWithStoresOf(layer) {
+	const modules = nextModulesWithStores.filter((entry) => entry.layer === layer);
+	if (modules.length === 0) return;
+	return withStoresFiles(modules.map(({ module }) => module));
+}
+const performWork = "function performWork(request) {";
+const issues = "https://github.com/storybookjs/storybook-for-pages/issues";
+function nextVersionOf(id) {
+	const root = normalizePath(id).match(/^(.*\/next)\/dist\//)?.[1];
+	try {
+		return JSON.parse(fs.readFileSync(`${root}/package.json`, "utf8")).version;
+	} catch {
+		return "?";
+	}
+}
+function createServerCode(registry, options = {}) {
+	let asyncContext = "compiled";
+	const patterns = [options.browserModules ?? []].flat();
+	const hostFiles = [options.host?.files ?? []].flat();
+	const packages = options.host?.packages ?? [];
+	let isBrowserModule = () => false;
+	const testFileMatchers = [];
+	let isOwnFileOfHost = () => false;
+	const hostPackageNamesOfOptions = hostPackages(packages);
+	let hostPackageDirs = /* @__PURE__ */ new Set();
+	/**
+	* Whether a file is one of the host's: a test file or a setup file of
+	* Vitest, or a file of another host, like a story.
+	*/
+	function isHostFile(file) {
+		return isOwnFileOfHost(normalizePath(file)) || isTestFile(file);
+	}
+	/** Whether a file is a test file or a setup file of Vitest. */
+	function isTestFile(file) {
+		file = normalizePath(file);
+		return testFileMatchers.some((matches) => matches(file));
+	}
+	const knowsHostFiles = () => hostFiles.length > 0 || testFileMatchers.length > 0;
+	/**
+	* Whether a file is server code in a layer. The rsc layer shares its
+	* environment with the test: the test files, what runs them and the
+	* `browserModules` of the options are not.
+	*/
+	function isServerCode(file, layer) {
+		if (layer === "browser" || !path.isAbsolute(file)) return false;
+		file = normalizePath(file);
+		if (isOwnFile(file)) return false;
+		if (layer === "ssr") return true;
+		if (isBrowserModule(file) || isHostFile(file)) return false;
+		return !isHostPackageFile(file);
+	}
+	/**
+	* Whether a file is of a package of the host or of what one depends on:
+	* Vitest's runtime, or a package of `host.packages`.
+	*/
+	function isHostPackageFile(file) {
+		const packageDir = packageDirOf(normalizePath(file));
+		return packageDir !== void 0 && hostPackageDirs.has(packageDir);
+	}
+	function compileAsyncFunctions(context, code, file) {
+		if (asyncContext === "native") return;
+		try {
+			return transformAsyncFunctions(code, file, `${registry}.asyncFunctionHooks`);
+		} catch (error) {
+			const reason = String(error instanceof Error ? error.message : error);
+			context.warn(`vitest-plugin-rsc: the async functions of ${file} do not keep their stores across an await, it does not parse as JavaScript. ${reason.replace(/\s+/g, " ")}`);
+		}
+	}
+	/** The file of a module, if it is a source file that is server code in a layer. */
+	function sourceFileOf(id, cacheDir, layer) {
+		const file = id.split("?")[0];
+		if (!/\.[cm]?[jt]sx?$/.test(file) || !fs.existsSync(file)) return;
+		if (file.includes("/node_modules/") || file.startsWith(`${cacheDir}/`)) return;
+		if (isServerCode(file, layer)) return file;
+	}
+	function flightServerOf(code, id) {
+		if (asyncContext === "native" || !vendoredFlightServer.test(normalizePath(id))) return;
+		if (!code.includes(performWork)) throw new Error(`vitest-plugin-rsc: ${id}, React's Flight server of next@${nextVersionOf(id)}, has no \`${performWork}\` to compile, which every render of a server needs to keep its stores. This Next.js is newer than the plugin knows: report it at ${issues}.`);
+		return {
+			code: code.replace(performWork, `function performWork(request) { ${registry}.performWork(request, performWorkOfReact); }\nfunction performWorkOfReact(request) {`),
+			define: { queueMicrotask: `${registry}.queueMicrotask` }
+		};
+	}
+	return {
+		isServerCode,
+		isHostFile,
+		isHostPackageFile,
+		isTestFile,
+		/**
+		* Whether an import is of a package of the host, by its name: `vitest`,
+		* `vitest/browser`, `@vitest/spy`. Not what such a package depends on.
+		*/
+		isHostPackage(specifier) {
+			return hostPackageNamesOfOptions.some((name) => name.endsWith("/*") ? specifier.startsWith(name.slice(0, -1)) : specifier === name || specifier.startsWith(`${name}/`));
+		},
+		/**
+		* Whether a source file is code of the app in a layer: what Next's build
+		* compiles. Not in the rsc layer: what is the browser's there, the test
+		* files and the `browserModules`. And in no layer a file of the host,
+		* which with `"use client"` is a module of the browser layer: it is the
+		* host's to compile, as any test file of Vitest, with Vite's own
+		* transforms and the host's config, not with Next's.
+		*/
+		isAppCode(file, layer) {
+			if (!path.isAbsolute(file) || normalizePath(file).includes("/node_modules/")) return false;
+			if (layer !== "rsc") return !isOwnFile(file) && !isHostFile(file);
+			return knowsHostFiles() && isServerCode(file, layer);
+		},
+		/** For the `define` of the optimizer of a server layer, which Vite keys its cache on. */
+		get cacheKey() {
+			return {
+				__vitest_plugin_rsc_browser_modules__: JSON.stringify([
+					patterns.map(String),
+					hostFiles.map(String),
+					packages
+				]),
+				__vitest_plugin_rsc_modules_with_stores__: JSON.stringify(nextModulesWithStores),
+				__vitest_plugin_rsc_async_context__: JSON.stringify(asyncContext)
+			};
+		},
+		/**
+		* The same for the browser layer, which pre-bundles the packages of the
+		* host as the page's own: Vite does not key its cache on the plugins of
+		* the optimizer.
+		*/
+		browserCacheKey: { __vitest_plugin_rsc_host_packages__: JSON.stringify(packages) },
+		/** For a module this plugin generates, with the constants of its layer. */
+		compile: async (code, id, define) => (await compileServerCode(code, id, registry, define))?.code ?? code,
+		/**
+		* Call once the root of the project is known, and where the server runs:
+		* see `AsyncContext`.
+		*/
+		configure(root, carried = "compiled") {
+			asyncContext = carried;
+			if (patterns.length > 0) isBrowserModule = createFilter(patterns, null, { resolve: root });
+			if (hostFiles.length > 0) isOwnFileOfHost = createFilter(hostFiles, null, { resolve: root });
+			hostPackageDirs = findPackagesWithDependencies(hostPackageNames(root, packages), root);
+		},
+		/** Call with what a Vitest config says is a test file or a setup file. */
+		addTestFiles(matches) {
+			testFileMatchers.push(matches);
+		},
+		/**
+		* What a dependency of a server layer needs on top of `compileServerCode()`
+		* to keep its stores across an `await` and a render, for a static build,
+		* which has no optimizer: see `optimizerDefine()`, `optimizerPlugin()` and
+		* `asyncFunctionsOptimizerPlugin()`.
+		*/
+		forStores(context, code, id, layer) {
+			if (nextModulesWithStoresOf(layer)?.test(normalizePath(id))) return {
+				code: compileAsyncFunctions(context, code, id)?.code ?? code,
+				define: {}
+			};
+			return (layer === "rsc" ? flightServerOf(code, id) : void 0) ?? {
+				code,
+				define: {}
+			};
+		},
+		/**
+		* For the dependency optimizer of a layer: what the bundler replaces in
+		* every module of the pre-bundle, by its `transform.define`, natively and
+		* in parallel. In the ssr layer every dependency is server code
+		* (`isServerCode()`), and of this plugin's own files the pre-bundle has
+		* only its stand-ins of the modules of Node.js and of `fastCrypto`: those
+		* take the server's timers too, as Node's own modules do. The bundler
+		* also reaches a dependency in TypeScript or JSX, which oxc does not take
+		* as JavaScript. The rsc layer pre-bundles the host's packages with the
+		* app's, so there it is `optimizerPlugin()`, file by file.
+		*/
+		optimizerDefine(layer) {
+			return layer === "ssr" ? {
+				...serverGlobalsOf(registry),
+				...browserTypeofs
+			} : {};
+		},
+		/**
+		* For the dependency optimizer of the rsc layer: its pre-bundled
+		* dependencies that are server code.
+		*/
+		optimizerPlugin() {
+			return {
+				name,
+				async transform(code, id) {
+					if (!/\.[cm]?js$/.test(id) || !isServerCode(id, "rsc")) return;
+					const flight = flightServerOf(code, id);
+					if (flight) code = flight.code;
+					const define = flight?.define;
+					try {
+						return await compileServerCode(code, id, registry, define);
+					} catch (error) {
+						const reason = String(error instanceof Error ? error.message : error);
+						this.warn(`vitest-plugin-rsc: ${id} is not compiled as server code, it does not parse as JavaScript. ${reason.replace(/\s+/g, " ")}`);
+					}
+				}
+			};
+		},
+		/**
+		* The async functions that have to read, after an `await`, a store Next
+		* entered for them, or left for them with `exit()`: see
+		* async-local-storage-transform.ts. For the dependency optimizer of a
+		* server layer, the modules of Next's server in `nextModulesWithStores`
+		* that are that layer's. The bundler hands it each file of a dependency
+		* it pre-bundles, by its path, so a module inside the bundle of
+		* `app-page/module` is one.
+		*/
+		asyncFunctionsOptimizerPlugin(layer) {
+			const modules = nextModulesWithStoresOf(layer);
+			return {
+				name: asyncFunctionsName,
+				transform(code, id) {
+					if (modules?.test(normalizePath(id))) return compileAsyncFunctions(this, code, id);
+				}
+			};
+		},
+		/** And the source files of the app in the `rsc` layer, by the name of its environment. */
+		asyncFunctionsPlugin(environment) {
+			return {
+				name: asyncFunctionsName,
+				applyToEnvironment: ({ name }) => name === environment,
+				transform(code, id) {
+					const file = sourceFileOf(id, normalizePath(this.environment.config.cacheDir), "rsc");
+					if (file && knowsHostFiles()) return compileAsyncFunctions(this, code, file);
+				}
+			};
+		},
+		/** For the source files of the server layers, by the name of their environment. */
+		plugin(environments) {
+			return {
+				name,
+				applyToEnvironment: (environment) => Object.hasOwn(environments, environment.name),
+				async transform(code, id) {
+					const layer = environments[this.environment.name];
+					const file = sourceFileOf(id, normalizePath(this.environment.config.cacheDir), layer);
+					if (!file) return;
+					if (layer === "rsc" && !knowsHostFiles()) throw new Error(`vitest-plugin-rsc: ${file} is a file of the app, or one of the host's, and nothing says which. Under Vitest the test files and the setup files come from its config, through \`configureVitest\`, which Vitest calls for the plugins of a project, not for one of \`injectTestProjects\`. Another host lists its files in the \`host.files\` option of vitestPluginNext().`);
+					return compileServerCode(code, file, registry);
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { compileServerCode, createServerCode };

package/dist/server-in-front.d.ts

@@ -0,0 +1,37 @@
+import { ServerRequest } from "./registry.js";
+import { MiddlewareContext, MiddlewareResult, ResolveRoutesResult } from "@next/routing";
+
+//#region src/server-in-front.d.ts
+type InvokeMiddleware = (context: MiddlewareContext) => Promise<MiddlewareResult>;
+declare function incoming<T extends Pick<ServerRequest, "url" | "headers">>(request: T): T;
+declare function resolve(request: Pick<ServerRequest, "url" | "headers">, requestBody: ReadableStream<Uint8Array>, invokeMiddleware: InvokeMiddleware, proxy: boolean): Promise<ResolveRoutesResult>;
+/**
+ * What the middleware did with a request, read off its `response`, with the
+ * `headers` and the `url` it got the request with: as `next start` reads it.
+ *
+ * That is `responseToMiddlewareResult()` of `@next/routing`, but for a
+ * response with a `Location` header and a status that is no redirect. Next's
+ * own server in front of the app, `resolveRoutes()` of
+ * `next/dist/server/lib/router-utils/resolve-routes`, answers with that
+ * response, its status and its body: the middleware answered itself. The
+ * function of `@next/routing` keeps the header for the response, and says
+ * neither a redirect nor `bodySent`, so its `resolveRoutes()` takes the
+ * request on to a route. It leaves out such a response where it marks one
+ * that answers itself, with `x-middleware-refresh`, as Next does, and only
+ * Next's server has the branch that ends the request for it.
+ */
+declare function middlewareResult(response: Response, headers: Headers, url: URL): MiddlewareResult;
+declare function redirectStatus(resolved: ResolveRoutesResult): number | undefined;
+/**
+ * Whether the server has something for a request: a route of the app, a page
+ * or a route handler, the route of the node a test renders, a redirect or a
+ * rewrite of `next.config`, or a middleware whose matcher takes it. Only
+ * running the middleware tells what it does with the request. At the pathname
+ * a test opened without `proxy`, only the routes count.
+ *
+ * Nothing runs for the answer, and nothing waits for it: not the ssr layer
+ * either.
+ */
+declare function takesRequest(request: Pick<ServerRequest, "url" | "headers">): Promise<boolean>;
+//#endregion
+export { InvokeMiddleware, incoming, middlewareResult, redirectStatus, resolve, takesRequest };

package/dist/server-in-front.js

@@ -0,0 +1,90 @@
+import { openedAt } from "./registry.js";
+import { filterInternalHeaders, fromNodeOutgoingHttpHeaders, splitCookiesString, toNodeOutgoingHttpHeaders } from "./compat/server/headers.js";
+import { resolveRoutes, responseToMiddlewareResult } from "@next/routing";
+import { routing } from "virtual:vitest-plugin-rsc/next-manifest";
+//#region src/server-in-front.ts
+const pathnames = Object.keys(routing.outputs);
+function incoming(request) {
+	const headers = toNodeOutgoingHttpHeaders(request.headers);
+	filterInternalHeaders(headers);
+	const url = new URL(request.url);
+	const isHttps = url.protocol === "https:";
+	headers["x-forwarded-host"] ??= headers.host ?? url.host;
+	headers["x-forwarded-port"] ??= url.port || (isHttps ? "443" : "80");
+	headers["x-forwarded-proto"] ??= isHttps ? "https" : "http";
+	return {
+		...request,
+		headers: fromNodeOutgoingHttpHeaders(headers)
+	};
+}
+async function resolve(request, requestBody, invokeMiddleware, proxy) {
+	const resolved = await resolveRoutes({
+		url: new URL(request.url),
+		headers: request.headers,
+		requestBody,
+		basePath: routing.basePath,
+		buildId: routing.buildId,
+		pathnames,
+		routes: proxy ? routing.routes : routing.appRoutes,
+		invokeMiddleware
+	});
+	const headers = resolved.resolvedHeaders;
+	const cookies = headers?.getSetCookie() ?? [];
+	if (headers && cookies.length > 0) {
+		headers.delete("set-cookie");
+		for (const cookie of cookies.flatMap(splitCookiesString)) headers.append("set-cookie", cookie);
+	}
+	return resolved;
+}
+/**
+* What the middleware did with a request, read off its `response`, with the
+* `headers` and the `url` it got the request with: as `next start` reads it.
+*
+* That is `responseToMiddlewareResult()` of `@next/routing`, but for a
+* response with a `Location` header and a status that is no redirect. Next's
+* own server in front of the app, `resolveRoutes()` of
+* `next/dist/server/lib/router-utils/resolve-routes`, answers with that
+* response, its status and its body: the middleware answered itself. The
+* function of `@next/routing` keeps the header for the response, and says
+* neither a redirect nor `bodySent`, so its `resolveRoutes()` takes the
+* request on to a route. It leaves out such a response where it marks one
+* that answers itself, with `x-middleware-refresh`, as Next does, and only
+* Next's server has the branch that ends the request for it.
+*/
+function middlewareResult(response, headers, url) {
+	const result = responseToMiddlewareResult(response, headers, url);
+	if (result.bodySent || result.redirect || !response.headers.has("location")) return result;
+	if (result.rewrite && result.rewrite.origin !== url.origin) return result;
+	return {
+		...result,
+		bodySent: true
+	};
+}
+function redirectStatus(resolved) {
+	const status = resolved.redirect?.status ?? resolved.status;
+	return status !== void 0 && status >= 300 && status < 400 ? status : void 0;
+}
+/**
+* Whether the server has something for a request: a route of the app, a page
+* or a route handler, the route of the node a test renders, a redirect or a
+* rewrite of `next.config`, or a middleware whose matcher takes it. Only
+* running the middleware tells what it does with the request. At the pathname
+* a test opened without `proxy`, only the routes count.
+*
+* Nothing runs for the answer, and nothing waits for it: not the ssr layer
+* either.
+*/
+async function takesRequest(request) {
+	const opened = openedAt(new URL(request.url));
+	if (opened?.node) return true;
+	let matched = false;
+	const invokeMiddleware = async () => {
+		matched = true;
+		return {};
+	};
+	const proxy = opened?.proxy ?? true;
+	const resolved = await resolve(incoming(request), new ReadableStream(), invokeMiddleware, proxy);
+	return matched || redirectStatus(resolved) !== void 0 || resolved.externalRewrite !== void 0 || routing.outputs[resolved.resolvedPathname ?? ""] !== void 0;
+}
+//#endregion
+export { incoming, middlewareResult, redirectStatus, resolve, takesRequest };

package/dist/server-layers.d.ts

@@ -0,0 +1,22 @@
+import { ssr_d_exports } from "./ssr.js";
+
+//#region src/server-layers.d.ts
+type SsrLayer = typeof ssr_d_exports;
+/**
+ * The rsc layer: Server Components, Server Actions, route handlers and the
+ * Flight encoder, see rsc.ts. The document's own module graph.
+ */
+declare function rscLayer(): Promise<unknown>;
+/**
+ * The ssr layer: Next's request handler and HTML renderer, see ssr.ts, with
+ * the rsc layer, which a request needs too. It starts to load the first time
+ * something asks for it: a request that the server handles, or the entry of
+ * the server's API as it evaluates. The server in front of the app needs
+ * neither layer: see server-in-front.ts. A build fetches the layer's file
+ * when its runner asks for it: see built-layers.ts.
+ */
+declare function ssrLayer(): Promise<SsrLayer>;
+/** The ssr layer once it has loaded: until then there is nothing of it to settle or reset. */
+declare function loadedSsrLayer(): SsrLayer | undefined;
+//#endregion
+export { loadedSsrLayer, rscLayer, ssrLayer };