@qzsy/vinext 0.1.7

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

@@ -0,0 +1,311 @@
+import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
+import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.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
+async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset) {
+	if (phase === "direct" || request.method !== "GET" && request.method !== "HEAD" || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
+	const assetUrl = new URL(request.url);
+	assetUrl.pathname = requestPathname;
+	assetUrl.search = "";
+	const response = await fetchAsset(new Request(assetUrl, request));
+	return response.status === 404 ? false : response;
+}
+/**
+* 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.
+* The adapter is responsible for that pre-processing before calling runPagesRequest.
+* The adapter also handles: open-redirect guard, _next/static 404, image optimization,
+* _next/data normalization and classification: adapters must rewrite the data
+* URL to its page pathname and set `isDataReq` (the source of truth here), Node
+* decode/normalize/400, public-file serving.
+* runPagesRequest receives a "clean" request with basePath-stripped URL.
+*/
+async function runPagesRequest(request, deps) {
+	const { basePath, trailingSlash, i18nConfig, configRedirects, configRewrites, configHeaders, hadBasePath, isDataReq, isDataRequest } = deps;
+	const proxyExternal = (currentReq, externalUrl) => deps.proxyExternal ? deps.proxyExternal(currentReq, externalUrl) : proxyExternalRequest(currentReq, externalUrl);
+	const url = new URL(request.url);
+	let pathname = url.pathname;
+	const search = url.search;
+	const basePathState = {
+		basePath,
+		hadBasePath
+	};
+	{
+		const trailingSlashRedirect = isDataReq ? null : normalizeTrailingSlash(pathname, basePath, trailingSlash, search);
+		if (trailingSlashRedirect) return {
+			type: "response",
+			response: trailingSlashRedirect
+		};
+	}
+	const reqCtx = requestContextFromRequest(request);
+	const requestHostname = i18nConfig ? url.hostname : "";
+	const matchPathname = i18nConfig ? normalizeDefaultLocalePathname(pathname, i18nConfig, { hostname: requestHostname }) : pathname;
+	if (configRedirects.length) {
+		const redirect = matchRedirect(matchPathname, configRedirects, reqCtx, basePathState);
+		if (redirect) {
+			const location = preserveRedirectDestinationQuery(sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination), deps.rawSearch ?? search);
+			return {
+				type: "response",
+				response: new Response(null, {
+					status: redirect.permanent ? 308 : 307,
+					headers: { Location: location }
+				})
+			};
+		}
+	}
+	const originalResolvedUrl = pathname + search;
+	let resolvedUrl = originalResolvedUrl;
+	const middlewareHeaders = {};
+	let middlewareStatus;
+	const serveFilesystemRoute = async (requestPathname, phase) => {
+		if (!deps.serveFilesystemRoute) return null;
+		const served = await deps.serveFilesystemRoute(requestPathname, middlewareHeaders, phase);
+		if (served instanceof Response) return {
+			type: "response",
+			response: mergeHeaders(served, middlewareHeaders, middlewareStatus)
+		};
+		return served ? { type: "handled" } : null;
+	};
+	if (typeof deps.runMiddleware === "function") {
+		const result = await deps.runMiddleware(request, deps.ctx ?? null, { isDataRequest });
+		if (result.waitUntilPromises && result.waitUntilPromises.length > 0) {
+			const ctx = deps.ctx;
+			if (ctx && typeof ctx.waitUntil === "function") for (const p of result.waitUntilPromises) ctx.waitUntil(p);
+			else Promise.allSettled(result.waitUntilPromises);
+		}
+		if (!result.continue) {
+			if (result.redirectUrl) {
+				const redirectHeaders = { Location: result.redirectUrl };
+				if (result.responseHeaders) for (const [key, value] of result.responseHeaders) {
+					const existing = redirectHeaders[key];
+					if (existing === void 0) redirectHeaders[key] = value;
+					else if (Array.isArray(existing)) existing.push(value);
+					else redirectHeaders[key] = [existing, value];
+				}
+				const headers = new Headers();
+				for (const [k, v] of Object.entries(redirectHeaders)) if (Array.isArray(v)) for (const item of v) headers.append(k, item);
+				else headers.set(k, v);
+				return {
+					type: "response",
+					response: new Response(null, {
+						status: result.redirectStatus ?? 307,
+						headers
+					})
+				};
+			}
+			if (result.response) return {
+				type: "response",
+				response: result.response
+			};
+		}
+		if (result.responseHeaders) for (const [key, value] of result.responseHeaders) if (key === "set-cookie") {
+			const existing = middlewareHeaders[key];
+			if (Array.isArray(existing)) existing.push(value);
+			else if (existing) middlewareHeaders[key] = [existing, value];
+			else middlewareHeaders[key] = [value];
+		} else middlewareHeaders[key] = value;
+		if (result.rewriteUrl) resolvedUrl = result.rewriteUrl;
+		middlewareStatus = result.status ?? result.rewriteStatus;
+	}
+	const { postMwReqCtx, request: postMwReq } = applyMiddlewareRequestHeaders(middlewareHeaders, request, { preserveCredentialHeaders: isExternalUrl(resolvedUrl) });
+	request = postMwReq;
+	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,
+		pathname: matchPathname,
+		requestContext: reqCtx,
+		basePathState
+	});
+	if (isExternalUrl(resolvedUrl)) return {
+		type: "response",
+		response: mergeHeaders(await proxyExternal(request, resolvedUrl), middlewareHeaders, void 0)
+	};
+	const directFilesystemResult = await serveFilesystemRoute(pathname, "direct");
+	if (directFilesystemResult) return directFilesystemResult;
+	let configRewriteFired = false;
+	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 = pathnameForResolvedUrl(resolvedUrl);
+			configRewriteFired = true;
+		}
+	}
+	if (configRewriteFired) {
+		const beforeFilesResult = await serveFilesystemRoute(resolvedPathname, "beforeFiles");
+		if (beforeFilesResult) return beforeFilesResult;
+	}
+	if (basePath && !hadBasePath && !configRewriteFired) return {
+		type: "response",
+		response: new Response("This page could not be found", {
+			status: 404,
+			headers: { "Content-Type": "text/html; charset=utf-8" }
+		})
+	};
+	const handleResolvedApiRoute = async () => {
+		const apiLookupUrl = stripI18nLocaleForApiRoute(resolvedUrl, i18nConfig);
+		const apiLookupPathname = apiLookupUrl.split("?")[0];
+		if (!apiLookupPathname.startsWith("/api/") && apiLookupPathname !== "/api") return null;
+		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)
+			};
+		}
+		return {
+			type: "api",
+			apiUrl: apiLookupUrl,
+			stagedHeaders: middlewareHeaders,
+			requestHeaders: request.headers,
+			middlewareStatus
+		};
+	};
+	const apiResult = await handleResolvedApiRoute();
+	if (apiResult) return apiResult;
+	let pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+	let resolvedPathnameChanged = false;
+	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 = pathnameForResolvedUrl(resolvedUrl);
+			resolvedPathnameChanged = true;
+			const afterFilesFilesystemResult = await serveFilesystemRoute(resolvedPathname, "afterFiles");
+			if (afterFilesFilesystemResult) return afterFilesFilesystemResult;
+			const afterFilesApiResult = await handleResolvedApiRoute();
+			if (afterFilesApiResult) return afterFilesApiResult;
+			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") {
+		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);
+			const fallbackFilesystemResult = await serveFilesystemRoute(resolvedPathname, "fallback");
+			if (fallbackFilesystemResult) return fallbackFilesystemResult;
+			const fallbackApiResult = await handleResolvedApiRoute();
+			if (fallbackApiResult) return fallbackApiResult;
+			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();
+		for (const [k, v] of Object.entries(middlewareHeaders)) if (Array.isArray(v)) for (const item of v) stagedHeaders.append(k, item);
+		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) 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);
+			const fallbackFilesystemResult = await serveFilesystemRoute(resolvedPathname, "fallback");
+			if (fallbackFilesystemResult) return fallbackFilesystemResult;
+			const fallbackApiResult = await handleResolvedApiRoute();
+			if (fallbackApiResult) return fallbackApiResult;
+			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);
+		if (merged !== response) merged.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
+		return {
+			type: "response",
+			response: merged,
+			defaultContentType: "text/html"
+		};
+	}
+	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);
+		const fallbackFilesystemResult = await serveFilesystemRoute(resolvedPathname, "fallback");
+		if (fallbackFilesystemResult) return fallbackFilesystemResult;
+		const fallbackApiResult = await handleResolvedApiRoute();
+		if (fallbackApiResult) return fallbackApiResult;
+		if (deps.matchPageRoute?.(resolvedPathname, request)) break;
+	}
+	refreshDataRewriteHeader();
+	return {
+		type: "render",
+		resolvedUrl,
+		renderOptions: isDataReq ? { isDataReq: true } : void 0,
+		stagedHeaders: middlewareHeaders,
+		requestHeaders: request.headers,
+		middlewareStatus,
+		isDataReq
+	};
+}
+//#endregion
+export { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath };

package/dist/server/pages-revalidate.d.ts

@@ -0,0 +1,15 @@
+import { IncomingMessage } from "node:http";
+
+//#region src/server/pages-revalidate.d.ts
+type RevalidateOptions = {
+  /**
+   * Only revalidate the path if it was already generated (cached). Mirrors
+   * Next.js's `unstable_onlyGenerated`: sets the
+   * `x-prerender-revalidate-if-generated` header and makes a 404 response count
+   * as a successful no-op rather than an error.
+   */
+  unstable_onlyGenerated?: boolean;
+};
+declare function performOnDemandRevalidate(source: IncomingMessage | Headers, urlPath: string, opts?: RevalidateOptions): Promise<void>;
+//#endregion
+export { RevalidateOptions, performOnDemandRevalidate };

package/dist/server/pages-revalidate.js

@@ -0,0 +1,19 @@
+import "./headers.js";
+import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, getRevalidateSecret } from "./isr-cache.js";
+import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
+//#region src/server/pages-revalidate.ts
+async function performOnDemandRevalidate(source, urlPath, opts = {}) {
+	if (typeof urlPath !== "string" || !urlPath.startsWith("/")) throw new Error(`Invalid urlPath provided to revalidate(), must be a path e.g. /blog/post-1, received ${urlPath}`);
+	const proto = resolveRequestProtocol(source);
+	const host = resolveRequestHost(source, "localhost");
+	const target = new URL(urlPath, `${proto}://${host}`);
+	const headers = { [PRERENDER_REVALIDATE_HEADER]: getRevalidateSecret() };
+	if (opts.unstable_onlyGenerated) headers[PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER] = "1";
+	const res = await fetch(target, {
+		method: "HEAD",
+		headers
+	});
+	if (!(res.headers.get("x-nextjs-cache")?.toUpperCase() === "REVALIDATED" || res.status === 200 || res.status === 404 && opts.unstable_onlyGenerated === true)) throw new Error(`Failed to revalidate ${urlPath}: ${res.status}`);
+}
+//#endregion
+export { performOnDemandRevalidate };

package/dist/server/pages-serializable-props.d.ts

@@ -0,0 +1,24 @@
+//#region src/server/pages-serializable-props.d.ts
+/**
+ * Validate that the value returned as `props` from `getStaticProps` /
+ * `getServerSideProps` is JSON-serializable. Throws a friendly
+ * `SerializableError` matching Next.js's error shape if it isn't.
+ *
+ * Ported from Next.js:
+ *   .nextjs-ref/packages/next/src/lib/is-serializable-props.ts
+ *   .nextjs-ref/packages/next/src/shared/lib/is-plain-object.ts
+ *
+ * Tested in Next.js by `test/unit/is-serializable-props.test.ts` and the
+ * `non-json` / `non-json-blocking` cases in `test/e2e/prerender.test.ts`.
+ *
+ * Next.js calls this from `packages/next/src/server/render.tsx` for both
+ * `getStaticProps` and `getServerSideProps`. We do the same in
+ * `pages-page-data.ts` so users see a clear error instead of an empty page
+ * when they accidentally return a `Date`, `Map`, or class instance.
+ */
+declare class SerializableError extends Error {
+  constructor(page: string, method: string, path: string, message: string);
+}
+declare function isSerializableProps(page: string, method: string, input: unknown): true;
+//#endregion
+export { SerializableError, isSerializableProps };

package/dist/server/pages-serializable-props.js

@@ -0,0 +1,67 @@
+//#region src/server/pages-serializable-props.ts
+/**
+* Validate that the value returned as `props` from `getStaticProps` /
+* `getServerSideProps` is JSON-serializable. Throws a friendly
+* `SerializableError` matching Next.js's error shape if it isn't.
+*
+* Ported from Next.js:
+*   .nextjs-ref/packages/next/src/lib/is-serializable-props.ts
+*   .nextjs-ref/packages/next/src/shared/lib/is-plain-object.ts
+*
+* Tested in Next.js by `test/unit/is-serializable-props.test.ts` and the
+* `non-json` / `non-json-blocking` cases in `test/e2e/prerender.test.ts`.
+*
+* Next.js calls this from `packages/next/src/server/render.tsx` for both
+* `getStaticProps` and `getServerSideProps`. We do the same in
+* `pages-page-data.ts` so users see a clear error instead of an empty page
+* when they accidentally return a `Date`, `Map`, or class instance.
+*/
+function getObjectClassLabel(value) {
+	return Object.prototype.toString.call(value);
+}
+function isPlainObject(value) {
+	if (getObjectClassLabel(value) !== "[object Object]") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.prototype.hasOwnProperty.call(prototype, "isPrototypeOf");
+}
+const REGEX_PLAIN_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SerializableError = class extends Error {
+	constructor(page, method, path, message) {
+		super(path ? `Error serializing \`${path}\` returned from \`${method}\` in "${page}".\nReason: ${message}` : `Error serializing props returned from \`${method}\` in "${page}".\nReason: ${message}`);
+		this.name = "SerializableError";
+	}
+};
+function isSerializableProps(page, method, input) {
+	if (!isPlainObject(input)) throw new SerializableError(page, method, "", `Props must be returned as a plain object from ${method}: \`{ props: { ... } }\` (received: \`${getObjectClassLabel(input)}\`).`);
+	function visit(visited, value, path) {
+		if (visited.has(value)) throw new SerializableError(page, method, path, `Circular references cannot be expressed in JSON (references: \`${visited.get(value) || "(self)"}\`).`);
+		visited.set(value, path);
+	}
+	function isSerializable(refs, value, path) {
+		const type = typeof value;
+		if (value === null || type === "boolean" || type === "number" || type === "string") return true;
+		if (type === "undefined") throw new SerializableError(page, method, path, "`undefined` cannot be serialized as JSON. Please use `null` or omit this value.");
+		if (isPlainObject(value)) {
+			visit(refs, value, path);
+			const entries = Object.entries(value);
+			for (const [key, nestedValue] of entries) {
+				const nextPath = REGEX_PLAIN_IDENTIFIER.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+				const newRefs = new Map(refs);
+				isSerializable(newRefs, key, nextPath);
+				isSerializable(newRefs, nestedValue, nextPath);
+			}
+			return true;
+		}
+		if (Array.isArray(value)) {
+			visit(refs, value, path);
+			value.forEach((nestedValue, index) => {
+				isSerializable(new Map(refs), nestedValue, `${path}[${index}]`);
+			});
+			return true;
+		}
+		throw new SerializableError(page, method, path, `\`${type}\`${type === "object" ? ` ("${Object.prototype.toString.call(value)}")` : ""} cannot be serialized as JSON. Please only return JSON serializable data types.`);
+	}
+	return isSerializable(/* @__PURE__ */ new Map(), input, "");
+}
+//#endregion
+export { SerializableError, isSerializableProps };

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

@@ -0,0 +1,16 @@
+//#region src/server/pregenerated-concrete-paths.d.ts
+declare global {
+  var __VINEXT_PREGENERATED_CONCRETE_PATHS: unknown;
+}
+declare function normalizePregeneratedPathname(pathname: string): string;
+declare function clearPregeneratedConcretePaths(): void;
+declare function addPregeneratedConcretePath(routePattern: string, pathname: string): void;
+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).
+ * Pathnames are normalised so they match the runtime `cleanPathname`.
+ */
+declare function initPregeneratedPathsFromGlobals(): void;
+//#endregion
+export { addPregeneratedConcretePath, clearPregeneratedConcretePaths, getRenderedConcreteUrlPathsForRoute, initPregeneratedPathsFromGlobals, normalizePregeneratedPathname };

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

@@ -0,0 +1,61 @@
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
+import { normalizePath } from "./normalize-path.js";
+//#region src/server/pregenerated-concrete-paths.ts
+function normalizePregeneratedPathname(pathname) {
+	return normalizePath(normalizePathnameForRouteMatch(pathname));
+}
+/**
+* Stores concrete URL paths pre-rendered at build time per route pattern.
+* Used by the PPR fallback-shell guard to avoid serving fallback shells for
+* known routes whose exact cache entry is temporarily absent.
+*
+* Populated by `seed-cache.ts` (Node) or from `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`
+* injected by `deploy.ts` after prerender (Workers).
+*/
+const concreteUrlPathsByRoute = /* @__PURE__ */ new Map();
+function clearPregeneratedConcretePaths() {
+	concreteUrlPathsByRoute.clear();
+}
+function addPregeneratedConcretePath(routePattern, pathname) {
+	let paths = concreteUrlPathsByRoute.get(routePattern);
+	if (!paths) {
+		paths = /* @__PURE__ */ new Set();
+		concreteUrlPathsByRoute.set(routePattern, paths);
+	}
+	paths.add(normalizePregeneratedPathname(pathname));
+}
+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).
+* Pathnames are normalised so they match the runtime `cleanPathname`.
+*/
+function initPregeneratedPathsFromGlobals() {
+	const raw = globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS;
+	const data = parsePregeneratedConcretePaths(raw);
+	if (!data) return;
+	clearPregeneratedConcretePaths();
+	for (const [routePattern, pathnames] of data) for (const pathname of pathnames) addPregeneratedConcretePath(routePattern, pathname);
+}
+function parsePregeneratedConcretePaths(value) {
+	if (!Array.isArray(value)) return void 0;
+	const result = [];
+	for (const entry of value) {
+		if (!Array.isArray(entry)) return void 0;
+		if (entry.length !== 2) return void 0;
+		const [pattern, paths] = entry;
+		if (typeof pattern !== "string") return void 0;
+		if (!Array.isArray(paths)) return void 0;
+		const strings = [];
+		for (const p of paths) {
+			if (typeof p !== "string") return void 0;
+			strings.push(p);
+		}
+		result.push([pattern, strings]);
+	}
+	return result;
+}
+//#endregion
+export { addPregeneratedConcretePath, clearPregeneratedConcretePaths, getRenderedConcreteUrlPathsForRoute, initPregeneratedPathsFromGlobals, normalizePregeneratedPathname };

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

@@ -0,0 +1,23 @@
+//#region src/server/prerender-route-params.d.ts
+type PrerenderRouteParams = Record<string, string | string[]>;
+type PrerenderRouteParamsPayload = {
+  fallbackParamNames?: readonly string[];
+  params: PrerenderRouteParams;
+  routePattern: string;
+};
+type PrerenderRouteParamsRouteMatch = {
+  kind: "exact";
+  params: PrerenderRouteParams;
+} | {
+  fallbackParamNames: readonly string[];
+  kind: "fallback-shell";
+  params: PrerenderRouteParams;
+};
+declare function serializePrerenderRouteParamsHeader(payload: PrerenderRouteParamsPayload | null): string | null;
+declare function readTrustedPrerenderRouteParamsFromHeaders(headers: Headers, expectedSecret?: string): PrerenderRouteParamsPayload | null;
+declare function readTrustedPrerenderRouteParams(request: Request): PrerenderRouteParamsPayload | null;
+declare function prerenderRouteParamsPayloadMatchesRoute(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): payload is PrerenderRouteParamsPayload;
+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, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };