vinext 0.1.1 → 0.1.3

package/dist/server/pages-request-pipeline.js

@@ -1,11 +1,32 @@
-import { hasBasePath } from "../utils/base-path.js";
+import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
-import { applyConfigHeadersToHeaderRecord, normalizeTrailingSlash } from "./request-pipeline.js";
+import { applyConfigHeadersToHeaderRecord, cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
 import { mergeRewriteQuery } from "../utils/query.js";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
 import { mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
 /**
+* Wrap an adapter's `runMiddleware` callback so middleware receives the original
+* (pre-basePath-stripping) URL. Adapters strip the basePath before handing the
+* request to `runPagesRequest`, but Next.js passes the un-stripped URL to the
+* middleware adapter so `request.nextUrl.basePath` reflects whether the URL
+* actually had the basePath prefix. Requests outside the basePath
+* (`hadBasePath === false`) are passed through untouched so middleware sees
+* `nextUrl.basePath === ""` and can redirect them into the basePath
+* (see the middleware-base-path e2e test / #1830).
+*
+* Shared by the Node prod server (prod-server.ts) and the generated Pages
+* Router worker entry (deploy.ts) to keep the two adapters in sync.
+*/
+function wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) {
+	if (!hadBasePath || !basePath) return runMiddleware;
+	return (request, ctx, opts) => {
+		const mwUrl = new URL(request.url);
+		mwUrl.pathname = addBasePathToPathname(mwUrl.pathname, basePath);
+		return runMiddleware(new Request(mwUrl, request), ctx, opts);
+	};
+}
+/**
 * Run the Pages Router request pipeline.
 *
 * ASSUMPTION: request already has internal headers filtered and basePath stripped.
@@ -47,7 +68,8 @@ async function runPagesRequest(request, deps) {
 			};
 		}
 	}
-	let resolvedUrl = pathname + search;
+	const originalResolvedUrl = pathname + search;
+	let resolvedUrl = originalResolvedUrl;
 	const middlewareHeaders = {};
 	let middlewareStatus;
 	if (typeof deps.runMiddleware === "function") {
@@ -93,7 +115,12 @@ async function runPagesRequest(request, deps) {
 	}
 	const { postMwReqCtx, request: postMwReq } = applyMiddlewareRequestHeaders(middlewareHeaders, request, { preserveCredentialHeaders: isExternalUrl(resolvedUrl) });
 	request = postMwReq;
-	let resolvedPathname = resolvedUrl.split("?")[0];
+	const pathnameForResolvedUrl = (value) => value.split("#", 1)[0].split("?", 1)[0];
+	const rewriteRequestContext = () => ({
+		...postMwReqCtx,
+		query: new URL(resolvedUrl, url).searchParams
+	});
+	let resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 	const matchResolvedPathname = (p) => i18nConfig ? normalizeDefaultLocalePathname(p, i18nConfig, { hostname: requestHostname }) : p;
 	if (configHeaders.length) applyConfigHeadersToHeaderRecord(middlewareHeaders, {
 		configHeaders,
@@ -109,15 +136,15 @@ async function runPagesRequest(request, deps) {
 		if (await deps.serveStaticFile(pathname, middlewareHeaders)) return { type: "handled" };
 	}
 	let configRewriteFired = false;
-	if (configRewrites.beforeFiles?.length) {
-		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.beforeFiles, postMwReqCtx, basePathState);
+	for (const rewrite of configRewrites.beforeFiles ?? []) {
+		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
 				response: await proxyExternal(request, rewritten)
 			};
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
-			resolvedPathname = resolvedUrl.split("?")[0];
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			configRewriteFired = true;
 		}
 	}
@@ -130,34 +157,61 @@ async function runPagesRequest(request, deps) {
 	};
 	const apiLookupUrl = stripI18nLocaleForApiRoute(resolvedUrl, i18nConfig);
 	const apiLookupPathname = apiLookupUrl.split("?")[0];
-	if (apiLookupPathname.startsWith("/api/") || apiLookupPathname === "/api") if (typeof deps.handleApi === "function") return {
-		type: "response",
-		defaultContentType: "application/octet-stream",
-		response: mergeHeaders(await deps.handleApi(request, apiLookupUrl, deps.ctx ?? null), middlewareHeaders, middlewareStatus)
-	};
-	else return {
+	if (apiLookupPathname.startsWith("/api/") || apiLookupPathname === "/api") if (typeof deps.handleApi === "function") {
+		let apiRequest = request;
+		if (basePath && hadBasePath) {
+			const apiRequestUrl = new URL(request.url);
+			apiRequestUrl.pathname = addBasePathToPathname(apiRequestUrl.pathname, basePath);
+			apiRequest = cloneRequestWithUrl(request, apiRequestUrl.toString());
+		}
+		return {
+			type: "response",
+			defaultContentType: "application/octet-stream",
+			response: mergeHeaders(await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null), middlewareHeaders, middlewareStatus)
+		};
+	} else return {
 		type: "api",
 		apiUrl: apiLookupUrl,
 		stagedHeaders: middlewareHeaders,
 		requestHeaders: request.headers,
 		middlewareStatus
 	};
-	const pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+	let pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
 	let resolvedPathnameChanged = false;
-	if ((!pageMatch || pageMatch.route.isDynamic) && configRewrites.afterFiles?.length) {
-		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.afterFiles, postMwReqCtx, basePathState);
+	if (!pageMatch || pageMatch.route.isDynamic) for (const rewrite of configRewrites.afterFiles ?? []) {
+		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
 				response: await proxyExternal(request, rewritten)
 			};
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
-			resolvedPathname = resolvedUrl.split("?")[0];
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			resolvedPathnameChanged = true;
+			pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+			if (pageMatch) break;
 		}
 	}
+	const refreshDataRewriteHeader = () => {
+		if ((isDataReq || isDataRequest) && resolvedUrl !== originalResolvedUrl && !isExternalUrl(resolvedUrl)) middlewareHeaders["x-nextjs-rewrite"] = resolvedUrl;
+		else delete middlewareHeaders["x-nextjs-rewrite"];
+	};
+	refreshDataRewriteHeader();
 	if (typeof deps.renderPage === "function") {
-		const renderPageMatch = resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch;
+		let renderPageMatch = pageMatch;
+		if ((isDataReq || isDataRequest) && !renderPageMatch && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
+			const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
+			if (!fallbackRewrite) continue;
+			if (isExternalUrl(fallbackRewrite)) return {
+				type: "response",
+				response: await proxyExternal(request, fallbackRewrite)
+			};
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
+			renderPageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+			refreshDataRewriteHeader();
+			if (renderPageMatch) break;
+		}
 		const shouldDeferErrorPageOnMiss = !isDataReq && !isDataRequest && !!deps.matchPageRoute && !renderPageMatch;
 		const initialRenderOptions = shouldDeferErrorPageOnMiss ? { renderErrorPageOnMiss: false } : isDataReq ? { isDataReq: true } : void 0;
 		const stagedHeaders = new Headers();
@@ -165,16 +219,18 @@ async function runPagesRequest(request, deps) {
 		else stagedHeaders.set(k, v);
 		let response = await deps.renderPage(request, resolvedUrl, initialRenderOptions, stagedHeaders);
 		let matchedFallbackRewrite = false;
-		if (response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) {
-			const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.fallback, postMwReqCtx, basePathState);
-			if (fallbackRewrite) {
-				if (isExternalUrl(fallbackRewrite)) return {
-					type: "response",
-					response: await proxyExternal(request, fallbackRewrite)
-				};
-				response = await deps.renderPage(request, mergeRewriteQuery(resolvedUrl, fallbackRewrite), void 0, stagedHeaders);
-				matchedFallbackRewrite = true;
-			}
+		if (response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
+			const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
+			if (!fallbackRewrite) continue;
+			if (isExternalUrl(fallbackRewrite)) return {
+				type: "response",
+				response: await proxyExternal(request, fallbackRewrite)
+			};
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
+			response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
+			matchedFallbackRewrite = true;
+			if (response.status !== 404) break;
 		}
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && !matchedFallbackRewrite) response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
 		const merged = mergeHeaders(response, middlewareHeaders, middlewareStatus);
@@ -185,16 +241,18 @@ async function runPagesRequest(request, deps) {
 			defaultContentType: "text/html"
 		};
 	}
-	if (!(resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch) && configRewrites.fallback?.length) {
-		const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.fallback, postMwReqCtx, basePathState);
-		if (fallbackRewrite) {
-			if (isExternalUrl(fallbackRewrite)) return {
-				type: "response",
-				response: await proxyExternal(request, fallbackRewrite)
-			};
-			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
-		}
+	if (!(resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch) && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
+		const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
+		if (!fallbackRewrite) continue;
+		if (isExternalUrl(fallbackRewrite)) return {
+			type: "response",
+			response: await proxyExternal(request, fallbackRewrite)
+		};
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+		resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
+		if (deps.matchPageRoute?.(resolvedPathname, request)) break;
 	}
+	refreshDataRewriteHeader();
 	return {
 		type: "render",
 		resolvedUrl,
@@ -206,4 +264,4 @@ async function runPagesRequest(request, deps) {
 	};
 }
 //#endregion
-export { runPagesRequest };
+export { runPagesRequest, wrapMiddlewareWithBasePath };

package/dist/server/pregenerated-concrete-paths.d.ts

@@ -4,28 +4,12 @@ declare global {
 }
 declare function normalizePregeneratedPathname(pathname: string): string;
 declare function clearPregeneratedConcretePaths(): void;
-/**
- * Records a concrete URL path for a route pattern. The pathname is normalized
- * here so this is the single source of truth: every caller — the Worker global
- * table and the Node `seed-cache.ts` path — stores the canonical form that
- * matches the runtime `cleanPathname` lookup without having to pre-normalize.
- */
 declare function addPregeneratedConcretePath(routePattern: string, pathname: string): void;
-/**
- * Returns the live backing `Set` for a route pattern (not a copy) to keep
- * lookups allocation-free on the serving hot path. The `ReadonlySet` type
- * forbids mutation at compile time. Callers must treat the result as
- * point-in-time and must NOT retain it across a re-seed: each
- * `initPregeneratedPathsFromGlobals` call runs `clearPregeneratedConcretePaths`,
- * which empties the map, leaving any previously-returned reference stale. Read
- * it, use it, drop it — never cache the reference.
- */
 declare function getRenderedConcreteUrlPathsForRoute(routePattern: string): ReadonlySet<string> | undefined;
 /**
  * Populate the registry from `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`.
  * No-op when the global is not set (Node path — seed-cache handles it later).
- * `addPregeneratedConcretePath` normalizes each pathname so it matches the
- * runtime `cleanPathname`.
+ * Pathnames are normalised so they match the runtime `cleanPathname`.
  */
 declare function initPregeneratedPathsFromGlobals(): void;
 //#endregion

package/dist/server/pregenerated-concrete-paths.js

@@ -16,38 +16,21 @@ const concreteUrlPathsByRoute = /* @__PURE__ */ new Map();
 function clearPregeneratedConcretePaths() {
 	concreteUrlPathsByRoute.clear();
 }
-/**
-* Records a concrete URL path for a route pattern. The pathname is normalized
-* here so this is the single source of truth: every caller — the Worker global
-* table and the Node `seed-cache.ts` path — stores the canonical form that
-* matches the runtime `cleanPathname` lookup without having to pre-normalize.
-*/
 function addPregeneratedConcretePath(routePattern, pathname) {
-	const normalized = normalizePregeneratedPathname(pathname);
 	let paths = concreteUrlPathsByRoute.get(routePattern);
 	if (!paths) {
 		paths = /* @__PURE__ */ new Set();
 		concreteUrlPathsByRoute.set(routePattern, paths);
 	}
-	paths.add(normalized);
+	paths.add(normalizePregeneratedPathname(pathname));
 }
-/**
-* Returns the live backing `Set` for a route pattern (not a copy) to keep
-* lookups allocation-free on the serving hot path. The `ReadonlySet` type
-* forbids mutation at compile time. Callers must treat the result as
-* point-in-time and must NOT retain it across a re-seed: each
-* `initPregeneratedPathsFromGlobals` call runs `clearPregeneratedConcretePaths`,
-* which empties the map, leaving any previously-returned reference stale. Read
-* it, use it, drop it — never cache the reference.
-*/
 function getRenderedConcreteUrlPathsForRoute(routePattern) {
 	return concreteUrlPathsByRoute.get(routePattern);
 }
 /**
 * Populate the registry from `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`.
 * No-op when the global is not set (Node path — seed-cache handles it later).
-* `addPregeneratedConcretePath` normalizes each pathname so it matches the
-* runtime `cleanPathname`.
+* Pathnames are normalised so they match the runtime `cleanPathname`.
 */
 function initPregeneratedPathsFromGlobals() {
 	const raw = globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS;

package/dist/server/prerender-manifest.d.ts

@@ -0,0 +1,33 @@
+//#region src/server/prerender-manifest.d.ts
+type PrerenderManifestRoute = {
+  route: string;
+  status?: string;
+  revalidate?: number | false;
+  expire?: number;
+  path?: string;
+  router?: string;
+  fallback?: boolean;
+};
+type PrerenderManifest = {
+  buildId?: string;
+  trailingSlash?: boolean;
+  routes?: PrerenderManifestRoute[];
+};
+declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
+declare function getRenderedAppRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
+/**
+ * Returns true when `pathname` contains bracket-delimited route params,
+ * indicating it is a fallback-shell placeholder (e.g. `/en/blog/[slug]`)
+ * rather than a concrete rendered URL.
+ */
+declare function isFallbackShellArtifactPath(pathname: string, route?: PrerenderManifestRoute): boolean;
+/**
+ * Build the pregenerated concrete-path payload table from a prerender manifest.
+ *
+ * Filters out fallback-shell placeholder paths and groups remaining concrete
+ * paths by route pattern. Returns an empty array when the manifest has no
+ * rendered App routes or all routes are fallback-shell artifacts.
+ */
+declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest): Array<[string, string[]]>;
+//#endregion
+export { buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };

package/dist/server/prerender-manifest.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+//#region src/server/prerender-manifest.ts
+function readPrerenderManifest(manifestPath) {
+	if (!fs.existsSync(manifestPath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+	} catch (error) {
+		console.warn(`[vinext] Failed to read prerender manifest at ${manifestPath}:`, error);
+		return null;
+	}
+}
+function getRenderedAppRoutes(routes) {
+	return routes.filter((r) => r.status === "rendered" && r.router === "app");
+}
+function groupRoutesByPattern(routes) {
+	const byPattern = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const pathname = r.path ?? r.route;
+		const existing = byPattern.get(r.route);
+		if (existing) existing.push(pathname);
+		else byPattern.set(r.route, [pathname]);
+	}
+	return byPattern;
+}
+/**
+* Returns true when `pathname` contains bracket-delimited route params,
+* indicating it is a fallback-shell placeholder (e.g. `/en/blog/[slug]`)
+* rather than a concrete rendered URL.
+*/
+function isFallbackShellArtifactPath(pathname, route) {
+	if (route?.fallback === true) return true;
+	if (route?.fallback === void 0) {
+		if (process.env.NODE_ENV !== "production") console.warn("[vinext] Legacy manifest detected: missing `fallback` flag for route. Using bracket heuristic for fallback-shell detection. A concrete URL containing literal brackets may be misclassified as a fallback shell.");
+		return pathname.includes("[") || pathname.includes("]");
+	}
+	return false;
+}
+/**
+* Build the pregenerated concrete-path payload table from a prerender manifest.
+*
+* Filters out fallback-shell placeholder paths and groups remaining concrete
+* paths by route pattern. Returns an empty array when the manifest has no
+* rendered App routes or all routes are fallback-shell artifacts.
+*/
+function buildPregeneratedConcretePathTable(manifest) {
+	const routes = manifest?.routes;
+	if (!routes?.length) return [];
+	const concreteRoutes = getRenderedAppRoutes(routes).filter((r) => {
+		return !isFallbackShellArtifactPath(r.path ?? r.route, r);
+	});
+	return Array.from(groupRoutesByPattern(concreteRoutes).entries());
+}
+//#endregion
+export { buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };

package/dist/server/prerender-route-params.d.ts

@@ -5,7 +5,6 @@ type PrerenderRouteParamsPayload = {
   params: PrerenderRouteParams;
   routePattern: string;
 };
-/** @public exported for #1716 serving consumers; not yet referenced in-repo */
 type PrerenderRouteParamsRouteMatch = {
   kind: "exact";
   params: PrerenderRouteParams;
@@ -21,4 +20,4 @@ declare function prerenderRouteParamsPayloadMatchesRoute(payload: PrerenderRoute
 declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
 declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
 //#endregion
-export { PrerenderRouteParams, PrerenderRouteParamsPayload, PrerenderRouteParamsRouteMatch, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
+export { PrerenderRouteParams, PrerenderRouteParamsPayload, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };

package/dist/server/prod-server.d.ts

@@ -3,6 +3,44 @@ import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/server/prod-server.d.ts
+/**
+ * Import a built server entry module (App Router RSC entry or Pages Router
+ * server entry) by absolute file path.
+ *
+ * The first import of a given path uses the plain file:// URL with NO query
+ * string. This is load-bearing: code-split builds emit lazy chunks that
+ * import the entry back by bare specifier (default Vite builds on both
+ * supported majors — Rollup on Vite 7 and Rolldown on Vite 8 — hoist modules
+ * shared between the entry's static graph and lazy route chunks into the
+ * entry chunk, which the chunks then import as e.g. "../../index.js").
+ * Node keys its ESM cache on the full URL including the query string, so if
+ * the server imported the entry as `index.js?t=<mtime>`, a chunk's bare
+ * back-import would evaluate the entire server bundle a second time and
+ * module-level singletons (db pools, service registries) would silently
+ * diverge between the two copies. See
+ * https://github.com/cloudflare/vinext/issues/1923.
+ *
+ * A `?t=<mtime>` query string is appended only when the same path is
+ * imported again after a rebuild (different mtime) — e.g. test suites that
+ * rebuild a fixture to the same output path within one process — where the
+ * bare URL's cache entry would return the stale previous build. Note this
+ * rebuild branch trades the single-instance guarantee back: chunks that
+ * import the entry by bare path still resolve to the FIRST build's cache
+ * entry, so freshness and single-instance only hold together on the first
+ * import of a path. Production processes import each entry path exactly
+ * once and always get both.
+ *
+ * The entry is imported via its canonical real path: the bundler
+ * canonicalizes module ids with fs.realpathSync.native, so chunks evaluate
+ * under realpath-based URLs and their relative imports resolve to realpath
+ * URLs too. Importing the entry through a symlinked path (macOS /var/...
+ * tmpdirs, symlinked deploy directories) would otherwise create a second
+ * instance keyed on the symlinked URL.
+ *
+ * Exported for direct unit testing of the URL choice.
+ */
+declare function resolveServerEntryImportUrl(entryPath: string): string;
+declare function importServerEntryModule(entryPath: string): Promise<any>;
 type ProdServerOptions = {
   /** Port to listen on */port?: number; /** Host to bind to */
   host?: string; /** Path to the build output directory */
@@ -105,4 +143,4 @@ declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): AppRoute
  */
 declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, importServerEntryModule, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };