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

package/dist/project/loaders.d.ts

@@ -0,0 +1,71 @@
+import { NextBuild } from "../build.js";
+import { NextContext } from "./context.js";
+import { NextProject } from "../project.js";
+import fs from "node:fs";
+
+//#region src/project/loaders.d.ts
+type LoaderContext = {
+  getOptions(): unknown; /** The options as a loader of webpack 4 reads them. */
+  query: unknown;
+  mode: "development" | "production";
+  _module: {
+    buildInfo: Record<string, unknown>;
+  };
+  async(): (error: Error | null, ...result: unknown[]) => void;
+  callback(error: Error | null, ...result: unknown[]): void;
+  cacheable(flag?: boolean): void;
+  currentTraceSpan: TraceSpan;
+  resourcePath: string;
+  resourceQuery: string;
+  context: string;
+  rootContext: string;
+  emitFile(name: string, content: Buffer): void;
+  emitWarning(warning: Error): void;
+  emitError(error: Error): void;
+  addDependency(file: string): void;
+  addContextDependency(directory: string): void;
+  resolve(directory: string, request: string, callback: (error: Error | null, file?: string) => void): void;
+  getResolve(): () => Promise<never>;
+  loadModule(request: string, callback: (error: Error | null, source?: string, map?: null, module?: LoadedModule) => void): void;
+  fs: typeof fs;
+  utils: {
+    contextify(context: string, request: string): string;
+  };
+  sourceMap: boolean;
+};
+type TraceSpan = {
+  traceChild(): TraceSpan;
+  traceFn<T>(fn: () => T): T;
+  traceAsyncFn<T>(fn: () => T): T;
+  setAttribute(): void;
+};
+type Loader = (this: LoaderContext, ...input: unknown[]) => unknown;
+type LoadedModule = {
+  dependencies: {
+    constructor: {
+      name: "HarmonyExportSpecifierDependency";
+    };
+    name: string;
+  }[];
+};
+/** Calls a webpack loader of Next for one module, the way webpack does. */
+type RunLoader = (loader: Loader, options: unknown, resource: string, ...input: unknown[]) => Promise<unknown[]>;
+/**
+ * `sassOptions` of `next.config`, as Vite's options of Sass. Next gives
+ * sass-loader the options of Sass, and `additionalData`, or `prependData`,
+ * which goes before the source of each file, as it does for Vite. A path to
+ * load from is one of the project, where Next's build runs. Not
+ * `implementation`: Vite takes `sass-embedded` where it is installed, and
+ * `sass` otherwise.
+ */
+declare function sassPreprocessorOptions(sassOptions: Record<string, unknown>, root: string): Record<string, unknown> | undefined;
+/**
+ * Next's webpack loaders for fonts and images, what they emit for the
+ * browser, and Next's image optimizer. `build` is the code that Next's
+ * runtime and React run, see build.ts.
+ */
+declare function createLoaders(context: NextContext, build: NextBuild): Pick<NextProject, "isImage" | "loadImage" | "loadFont" | "loadCssOptions" | "assetPath" | "readEmittedFile" | "emittedFiles" | "optimizeImage" | "loadRootParams"> & {
+  runLoader: RunLoader;
+};
+//#endregion
+export { Loader, LoaderContext, RunLoader, createLoaders, sassPreprocessorOptions };

package/dist/project/loaders.js

@@ -0,0 +1,300 @@
+import { fontLoaderPath } from "../compat/paths.js";
+import { exportsOf } from "./module-exports.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+import querystring from "node:querystring";
+import { compileFunction } from "node:vm";
+//#region src/project/loaders.ts
+function hasOtherPostCssConfig(root) {
+	const names = (directory) => {
+		try {
+			return fs.readdirSync(directory);
+		} catch {
+			return [];
+		}
+	};
+	return names(root).some((name) => /^(?:\.postcssrc(?:\..+)?|postcss\.config\..+)$/.test(name)) || names(path.join(root, ".config")).some((name) => name.startsWith("postcssrc"));
+}
+/**
+* `sassOptions` of `next.config`, as Vite's options of Sass. Next gives
+* sass-loader the options of Sass, and `additionalData`, or `prependData`,
+* which goes before the source of each file, as it does for Vite. A path to
+* load from is one of the project, where Next's build runs. Not
+* `implementation`: Vite takes `sass-embedded` where it is installed, and
+* `sass` otherwise.
+*/
+function sassPreprocessorOptions(sassOptions, root) {
+	const { prependData, additionalData, implementation: _, loadPaths, ...options } = sassOptions;
+	const data = prependData ?? additionalData;
+	const sass = {
+		...options,
+		...Array.isArray(loadPaths) && { loadPaths: loadPaths.map((entry) => path.resolve(root, String(entry))) },
+		...data !== void 0 && { additionalData: typeof data === "function" ? (source, file) => data(source, {
+			resourcePath: file,
+			rootContext: root
+		}) : data }
+	};
+	return Object.keys(sass).length > 0 ? sass : void 0;
+}
+/**
+* Next's webpack loaders for fonts and images, what they emit for the
+* browser, and Next's image optimizer. `build` is the code that Next's
+* runtime and React run, see build.ts.
+*/
+function createLoaders(context, build) {
+	const { root, projectRequire, nextDir, fail, config, next } = context;
+	const { COMPILER_NAMES, getContentType, getExtension, getNextFontLoader, getPostCssPlugins, getSupportedBrowsers, getCssModuleLoader, localByDefault, findConfig, imageOptimizer, nextFontLoader, nextRootParamsLoader, nextImageLoader, nextImageLoaderRegex } = next;
+	const emitted = /* @__PURE__ */ new Map();
+	const span = {
+		traceChild: () => span,
+		traceFn: (fn) => fn(),
+		traceAsyncFn: (fn) => fn(),
+		setAttribute: () => {}
+	};
+	const runLoaderEmitting = (emits) => (loader, options, resource, ...input) => new Promise((resolve, reject) => {
+		const queryAt = resource.indexOf("?");
+		const resourcePath = queryAt < 0 ? resource : resource.slice(0, queryAt);
+		let callsBack = false;
+		const callback = (error, ...result) => error ? reject(error) : resolve(result);
+		const context = {
+			getOptions: () => options ?? {},
+			query: options ?? {},
+			mode: build,
+			_module: { buildInfo: {} },
+			async: () => {
+				callsBack = true;
+				return callback;
+			},
+			callback: (...args) => {
+				callsBack = true;
+				callback(...args);
+			},
+			cacheable: () => {},
+			currentTraceSpan: span,
+			resourcePath,
+			resourceQuery: queryAt < 0 ? "" : resource.slice(queryAt),
+			context: path.dirname(resourcePath),
+			rootContext: root,
+			emitFile: (name, content) => {
+				const file = name.replace(/^\//, "");
+				emitted.set(file, content);
+				emits?.(file);
+			},
+			emitWarning: (warning) => console.warn(warning),
+			emitError: reject,
+			addDependency: () => {},
+			addContextDependency: () => {},
+			resolve: (directory, request, callback) => {
+				const file = path.resolve(directory, request);
+				if (fs.existsSync(file)) callback(null, file);
+				else callback(/* @__PURE__ */ new Error(`Can't resolve '${request}' in '${directory}'`));
+			},
+			getResolve: () => () => Promise.reject(/* @__PURE__ */ new Error("Not resolved by vitest-plugin-rsc")),
+			loadModule: (request, respond) => {
+				const read = async () => {
+					const source = await fs.promises.readFile(request, "utf8");
+					const { names } = await exportsOf(source, request);
+					return {
+						source,
+						module: { dependencies: [...names].filter((name) => name !== "default").map((name) => ({
+							constructor: { name: "HarmonyExportSpecifierDependency" },
+							name
+						})) }
+					};
+				};
+				read().then(({ source, module }) => respond(null, source, null, module), (error) => respond(error));
+			},
+			fs,
+			utils: { contextify: (_context, request) => request },
+			sourceMap: false
+		};
+		Promise.resolve(loader.call(context, ...input)).then((result) => callsBack || resolve([result]), reject);
+	});
+	const runLoader = runLoaderEmitting();
+	const resolve = (id) => {
+		try {
+			return projectRequire.resolve(id);
+		} catch (error) {
+			return fail(`${id} is not there`, error);
+		}
+	};
+	let postcss;
+	try {
+		postcss = createRequire(path.join(nextDir, "package.json"))("postcss");
+	} catch (error) {
+		fail("it no longer depends on `postcss`", error);
+	}
+	const fontLoaders = ["google", "local"].map((name) => {
+		const target = resolve(`next/font/${name}/target.css`);
+		const loaders = getNextFontLoader({
+			hasAppDir: true,
+			isClient: true,
+			isServer: false,
+			isDevelopment: true,
+			assetPrefix: config.assetPrefix,
+			deploymentId: config.deploymentId,
+			experimental: config.experimental
+		}, async () => ({ postcss }), resolve(fontLoaderPath(name)));
+		const cssLoader = loaders.find((entry) => entry.loader?.includes("css-loader"));
+		const fontLoader = loaders.find((entry) => entry.loader === "next-font-loader");
+		if (!cssLoader?.loader || !fontLoader) fail("`getNextFontLoader()` no longer uses css-loader and next-font-loader");
+		return {
+			prefix: `next/font/${name}/target.css?`,
+			target,
+			cssLoader: projectRequire(cssLoader.loader).default,
+			cssOptions: cssLoader.options,
+			fontOptions: fontLoader.options
+		};
+	});
+	const fonts = /* @__PURE__ */ new Map();
+	const loadFont = async (request) => {
+		const font = fontLoaders.find((candidate) => request.startsWith(candidate.prefix));
+		const resource = font.target + request.slice(font.prefix.length - 1);
+		const files = [];
+		const [css, map, meta] = await runLoaderEmitting((file) => {
+			if (/\.(?:woff|woff2|eot|ttf|otf)$/.test(file)) files.push(file);
+		})(nextFontLoader, font.fontOptions, resource);
+		const [code] = await runLoader(font.cssLoader, font.cssOptions, resource, css, map, meta);
+		const cssModule = {
+			id: resource,
+			exports: {}
+		};
+		compileFunction(code, [
+			"module",
+			"exports",
+			"require"
+		])(cssModule, cssModule.exports, projectRequire);
+		const list = cssModule.exports;
+		if (!Array.isArray(list) || !list.locals) fail("css-loader no longer makes a list of CSS with `locals` of a `next/font` call");
+		return {
+			css: String(list),
+			exports: list.locals,
+			files
+		};
+	};
+	const [cssModuleLoader] = getCssModuleLoader({
+		isClient: false,
+		isServer: true,
+		hasAppDir: true,
+		isAppDir: true,
+		isDevelopment: false,
+		experimental: {
+			...config.experimental,
+			useLightningcss: false
+		}
+	}, postcss).filter((entry) => entry.loader?.includes("css-loader"));
+	const rule = cssModuleLoader?.options?.modules;
+	const mode = typeof rule?.mode === "string" ? rule.mode : fail("`getCssModuleLoader()` no longer gives css-loader the `mode` of a CSS module");
+	const getLocalIdent = typeof rule?.getLocalIdent === "function" ? rule.getLocalIdent : fail("`getCssModuleLoader()` no longer gives css-loader a `getLocalIdent`");
+	const checkMode = {
+		postcssPlugin: "vitest-plugin-rsc:next-css-module-mode",
+		Once(root, { result, postcss: process }) {
+			const file = (result.opts.from ?? "").split("?")[0];
+			if (!/\.module\.(?:css|scss|sass)$/.test(file)) return;
+			process([localByDefault({ mode })]).process(root.clone(), { from: file }).root;
+		}
+	};
+	const loadCssOptions = async () => {
+		const { experimental } = config;
+		const differences = [];
+		if (experimental.useLightningcss) differences.push("`experimental.useLightningcss` is not supported: the CSS is compiled with PostCSS");
+		let postcss;
+		if (await findConfig(root, "postcss") || !hasOtherPostCssConfig(root)) postcss = { plugins: [...await getPostCssPlugins(root, getSupportedBrowsers(root, false), experimental.disablePostcssPresetEnv), checkMode] };
+		else differences.push("the app's PostCSS config is one only Vite reads: a CSS module is not held to Next's mode for it");
+		const sass = sassPreprocessorOptions(config.sassOptions ?? {}, root);
+		return {
+			options: {
+				postcss,
+				...sass && { preprocessorOptions: {
+					scss: sass,
+					sass
+				} },
+				modules: { generateScopedName: (name, file) => getLocalIdent({
+					rootContext: root,
+					resourcePath: file.split("?")[0]
+				}, void 0, name, { context: root }) }
+			},
+			differences
+		};
+	};
+	const emittedPath = `${config.assetPrefix.startsWith("/") ? config.assetPrefix : ""}/_next/`;
+	const { images } = config;
+	return {
+		runLoader,
+		isImage: (file) => !images.disableStaticImages && nextImageLoaderRegex.test(file),
+		async loadImage(file) {
+			const options = {
+				isDev: false,
+				compilerType: COMPILER_NAMES.client,
+				assetPrefix: config.assetPrefix,
+				basePath: config.basePath,
+				outputHashSalt: config.outputHashSalt
+			};
+			const [code] = await runLoader(nextImageLoader, options, file, await fs.promises.readFile(file));
+			if (typeof code !== "string" || !code.startsWith("export default {")) fail("next-image-loader no longer exports the data of an image");
+			return code;
+		},
+		loadCssOptions,
+		loadFont(request) {
+			let font = fonts.get(request);
+			if (!font) {
+				fonts.set(request, font = loadFont(request));
+				font.catch(() => fonts.delete(request));
+			}
+			return font;
+		},
+		assetPath: emittedPath,
+		async loadRootParams() {
+			const options = {
+				appDir: context.appDir,
+				pageExtensions: config.pageExtensions
+			};
+			const [code] = await runLoader(nextRootParamsLoader, options, context.appDir);
+			return String(code);
+		},
+		emittedFiles: () => [...emitted].map(([name, body]) => ({
+			pathname: `${emittedPath}${name}`,
+			body
+		})),
+		readEmittedFile(pathname) {
+			if (!pathname.startsWith(emittedPath)) return;
+			const name = pathname.slice(emittedPath.length);
+			const body = emitted.get(name);
+			if (!body) return;
+			return {
+				body,
+				contentType: getContentType(path.extname(name).slice(1)) ?? ""
+			};
+		},
+		async optimizeImage(request, response, serveFile) {
+			const url = new URL(request.url, "http://n");
+			if (url.pathname !== images.path) return false;
+			if (images.loader !== "default" || images.unoptimized) {
+				response.statusCode = 404;
+				response.end();
+				return true;
+			}
+			const { ImageOptimizerCache, ImageError } = imageOptimizer;
+			const query = querystring.parse(url.search.slice(1));
+			const params = ImageOptimizerCache.validateParams(request, query, config, false);
+			if ("errorMessage" in params) {
+				response.statusCode = 400;
+				response.end(params.errorMessage);
+				return true;
+			}
+			try {
+				const upstream = params.isAbsolute ? await imageOptimizer.fetchExternalImage(params.href, images.dangerouslyAllowLocalIP, images.maximumResponseBody, images.maximumRedirects) : await imageOptimizer.fetchInternalImage(params.href, request, response, images.maximumResponseBody, serveFile);
+				const { buffer, contentType, maxAge, etag } = await imageOptimizer.imageOptimizer(upstream, params, config, { isDev: false });
+				imageOptimizer.sendResponse(request, response, params.href, getExtension(contentType), buffer, etag, params.isStatic, "MISS", images, maxAge, true);
+			} catch (error) {
+				if (!(error instanceof ImageError)) throw error;
+				response.statusCode = error.statusCode;
+				response.end(error.message);
+			}
+			return true;
+		}
+	};
+}
+//#endregion
+export { createLoaders, sassPreprocessorOptions };

package/dist/project/metadata.d.ts

@@ -0,0 +1,8 @@
+import { RunLoader } from "./loaders.js";
+import { NextContext } from "./context.js";
+import { NextProject } from "../project.js";
+
+//#region src/project/metadata.d.ts
+declare function createMetadataLoaders(context: NextContext, runLoader: RunLoader): Pick<NextProject, "metadataImageMeta" | "isMetadataRequest" | "loadMetadata">;
+//#endregion
+export { createMetadataLoaders };

package/dist/project/metadata.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import querystring from "node:querystring";
+//#region src/project/metadata.ts
+const metadataRequest = /^(next-metadata-(?:image|route)-loader)\?([^!]*)!(.*)$/;
+function createMetadataLoaders(context, runLoader) {
+	const { fail, replace, next } = context;
+	const { nextMetadataImageLoader, nextMetadataRouteLoader, WEBPACK_RESOURCE_QUERIES } = next;
+	return {
+		metadataImageMeta: `?${WEBPACK_RESOURCE_QUERIES.metadataImageMeta}`,
+		isMetadataRequest: (source) => metadataRequest.test(source),
+		async loadMetadata(request) {
+			const [, loader, query = "", resource = ""] = metadataRequest.exec(request) ?? fail(`${request} is no request for a metadata loader`);
+			const options = querystring.parse(query);
+			if (loader === "next-metadata-route-loader") {
+				const file = String(options.filePath);
+				let [code] = await runLoader(nextMetadataRouteLoader, options, resource);
+				if (options.isDynamicRouteExtension !== "1" && process.env.NODE_ENV !== "production") code = replace(code, JSON.stringify("no-cache, no-store"), JSON.stringify("public, max-age=0, must-revalidate"), "the route of a static metadata file");
+				return {
+					code,
+					watchFiles: [file]
+				};
+			}
+			const file = resource.split("?")[0];
+			const content = await fs.promises.readFile(file);
+			const [code] = await runLoader(nextMetadataImageLoader, options, resource, content);
+			return {
+				code,
+				watchFiles: [file]
+			};
+		}
+	};
+}
+//#endregion
+export { createMetadataLoaders };

package/dist/project/module-exports.d.ts

@@ -0,0 +1,29 @@
+//#region src/project/module-exports.d.ts
+/**
+ * The names an ES module exports in its own code, `default` among them, and
+ * the modules of its `export *`. Of JavaScript, like Next's compiled files and
+ * the modules the plugin generates.
+ */
+declare function declaredExports(code: string): {
+  names: Set<string>;
+  stars: string[];
+};
+/**
+ * What an ES module of Next exports: declared there, exported apart from its
+ * declaration, or from another module of Next with `export ... from` or
+ * `export *`. A module of CommonJS has none here.
+ */
+declare function exportNamesOf(file: string, seen?: Set<string>): Set<string>;
+/** Whether an ES module of Next exports a name: see `exportNamesOf()`. */
+declare const hasExport: (file: string, name: string) => boolean;
+/**
+ * What a module of the app exports, read off its code: the names, `default`
+ * among them, and the modules of its `export *`, whose names are theirs.
+ */
+declare function exportsOf(code: string, file: string): Promise<{
+  names: Set<string>;
+  stars: string[];
+}>;
+declare function exportStubs(code: string, file: string): Promise<string>;
+//#endregion
+export { declaredExports, exportNamesOf, exportStubs, exportsOf, hasExport };

package/dist/project/module-exports.js

@@ -0,0 +1,77 @@
+import { moduleFileAt } from "./context.js";
+import { parseAst, transformWithOxc } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+//#region src/project/module-exports.ts
+function nameOf(node) {
+	return "name" in node ? String(node.name) : "value" in node ? String(node.value) : "";
+}
+function bound(pattern, names) {
+	if (!pattern || !("type" in pattern)) return;
+	if (pattern.type === "Identifier") names.add(nameOf(pattern));
+	for (const key of [
+		"properties",
+		"elements",
+		"value",
+		"argument",
+		"left"
+	]) {
+		const child = pattern[key];
+		for (const part of [child].flat()) if (typeof part === "object") bound(part, names);
+	}
+}
+/**
+* The names an ES module exports in its own code, `default` among them, and
+* the modules of its `export *`. Of JavaScript, like Next's compiled files and
+* the modules the plugin generates.
+*/
+function declaredExports(code) {
+	const names = /* @__PURE__ */ new Set();
+	const stars = [];
+	for (const node of parseAst(code).body) if (node.type === "ExportDefaultDeclaration") names.add("default");
+	else if (node.type === "ExportAllDeclaration") {
+		if (node.exported) names.add(nameOf(node.exported));
+		else stars.push(node.source.value);
+	} else if (node.type === "ExportNamedDeclaration") {
+		for (const specifier of node.specifiers) names.add(nameOf(specifier.exported));
+		const { declaration } = node;
+		if (declaration?.type === "VariableDeclaration") for (const { id } of declaration.declarations) bound(id, names);
+		else if (declaration && "id" in declaration && declaration.id) names.add(nameOf(declaration.id));
+	}
+	return {
+		names,
+		stars
+	};
+}
+/**
+* What an ES module of Next exports: declared there, exported apart from its
+* declaration, or from another module of Next with `export ... from` or
+* `export *`. A module of CommonJS has none here.
+*/
+function exportNamesOf(file, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(file)) return /* @__PURE__ */ new Set();
+	seen.add(file);
+	const { names, stars } = declaredExports(fs.readFileSync(file, "utf8"));
+	for (const star of stars) {
+		const from = star.startsWith(".") && moduleFileAt(path.resolve(path.dirname(file), star));
+		if (!from) continue;
+		for (const name of exportNamesOf(from, seen)) if (name !== "default") names.add(name);
+	}
+	return names;
+}
+/** Whether an ES module of Next exports a name: see `exportNamesOf()`. */
+const hasExport = (file, name) => exportNamesOf(file).has(name);
+/**
+* What a module of the app exports, read off its code: the names, `default`
+* among them, and the modules of its `export *`, whose names are theirs.
+*/
+async function exportsOf(code, file) {
+	return declaredExports((await transformWithOxc(code, file, { sourcemap: false })).code);
+}
+async function exportStubs(code, file) {
+	const { names, stars } = await exportsOf(code, file);
+	const named = [...names].filter((name) => /^[\w$]+$/.test(name) && name !== "default");
+	return (named.length > 0 ? `const _ = undefined;\nexport { ${named.map((name) => `_ as ${name}`).join(", ")} };\n` : "") + (names.has("default") ? "export default undefined;\n" : "") + stars.map((star) => `export * from ${JSON.stringify(star)};\n`).join("");
+}
+//#endregion
+export { declaredExports, exportNamesOf, exportStubs, exportsOf, hasExport };

package/dist/project/routes.d.ts

@@ -0,0 +1,19 @@
+import { NextContext } from "./context.js";
+import { NextRoute } from "../project.js";
+
+//#region src/project/routes.d.ts
+/** The routes of the app, as `discoverAppRoutes()` lists them. */
+type AppRoutes = Awaited<ReturnType<typeof discoverAppRoutes>>;
+/**
+ * The routes of the app, the way `next build` lists its entries, and what
+ * `next build` rejects an app for.
+ */
+declare function discoverAppRoutes(context: NextContext): Promise<{
+  routes: NextRoute[]; /** The pages of each route, by its pathname: a route can have a page in each of its slots. */
+  appPathsPerRoute: Record<string, string[]>;
+  strictRouteMatching: true | undefined;
+  edgeRouteFiles: string[];
+  routeFile: (route: NextRoute) => string | undefined;
+}>;
+//#endregion
+export { AppRoutes, discoverAppRoutes };

package/dist/project/routes.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import fs from "node:fs";
+//#region src/project/routes.ts
+/**
+* The routes of the app, the way `next build` lists its entries, and what
+* `next build` rejects an app for.
+*/
+async function discoverAppRoutes(context) {
+	const { root, fail, config, appDir, pageExtensions, next } = context;
+	const { APP_DIR_ALIAS, IncompatibleParallelRouteSlotsError, MissingCanonicalInterceptionRoutesError, UnmatchedAppPagesError, compareAppPaths, discoverRoutes, findMissingCanonicalInterceptionRoutes, getAppPageStaticInfo, isAppPageRoute, isAppRouteRoute, normalizeAppPath, normalizeCatchAllRoutes, selectAppPageEntry } = next;
+	const discovered = await discoverRoutes({
+		appDir,
+		pagesDir: void 0,
+		pageExtensions,
+		isDev: false,
+		baseDir: root,
+		isSrcDir: path.basename(path.dirname(appDir)) === "src"
+	});
+	const mappedAppPages = discovered.mappedAppPages ?? fail("`discoverRoutes()` returns no `mappedAppPages`");
+	const appPathsPerRoute = {};
+	for (const page of Object.keys(mappedAppPages)) (appPathsPerRoute[normalizeAppPath(page)] ??= []).push(page);
+	const { strictRouteMatching: strict } = config.experimental;
+	const strictRouteMatching = strict || void 0;
+	const { unmatchedAppPages, incompatibleParallelRouteSlots } = normalizeCatchAllRoutes(appPathsPerRoute, {
+		strictRouteMatching,
+		defaultAppPaths: Object.keys(discovered.mappedAppDefaults ?? {})
+	});
+	const pagePathsPerRoute = Object.fromEntries(Object.entries(appPathsPerRoute).flatMap(([pathname, appPaths]) => {
+		const pages = appPaths.filter(isAppPageRoute);
+		return pages.length > 0 ? [[pathname, pages]] : [];
+	}));
+	const missingCanonical = strictRouteMatching ? findMissingCanonicalInterceptionRoutes(pagePathsPerRoute) : [];
+	const routeErrors = [
+		...missingCanonical.length > 0 ? [new MissingCanonicalInterceptionRoutesError(missingCanonical)] : [],
+		...incompatibleParallelRouteSlots.length > 0 ? [new IncompatibleParallelRouteSlotsError(incompatibleParallelRouteSlots.map((slot) => ({
+			...slot,
+			layoutFile: path.relative(root, path.join(appDir, slot.layoutPath, "layout"))
+		})))] : [],
+		...unmatchedAppPages.length > 0 ? [new UnmatchedAppPagesError(unmatchedAppPages)] : []
+	];
+	if (routeErrors.length > 0) throw new Error(`vitest-plugin-rsc: \`next build\` fails on the routes of this app.\n\n` + routeErrors.map((error) => error.message).join("\n\n"));
+	const fromRoot = (file) => path.relative(root, file).split(path.sep).join("/");
+	const isRouteHandler = isAppRouteRoute;
+	const routes = [];
+	for (const [pathname, appPaths] of Object.entries(appPathsPerRoute)) {
+		appPaths.sort(compareAppPaths);
+		const page = selectAppPageEntry(pathname, appPaths);
+		const pagePath = mappedAppPages[page];
+		const own = appPaths.filter((appPath) => normalizeAppPath(appPath) === pathname);
+		const pages = own.filter((appPath) => appPath.endsWith("/page"));
+		const handlers = own.filter(isRouteHandler);
+		if (pages.length > 0 && handlers.length > 0) throw new Error(`vitest-plugin-rsc: ${pathname} is both a page and a route handler (${pages.join(", ")} and ${handlers.join(", ")}). A path can only be one of them.`);
+		const kind = page.endsWith("/page") ? "page" : isRouteHandler(page) ? "route" : void 0;
+		if (kind) routes.push({
+			kind,
+			page,
+			pathname,
+			appPaths,
+			pagePath
+		});
+	}
+	const routeFile = (route) => route.pagePath.startsWith(APP_DIR_ALIAS) ? path.join(appDir, route.pagePath.slice(APP_DIR_ALIAS.length)) : void 0;
+	for (const route of routes) {
+		const file = routeFile(route);
+		if (route.kind !== "page" || !file) continue;
+		const hasLayout = (directory) => pageExtensions.some((extension) => fs.existsSync(path.join(directory, `layout.${extension}`))) || directory !== appDir && hasLayout(path.dirname(directory));
+		if (!hasLayout(path.dirname(file))) throw new Error(`vitest-plugin-rsc: ${fromRoot(file)} does not have a root layout: there is no layout file in its directory or in one above it, up to the app directory. \`next build\` stops at that too.`);
+	}
+	const edgeRouteFiles = [];
+	for (const route of routes) {
+		const file = routeFile(route);
+		if (!file) continue;
+		const { runtime } = await getAppPageStaticInfo({
+			pageFilePath: file,
+			nextConfig: config,
+			isDev: false,
+			page: route.page,
+			pageType: "app"
+		});
+		if (runtime === "edge") edgeRouteFiles.push(fromRoot(file));
+	}
+	return {
+		routes,
+		/** The pages of each route, by its pathname: a route can have a page in each of its slots. */
+		appPathsPerRoute,
+		strictRouteMatching,
+		edgeRouteFiles,
+		routeFile
+	};
+}
+//#endregion
+export { discoverAppRoutes };

package/dist/project/routing.d.ts

@@ -0,0 +1,46 @@
+import { Header } from "../compat/types.js";
+import { AppRoutes } from "./routes.js";
+import { NextContext } from "./context.js";
+import { NextRouting } from "../project.js";
+import * as _$next_dist_build_index0 from "next/dist/build/index.js";
+import * as _$next_dist_build_analysis_get_page_static_info0 from "next/dist/build/analysis/get-page-static-info.js";
+
+//#region src/project/routing.d.ts
+/**
+ * A rule of `headers()` in `next.config` with its `Set-Cookie` headers as
+ * one, joined with a comma. Next's build hands an adapter the headers of a
+ * rule as an object, one value per name, and `@next/routing` sets each on
+ * the response: the second cookie would be lost. `next start` sends every
+ * one. Joined, they are the way Next's build writes the `set-cookie` of a
+ * prerendered route, and `resolve()` in server-in-front.ts splits them
+ * again, with the split Next's `toNodeOutgoingHttpHeaders()` has for them.
+ */
+declare function joinSetCookies<T extends Pick<Header, "headers">>(rule: T): T;
+/** The middleware of the app, as `findMiddleware()` finds it. */
+type FoundMiddleware = Awaited<ReturnType<typeof findMiddleware>>;
+declare function findMiddleware(context: NextContext): Promise<{
+  middlewareFile: string | undefined;
+  middleware: {
+    page: string;
+    pagePath: string;
+    staticInfo: Omit<_$next_dist_build_analysis_get_page_static_info0.PageStaticInfo, "config">;
+  } | undefined;
+}>;
+/** `adapterPath` is the file of the adapter that Next's build hands the routes to: adapter.ts. */
+declare function buildRouting(context: NextContext, {
+  routes,
+  appPathsPerRoute
+}: AppRoutes, {
+  middleware
+}: FoundMiddleware, adapterPath: string): Promise<{
+  routing: NextRouting;
+  routesManifest: _$next_dist_build_index0.RoutesManifest;
+  unmatchedRoutes: string[];
+  pageOf: (url: URL, {
+    proxy
+  }: {
+    proxy: boolean;
+  }) => Promise<string | undefined>;
+}>;
+//#endregion
+export { FoundMiddleware, buildRouting, findMiddleware, joinSetCookies };