vinext 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/config/request-context.d.ts

@@ -0,0 +1,14 @@
+//#region src/config/request-context.d.ts
+/** Request context needed for evaluating has/missing conditions. */
+type RequestContext = {
+  readonly headers: Headers;
+  readonly cookies: Record<string, string>;
+  readonly query: URLSearchParams;
+  readonly host: string;
+};
+declare function parseCookies(cookieHeader: string | null): Record<string, string>;
+declare function normalizeHost(hostHeader: string | null, fallbackHostname: string): string;
+/** Build a lazily parsed request context from a Web Request. */
+declare function requestContextFromRequest(request: Request): RequestContext;
+//#endregion
+export { RequestContext, normalizeHost, parseCookies, requestContextFromRequest };

package/dist/config/request-context.js

@@ -0,0 +1,26 @@
+import { parseCookieHeader } from "../utils/parse-cookie.js";
+//#region src/config/request-context.ts
+function parseCookies(cookieHeader) {
+	return parseCookieHeader(cookieHeader);
+}
+function normalizeHost(hostHeader, fallbackHostname) {
+	return (hostHeader ?? fallbackHostname).split(":", 1)[0].toLowerCase();
+}
+/** Build a lazily parsed request context from a Web Request. */
+function requestContextFromRequest(request) {
+	const url = new URL(request.url);
+	let cookies;
+	let query;
+	return {
+		headers: request.headers,
+		get cookies() {
+			return cookies ??= parseCookies(request.headers.get("cookie"));
+		},
+		get query() {
+			return query ??= url.searchParams;
+		},
+		host: normalizeHost(request.headers.get("host"), url.hostname)
+	};
+}
+//#endregion
+export { normalizeHost, parseCookies, requestContextFromRequest };

package/dist/entries/app-browser-entry.d.ts

@@ -15,15 +15,9 @@ declare function generateBrowserEntry(routes?: readonly AppRoute[], routeManifes
   beforeFiles: NextRewrite[];
   fallback: NextRewrite[];
 }): string;
-/**
- * Filter for routes that should appear in the `__VINEXT_LINK_PREFETCH_ROUTES__`
- * manifest. Exported so the Pages Router client entry can reuse it when
- * emitting the same manifest for hybrid builds — see issue #1526 and
- * `pages-client-entry.ts`.
- */
-declare function isLinkPrefetchRoute(route: AppRoute): boolean;
-declare function toDocumentOnlyAppRoute(route: AppRoute): VinextLinkPrefetchRoute;
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
-declare function toLinkPrefetchRoute(route: AppRoute): VinextLinkPrefetchRoute;
+declare function toLinkPrefetchRoute(route: AppRoute, hasSiblingInterceptLoading?: boolean): VinextLinkPrefetchRoute;
+/** Project App routes together so sibling-intercept loading is applied to its target route. */
+declare function toLinkPrefetchRoutes(routes: readonly AppRoute[]): VinextLinkPrefetchRoute[];
 //#endregion
-export { generateBrowserEntry, isLinkPrefetchRoute, toDocumentOnlyAppRoute, toLinkPrefetchRoute };
+export { generateBrowserEntry, toLinkPrefetchRoute, toLinkPrefetchRoutes };

package/dist/entries/app-browser-entry.js

@@ -1,4 +1,5 @@
 import { resolveClientRuntimeModule, resolveRuntimeEntryModule } from "./runtime-entry-module.js";
+import { patternsStructurallyEquivalent } from "../routing/app-route-graph.js";
 //#region src/entries/app-browser-entry.ts
 /**
 * Generate the virtual browser entry module.
@@ -14,7 +15,7 @@ function generateBrowserEntry(routes = [], routeManifest = null, pagesPrefetchRo
 }) {
 	const entryPath = resolveRuntimeEntryModule("app-browser-entry");
 	const navigationRuntimePath = resolveClientRuntimeModule("navigation-runtime");
-	const prefetchRoutes = routes.map((route) => isLinkPrefetchRoute(route) ? toLinkPrefetchRoute(route) : toDocumentOnlyAppRoute(route));
+	const prefetchRoutes = toLinkPrefetchRoutes(routes);
 	return `import { registerNavigationRuntimeBootstrap } from ${JSON.stringify(navigationRuntimePath)};
 
 window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(prefetchRoutes)};
@@ -50,15 +51,30 @@ function toDocumentOnlyAppRoute(route) {
 function requiresDynamicNavigationRequest(route) {
 	return route.isDynamic && route.parallelSlots.length > 0;
 }
+function splitPatternParts(pattern) {
+	return pattern.split("/").filter(Boolean);
+}
+function interceptTargetsRoute(interceptTargetPattern, route) {
+	return patternsStructurallyEquivalent(splitPatternParts(interceptTargetPattern), route.patternParts);
+}
+function hasLoadingBoundary(route, hasSiblingInterceptLoading) {
+	return route.loadingPath !== null || (route.loadingPaths?.length ?? 0) > 0 || route.parallelSlots.some((slot) => slot.loadingPath !== null || (slot.loadingPaths?.length ?? 0) > 0 || slot.interceptingRoutes.some((intercept) => interceptTargetsRoute(intercept.targetPattern, route) && (intercept.loadingPaths?.length ?? 0) > 0)) || hasSiblingInterceptLoading;
+}
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
-function toLinkPrefetchRoute(route) {
+function toLinkPrefetchRoute(route, hasSiblingInterceptLoading = route.siblingIntercepts.some((intercept) => interceptTargetsRoute(intercept.targetPattern, route) && (intercept.loadingPaths?.length ?? 0) > 0)) {
 	return {
-		canPrefetchLoadingShell: route.loadingPath !== null,
+		canPrefetchLoadingShell: hasLoadingBoundary(route, hasSiblingInterceptLoading),
 		patternParts: [...route.patternParts],
 		isDynamic: route.isDynamic,
 		...requiresDynamicNavigationRequest(route) ? { requiresDynamicNavigationRequest: true } : {}
 	};
 }
+/** Project App routes together so sibling-intercept loading is applied to its target route. */
+function toLinkPrefetchRoutes(routes) {
+	const siblingInterceptLoadingTargets = [];
+	for (const route of routes) for (const intercept of route.siblingIntercepts) if ((intercept.loadingPaths?.length ?? 0) > 0) siblingInterceptLoadingTargets.push(splitPatternParts(intercept.targetPattern));
+	return routes.map((route) => isLinkPrefetchRoute(route) ? toLinkPrefetchRoute(route, siblingInterceptLoadingTargets.some((targetParts) => patternsStructurallyEquivalent(targetParts, route.patternParts))) : toDocumentOnlyAppRoute(route));
+}
 function buildRouteManifestExpression(routeManifest) {
 	if (routeManifest === null) return "null";
 	const graph = routeManifest.segmentGraph;
@@ -84,4 +100,4 @@ function buildMapExpression(map) {
 	return `new Map(${JSON.stringify(Array.from(map.entries()))})`;
 }
 //#endregion
-export { generateBrowserEntry, isLinkPrefetchRoute, toDocumentOnlyAppRoute, toLinkPrefetchRoute };
+export { generateBrowserEntry, toLinkPrefetchRoute, toLinkPrefetchRoutes };

package/dist/entries/app-rsc-entry.js

@@ -195,6 +195,7 @@ import {
   isrGet as __isrGet,
   isrSet as __isrSet,
   isrSetPrerenderedAppPage as __isrSetPrerenderedAppPage,
+  isOnDemandRevalidateRequest as __isOnDemandRevalidateRequest,
   triggerBackgroundRegeneration as __triggerBackgroundRegeneration,
 } from ${JSON.stringify(isrCachePath)};
 // Import server-only state module to register ALS-backed accessors.
@@ -401,6 +402,10 @@ function matchRoute(url) {
   return __routeMatcher.matchRoute(url);
 }
 
+function matchRequestRoute(url) {
+  return __routeMatcher.matchRequestRoute(url);
+}
+
 /**
  * Check if a pathname matches any intercepting route.
  * Returns the match info or null.
@@ -432,6 +437,8 @@ async function buildPageElements(route, params, routePath, pageRequest, layoutPa
 }
 
 const __i18nConfig = ${JSON.stringify(i18nConfig)};
+export { __i18nConfig };
+export const authorizeOnDemandRevalidate = __isOnDemandRevalidateRequest;
 const __configRedirects = ${JSON.stringify(redirects)};
 const __configRewrites = ${JSON.stringify(rewrites)};
 const __configHeaders = ${JSON.stringify(headers)};
@@ -523,6 +530,7 @@ export default createAppRscHandler({
     actionFailed,
     handlerStart,
     interceptionContext,
+    interceptionPathname,
     isProgressiveActionRender,
     isRscRequest,
     middlewareContext,
@@ -589,6 +597,7 @@ export default createAppRscHandler({
           observeMetadataSearchParamsAccess: buildOptions?.observeMetadataSearchParamsAccess === true,
           observePageSearchParamsAccess: buildOptions?.observePageSearchParamsAccess === true,
           serveStreamingMetadata: buildOptions?.serveStreamingMetadata,
+          isProduction: process.env.NODE_ENV === "production",
         }, layoutParamAccess, displayPathname);
       },
       clientReuseManifest,
@@ -608,7 +617,10 @@ export default createAppRscHandler({
       fetchCache: __segmentConfig.fetchCache ?? null,
       isEdgeRuntime: __isEdgeRuntime(__segmentConfig.runtime),
       findIntercept(pathname) {
-        return findIntercept(pathname, interceptionContext);
+        return findIntercept(
+          pathname === cleanPathname ? interceptionPathname : pathname,
+          interceptionContext,
+        );
       },
       generateStaticParams: __generateStaticParams,
       getFontLinks: _getSSRFontLinks,
@@ -660,7 +672,7 @@ export default createAppRscHandler({
         });
       },
       async probePage(probeSearchParams = searchParams) {
-        const __probeIntercept = findIntercept(cleanPathname, interceptionContext);
+        const __probeIntercept = findIntercept(interceptionPathname, interceptionContext);
         // The intercepting-route page module is lazy (page: null + __pageLoader).
         // Resolve it before probing so buildAppPageProbes inspects the real page
         // component for dynamic bailout — matching the render path, which also
@@ -682,7 +694,7 @@ export default createAppRscHandler({
         }));
       },
       renderErrorBoundaryPage(renderErr, errorOrigin) {
-        const __activeIntercept = findIntercept(cleanPathname, interceptionContext);
+        const __activeIntercept = findIntercept(interceptionPathname, interceptionContext);
         return __fallbackRenderer.renderErrorBoundary(route, renderErr, isRscRequest, request, params, scriptNonce, middlewareContext, {
           isEdgeRuntime: __isEdgeRuntime(__segmentConfig.runtime),
           sourcePageSegments: __activeIntercept?.slotKey === __SIBLING_PAGE_INTERCEPT_SLOT_KEY
@@ -691,9 +703,10 @@ export default createAppRscHandler({
         }, errorOrigin);
       },
       renderHttpAccessFallbackPage(statusCode, opts, currentMiddlewareContext) {
-        const __activeIntercept = findIntercept(cleanPathname, interceptionContext);
+        const __activeIntercept = findIntercept(interceptionPathname, interceptionContext);
         return __fallbackRenderer.renderHttpAccessFallback(route, statusCode, isRscRequest, request, opts, scriptNonce, currentMiddlewareContext, {
           isEdgeRuntime: __isEdgeRuntime(__segmentConfig.runtime),
+          routePathname: cleanPathname,
           sourcePageSegments: __activeIntercept?.slotKey === __SIBLING_PAGE_INTERCEPT_SLOT_KEY
             ? __activeIntercept.sourcePageSegments
             : null,
@@ -772,6 +785,7 @@ export default createAppRscHandler({
     contentType,
     middlewareContext,
     request,
+    routeMatch,
   }) {
     const {
       handleProgressiveServerActionRequest: __handleProgressiveServerActionRequest,
@@ -792,11 +806,10 @@ export default createAppRscHandler({
       contentType,
       actionId,
     );
-    const __progressiveActionMatch = __isProgressiveAction ? matchRoute(cleanPathname) : null;
     const __hasPageRoute = Boolean(
-      __progressiveActionMatch &&
-        __progressiveActionMatch.route.__loadPage &&
-        !__progressiveActionMatch.route.__loadRouteHandler,
+      __isProgressiveAction &&
+        routeMatch?.route.__loadPage &&
+        !routeMatch.route.__loadRouteHandler,
     );
     return __handleProgressiveServerActionRequest({
       actionId,
@@ -829,6 +842,8 @@ export default createAppRscHandler({
     middlewareContext,
     mountedSlotsHeader,
     request,
+    routeMatch,
+    routePathname,
     searchParams,
   }) {
     const {
@@ -836,7 +851,7 @@ export default createAppRscHandler({
       readActionBodyWithLimit: __readBodyWithLimit,
       readActionFormDataWithLimit: __readFormDataWithLimit,
     } = await __loadAppServerActionExecution();
-    const __actionMatch = matchRoute(cleanPathname);
+    const __actionMatch = routeMatch;
     if (__actionMatch) await __ensureRouteLoaded(__actionMatch.route);
     const __actionIsEdgeRuntime = __actionMatch
       ? __isEdgeRuntime(__resolveRouteRuntime(__actionMatch.route))
@@ -876,6 +891,8 @@ export default createAppRscHandler({
         __clearRequestContext();
       },
       contentType,
+      currentRouteMatch: __actionMatch,
+      currentRoutePathname: routePathname,
       createNotFoundElement(actionRouteId) {
         return {
           ...__AppElementsWire.createMetadataEntries({
@@ -940,6 +957,9 @@ export default createAppRscHandler({
           interceptLayouts: intercept.interceptLayouts,
           interceptLayoutSegments: intercept.interceptLayoutSegments,
           interceptBranchSegments: intercept.interceptBranchSegments,
+          interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
+          interceptNotFound: intercept.notFound,
+          interceptNotFoundTreePosition: intercept.notFoundTreePosition,
           interceptSlotId: intercept.slotId,
           interceptSlotKey: intercept.slotKey,
           interceptSourceMatchedUrl: interceptionContext,
@@ -963,6 +983,7 @@ export default createAppRscHandler({
     });
   },` : ""}
   matchRoute,
+  matchRequestRoute,
   ${middlewarePath ? `runMiddleware({ cleanPathname, context, hadBasePath, isDataRequest, request }) {
     return __applyAppMiddleware({
       basePath: __basePath,

package/dist/entries/app-rsc-manifest.js

@@ -53,6 +53,7 @@ function registerRouteModules(routes, imports) {
 		for (const layout of route.layouts) imports.getLazyLoaderVar(layout);
 		for (const tmpl of route.templates) imports.getLazyLoaderVar(tmpl);
 		if (route.loadingPath) imports.getLazyLoaderVar(route.loadingPath);
+		for (const loadingPath of route.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 		if (route.errorPath) imports.getLazyLoaderVar(route.errorPath);
 		if (route.layoutErrorPaths) {
 			for (const ep of route.layoutErrorPaths) if (ep) imports.getLazyLoaderVar(ep);
@@ -76,15 +77,21 @@ function registerRouteModules(routes, imports) {
 			if (slot.layoutPath) imports.getLazyLoaderVar(slot.layoutPath);
 			for (const layoutPath of slot.configLayoutPaths ?? []) imports.getLazyLoaderVar(layoutPath);
 			if (slot.loadingPath) imports.getLazyLoaderVar(slot.loadingPath);
+			for (const loadingPath of slot.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 			if (slot.errorPath) imports.getLazyLoaderVar(slot.errorPath);
+			if (slot.notFoundPath) imports.getLazyLoaderVar(slot.notFoundPath);
 			for (const ir of slot.interceptingRoutes) {
 				imports.getLazyLoaderVar(ir.pagePath);
+				if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
 				for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
+				for (const loadingPath of ir.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 			}
 		}
 		for (const ir of route.siblingIntercepts ?? []) {
 			imports.getLazyLoaderVar(ir.pagePath);
+			if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
 			for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
+			for (const loadingPath of ir.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 		}
 	}
 }
@@ -99,10 +106,12 @@ function buildRouteEntries(routes, imports) {
 		const staticSiblings = route.isDynamic ? computeAppRouteStaticSiblings(routes, route) : [];
 		const layoutLoaders = lazyLoaderArray(route.layouts, imports);
 		const templateLoaders = lazyLoaderArray(route.templates, imports);
+		const loadingPaths = route.loadingPaths ?? [];
 		const notFoundPaths = route.notFoundPaths ?? [];
 		const forbiddenPaths = route.forbiddenPaths ?? [];
 		const unauthorizedPaths = route.unauthorizedPaths ?? [];
 		const notFoundLoaders = lazyLoaderArray(notFoundPaths, imports);
+		const loadingLoaders = lazyLoaderArray(loadingPaths, imports);
 		const forbiddenLoaders = lazyLoaderArray(forbiddenPaths, imports);
 		const unauthorizedLoaders = lazyLoaderArray(unauthorizedPaths, imports);
 		const siblingInterceptEntries = (route.siblingIntercepts ?? []).map((ir) => `    {
@@ -115,8 +124,15 @@ function buildRouteEntries(routes, imports) {
       __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
       interceptLayoutSegments: ${JSON.stringify(ir.layoutSegments ?? [])},
       interceptBranchSegments: ${JSON.stringify(ir.branchSegments ?? [])},
+      interceptLoadings: ${moduleArray(ir.loadingPaths?.length ?? 0)},
+      __loadInterceptLoadings: ${lazyLoaderArray(ir.loadingPaths ?? [], imports)},
+      interceptLoadingTreePositions: ${JSON.stringify(ir.loadingTreePositions ?? [])},
+      interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
       page: null,
       __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
+      notFound: null,
+      __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
+      notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
       params: ${JSON.stringify(ir.params)},
     }`);
 		const slotEntries = route.parallelSlots.map((slot) => {
@@ -129,13 +145,21 @@ function buildRouteEntries(routes, imports) {
           __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
           interceptLayoutSegments: ${JSON.stringify(ir.layoutSegments ?? [])},
           interceptBranchSegments: ${JSON.stringify(ir.branchSegments ?? [])},
+          interceptLoadings: ${moduleArray(ir.loadingPaths?.length ?? 0)},
+          __loadInterceptLoadings: ${lazyLoaderArray(ir.loadingPaths ?? [], imports)},
+          interceptLoadingTreePositions: ${JSON.stringify(ir.loadingTreePositions ?? [])},
+          interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
           page: null,
           __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
+          notFound: null,
+          __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
+          notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
           params: ${JSON.stringify(ir.params)},
         }`);
 			return `      ${JSON.stringify(slot.key)}: {
         id: ${JSON.stringify(slot.id ?? null)},
         name: ${JSON.stringify(slot.name)},
+        ownerTreePosition: ${slot.ownerTreePosition ?? "null"},
         page: null,
         __loadPage: ${slot.pagePath ? imports.getLazyLoaderVar(slot.pagePath) : "null"},
         default: null,
@@ -147,8 +171,14 @@ function buildRouteEntries(routes, imports) {
         configLayoutTreePositions: ${JSON.stringify(slot.configLayoutTreePositions ?? [])},
         loading: null,
         __loadLoading: ${slot.loadingPath ? imports.getLazyLoaderVar(slot.loadingPath) : "null"},
+        loadings: ${moduleArray(slot.loadingPaths?.length ?? 0)},
+        __loadLoadings: ${lazyLoaderArray(slot.loadingPaths ?? [], imports)},
+        loadingTreePositions: ${JSON.stringify(slot.loadingTreePositions ?? [])},
         error: null,
         __loadError: ${slot.errorPath ? imports.getLazyLoaderVar(slot.errorPath) : "null"},
+        notFound: null,
+        __loadNotFound: ${slot.notFoundPath ? imports.getLazyLoaderVar(slot.notFoundPath) : "null"},
+        notFoundTreePosition: ${slot.notFoundTreePosition ?? "null"},
         layoutIndex: ${slot.layoutIndex},
         routeSegments: ${JSON.stringify(slot.routeSegments)},
         slotPatternParts: ${slot.slotPatternParts ? JSON.stringify(slot.slotPatternParts) : "null"},
@@ -186,6 +216,9 @@ ${interceptEntries.join(",\n")}
     layoutTreePositions: ${JSON.stringify(route.layoutTreePositions)},
     templates: ${moduleArray(route.templates.length)},
     __loadTemplates: ${templateLoaders},
+    loadings: ${moduleArray(loadingPaths.length)},
+    __loadLoadings: ${loadingLoaders},
+    loadingTreePositions: ${JSON.stringify(route.loadingTreePositions ?? null)},
     errors: ${moduleArray(layoutErrorPaths.length)},
     __loadErrors: ${layoutErrorLoaders},
     errorPaths: ${moduleArray(errorPaths.length)},
@@ -204,14 +237,17 @@ ${siblingInterceptEntries.join(",\n")}
     __loadError: ${route.errorPath ? imports.getLazyLoaderVar(route.errorPath) : "null"},
     notFound: null,
     __loadNotFound: ${route.notFoundPath ? imports.getLazyLoaderVar(route.notFoundPath) : "null"},
+    notFoundTreePosition: ${route.notFoundTreePosition ?? "null"},
     notFounds: ${moduleArray(notFoundPaths.length)},
     __loadNotFounds: ${notFoundLoaders},
     forbidden: null,
     __loadForbidden: ${route.forbiddenPath ? imports.getLazyLoaderVar(route.forbiddenPath) : "null"},
+    forbiddenTreePosition: ${route.forbiddenTreePosition ?? "null"},
     forbiddens: ${moduleArray(forbiddenPaths.length)},
     __loadForbiddens: ${forbiddenLoaders},
     unauthorized: null,
     __loadUnauthorized: ${route.unauthorizedPath ? imports.getLazyLoaderVar(route.unauthorizedPath) : "null"},
+    unauthorizedTreePosition: ${route.unauthorizedTreePosition ?? "null"},
     unauthorizeds: ${moduleArray(unauthorizedPaths.length)},
     __loadUnauthorizeds: ${unauthorizedLoaders},
   }`;

package/dist/entries/pages-client-entry.js

@@ -177,7 +177,6 @@ async function hydrate() {
     element = React.createElement(AppComponent, {
       ...props,
       Component: PageComponent,
-      pageProps: rawPageProps,
       router: Router,
     });
   } catch {

package/dist/entries/pages-server-entry.js

@@ -24,6 +24,7 @@ const _pagesApiRoutePath = resolveEntryPath("../server/pages-api-route.js", impo
 const _serverGlobalsPath = resolveEntryPath("../server/server-globals.js", import.meta.url);
 const _queryUtilsPath = resolveEntryPath("../utils/query.js", import.meta.url);
 const _pagesPageHandlerPath = resolveEntryPath("../server/pages-page-handler.js", import.meta.url);
+const _isrCachePath = resolveEntryPath("../server/isr-cache.js", import.meta.url);
 async function getPagesDataKind(filePath) {
 	const source = await readFile(filePath, "utf8");
 	if (hasExportedName(source, "getStaticProps")) return "static";
@@ -71,6 +72,7 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 		},
 		headers: nextConfig?.headers ?? [],
 		expireTime: nextConfig?.expireTime,
+		allowedRevalidateHeaderKeys: nextConfig?.allowedRevalidateHeaderKeys ?? [],
 		cacheMaxMemorySize: nextConfig?.cacheMaxMemorySize,
 		htmlLimitedBots: nextConfig?.htmlLimitedBots,
 		i18n: nextConfig?.i18n ?? null,
@@ -151,11 +153,17 @@ import { handlePagesApiRoute as __handlePagesApiRoute } from ${JSON.stringify(_p
 import { normalizePagesDataRequest as __normalizePagesDataRequest, buildNextDataNotFoundResponse as __buildNextDataNotFoundResponse } from ${JSON.stringify(_pagesDataRoutePath)};
 import { buildDefaultPagesNotFoundResponse as __buildDefaultPagesNotFoundResponse } from ${JSON.stringify(_pagesDefault404Path)};
 import { createPagesPageHandler as __createPagesPageHandler } from ${JSON.stringify(_pagesPageHandlerPath)};
+import { isOnDemandRevalidateRequest as __isOnDemandRevalidateRequest } from ${JSON.stringify(_isrCachePath)};
 ${instrumentationImportCode}
 ${middlewareImportCode}
 
 ${instrumentationInitCode}
 
+// The outer Node production pipeline runs outside this generated bundle, so
+// it cannot safely validate against its own development fallback secret. Give
+// it a verifier closed over this entry's build-time-baked secret instead.
+export const authorizeOnDemandRevalidate = __isOnDemandRevalidateRequest;
+
 // i18n config (embedded at build time)
 const i18nConfig = ${i18nConfigJson};
 
@@ -236,8 +244,8 @@ const _apiRouteTrie = _buildRouteTrie(apiRoutes);
 function matchRoute(url, routes) {
   const pathname = url.split("?")[0];
   let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\\/$/, "");
-  // NOTE: Do NOT decodeURIComponent here. The pathname is already decoded at
-  // the entry point. Decoding again would create a double-decode vector.
+  // Static route selection uses raw encoded identity (/%61bout must not
+  // select /about). _trieMatch decodes dynamic captures exactly once.
   const urlParts = normalizedUrl.split("/").filter(Boolean);
   const trie = routes === pageRoutes ? _pageRouteTrie : _apiRouteTrie;
   return _trieMatch(trie, urlParts);
@@ -307,6 +315,7 @@ const _renderPage = __createPagesPageHandler({
       : null,
   setI18nContext: typeof setI18nContext === "function" ? setI18nContext : null,
   wrapWithRouterContext: typeof wrapWithRouterContext === "function" ? wrapWithRouterContext : null,
+  router: Router,
   resetSSRHead: typeof resetSSRHead === "function" ? resetSSRHead : undefined,
   getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : undefined,
   setDocumentInitialHead: typeof setDocumentInitialHead === "function" ? setDocumentInitialHead : undefined,
@@ -343,7 +352,6 @@ const _renderPage = __createPagesPageHandler({
       ? React.createElement(AppComponent, {
           ...props,
           Component: PageComponent,
-          pageProps: rawPageProps,
           router: Router,
         })
       : React.createElement(PageComponent, pageProps);
@@ -361,7 +369,6 @@ const _renderPage = __createPagesPageHandler({
       ? React.createElement(FinalApp, {
           ...props,
           Component: FinalComp,
-          pageProps: rawPageProps,
           router: Router,
         })
       : React.createElement(FinalComp, pageProps);
@@ -378,7 +385,7 @@ export async function renderPage(request, url, manifest, ctx, middlewareHeaders,
 
 
 
-export async function handleApiRoute(request, url, ctx) {
+export async function handleApiRoute(request, url, ctx, trustedRevalidateOrigin) {
   __registerConfiguredCacheAdapters();
   const match = matchRoute(url, apiRoutes);
   return __handlePagesApiRoute({
@@ -386,6 +393,7 @@ export async function handleApiRoute(request, url, ctx) {
     match,
     nextConfig: vinextConfig,
     request,
+    trustedRevalidateOrigin,
     url,
     reportRequestError(error, routePattern) {
       console.error("[vinext] API error:", error);