vinext 0.0.55 → 0.1.0

package/dist/server/pages-page-handler.js

@@ -0,0 +1,335 @@
+import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { reportRequestError } from "./instrumentation.js";
+import { isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { getScriptNonceFromHeaderSources } from "./csp.js";
+import { resolvePagesI18nRequest } from "./pages-i18n.js";
+import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
+import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
+import { buildNextDataJsonResponse, buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { createPagesReqRes } from "./pages-node-compat.js";
+import { collectAssetTags, resolveClientModuleUrl } from "./pages-asset-tags.js";
+import { renderPagesPageResponse } from "./pages-page-response.js";
+import { resolvePagesPageData } from "./pages-page-data.js";
+//#region src/server/pages-page-handler.ts
+function buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales) {
+	return {
+		locale,
+		locales: i18nConfig ? i18nConfig.locales : void 0,
+		defaultLocale: currentDefaultLocale,
+		domainLocales
+	};
+}
+/**
+* Create the Pages Router render function (`_renderPage`).
+*
+* The returned function is self-recursive for 404/500 fallback renders and
+* accepts the same options shape the generated entry always passed inline.
+*/
+function createPagesPageHandler(opts) {
+	const { pageRoutes, errorPageRoute, matchRoute, i18nConfig, vinextConfig, buildId, hasMiddleware, appAssetPath, setSSRContext, setI18nContext, wrapWithRouterContext, resetSSRHead, getSSRHeadHTML, setDocumentInitialHead, flushPreloads, getFontLinks, getFontStyles, getFontPreloads, renderToReadableStream, renderIsrPassToStringAsync, safeJsonStringify, sanitizeDestination, createPageElement, enhancePageElement, AppComponent, DocumentComponent } = opts;
+	function renderToStringAsync(element) {
+		return renderToReadableStream(element).then((stream) => new Response(stream).text());
+	}
+	function findNotFoundRoute() {
+		for (let i = 0; i < pageRoutes.length; i++) if (pageRoutes[i].pattern === "/404") return pageRoutes[i];
+		return errorPageRoute;
+	}
+	function isrCacheKeyForRequest(i18nCacheVariant) {
+		if (!i18nCacheVariant) return (router, pathname) => isrCacheKey(router, pathname, buildId ?? void 0);
+		return (router, pathname) => isrCacheKey(router, pathname + "::i18n=" + encodeURIComponent(i18nCacheVariant), buildId ?? void 0);
+	}
+	async function renderPage(request, url, manifest, middlewareHeaders, options) {
+		let isDataReq = !!(options && options.isDataReq);
+		if (!isDataReq) {
+			const dataNorm = normalizePagesDataRequest(request, buildId);
+			if (dataNorm.notFoundResponse) return dataNorm.notFoundResponse;
+			if (dataNorm.isDataReq) {
+				isDataReq = true;
+				if (url && url.startsWith("/_next/data/")) {
+					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+					url = dataNorm.normalizedPathname + qs;
+				}
+			}
+		}
+		const statusCode = options && typeof options.statusCode === "number" ? options.statusCode : void 0;
+		const asPath = options && typeof options.asPath === "string" ? options.asPath : void 0;
+		const renderErrorPageOnMiss = !(options && options.renderErrorPageOnMiss === false);
+		const isInternalErrorRender = !!(options && options.__isInternalErrorRender);
+		const err = options && options.err;
+		const localeInfo = i18nConfig ? resolvePagesI18nRequest(url, i18nConfig, request.headers, new URL(request.url).hostname, vinextConfig.basePath, vinextConfig.trailingSlash) : {
+			locale: void 0,
+			url,
+			hadPrefix: false,
+			domainLocale: void 0,
+			redirectUrl: void 0
+		};
+		const locale = localeInfo.locale;
+		const routeUrl = localeInfo.url;
+		const currentDefaultLocale = i18nConfig ? localeInfo.domainLocale ? localeInfo.domainLocale.defaultLocale : i18nConfig.defaultLocale : void 0;
+		const domainLocales = i18nConfig ? i18nConfig.domains : void 0;
+		const pageIsrCacheKey = isrCacheKeyForRequest(i18nConfig ? localeInfo.domainLocale ? "domain:" + String(localeInfo.domainLocale.domain).toLowerCase() : "locale:" + String(locale) : null);
+		if (localeInfo.redirectUrl) return new Response(null, {
+			status: 307,
+			headers: { Location: localeInfo.redirectUrl }
+		});
+		let match = options && options.__forcedRoute ? {
+			route: options.__forcedRoute,
+			params: {}
+		} : matchRoute(routeUrl, pageRoutes);
+		let renderStatusCodeOverride = statusCode;
+		let renderAsPath = asPath;
+		if (!match) {
+			if (isDataReq) return buildNextDataNotFoundResponse();
+			if (!renderErrorPageOnMiss) return buildDefaultPagesNotFoundResponse();
+			const notFoundRoute = findNotFoundRoute();
+			if (notFoundRoute) {
+				match = {
+					route: notFoundRoute,
+					params: {}
+				};
+				renderStatusCodeOverride = 404;
+				renderAsPath = routeUrl;
+			} else return buildDefaultPagesNotFoundResponse();
+		}
+		const { route, params } = match;
+		return runWithRequestContext(createRequestContext({ executionContext: getRequestExecutionContext() }), async () => {
+			ensureFetchPatch();
+			try {
+				const routePattern = patternToNextFormat(route.pattern);
+				const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : void 0);
+				const query = mergeRouteParamsIntoQuery(parseQueryString(routeUrl), params);
+				function applySSRContext() {
+					if (typeof setSSRContext === "function") setSSRContext({
+						pathname: routePattern,
+						query,
+						asPath: renderAsPath ?? routeUrl,
+						locale,
+						locales: i18nConfig ? i18nConfig.locales : void 0,
+						defaultLocale: currentDefaultLocale,
+						domainLocales
+					});
+					if (i18nConfig && typeof setI18nContext === "function") setI18nContext({
+						locale,
+						locales: i18nConfig.locales,
+						defaultLocale: currentDefaultLocale,
+						domainLocales,
+						hostname: new URL(request.url).hostname
+					});
+				}
+				applySSRContext();
+				const pageModule = route.module;
+				const PageComponent = pageModule.default;
+				if (!PageComponent) return new Response("Page has no default export", { status: 500 });
+				if (!isDataReq && routePattern !== "/_error" && routePattern !== "/404" && routePattern !== "/500" && renderStatusCodeOverride === void 0) {
+					const methodResponse = resolvePagesPageMethodResponse({
+						hasGetServerSideProps: typeof pageModule.getServerSideProps === "function",
+						method: request.method
+					});
+					if (methodResponse) return methodResponse;
+				}
+				const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath);
+				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath);
+				const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareHeaders);
+				let fontLinkHeader = "";
+				let allFontPreloads = [];
+				try {
+					allFontPreloads = getFontPreloads();
+					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + p.href + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
+				} catch {}
+				const pageDataResult = await resolvePagesPageData({
+					isDataReq,
+					err,
+					applyRequestContexts: applySSRContext,
+					buildId,
+					createGsspReqRes() {
+						return createPagesReqRes({
+							body: void 0,
+							query,
+							request,
+							url: routeUrl
+						});
+					},
+					createPageElement(currentPageProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentPageProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					fontLinkHeader,
+					i18n: buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales),
+					isrCacheKey: pageIsrCacheKey,
+					isrGet,
+					isrSet,
+					expireSeconds: vinextConfig.expireTime,
+					isBuildTimePrerendering: typeof process !== "undefined" && process.env && process.env.VINEXT_PRERENDER === "1",
+					pageModule,
+					params,
+					query,
+					asPath: renderAsPath ?? routeUrl,
+					renderIsrPassToStringAsync,
+					route: { isDynamic: route.isDynamic },
+					routePattern,
+					routeUrl,
+					runInFreshUnifiedContext(callback) {
+						return runWithRequestContext(createRequestContext({ executionContext: getRequestExecutionContext() }), async () => {
+							ensureFetchPatch();
+							return callback();
+						});
+					},
+					safeJsonStringify,
+					sanitizeDestination,
+					scriptNonce,
+					statusCode: renderStatusCode,
+					triggerBackgroundRegeneration,
+					vinext: {
+						pageModuleUrl,
+						appModuleUrl,
+						hasMiddleware
+					}
+				});
+				if (pageDataResult.kind === "notFound") {
+					const notFoundRoute = findNotFoundRoute();
+					if (notFoundRoute && routePattern !== "/404" && routePattern !== "/_error") return renderPage(request, url, manifest, middlewareHeaders, {
+						statusCode: 404,
+						asPath: renderAsPath ?? routeUrl,
+						renderErrorPageOnMiss: false,
+						__forcedRoute: notFoundRoute
+					});
+					return buildDefaultPagesNotFoundResponse();
+				}
+				if (pageDataResult.kind === "response") return pageDataResult.response;
+				let pageProps = pageDataResult.pageProps;
+				if (routePattern === "/_error" && typeof renderStatusCode === "number") pageProps = {
+					...pageProps,
+					statusCode: renderStatusCode
+				};
+				const gsspRes = pageDataResult.gsspRes;
+				const isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
+				const isFallbackRender = pageDataResult.isFallback === true;
+				if (isFallbackRender && typeof setSSRContext === "function") setSSRContext({
+					pathname: routePattern,
+					query,
+					asPath: renderAsPath ?? routeUrl,
+					locale,
+					locales: i18nConfig ? i18nConfig.locales : void 0,
+					defaultLocale: currentDefaultLocale,
+					domainLocales,
+					isFallback: true
+				});
+				if (isDataReq) {
+					const init = { headers: {} };
+					if (gsspRes && typeof gsspRes.getHeaders === "function") {
+						const gsspHeaders = gsspRes.getHeaders();
+						for (const k of Object.keys(gsspHeaders)) {
+							const v = gsspHeaders[k];
+							if (v === void 0 || v === null) continue;
+							init.headers[k] = Array.isArray(v) ? v.join(", ") : String(v);
+						}
+					}
+					if (gsspRes) {
+						let hasUserCacheControl = false;
+						for (const headerKey of Object.keys(init.headers)) if (headerKey.toLowerCase() === "cache-control") {
+							hasUserCacheControl = true;
+							break;
+						}
+						if (!hasUserCacheControl) init.headers["Cache-Control"] = "private, no-cache, no-store, max-age=0, must-revalidate";
+					}
+					return buildNextDataJsonResponse(pageProps, safeJsonStringify, init);
+				}
+				const pageModuleIds = [];
+				if (route.filePath) pageModuleIds.push(route.filePath);
+				if (appAssetPath) pageModuleIds.push(appAssetPath);
+				return await renderPagesPageResponse({
+					assetTags: collectAssetTags({
+						manifest,
+						moduleIds: pageModuleIds,
+						scriptNonce,
+						disableOptimizedLoading: vinextConfig.disableOptimizedLoading
+					}),
+					buildId,
+					clearSsrContext() {
+						if (typeof setSSRContext === "function") setSSRContext(null);
+					},
+					createPageElement(currentPageProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentPageProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					enhancePageElement(renderPageOpts) {
+						const el = enhancePageElement(PageComponent, AppComponent, pageProps, renderPageOpts);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					DocumentComponent,
+					flushPreloads: typeof flushPreloads === "function" ? flushPreloads : void 0,
+					fontLinkHeader,
+					fontPreloads: allFontPreloads,
+					getFontLinks,
+					getFontStyles,
+					getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : void 0,
+					clientTraceMetadata: vinextConfig.clientTraceMetadata,
+					gsspRes,
+					isrCacheKey: pageIsrCacheKey,
+					expireSeconds: vinextConfig.expireTime,
+					isrRevalidateSeconds,
+					isrSet,
+					i18n: buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales),
+					isFallback: isFallbackRender,
+					pageProps,
+					params,
+					renderDocumentToString(element) {
+						return renderToStringAsync(element);
+					},
+					renderToReadableStream,
+					resetSSRHead: typeof resetSSRHead === "function" ? resetSSRHead : void 0,
+					setDocumentInitialHead: typeof setDocumentInitialHead === "function" ? setDocumentInitialHead : void 0,
+					routePattern,
+					routeUrl,
+					safeJsonStringify,
+					scriptNonce,
+					statusCode: renderStatusCode,
+					vinext: {
+						pageModuleUrl,
+						appModuleUrl,
+						hasMiddleware
+					}
+				});
+			} catch (e) {
+				console.error("[vinext] SSR error:", e);
+				reportRequestError(e instanceof Error ? e : new Error(String(e)), {
+					path: url,
+					method: request.method,
+					headers: Object.fromEntries(request.headers.entries())
+				}, {
+					routerKind: "Pages Router",
+					routePath: route.pattern,
+					routeType: "render"
+				}).catch(() => {});
+				if (!isInternalErrorRender && !isDataReq) {
+					let errorRoute = null;
+					for (let i = 0; i < pageRoutes.length; i++) if (pageRoutes[i].pattern === "/500") {
+						errorRoute = pageRoutes[i];
+						break;
+					}
+					if (!errorRoute && errorPageRoute) errorRoute = errorPageRoute;
+					if (errorRoute) try {
+						return await renderPage(request, url, manifest, middlewareHeaders, {
+							statusCode: 500,
+							asPath: url,
+							renderErrorPageOnMiss: false,
+							__isInternalErrorRender: true,
+							__forcedRoute: errorRoute,
+							err: e instanceof Error ? e : new Error(String(e))
+						});
+					} catch (errorPageErr) {
+						console.error("[vinext] Error page render failed:", errorPageErr);
+					}
+				}
+				return new Response("Internal Server Error", { status: 500 });
+			}
+		});
+	}
+	return renderPage;
+}
+//#endregion
+export { createPagesPageHandler };

package/dist/server/pages-page-method.d.ts

@@ -44,5 +44,4 @@ type PagesPageMethodOptions = {
  */
 declare function resolvePagesPageMethodResponse(options: PagesPageMethodOptions): Response | null;
 //#endregion
-export { resolvePagesPageMethodResponse };
-//# sourceMappingURL=pages-page-method.d.ts.map
+export { resolvePagesPageMethodResponse };

package/dist/server/pages-page-method.js

@@ -15,5 +15,3 @@ function resolvePagesPageMethodResponse(options) {
 }
 //#endregion
 export { resolvePagesPageMethodResponse };
-
-//# sourceMappingURL=pages-page-method.js.map

package/dist/server/pages-page-response.d.ts

@@ -79,5 +79,4 @@ declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseO
 }): string;
 declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
 //#endregion
-export { PagesGsspResponse, PagesI18nRenderContext, buildPagesNextDataScript, renderPagesPageResponse };
-//# sourceMappingURL=pages-page-response.d.ts.map
+export { PagesGsspResponse, PagesI18nRenderContext, buildPagesNextDataScript, renderPagesPageResponse };

package/dist/server/pages-page-response.js

@@ -1,13 +1,14 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
-import { buildRevalidateCacheControl } from "./cache-control.js";
+import { applyCdnResponseHeaders, buildRevalidateCacheControl } from "./cache-control.js";
 import React from "react";
 //#region src/server/pages-page-response.ts
 function buildPagesFontHeadHtml(fontLinks, fontPreloads, fontStyles, scriptNonce) {
@@ -195,7 +196,12 @@ async function renderPagesPageResponse(options) {
 	const userSetCacheControl = responseHeaders.has("Cache-Control");
 	if (options.scriptNonce) responseHeaders.set("Cache-Control", "no-store, must-revalidate");
 	else if (options.isrRevalidateSeconds) {
-		responseHeaders.set("Cache-Control", buildRevalidateCacheControl(options.isrRevalidateSeconds, options.expireSeconds));
+		const isrPathname = options.routeUrl.split("?")[0];
+		const stem = isrPathname.endsWith("/") ? isrPathname.slice(0, -1) : isrPathname;
+		applyCdnResponseHeaders(responseHeaders, {
+			cacheControl: buildRevalidateCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
+			tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
+		});
 		setCacheStateHeaders(responseHeaders, "MISS");
 	} else if (options.gsspRes && !userSetCacheControl) responseHeaders.set("Cache-Control", "private, no-cache, no-store, max-age=0, must-revalidate");
 	if (options.fontLinkHeader) responseHeaders.set("Link", options.fontLinkHeader);
@@ -206,5 +212,3 @@ async function renderPagesPageResponse(options) {
 }
 //#endregion
 export { buildPagesNextDataScript, renderPagesPageResponse };
-
-//# sourceMappingURL=pages-page-response.js.map

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

@@ -21,5 +21,4 @@ declare class SerializableError extends Error {
 }
 declare function isSerializableProps(page: string, method: string, input: unknown): true;
 //#endregion
-export { SerializableError, isSerializableProps };
-//# sourceMappingURL=pages-serializable-props.d.ts.map
+export { SerializableError, isSerializableProps };

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

@@ -65,5 +65,3 @@ function isSerializableProps(page, method, input) {
 }
 //#endregion
 export { SerializableError, isSerializableProps };
-
-//# sourceMappingURL=pages-serializable-props.js.map

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

@@ -0,0 +1,32 @@
+//#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;
+/**
+ * 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`.
+ */
+declare function initPregeneratedPathsFromGlobals(): void;
+//#endregion
+export { addPregeneratedConcretePath, clearPregeneratedConcretePaths, getRenderedConcreteUrlPathsForRoute, initPregeneratedPathsFromGlobals, normalizePregeneratedPathname };

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

@@ -0,0 +1,78 @@
+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();
+}
+/**
+* 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);
+}
+/**
+* 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`.
+*/
+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-route-params.d.ts

@@ -1,14 +1,24 @@
 //#region src/server/prerender-route-params.d.ts
 type PrerenderRouteParams = Record<string, string | string[]>;
 type PrerenderRouteParamsPayload = {
+  fallbackParamNames?: readonly string[];
   params: PrerenderRouteParams;
   routePattern: string;
 };
+/** @public exported for #1716 serving consumers; not yet referenced in-repo */
+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 encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams): PrerenderRouteParamsPayload | null;
+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, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
-//# sourceMappingURL=prerender-route-params.d.ts.map
+export { PrerenderRouteParams, PrerenderRouteParamsPayload, PrerenderRouteParamsRouteMatch, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };

package/dist/server/prerender-route-params.js

@@ -12,7 +12,10 @@ function isPrerenderRouteParams(value) {
 }
 function isPrerenderRouteParamsPayload(value) {
 	if (!isUnknownRecord(value)) return false;
-	if (Object.keys(value).length !== 2) return false;
+	const keys = Object.keys(value);
+	if (keys.length !== 2 && keys.length !== 3) return false;
+	if (keys.some((key) => key !== "fallbackParamNames" && key !== "params" && key !== "routePattern")) return false;
+	if ("fallbackParamNames" in value && (!Array.isArray(value.fallbackParamNames) || !value.fallbackParamNames.every((name) => typeof name === "string"))) return false;
 	return typeof value.routePattern === "string" && value.routePattern.startsWith("/") && isPrerenderRouteParams(value.params);
 }
 function serializePrerenderRouteParamsHeader(payload) {
@@ -62,17 +65,34 @@ function decodedPrerenderRouteParamEquals(prerenderValue, matchedValue) {
 	return decoded !== null && decoded === matchedValue;
 }
 function prerenderRouteParamsPayloadMatchesRoute(payload, routePattern, params) {
-	if (payload === null) return false;
-	if (payload.routePattern !== routePattern) return false;
-	if (Object.keys(payload.params).length !== Object.keys(params).length) return false;
+	return matchPrerenderRouteParamsPayload(payload, routePattern, params)?.kind === "exact";
+}
+function matchPrerenderRouteParamsPayload(payload, routePattern, params) {
+	if (payload === null) return null;
+	if (payload.routePattern !== routePattern) return null;
+	if (Object.keys(payload.params).length !== Object.keys(params).length) return null;
 	for (const [key, prerenderValue] of Object.entries(payload.params)) {
 		const matchedValue = params[key];
-		if (matchedValue === void 0) return false;
-		if (!decodedPrerenderRouteParamEquals(prerenderValue, matchedValue)) return false;
+		if (matchedValue === void 0) return null;
+		if (!decodedPrerenderRouteParamEquals(prerenderValue, matchedValue)) return null;
 	}
-	return true;
+	if (payload.fallbackParamNames) {
+		const routeParamNames = new Set(routePattern.split("/").filter((part) => part.startsWith(":")).map((part) => part.endsWith("+") || part.endsWith("*") ? part.slice(1, -1) : part.slice(1)));
+		const fallbackParamNames = payload.fallbackParamNames.filter((name, index, names) => routeParamNames.has(name) && names.indexOf(name) === index);
+		if (fallbackParamNames.length !== payload.fallbackParamNames.length) return null;
+		if (fallbackParamNames.length === 0) return null;
+		return {
+			fallbackParamNames,
+			kind: "fallback-shell",
+			params: payload.params
+		};
+	}
+	return {
+		kind: "exact",
+		params: payload.params
+	};
 }
-function encodePrerenderRouteParams(pattern, params) {
+function encodePrerenderRouteParams(pattern, params, fallbackParamNames) {
 	const encoded = {};
 	for (const part of pattern.split("/").filter(Boolean)) {
 		let paramName = null;
@@ -84,11 +104,10 @@ function encodePrerenderRouteParams(pattern, params) {
 		else if (typeof value === "string") encoded[paramName] = encodeURIComponent(value);
 	}
 	return Object.keys(encoded).length > 0 ? {
+		...fallbackParamNames && fallbackParamNames.length > 0 ? { fallbackParamNames } : {},
 		routePattern: pattern,
 		params: encoded
 	} : null;
 }
 //#endregion
-export { encodePrerenderRouteParams, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
-
-//# sourceMappingURL=prerender-route-params.js.map
+export { encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };

package/dist/server/prerender-work-unit-setup.d.ts

@@ -3,5 +3,4 @@ declare function runWithPrerenderWorkUnit<T>(fn: () => Promise<T>, options?: {
   route?: string | (() => string);
 }): Promise<T>;
 //#endregion
-export { runWithPrerenderWorkUnit };
-//# sourceMappingURL=prerender-work-unit-setup.d.ts.map
+export { runWithPrerenderWorkUnit };

package/dist/server/prerender-work-unit-setup.js

@@ -26,5 +26,3 @@ function runWithPrerenderWorkUnit(fn, options) {
 }
 //#endregion
 export { runWithPrerenderWorkUnit };
-
-//# sourceMappingURL=prerender-work-unit-setup.js.map

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

@@ -1,6 +1,5 @@
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
-import * as _$node_http0 from "node:http";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/server/prod-server.d.ts
@@ -73,7 +72,7 @@ declare function sendWebResponse(webResponse: Response, req: IncomingMessage, re
  * Pages Router (dist/server/entry.js) and configures the appropriate handler.
  */
 declare function startProdServer(options?: ProdServerOptions): Promise<{
-  server: _$node_http0.Server<typeof IncomingMessage, typeof ServerResponse>;
+  server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;
   port: number;
 }>;
 type AppRouterPrerenderSeeder = (serverDir: string) => Promise<number>;
@@ -102,5 +101,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 };
-//# sourceMappingURL=prod-server.d.ts.map
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };

package/dist/server/prod-server.js

@@ -1135,5 +1135,3 @@ async function startPagesRouterServer(options) {
 }
 //#endregion
 export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
-
-//# sourceMappingURL=prod-server.js.map