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

package/dist/client.js

@@ -0,0 +1,263 @@
+import { registry } from "./registry.js";
+import { recordListeners } from "./leftovers.js";
+import { registerModuleLoader } from "./client-modules.js";
+import { AppRouter, HeadManagerContext, appBootstrap, callServer, createInitialRouterState, createMutableActionQueue, invalidateBfCache, invalidateEntirePrefetchCache, loadAppIndex } from "./compat/browser/client.js";
+import { unstable_rethrow } from "next/navigation.js";
+import { Fragment, StrictMode, useEffect } from "react";
+import { flushSync } from "react-dom";
+import ReactDOMClient from "react-dom/client";
+import { createFromReadableStream } from "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser";
+import { setNodeOnPage } from "@kasperpeulen/vitest-plugin-nextjs/node-rendered";
+import { jsx } from "react/jsx-runtime";
+//#region src/client.tsx
+let current;
+function report(error) {
+	if (!current) return;
+	current.nodeOnPage?.errored(error);
+	if (!current.signal.aborted && !isNextControlFlow(error)) current.errors.push(error);
+}
+function reportingErrors(options, report) {
+	const { onCaughtError, onUncaughtError } = options ?? {};
+	if (!options || !onCaughtError || !onUncaughtError) return options;
+	return {
+		...options,
+		onCaughtError(error, info) {
+			report(error);
+			onCaughtError(error, info);
+		},
+		onUncaughtError(error, info) {
+			report(error);
+			onUncaughtError(error, info);
+		}
+	};
+}
+function isNextControlFlow(error) {
+	try {
+		unstable_rethrow(error);
+		return false;
+	} catch (thrown) {
+		return thrown === error;
+	}
+}
+/**
+* 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.
+*/
+async function start(loaded, container, signal, nodeOnPage, errors, keep = false) {
+	setNodeOnPage(nodeOnPage);
+	const page = {
+		signal,
+		errors,
+		nodeOnPage,
+		leaving: false
+	};
+	current = page;
+	let nextLoaded;
+	const forgetLoader = registerModuleLoader("browser", new Promise((resolve) => nextLoaded = resolve));
+	globalThis.__viteRscCallServer = callServer;
+	let root;
+	const listeners = [];
+	const { hydrateRoot, createRoot } = ReactDOMClient;
+	const keepRoot = (target, create) => {
+		if (signal.aborted) return {
+			render() {},
+			unmount() {}
+		};
+		const isApp = target === document;
+		const to = isApp && container ? container : target;
+		const added = (isApp && container ? [document, container] : [document]).map((of) => recordListeners(of));
+		listeners.push(...added);
+		try {
+			const created = create(to, isApp);
+			if (isApp) root = created;
+			return created;
+		} finally {
+			for (const recorded of added) recorded.stop();
+		}
+	};
+	ReactDOMClient.hydrateRoot = (target, children, options) => keepRoot(target, (to, isApp) => hydrateRoot(to, children, {
+		...isApp ? reportingErrors(options, report) : options,
+		onRecoverableError(error, info) {
+			if (current?.leaving) return;
+			if (options?.onRecoverableError) options.onRecoverableError(error, info);
+			else reportError(error);
+		}
+	}));
+	ReactDOMClient.createRoot = (target, options) => keepRoot(target, (to, isApp) => createRoot(to, isApp ? reportingErrors(options, report) : options));
+	const leave = () => {
+		page.leaving = true;
+		forgetLoader();
+		root?.unmount();
+		for (const added of listeners) added.remove();
+	};
+	const firstSegments = [...documentSegments()];
+	try {
+		const { hydrate } = await loadAppIndex();
+		loaded();
+		nextLoaded();
+		signal.throwIfAborted();
+		const bootstrapScript = document.querySelector("script[src*='/_next/']");
+		if (!bootstrapScript) throw new Error("vitest-plugin-rsc: the response is not a page of the Next.js app");
+		Object.defineProperty(document, "currentScript", {
+			configurable: true,
+			value: bootstrapScript
+		});
+		try {
+			await new Promise((resolve, reject) => {
+				const abort = () => reject(signal.reason);
+				signal.addEventListener("abort", abort, { once: true });
+				globalThis.__NEXT_HYDRATED_CB = () => {
+					signal.removeEventListener("abort", abort);
+					resolve();
+				};
+				appBootstrap((assetPrefix) => {
+					hydrate([], assetPrefix).catch(reject);
+				});
+			});
+		} finally {
+			delete document.currentScript;
+			delete globalThis.__NEXT_HYDRATED_CB;
+		}
+	} catch (error) {
+		leave();
+		throw error;
+	} finally {
+		if (!signal.aborted) {
+			ReactDOMClient.hydrateRoot = hydrateRoot;
+			ReactDOMClient.createRoot = createRoot;
+		}
+	}
+	if (!root) throw new Error("vitest-plugin-rsc: Next.js did not create a React root on the document, which the plugin needs to leave the page.");
+	if (!keep) return {
+		unmount: leave,
+		leaveApp: leave
+	};
+	let globalError;
+	app = {
+		root,
+		renders: 0,
+		globalError: () => globalError ??= Promise.resolve(createFromReadableStream(documentPayload(firstSegments), { callServer })).then((payload) => payload.G, (error) => {
+			globalError = void 0;
+			throw error;
+		})
+	};
+	return {
+		unmount: () => leavePage(page, forgetLoader),
+		leaveApp() {
+			app = void 0;
+			leave();
+		}
+	};
+}
+let app;
+function leavePage(page, forgetLoader) {
+	page.leaving = true;
+	forgetLoader();
+	flushSync(() => app?.root.render(null));
+}
+const documentSegments = () => self.__next_f ?? [];
+function documentPayload(segments = documentSegments()) {
+	const encoder = new TextEncoder();
+	return new ReadableStream({ start(controller) {
+		for (const [kind, data = ""] of segments) if (kind === 1) controller.enqueue(encoder.encode(data));
+		else if (kind === 3) controller.enqueue(Uint8Array.from(atob(data), (c) => c.charCodeAt(0)));
+		controller.close();
+	} });
+}
+function streamOfBytes(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+function Committed({ onCommit, children }) {
+	useEffect(onCommit, [onCommit]);
+	return children;
+}
+/**
+* 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.
+*/
+async function renderAgain(signal, errors, flight) {
+	const kept = app;
+	if (!kept) throw new Error("vitest-plugin-rsc: there is no kept app to render the page in.");
+	setNodeOnPage(void 0);
+	const page = {
+		signal,
+		errors,
+		nodeOnPage: void 0,
+		leaving: false
+	};
+	current = page;
+	const forgetLoader = registerModuleLoader("browser");
+	globalThis.__viteRscCallServer = callServer;
+	invalidateEntirePrefetchCache(null, null);
+	invalidateBfCache();
+	try {
+		const payload = await createFromReadableStream(flight ? streamOfBytes(flight) : documentPayload(), { callServer });
+		const globalErrorState = payload.G ?? await kept.globalError();
+		signal.throwIfAborted();
+		registry.replacingRouter = true;
+		let actionQueue;
+		try {
+			actionQueue = createMutableActionQueue(createInitialRouterState({
+				navigatedAt: Date.now(),
+				initialRSCPayload: payload.c ? payload : {
+					...payload,
+					c: (location.pathname + location.search).split("/")
+				},
+				initialFlightStreamForCache: null,
+				location: window.location
+			}));
+		} finally {
+			registry.replacingRouter = false;
+		}
+		const Strict = process.env.__NEXT_STRICT_MODE_APP ? StrictMode : Fragment;
+		await new Promise((resolve, reject) => {
+			const abort = () => reject(signal.reason);
+			signal.addEventListener("abort", abort, { once: true });
+			const committed = () => {
+				signal.removeEventListener("abort", abort);
+				resolve();
+			};
+			kept.root.render(/* @__PURE__ */ jsx(Strict, { children: /* @__PURE__ */ jsx(HeadManagerContext.Provider, {
+				value: { appDir: true },
+				children: /* @__PURE__ */ jsx(Committed, {
+					onCommit: committed,
+					children: /* @__PURE__ */ jsx(AppRouter, {
+						actionQueue,
+						globalErrorState
+					}, ++kept.renders)
+				})
+			}) }));
+		});
+	} catch (error) {
+		leavePage(page, forgetLoader);
+		throw error;
+	}
+	return {
+		unmount: () => leavePage(page, forgetLoader),
+		leaveApp() {
+			app = void 0;
+		}
+	};
+}
+//#endregion
+export { renderAgain, start };

package/dist/commonjs.d.ts

@@ -0,0 +1,44 @@
+import { NextLayer } from "./project.js";
+import { Plugin } from "vite";
+import MagicString from "magic-string";
+
+//#region src/commonjs.d.ts
+declare const missingHelper = "const $$cjsMissing = (source) => { throw Object.assign(new Error(`Cannot find module '${source}'`), { code: \"MODULE_NOT_FOUND\" }); };\n";
+/** What `compileCommonJs()` needs of the file. */
+type CommonJsOptions = {
+  /** The language of the code: `parseAstAsync` of Vite takes TypeScript as well. */lang?: "js" | "jsx" | "ts" | "tsx";
+  /**
+   * Whether a `require()` in a `try` finds its module. A module that is not
+   * there throws when the call runs, so the `catch` runs, as it does with
+   * webpack. Without this, every `require()` is an import.
+   */
+  resolves?: (source: string) => Promise<boolean>;
+  /**
+   * Whether a `require()` of `source` returns the default export of its
+   * module: a module of Node.js that is Node's own, whose default export is
+   * its `module.exports`, where the namespace of `node:events` is not the
+   * class. Without this, a module of Node.js is the ES module of a stand-in.
+   */
+  requiresDefault?: (source: string) => boolean;
+};
+type Node = {
+  type: string;
+  start: number;
+  end: number;
+  [key: string]: unknown;
+};
+declare function walk(node: Node, parent?: Node): Generator<[Node, Node | undefined]>;
+/** Compiles CommonJS in a module into ES module code. Nothing for a module without it. */
+declare function compileCommonJs(code: string, {
+  lang,
+  resolves,
+  requiresDefault
+}?: CommonJsOptions): Promise<{
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+} | undefined>;
+declare function createCommonJsPlugin(layerOf: (environment: string) => NextLayer | undefined, isAppCode: (file: string, layer: NextLayer) => boolean, /** Whether the layer imports Node's own module for `source`: see node-builtins.ts. */
+
+isNativeNodeModule: (source: string, layer: NextLayer) => boolean): Plugin;
+//#endregion
+export { CommonJsOptions, Node, compileCommonJs, createCommonJsPlugin, missingHelper, walk };

package/dist/commonjs.js

@@ -0,0 +1,111 @@
+import { parseAstAsync } from "vite";
+import { init, parse } from "cjs-module-lexer";
+import MagicString from "magic-string";
+//#region src/commonjs.ts
+/**
+* The export of a module compiled here that a `require()` of it returns: its
+* `module.exports`. A name, as Vite RSC reads the exports of a `"use client"`
+* module and takes no string for one.
+*/
+const moduleExports = "$$cjsModuleExports";
+const requireHelper = `const $$cjsRequire = (ns) => ${JSON.stringify(moduleExports)} in ns ? ns[${JSON.stringify(moduleExports)}] : Object.prototype.toString.call(ns) === "[object Module]" || ns.__esModule ? ns : ns.default;\n`;
+const missingHelper = "const $$cjsMissing = (source) => { throw Object.assign(new Error(`Cannot find module '${source}'`), { code: \"MODULE_NOT_FOUND\" }); };\n";
+const defaultOnly = /\.(?:json|css|scss|sass|less|styl|stylus|pcss)(?:\?|$)/;
+const isNode = (value) => typeof value === "object" && value !== null && typeof value.type === "string";
+function* walk(node, parent) {
+	yield [node, parent];
+	for (const key in node) {
+		const value = node[key];
+		for (const child of Array.isArray(value) ? value : [value]) if (isNode(child)) yield* walk(child, node);
+	}
+}
+const isIdentifier = (node, name) => isNode(node) && node.type === "Identifier" && node.name === name;
+const identifier = /^[A-Za-z_$][\w$]*$/;
+/** Compiles CommonJS in a module into ES module code. Nothing for a module without it. */
+async function compileCommonJs(code, { lang, resolves, requiresDefault = () => false } = {}) {
+	if (!/\brequire\s*\(|\bmodule\.exports\b|\bexports\.[\w$]+\s*=/.test(code)) return;
+	const ast = await parseAstAsync(code, { lang });
+	const requires = [];
+	let ownRequire = false;
+	let usesModule = false;
+	const tried = /* @__PURE__ */ new Set();
+	for (const [node] of walk(ast)) {
+		if (node.type !== "TryStatement") continue;
+		for (const [inner] of walk(node.block)) if (inner.type === "CallExpression") tried.add(inner);
+	}
+	for (const [node, parent] of walk(ast)) {
+		if (isIdentifier(node, "module") || isIdentifier(node, "exports")) {
+			if (!(parent?.type === "MemberExpression" && parent.property === node && !parent.computed || parent?.type === "Property" && parent.key === node && !parent.computed)) usesModule = true;
+		}
+		if (!isIdentifier(node, "require")) continue;
+		const args = parent?.arguments;
+		if (parent?.type === "CallExpression" && parent.callee === node) {
+			const [source] = args ?? [];
+			if (args?.length === 1 && source?.type === "Literal" && typeof source.value === "string") {
+				requires.push({
+					call: parent,
+					source: source.value,
+					tried: tried.has(parent)
+				});
+				continue;
+			}
+		}
+		if (parent?.type === "MemberExpression" && parent.object === node) continue;
+		ownRequire = true;
+	}
+	const isCommonJs = !ast.body.some((statement) => /^(?:Import|ExportNamed|ExportDefault|ExportAll)Declaration$/.test(statement.type)) && usesModule;
+	if (ownRequire || requires.length === 0 && !isCommonJs) return;
+	const output = new MagicString(code);
+	const imports = /* @__PURE__ */ new Map();
+	let missing = false;
+	for (const { call, source, tried } of requires) {
+		if (tried && resolves && !await resolves(source)) {
+			missing = true;
+			output.overwrite(call.start, call.end, `$$cjsMissing(${JSON.stringify(source)})`);
+			continue;
+		}
+		let name = imports.get(source);
+		if (!name) imports.set(source, name = `$$cjs${imports.size}`);
+		const value = defaultOnly.test(source) || requiresDefault(source) ? `${name}.default` : `$$cjsRequire(${name})`;
+		output.overwrite(call.start, call.end, value);
+	}
+	let header = [...imports].map(([source, name]) => `import * as ${name} from ${JSON.stringify(source)};\n`).join("");
+	if ([...imports.keys()].some((source) => !defaultOnly.test(source) && !requiresDefault(source))) header += requireHelper;
+	if (missing) header += missingHelper;
+	if (isCommonJs) {
+		header += "var module = { exports: {} }, exports = module.exports;\n";
+		let footer = `\nvar $$cjsExports = module.exports;\nexport { $$cjsExports as default, $$cjsExports as ${moduleExports} };\n`;
+		await init();
+		for (const name of new Set(parse(code).exports)) {
+			if (!identifier.test(name) || name === "default") continue;
+			footer += `var $$cjs_${name} = $$cjsExports.${name};\nexport { $$cjs_${name} as ${name} };\n`;
+		}
+		output.append(footer);
+	}
+	const afterDirectives = ast.body.find((statement) => !(statement.type === "ExpressionStatement" && "directive" in statement));
+	if (afterDirectives) output.appendLeft(afterDirectives.start, header);
+	else output.append(header);
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+function createCommonJsPlugin(layerOf, isAppCode, isNativeNodeModule) {
+	return {
+		name: "vitest-plugin-rsc:next-commonjs",
+		enforce: "pre",
+		async transform(code, id) {
+			const layer = layerOf(this.environment.name);
+			const file = id.split("?")[0];
+			const extension = /\.[cm]?([jt]sx?)$/.exec(file);
+			if (!layer || !extension || !isAppCode(file, layer)) return;
+			return compileCommonJs(code, {
+				lang: extension[1],
+				resolves: async (source) => await this.resolve(source, id) !== null,
+				requiresDefault: (source) => isNativeNodeModule(source, layer)
+			});
+		}
+	};
+}
+//#endregion
+export { compileCommonJs, createCommonJsPlugin, missingHelper, walk };

package/dist/compat/browser/client.d.ts

@@ -0,0 +1,19 @@
+import { appBootstrap } from "next/dist/client/app-bootstrap.js";
+import { callServer } from "next/dist/client/app-call-server.js";
+import AppRouter from "next/dist/client/components/app-router.js";
+import { createMutableActionQueue } from "next/dist/client/components/app-router-instance.js";
+import { createInitialRouterState } from "next/dist/client/components/router-reducer/create-initial-router-state.js";
+import { invalidateBfCache } from "next/dist/client/components/segment-cache/bfcache.js";
+import { invalidateEntirePrefetchCache } from "next/dist/client/components/segment-cache/cache.js";
+import { HeadManagerContext } from "next/dist/shared/lib/head-manager-context.shared-runtime";
+import * as _$next_dist_client_app_index0 from "next/dist/client/app-index.js";
+import * as _$next_dist_client_router_transition_types0 from "next/dist/client/router-transition-types.js";
+
+//#region src/compat/browser/client.d.ts
+/** Next's client entry, which reads the Flight payload in the document as it loads. */
+declare const loadAppIndex: () => Promise<{
+  default: typeof _$next_dist_client_app_index0;
+  hydrate(instrumentationModules: _$next_dist_client_router_transition_types0.ClientInstrumentationModules, assetPrefix: string): Promise<void>;
+}>;
+//#endregion
+export { AppRouter, HeadManagerContext, appBootstrap, callServer, createInitialRouterState, createMutableActionQueue, invalidateBfCache, invalidateEntirePrefetchCache, loadAppIndex };

package/dist/compat/browser/client.js

@@ -0,0 +1,13 @@
+import { appBootstrap } from "next/dist/client/app-bootstrap.js";
+import { callServer } from "next/dist/client/app-call-server.js";
+import AppRouter from "next/dist/client/components/app-router.js";
+import { createMutableActionQueue } from "next/dist/client/components/app-router-instance.js";
+import { createInitialRouterState } from "next/dist/client/components/router-reducer/create-initial-router-state.js";
+import { invalidateBfCache } from "next/dist/client/components/segment-cache/bfcache.js";
+import { invalidateEntirePrefetchCache } from "next/dist/client/components/segment-cache/cache.js";
+import { HeadManagerContext } from "next/dist/shared/lib/head-manager-context.shared-runtime";
+//#region src/compat/browser/client.ts
+/** Next's client entry, which reads the Flight payload in the document as it loads. */
+const loadAppIndex = () => import("next/dist/client/app-index.js");
+//#endregion
+export { AppRouter, HeadManagerContext, appBootstrap, callServer, createInitialRouterState, createMutableActionQueue, invalidateBfCache, invalidateEntirePrefetchCache, loadAppIndex };

package/dist/compat/build.d.ts

@@ -0,0 +1,145 @@
+import { Loader } from "../project/loaders.js";
+import { AppLoaderContext } from "../project/entries.js";
+import * as _$next_dist_server_lib_incremental_cache_index0 from "next/dist/server/lib/incremental-cache/index.js";
+import * as _$next_dist_shared_lib_router_utils_route_regex0 from "next/dist/shared/lib/router/utils/route-regex.js";
+import * as _$next_dist_build_adapter_build_complete0 from "next/dist/build/adapter/build-complete.js";
+import * as _$next_dist_build_analysis_get_page_static_info0 from "next/dist/build/analysis/get-page-static-info.js";
+import * as _$next_dist_lib_load_custom_routes0 from "next/dist/lib/load-custom-routes.js";
+import * as _$next_dist_build_route_discovery0 from "next/dist/build/route-discovery.js";
+import * as _$next_dist_build_normalize_catchall_routes0 from "next/dist/build/normalize-catchall-routes.js";
+import * as _$next_dist_shared_lib_router_utils_app_paths0 from "next/dist/shared/lib/router/utils/app-paths.js";
+import * as _$next_dist_lib_is_app_route_route0 from "next/dist/lib/is-app-route-route.js";
+import * as _$next_dist_lib_is_app_page_route0 from "next/dist/lib/is-app-page-route.js";
+import * as _$next_dist_shared_lib_router_utils_interception_routes0 from "next/dist/shared/lib/router/utils/interception-routes.js";
+import * as _$next_dist_shared_lib_errors_missing_canonical_interception_routes_error0 from "next/dist/shared/lib/errors/missing-canonical-interception-routes-error.js";
+import * as _$next_dist_shared_lib_errors_incompatible_parallel_route_slots_error0 from "next/dist/shared/lib/errors/incompatible-parallel-route-slots-error.js";
+import * as _$next_dist_shared_lib_errors_unmatched_app_pages_error0 from "next/dist/shared/lib/errors/unmatched-app-pages-error.js";
+import * as _$next_dist_build_define_env0 from "next/dist/build/define-env.js";
+import * as _$next_dist_lib_static_env0 from "next/dist/lib/static-env.js";
+import * as _$next_dist_build_create_compiler_aliases0 from "next/dist/build/create-compiler-aliases.js";
+import * as _$next_dist_lib_needs_experimental_react0 from "next/dist/lib/needs-experimental-react.js";
+import * as _$next_dist_build_load_entrypoint0 from "next/dist/build/load-entrypoint.js";
+import * as _$next_dist_build_swc_index0 from "next/dist/build/swc/index.js";
+import * as _$next_dist_build_swc_options0 from "next/dist/build/swc/options.js";
+import * as _$next_dist_build_load_jsconfig0 from "next/dist/build/load-jsconfig.js";
+import * as _$next_dist_build_webpack_config_blocks_css_loaders_next_font0 from "next/dist/build/webpack/config/blocks/css/loaders/next-font.js";
+import * as _$next_dist_build_webpack_config_blocks_css_plugins0 from "next/dist/build/webpack/config/blocks/css/plugins.js";
+import * as _$next_dist_build_get_supported_browsers0 from "next/dist/build/get-supported-browsers.js";
+import * as _$next_dist_build_webpack_config_blocks_css_loaders_modules0 from "next/dist/build/webpack/config/blocks/css/loaders/modules.js";
+import * as _$next_dist_lib_find_config0 from "next/dist/lib/find-config.js";
+import * as _$next_dist_server_image_optimizer0 from "next/dist/server/image-optimizer.js";
+import * as _$next_dist_lib_generate_interception_routes_rewrites0 from "next/dist/lib/generate-interception-routes-rewrites.js";
+import * as _$next_dist_build_generate_routes_manifest0 from "next/dist/build/generate-routes-manifest.js";
+import * as _$next_dist_lib_bundler0 from "next/dist/lib/bundler.js";
+import * as _$next_dist_lib_get_files_in_dir0 from "next/dist/lib/get-files-in-dir.js";
+import * as _$next_dist_build_get_static_info_including_layouts0 from "next/dist/build/get-static-info-including-layouts.js";
+import * as _$next_dist_build_entries0 from "next/dist/build/entries.js";
+import * as _$next_dist_server_config0 from "next/dist/server/config.js";
+import * as _$next_dist_lib_find_pages_dir0 from "next/dist/lib/find-pages-dir.js";
+import * as _$next_dist_build_generate_build_id0 from "next/dist/build/generate-build-id.js";
+
+//#region src/compat/build.d.ts
+/**
+ * The build code of the `next` that `projectRequire` finds. `fail` stops the
+ * run with what differs, and the version of that `next`.
+ */
+declare function loadNextBuild(projectRequire: NodeJS.Require, fail: (what: string, cause?: unknown) => never): {
+  loadConfig: typeof _$next_dist_server_config0.default;
+  PHASE_PRODUCTION_BUILD: "phase-production-build";
+  findPagesDir: typeof _$next_dist_lib_find_pages_dir0.findPagesDir;
+  generateBuildId: typeof _$next_dist_build_generate_build_id0.generateBuildId;
+  COMPILER_NAMES: {
+    readonly client: "client";
+    readonly server: "server";
+    readonly edgeServer: "edge-server";
+  };
+  APP_DIR_ALIAS: string;
+  MIDDLEWARE_FILENAME: string;
+  PROXY_FILENAME: string;
+  WEBPACK_LAYERS: {
+    GROUP: {
+      builtinReact: ("rsc" | "action-browser")[];
+      serverOnly: ("middleware" | "rsc" | "action-browser" | "instrument")[];
+      neutralTarget: ("api-node" | "api-edge")[];
+      clientOnly: ("ssr" | "app-pages-browser")[];
+      bundled: ("shared" | "middleware" | "rsc" | "ssr" | "action-browser" | "instrument" | "app-pages-browser")[];
+      appPages: ("rsc" | "ssr" | "action-browser" | "app-pages-browser")[];
+    };
+    shared: "shared";
+    reactServerComponents: "rsc";
+    serverSideRendering: "ssr";
+    actionBrowser: "action-browser";
+    apiNode: "api-node";
+    apiEdge: "api-edge";
+    middleware: "middleware";
+    instrument: "instrument";
+    edgeAsset: "edge-asset";
+    appPagesBrowser: "app-pages-browser";
+    pagesDirBrowser: "pages-dir-browser";
+    pagesDirEdge: "pages-dir-edge";
+    pagesDirNode: "pages-dir-node";
+  };
+  WEBPACK_RESOURCE_QUERIES: {
+    edgeSSREntry: string;
+    metadata: string;
+    metadataRoute: string;
+    metadataImageMeta: string;
+  };
+  discoverRoutes: typeof _$next_dist_build_route_discovery0.discoverRoutes;
+  createPagesMapping: typeof _$next_dist_build_route_discovery0.createPagesMapping;
+  normalizeCatchAllRoutes: typeof _$next_dist_build_normalize_catchall_routes0.normalizeCatchAllRoutes;
+  normalizeAppPath: typeof _$next_dist_shared_lib_router_utils_app_paths0.normalizeAppPath;
+  compareAppPaths: typeof _$next_dist_shared_lib_router_utils_app_paths0.compareAppPaths;
+  selectAppPageEntry: typeof _$next_dist_shared_lib_router_utils_app_paths0.selectAppPageEntry;
+  isAppRouteRoute: typeof _$next_dist_lib_is_app_route_route0.isAppRouteRoute;
+  isAppPageRoute: typeof _$next_dist_lib_is_app_page_route0.isAppPageRoute;
+  findMissingCanonicalInterceptionRoutes: typeof _$next_dist_shared_lib_router_utils_interception_routes0.findMissingCanonicalInterceptionRoutes;
+  MissingCanonicalInterceptionRoutesError: typeof _$next_dist_shared_lib_errors_missing_canonical_interception_routes_error0.MissingCanonicalInterceptionRoutesError;
+  IncompatibleParallelRouteSlotsError: typeof _$next_dist_shared_lib_errors_incompatible_parallel_route_slots_error0.IncompatibleParallelRouteSlotsError;
+  UnmatchedAppPagesError: typeof _$next_dist_shared_lib_errors_unmatched_app_pages_error0.UnmatchedAppPagesError;
+  getDefineEnv: typeof _$next_dist_build_define_env0.getDefineEnv;
+  getNextPublicEnvironmentVariables: typeof _$next_dist_lib_static_env0.getNextPublicEnvironmentVariables;
+  getNextConfigEnv: typeof _$next_dist_lib_static_env0.getNextConfigEnv;
+  SUPPORTED_NATIVE_MODULES: readonly ["buffer", "events", "assert", "util", "async_hooks"];
+  compilerAliases: typeof _$next_dist_build_create_compiler_aliases0;
+  needsExperimentalReact: typeof _$next_dist_lib_needs_experimental_react0.needsExperimentalReact;
+  loadEntrypoint: typeof _$next_dist_build_load_entrypoint0.loadEntrypoint;
+  nextAppLoader: (this: AppLoaderContext) => Promise<string>;
+  IncrementalCache: typeof _$next_dist_server_lib_incremental_cache_index0.IncrementalCache;
+  swc: typeof _$next_dist_build_swc_index0;
+  getLoaderSWCOptions: typeof _$next_dist_build_swc_options0.getLoaderSWCOptions;
+  loadJsConfig: typeof _$next_dist_build_load_jsconfig0.default;
+  getRSCModuleInformation: typeof _$next_dist_build_analysis_get_page_static_info0.getRSCModuleInformation;
+  getAppPageStaticInfo: typeof _$next_dist_build_analysis_get_page_static_info0.getAppPageStaticInfo;
+  nextImageLoaderRegex: RegExp;
+  nextImageLoader: Loader;
+  getNextFontLoader: typeof _$next_dist_build_webpack_config_blocks_css_loaders_next_font0.getNextFontLoader;
+  getPostCssPlugins: typeof _$next_dist_build_webpack_config_blocks_css_plugins0.getPostCssPlugins;
+  getSupportedBrowsers: typeof _$next_dist_build_get_supported_browsers0.getSupportedBrowsers;
+  getCssModuleLoader: typeof _$next_dist_build_webpack_config_blocks_css_loaders_modules0.getCssModuleLoader;
+  localByDefault: (options: {
+    mode: string;
+  }) => never;
+  findConfig: typeof _$next_dist_lib_find_config0.findConfig;
+  nextFontLoader: Loader;
+  nextRootParamsLoader: Loader;
+  imageOptimizer: typeof _$next_dist_server_image_optimizer0;
+  loadCustomRoutes: typeof _$next_dist_lib_load_custom_routes0.default;
+  generateInterceptionRoutesRewrites: typeof _$next_dist_lib_generate_interception_routes_rewrites0.generateInterceptionRoutesRewrites;
+  NEXT_URL: "next-url";
+  generateRoutesManifest: typeof _$next_dist_build_generate_routes_manifest0.generateRoutesManifest;
+  handleBuildComplete: typeof _$next_dist_build_adapter_build_complete0.handleBuildComplete;
+  Bundler: typeof _$next_dist_lib_bundler0.Bundler;
+  getFilesInDir: typeof _$next_dist_lib_get_files_in_dir0.getFilesInDir;
+  rootPageType: never;
+  getStaticInfoIncludingLayouts: typeof _$next_dist_build_get_static_info_including_layouts0.getStaticInfoIncludingLayouts;
+  getEdgeServerEntry: typeof _$next_dist_build_entries0.getEdgeServerEntry;
+  getNamedMiddlewareRegex: typeof _$next_dist_shared_lib_router_utils_route_regex0.getNamedMiddlewareRegex;
+  nextMiddlewareLoader: Loader;
+  getContentType: (extWithoutDot: string) => string | null;
+  getExtension: (contentType: string) => string | null;
+  nextMetadataImageLoader: Loader;
+  nextMetadataRouteLoader: Loader;
+};
+//#endregion
+export { loadNextBuild };