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

package/dist/project/context.js

@@ -0,0 +1,111 @@
+import { loadNextBuild } from "../compat/build.js";
+import { pageEnvOf, readTestEnv } from "./env.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+//#region src/project/context.ts
+const workingDirectory = process.cwd();
+let directoryQueue = Promise.resolve();
+function inDirectory(directory, load) {
+	const result = directoryQueue.then(async () => {
+		process.chdir(directory);
+		try {
+			return await load();
+		} finally {
+			process.chdir(workingDirectory);
+		}
+	});
+	directoryQueue = result.catch(() => {});
+	return result;
+}
+/** The file of a module of Next by its path, which may leave out `.js` or `/index.js`. */
+function moduleFileAt(base) {
+	return [
+		base,
+		`${base}.js`,
+		path.join(base, "index.js")
+	].find((candidate) => fs.statSync(candidate, { throwIfNoEntry: false })?.isFile());
+}
+async function openNextProject(root, projectRequire, options) {
+	const nextDir = path.dirname(projectRequire.resolve("next/package.json"));
+	const { version } = projectRequire("next/package.json");
+	const [major = 0, minor = 0] = version.split(".").map(Number);
+	if (major < 16 || major === 16 && minor < 4) throw new Error(`@kasperpeulen/vitest-plugin-nextjs needs next@16.4 or later, found next@${version}.`);
+	const fail = (what, cause) => {
+		throw new Error(`vitest-plugin-rsc: next@${version} differs from the Next.js this plugin was written for: ${what}. Use a version of @kasperpeulen/vitest-plugin-nextjs that supports next@${version}.`, { cause });
+	};
+	const replace = (code, piece, replacement, where) => {
+		const replaced = code.replace(piece, replacement);
+		return replaced === code ? fail(`${where} has no \`${piece}\` to replace`) : replaced;
+	};
+	const { loadConfig, PHASE_PRODUCTION_BUILD, findPagesDir, generateBuildId, ...next } = loadNextBuild(projectRequire, fail);
+	let nextEnv;
+	try {
+		nextEnv = createRequire(path.join(nextDir, "package.json")).resolve("@next/env");
+	} catch (error) {
+		return fail(`@next/env is not found next to next (${error.message})`, error);
+	}
+	const readEnv = () => readTestEnv(root, {
+		nextEnv,
+		envWorker: options.envWorker,
+		build: !!options.static
+	}).catch((error) => {
+		throw new Error(`vitest-plugin-rsc: the env files of ${root} do not load: ${error.message}`, { cause: error });
+	});
+	const testEnv = await readEnv();
+	for (const [name, value] of Object.entries(testEnv.values)) process.env[name] ??= value;
+	const loadedConfig = await inDirectory(root, () => loadConfig(PHASE_PRODUCTION_BUILD, root, { silent: true }));
+	const config = {
+		...loadedConfig,
+		i18n: null,
+		experimental: {
+			...loadedConfig.experimental,
+			cachedNavigations: false
+		},
+		...options.static && (loadedConfig.images?.loader ?? "default") === "default" && !loadedConfig.images?.loaderFile && { images: {
+			...loadedConfig.images,
+			unoptimized: true
+		} }
+	};
+	const { appDir } = findPagesDir(root);
+	if (!appDir) throw new Error(`vitest-plugin-rsc: no \`app\` directory found in ${root}`);
+	const { pageExtensions } = config;
+	const distDir = path.join(root, config.distDir);
+	await next.swc.loadBindings(config.experimental.useWasmBinary);
+	const buildId = await generateBuildId(config.generateBuildId, () => "vitest");
+	const buildEnvironment = {
+		__NEXT_BUILD_ID: buildId,
+		__NEXT_PREVIEW_MODE_ID: "vitest-preview-mode-id",
+		__NEXT_PREVIEW_MODE_SIGNING_KEY: "vitest-preview-mode-signing-key",
+		__NEXT_PREVIEW_MODE_ENCRYPTION_KEY: "vitest-preview-mode-encryption-key".padEnd(64, "0")
+	};
+	const previewProps = {
+		previewModeId: buildEnvironment.__NEXT_PREVIEW_MODE_ID,
+		previewModeSigningKey: buildEnvironment.__NEXT_PREVIEW_MODE_SIGNING_KEY,
+		previewModeEncryptionKey: buildEnvironment.__NEXT_PREVIEW_MODE_ENCRYPTION_KEY
+	};
+	return {
+		root,
+		/** What the page's `process.env` gets, see env.ts. */
+		env: pageEnvOf(testEnv, next.getNextConfigEnv(config)),
+		/** The env again, as the env files have it now. */
+		loadEnv: async () => pageEnvOf(await readEnv(), next.getNextConfigEnv(config)),
+		/** Finds `next`, and what the project has installed next to it. Not the global one. */
+		projectRequire,
+		nextDir,
+		version,
+		fail,
+		replace,
+		config,
+		appDir,
+		pageExtensions,
+		distDir,
+		buildId,
+		buildEnvironment,
+		previewProps,
+		/** The build code of the installed `next`, see compat/build.ts. */
+		next
+	};
+}
+//#endregion
+export { inDirectory, moduleFileAt, openNextProject };

package/dist/project/entries.d.ts

@@ -0,0 +1,42 @@
+import { componentPagePath } from "../styles-shared.js";
+import { AppLoaderOptions } from "../compat/types.js";
+import { RunLoader } from "./loaders.js";
+import { AppRoutes } from "./routes.js";
+import { FoundMiddleware } from "./routing.js";
+import { NextContext } from "./context.js";
+import { NextProject } from "../project.js";
+
+//#region src/project/entries.d.ts
+type AppLoaderContext = {
+  getOptions(): AppLoaderOptions;
+  _module: {
+    buildInfo: Record<string, unknown>;
+  };
+  _compilation: object;
+  _compiler: {
+    context: string;
+  };
+  addDependency(file: string): void;
+  addMissingDependency(file: string): void;
+  addContextDependency(dir: string): void;
+};
+/**
+ * What the loader tree of a route names a file of it: its path from the root
+ * of the project, with `/`. Next looks up the stylesheets of a segment by that
+ * name without its extension (`RouteSegment`), with a dev server and in a
+ * build. Not the absolute path that Next's webpack build names it by: a static
+ * build has the tree in its files, which are then the same on every machine.
+ * Turbopack's names are from a root too, `[project]/app/page.tsx`.
+ */
+declare function nameInLoaderTree(root: string, file: string): string;
+declare function routeEntries(context: NextContext, {
+  routes,
+  appPathsPerRoute,
+  strictRouteMatching,
+  routeFile
+}: AppRoutes, {
+  middleware,
+  middlewareFile
+}: FoundMiddleware, builtinBoundaries: Record<string, string>, runLoader: RunLoader): Pick<NextProject, "componentRoutes" | "loadRouteEntry" | "loadMiddlewareEntry">;
+//#endregion
+export { AppLoaderContext, componentPagePath, nameInLoaderTree, routeEntries };

package/dist/project/entries.js

@@ -0,0 +1,189 @@
+import { componentPagePath } from "../styles-shared.js";
+import { appPageRuntime } from "../compat/paths.js";
+import { normalizePath, parseAst } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import querystring from "node:querystring";
+//#region src/project/entries.ts
+const loadOnce = "const __vitest_plugin_rsc_once__ = (load) => {\n  let loaded;\n  return () => (loaded ??= load().catch((error) => { loaded = undefined; throw error; }));\n};\n";
+const segmentLoader = /\binstrumentModuleGetter\(\(\) => import\((\/\* webpackMode: "eager" \*\/ "(?:[^"\\]|\\.)*")\)\)/g;
+function loadingOnce(code) {
+	const once = code.replace(segmentLoader, "instrumentModuleGetter(__vitest_plugin_rsc_once__(() => import($1)))");
+	return once === code ? code : loadOnce + once;
+}
+const componentRoot = "(vitest-plugin-rsc)";
+const componentLayouts = "(vitest-plugin-rsc-layouts)";
+const componentPage = `page: [__next_component__, ${JSON.stringify(componentPagePath)}]`;
+const componentImport = `import { loadComponent as __next_component__ } from "@kasperpeulen/vitest-plugin-nextjs/rsc";\n`;
+function stripTurbopackTransitions(code) {
+	return code.replace(/\s+with\s*\{\s*['"]turbopack-transition['"]\s*:\s*['"][^'"]*['"]\s*\}/g, "");
+}
+/**
+* What the loader tree of a route names a file of it: its path from the root
+* of the project, with `/`. Next looks up the stylesheets of a segment by that
+* name without its extension (`RouteSegment`), with a dev server and in a
+* build. Not the absolute path that Next's webpack build names it by: a static
+* build has the tree in its files, which are then the same on every machine.
+* Turbopack's names are from a root too, `[project]/app/page.tsx`.
+*/
+function nameInLoaderTree(root, file) {
+	return normalizePath(path.relative(root, file));
+}
+const isLiteral = (node) => node?.type === "Literal";
+function nameFiles(root, code) {
+	const files = /* @__PURE__ */ new Set();
+	const specifiers = /* @__PURE__ */ new Set();
+	const strings = [];
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		const { type, source, callee, arguments: args } = node;
+		const specifier = type === "CallExpression" && callee?.type === "Identifier" && callee.name === "require" ? args?.[0] : source;
+		if (isLiteral(specifier) && typeof specifier.value === "string") {
+			specifiers.add(specifier);
+			if ((type === "ImportDeclaration" || type === "ImportExpression") && path.isAbsolute(specifier.value)) files.add(specifier.value);
+		}
+		if (isLiteral(node) && typeof node.value === "string") strings.push(node);
+		for (const value of Object.values(node)) if (value && typeof value === "object") visit(value);
+	};
+	visit(parseAst(code));
+	const names = strings.filter((string) => !specifiers.has(string) && files.has(string.value)).sort((a, b) => b.start - a.start);
+	for (const { value, start, end } of names) {
+		const name = JSON.stringify(nameInLoaderTree(root, value));
+		code = code.slice(0, start) + name + code.slice(end);
+	}
+	return {
+		code,
+		segments: [...files].map((file) => ({
+			file,
+			stylesheetsKey: nameInLoaderTree(root, file).replace(/\.[^.]+$/, "")
+		}))
+	};
+}
+function routeEntries(context, { routes, appPathsPerRoute, strictRouteMatching, routeFile }, { middleware, middlewareFile }, builtinBoundaries, runLoader) {
+	const { root, fail, replace, config, appDir, pageExtensions, buildId, next } = context;
+	const { getEdgeServerEntry, loadEntrypoint, nextAppLoader, nextMiddlewareLoader, rootPageType } = next;
+	const bindPageEntry = (code, where) => {
+		code = replace(code, /\b__webpack_require__\b/g, "__next_require__", where);
+		if (!code.includes(`"next/dist/build/templates/app-page-runtime"`) && !code.includes(`'next/dist/build/templates/app-page-runtime'`)) fail(`${where} has no \`${appPageRuntime}\``);
+		return `import { requireModule as __next_require__ } from "@kasperpeulen/vitest-plugin-nextjs/rsc";\n${code}`;
+	};
+	async function loadNodeEntry({ page, pathname }) {
+		const segment = (name, children, modules = "{}") => `[${JSON.stringify(name)}, ${children}, ${modules}, null]`;
+		let tree = `["__PAGE__", {}, { ${componentPage} }]`;
+		for (const name of pathname.split("/").filter(Boolean).reverse()) tree = segment(name, `{ children: ${tree} }`);
+		const boundaries = Object.entries(builtinBoundaries).map(([name, file]) => `${JSON.stringify(name)}: [() => import(${JSON.stringify(file)}), ${JSON.stringify(file)}]`);
+		tree = segment(componentRoot, `{ children: ${tree} }`, `{ ${boundaries.join(", ")} }`);
+		let code;
+		try {
+			code = await loadEntrypoint("app-page", {
+				VAR_DEFINITION_PAGE: page,
+				VAR_DEFINITION_PATHNAME: pathname
+			}, {
+				tree,
+				__next_app_require__: "__webpack_require__",
+				__next_app_load_chunk__: "() => Promise.resolve()"
+			});
+		} catch (error) {
+			return fail(`the app-page template does not take the injections of next-app-loader (${error.message})`, error);
+		}
+		return componentImport + bindPageEntry(stripTurbopackTransitions(code), "the app-page template");
+	}
+	const compilation = {};
+	const loadAppRouteEntry = async (route) => {
+		const watchFiles = /* @__PURE__ */ new Set();
+		const context = {
+			getOptions: () => ({
+				name: `app${route.page}`,
+				page: route.page,
+				pagePath: route.pagePath,
+				appDir,
+				appPaths: route.appPaths,
+				allNormalizedAppPaths: Object.keys(appPathsPerRoute),
+				pageExtensions,
+				rootDir: root,
+				basePath: config.basePath,
+				assetPrefix: config.assetPrefix,
+				nextConfigOutput: config.output ?? "",
+				preferredRegion: void 0,
+				middlewareConfig: Buffer.from("{}").toString("base64"),
+				isGlobalNotFoundEnabled: config.experimental.globalNotFound || void 0,
+				explicitParallelRouteChildren: config.experimental.explicitParallelRouteChildren || void 0,
+				strictRouteMatching,
+				isFinalRouteMatcher: strictRouteMatching
+			}),
+			_module: { buildInfo: {} },
+			_compilation: compilation,
+			_compiler: { context: root },
+			addDependency: (file) => watchFiles.add(file),
+			addMissingDependency: (file) => watchFiles.add(file),
+			addContextDependency: () => {}
+		};
+		let code = stripTurbopackTransitions(await nextAppLoader.call(context));
+		const where = "the output of next-app-loader";
+		if (route.kind === "route") code = replace(code, /(\buserland: \(\)\s*=>\s*)require\(/, "$1import(", where);
+		else code = bindPageEntry(code, where);
+		const named = nameFiles(root, code);
+		const pageFile = route.kind === "page" ? routeFile(route) : void 0;
+		if (pageFile && !named.segments.some((segment) => segment.file === pageFile)) fail(`${where} no longer imports the module of a page by its file`);
+		return {
+			code: loadingOnce(named.code),
+			watchFiles: [...watchFiles].filter((file) => fs.existsSync(file)),
+			segments: route.kind === "page" ? named.segments : []
+		};
+	};
+	return {
+		componentRoutes: [...[.../* @__PURE__ */ new Set(["/", ...routes.map((route) => route.pathname)])].filter((pathname) => !/^\/_(not-found|global-error)$/.test(pathname)).map((pathname) => ({
+			kind: "page",
+			page: `${pathname === "/" ? "" : pathname}/page`,
+			pathname,
+			component: `${componentRoot}${pathname}`
+		})), ...routes.filter((route) => route.kind === "page" && routeFile(route) && !route.page.includes("/@")).map((route) => ({
+			kind: "page",
+			page: route.page,
+			pathname: route.pathname,
+			component: `${componentLayouts}${route.page}`,
+			layouts: true
+		}))],
+		async loadRouteEntry(route) {
+			if (!("component" in route)) return loadAppRouteEntry(route);
+			if (!route.layouts) return {
+				code: await loadNodeEntry(route),
+				watchFiles: [],
+				segments: []
+			};
+			const appRoute = routes.find((candidate) => candidate.page === route.page);
+			const pageFile = routeFile(appRoute);
+			const file = JSON.stringify(nameInLoaderTree(root, pageFile)).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			const entry = await loadAppRouteEntry(appRoute);
+			const code = replace(entry.code, new RegExp(`\\bpage: \\[\\w+, ${file}\\]`), componentPage, "the output of next-app-loader");
+			return {
+				code: componentImport + code,
+				watchFiles: entry.watchFiles,
+				segments: entry.segments.filter((segment) => segment.file !== pageFile)
+			};
+		},
+		async loadMiddlewareEntry() {
+			if (!middleware || !middlewareFile) return;
+			const [loader, options = ""] = getEdgeServerEntry({
+				rootDir: root,
+				absolutePagePath: middleware.pagePath,
+				buildId,
+				bundlePath: middleware.page.slice(1),
+				config,
+				isDev: false,
+				isServerComponent: false,
+				page: middleware.page,
+				pages: {},
+				pagesType: rootPageType,
+				middleware: middleware.staticInfo.middleware,
+				middlewareConfig: middleware.staticInfo.middleware,
+				preferredRegion: middleware.staticInfo.preferredRegion
+			}).import.replace(/!$/, "").split("?");
+			if (loader !== "next-middleware-loader") fail("`getEdgeServerEntry()` no longer loads the middleware with next-middleware-loader");
+			const [code] = await runLoader(nextMiddlewareLoader, querystring.parse(options), middlewareFile);
+			return replace(stripTurbopackTransitions(code), /\brequire\(/g, "await import(", "the middleware template");
+		}
+	};
+}
+//#endregion
+export { componentPagePath, nameInLoaderTree, routeEntries };

package/dist/project/env-worker.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/project/env-worker.js

@@ -0,0 +1,9 @@
+import { createRequire } from "node:module";
+import { parentPort, workerData } from "node:worker_threads";
+//#region src/project/env-worker.ts
+const { nextEnv, root, files } = workerData;
+const { processEnv } = createRequire(import.meta.url)(nextEnv);
+const [, parsed = {}] = processEnv(files, root, console, true);
+parentPort.postMessage(parsed);
+//#endregion
+export {};

package/dist/project/env.d.ts

@@ -0,0 +1,36 @@
+//#region src/project/env.d.ts
+/** The env files that a run or a build reads, by their path from the root. */
+declare function envFilesOf(build: boolean): string[];
+type TestEnv = {
+  /** Each name of the files, with its value. */values: Record<string, string>; /** The files that were read, by their path from the root. */
+  files: string[];
+};
+/**
+ * The env files of a run or a build, parsed by the project's `@next/env` in
+ * `envWorker`, a thread with `NODE_ENV=test` for all of its env: see
+ * env-worker.ts.
+ */
+declare function readTestEnv(root: string, {
+  nextEnv,
+  envWorker,
+  build
+}: {
+  nextEnv: string;
+  envWorker: string;
+  build: boolean;
+}): Promise<TestEnv>;
+type PageEnv = TestEnv & {
+  /** The names that only `env` of `next.config` has. */configNames: string[];
+};
+/**
+ * What the page's `process.env` gets: the test env, and `env` of
+ * `next.config`, which Next's `getNextConfigEnv()` gives as defines.
+ */
+declare function pageEnvOf(testEnv: TestEnv, configDefines: Record<string, unknown>): PageEnv;
+/**
+ * What a run or a build says of the env, once: the files it read, and in a
+ * build the names it bundles. Never a value.
+ */
+declare function describeEnv(env: PageEnv, build: boolean): string;
+//#endregion
+export { PageEnv, TestEnv, describeEnv, envFilesOf, pageEnvOf, readTestEnv };

package/dist/project/env.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import fs from "node:fs";
+import { Worker } from "node:worker_threads";
+//#region src/project/env.ts
+/** Next's env files in its test mode. A name takes the value of the first file that has it. */
+const testEnvFiles = [
+	".env.test.local",
+	".env.test",
+	".env"
+];
+/** The env files that a run or a build reads, by their path from the root. */
+function envFilesOf(build) {
+	return build ? testEnvFiles.filter((file) => !file.endsWith(".local")) : testEnvFiles;
+}
+const isNextsOwn = (name) => name === "NODE_ENV" || name === "NEXT_RUNTIME" || name.startsWith("__NEXT_");
+/**
+* The env files of a run or a build, parsed by the project's `@next/env` in
+* `envWorker`, a thread with `NODE_ENV=test` for all of its env: see
+* env-worker.ts.
+*/
+async function readTestEnv(root, { nextEnv, envWorker, build }) {
+	const files = envFilesOf(build).flatMap((file) => {
+		const stats = fs.statSync(path.join(root, file), { throwIfNoEntry: false });
+		return stats?.isFile() || stats?.isFIFO() ? [{
+			path: file,
+			contents: fs.readFileSync(path.join(root, file), "utf8"),
+			env: {}
+		}] : [];
+	});
+	if (files.length === 0) return {
+		values: {},
+		files: []
+	};
+	const worker = new Worker(envWorker, {
+		env: { NODE_ENV: "test" },
+		workerData: {
+			nextEnv,
+			root,
+			files
+		}
+	});
+	const parsed = await new Promise((resolve, reject) => {
+		worker.once("message", resolve);
+		worker.once("error", reject);
+		worker.once("exit", (code) => reject(/* @__PURE__ */ new Error(`the thread exited with ${code}`)));
+	});
+	return {
+		values: Object.fromEntries(Object.entries(parsed).filter(([name]) => !isNextsOwn(name))),
+		files: files.map((file) => file.path)
+	};
+}
+/**
+* What the page's `process.env` gets: the test env, and `env` of
+* `next.config`, which Next's `getNextConfigEnv()` gives as defines.
+*/
+function pageEnvOf(testEnv, configDefines) {
+	const configEnv = Object.fromEntries(Object.entries(configDefines).map(([key, value]) => [key.slice(12), String(value)]));
+	return {
+		values: {
+			...configEnv,
+			...testEnv.values
+		},
+		files: testEnv.files,
+		configNames: Object.keys(configEnv).filter((name) => !(name in testEnv.values))
+	};
+}
+/**
+* What a run or a build says of the env, once: the files it read, and in a
+* build the names it bundles. Never a value.
+*/
+function describeEnv(env, build) {
+	const files = env.files.length > 0 ? env.files.join(", ") : `no env file, as there is no ${envFilesOf(build).join(" or ")}`;
+	if (!build) return `vitest-plugin-rsc: process.env of the app's server code is from ${files}`;
+	const fileNames = Object.keys(env.values).filter((name) => !env.configNames.includes(name));
+	return [
+		`vitest-plugin-rsc: the build puts into the site the env of ${files}`,
+		fileNames.length > 0 && `: ${fileNames.join(", ")}`,
+		env.configNames.length > 0 && `; and env of next.config: ${env.configNames.join(", ")}`
+	].filter(Boolean).join("");
+}
+//#endregion
+export { describeEnv, envFilesOf, pageEnvOf, readTestEnv };

package/dist/project/layers.d.ts

@@ -0,0 +1,31 @@
+import { NextBuild } from "../build.js";
+import { NextContext } from "./context.js";
+import { NextLayer } from "../project.js";
+
+//#region src/project/layers.d.ts
+/**
+ * What Next's build gives each layer: its compile-time constants and its
+ * module aliases. And the exports of the Flight codec of the rsc layer.
+ */
+declare function layerTables(context: NextContext, build: NextBuild): Promise<{
+  defines: {
+    rsc: {
+      [x: string]: string;
+    };
+    ssr: {
+      [x: string]: string;
+    };
+    browser: {
+      [x: string]: string;
+    };
+  };
+  aliases: {
+    rsc: Record<string, string | false>;
+    ssr: Record<string, string | false>;
+    browser: Record<string, string | false>;
+  };
+  appAliases: Record<NextLayer, Record<string, string>>;
+  flightExports: Record<"server" | "client" | "static", string[]>;
+}>;
+//#endregion
+export { layerTables };

package/dist/project/layers.js

@@ -0,0 +1,150 @@
+import { rscFlightCodec } from "../flight.js";
+import { aliasPaths, nextModulesWithStores, withStoresId } from "../compat/paths.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+import { init, parse } from "cjs-module-lexer";
+//#region src/project/layers.ts
+/**
+* What Next's build gives each layer: its compile-time constants and its
+* module aliases. And the exports of the Flight codec of the rsc layer.
+*/
+async function layerTables(context, build) {
+	const { root, nextDir, projectRequire, fail, config, appDir, pageExtensions, distDir, buildEnvironment, next } = context;
+	const { SUPPORTED_NATIVE_MODULES, compilerAliases, getDefineEnv, getNextPublicEnvironmentVariables, getNextConfigEnv, needsExperimentalReact } = next;
+	const definesFor = (layer) => {
+		const envKeys = new Set(Object.keys({
+			...getNextPublicEnvironmentVariables(),
+			...getNextConfigEnv(config)
+		}));
+		const defines = getDefineEnv({
+			isTurbopack: false,
+			config,
+			dev: false,
+			distDir,
+			projectPath: root,
+			fetchCacheKeyPrefix: config.experimental.fetchCacheKeyPrefix,
+			hasRewrites: false,
+			isClient: layer === "browser",
+			isEdgeServer: false,
+			isNodeServer: layer !== "browser",
+			clientRouterFilters: void 0,
+			middlewareMatchers: void 0,
+			rewrites: {
+				beforeFiles: [],
+				afterFiles: [],
+				fallback: []
+			}
+		});
+		if (layer !== "browser" && defines["process.env.NEXT_RUNTIME"] !== "\"nodejs\"") fail("`getDefineEnv()` does not define `process.env.NEXT_RUNTIME` as `nodejs`");
+		if (layer !== "browser") defines["process.env.__NEXT_USE_NODE_STREAMS"] = "false";
+		if ("process.env.__NEXT_RELATIVE_PROJECT_DIR" in defines) defines["process.env.__NEXT_RELATIVE_PROJECT_DIR"] = "\"\"";
+		return {
+			...layer !== "browser" && Object.fromEntries(Object.entries(buildEnvironment).map(([name, value]) => [`process.env.${name}`, JSON.stringify(value)])),
+			...Object.fromEntries(Object.entries(defines).filter(([key, value]) => typeof value === "string" && !envKeys.has(key)))
+		};
+	};
+	const appAliases = {
+		rsc: {},
+		ssr: {},
+		browser: {}
+	};
+	const aliasesFor = (layer) => {
+		const aliases = { "@opentelemetry/api$": aliasPaths.openTelemetry };
+		if (layer === "browser") for (const name of SUPPORTED_NATIVE_MODULES) {
+			if (name === "async_hooks") continue;
+			aliases[`${name}$`] = aliases[`node:${name}$`] = aliasPaths.polyfill(name);
+		}
+		else {
+			for (const kind of ["app-page", "app-route"]) {
+				const file = aliasPaths.routeModule(kind);
+				aliases[`${file}.compiled$`] = aliases[`${file}.compiled.js$`] = file;
+			}
+			for (const channel of ["", "-experimental"]) aliases[`${aliasPaths.reactDomServer(channel)}$`] = aliasPaths.reactDomServerEdge(channel, build);
+		}
+		const base = compilerAliases.createWebpackAliases({
+			distDir,
+			isClient: layer === "browser",
+			isEdgeServer: layer !== "browser",
+			dev: false,
+			config,
+			pagesDir: void 0,
+			appDir,
+			dir: root,
+			reactProductionProfiling: false
+		});
+		for (const [key, target] of Object.entries(base)) aliases[key] = Array.isArray(target) ? target.find((candidate) => ["", ...pageExtensions.map((extension) => `.${extension}`)].some((extension) => path.isAbsolute(candidate) && fs.existsSync(candidate + extension))) ?? false : target;
+		const channel = needsExperimentalReact(config) ? "-experimental" : "";
+		const vendoredReactAliases = (isEdgeServer) => compilerAliases.createVendoredReactAliases(channel, {
+			layer: layer === "browser" ? "app-pages-browser" : layer,
+			isBrowser: layer === "browser",
+			isEdgeServer,
+			reactProductionProfiling: false
+		});
+		Object.assign(aliases, compilerAliases.createServerOnlyClientOnlyAliases(layer === "rsc"), vendoredReactAliases(layer !== "browser"), compilerAliases.createNextApiEsmAliases(), compilerAliases.createAppRouterApiAliases(layer === "rsc"));
+		if (layer === "ssr") {
+			const nodeTable = vendoredReactAliases(false);
+			for (const key of ["react-dom/server$", "react-dom/static$"]) {
+				const entry = nodeTable[key];
+				if (typeof entry !== "string") return fail(`Next's alias table for Node.js has no \`${key}\``);
+				appAliases[layer][key] = entry;
+			}
+		}
+		if (typeof aliases["react-server-dom-webpack/server$"] !== "string") fail("the alias tables have no `react-server-dom-webpack/server$`");
+		for (const { module } of nextModulesWithStores) {
+			const id = withStoresId(module);
+			try {
+				projectRequire.resolve(id);
+			} catch (error) {
+				return fail(`${id} is not there`, error);
+			}
+		}
+		if (layer === "rsc") {
+			const contexts = aliasPaths.vendoredContexts;
+			let files;
+			try {
+				files = fs.readdirSync(path.join(nextDir, contexts.slice(5)));
+			} catch {
+				return fail(`${contexts} is not there`);
+			}
+			const names = files.filter((file) => file.endsWith(".js") && file !== "entrypoints.js").map((file) => file.slice(0, -3));
+			if (names.length === 0) fail(`${contexts} has no contexts`);
+			for (const name of names) aliases[`${aliasPaths.sharedRuntime(name)}$`] = `${contexts}/${name}`;
+		}
+		return aliases;
+	};
+	const aliases = {
+		rsc: aliasesFor("rsc"),
+		ssr: aliasesFor("ssr"),
+		browser: aliasesFor("browser")
+	};
+	await init();
+	const exportsOf = (file) => {
+		const { exports, reexports } = parse(fs.readFileSync(file, "utf8"));
+		const requireFrom = createRequire(file);
+		return [...exports.filter((name) => name !== "__esModule"), ...reexports.flatMap((reexport) => exportsOf(requireFrom.resolve(reexport)))];
+	};
+	const flightExports = {};
+	for (const entry of Object.keys(rscFlightCodec)) {
+		const specifier = `react-server-dom-webpack/${entry}`;
+		const target = aliases.rsc[`${specifier}$`];
+		if (typeof target !== "string") return fail(`the alias tables have no \`${specifier}$\``);
+		try {
+			flightExports[entry] = [...new Set(exportsOf(projectRequire.resolve(target)))];
+		} catch (error) {
+			return fail(`${target} cannot be read (${error.message})`, error);
+		}
+	}
+	return {
+		defines: {
+			rsc: definesFor("rsc"),
+			ssr: definesFor("ssr"),
+			browser: definesFor("browser")
+		},
+		aliases,
+		appAliases,
+		flightExports
+	};
+}
+//#endregion
+export { layerTables };