vinext 0.1.8 → 0.2.0

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

@@ -197,6 +197,7 @@ type ResolvePagesPageDataOptions = {
 };
 type ResolvePagesPageDataRenderResult = {
   kind: "render";
+  documentReqRes: PagesGsspContextResponse | null;
   gsspRes: PagesGsspResponse | null;
   isrRevalidateSeconds: number | null;
   pageProps: Record<string, unknown>;
@@ -217,7 +218,29 @@ type ResolvePagesPageDataNotFoundResult = {
   kind: "notFound";
 };
 type ResolvePagesPageDataResult = ResolvePagesPageDataRenderResult | ResolvePagesPageDataResponseResult | ResolvePagesPageDataNotFoundResult;
+/**
+ * Compare a `getStaticPaths` entry against the actual request params.
+ *
+ * Handles both shapes Next.js allows:
+ *   - { params: { ... } }
+ *   - "string-path"
+ *
+ * For a string entry, compare the entry against the current request URL using
+ * the shared `normalizeStaticPathname` helper from
+ * `../routing/route-pattern.ts` (which mirrors the Next.js
+ * `removeTrailingSlash` behaviour in
+ * `.nextjs-ref/packages/next/src/build/static-paths/pages.ts`). For an object
+ * entry with a missing `params` key, return false rather than throwing — the
+ * caller will respond with a 404 just like Next.js does for unlisted paths.
+ */
+type PagesRouteParam = {
+  key: string;
+  repeat: boolean;
+  optional: boolean;
+};
+declare function getPagesRouteParams(routePattern: string): PagesRouteParam[];
+declare function matchesPagesStaticPath(pathEntry: PagesStaticPathsEntry, params: Record<string, unknown>, routeParams: PagesRouteParam[], routeUrl: string): boolean;
 declare function renderPagesIsrHtml(options: RenderPagesIsrHtmlOptions): Promise<string>;
 declare function resolvePagesPageData(options: ResolvePagesPageDataOptions): Promise<ResolvePagesPageDataResult>;
 //#endregion
-export { PagesPageModule, ResolvePagesPageDataOptions, renderPagesIsrHtml, resolvePagesPageData };
+export { PagesPageModule, PagesRouteParam, PagesStaticPathsEntry, ResolvePagesPageDataOptions, getPagesRouteParams, matchesPagesStaticPath, renderPagesIsrHtml, resolvePagesPageData };

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

@@ -1,15 +1,15 @@
 import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
-import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { decideIsr } from "./isr-decision.js";
 import { buildPagesCacheValue } from "./isr-cache.js";
-import { isSerializableProps } from "./pages-serializable-props.js";
+import { normalizeStaticPathname } from "../routing/route-pattern.js";
+import { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, requestsNoCache } from "./pages-page-response.js";
 import { hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { buildNextDataPropsJsonResponse } from "./pages-data-route.js";
-import { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, requestsNoCache } from "./pages-page-response.js";
+import { isSerializableProps } from "./pages-serializable-props.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 //#region src/server/pages-page-data.ts
 function buildPagesDataNotFoundResponse(deploymentId) {
 	const headers = { "Content-Type": "application/json" };
@@ -128,28 +128,45 @@ function buildPagesRedirectResponse(redirect, options, props = { pageProps: {} }
 		headers: { Location: destination }
 	});
 }
-/**
-* Compare a `getStaticPaths` entry against the actual request params.
-*
-* Handles both shapes Next.js allows:
-*   - { params: { ... } }
-*   - "string-path"
-*
-* For a string entry, compare the entry against the current request URL using
-* the shared `normalizeStaticPathname` helper from
-* `../routing/route-pattern.ts` (which mirrors the Next.js
-* `removeTrailingSlash` behaviour in
-* `.nextjs-ref/packages/next/src/build/static-paths/pages.ts`). For an object
-* entry with a missing `params` key, return false rather than throwing — the
-* caller will respond with a 404 just like Next.js does for unlisted paths.
-*/
-function matchesPagesStaticPath(pathEntry, params, routeUrl) {
+function getPagesRouteParams(routePattern) {
+	return routePattern.split("/").map((segment) => {
+		const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+		if (optionalCatchAll) return {
+			key: optionalCatchAll[1],
+			repeat: true,
+			optional: true
+		};
+		const requiredCatchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+		if (requiredCatchAll) return {
+			key: requiredCatchAll[1],
+			repeat: true,
+			optional: false
+		};
+		const dynamic = segment.match(/^\[(.+)\]$/);
+		if (dynamic) return {
+			key: dynamic[1],
+			repeat: false,
+			optional: false
+		};
+		return null;
+	}).filter((param) => param !== null);
+}
+function matchesPagesStaticPath(pathEntry, params, routeParams, routeUrl) {
 	if (typeof pathEntry === "string") return normalizeStaticPathname(pathEntry) === normalizeStaticPathname(routeUrl);
 	const entryParams = pathEntry.params;
 	if (entryParams === void 0 || entryParams === null) return false;
-	return Object.entries(entryParams).every(([key, value]) => {
+	return routeParams.every(({ key, repeat, optional }) => {
+		if (!Object.hasOwn(entryParams, key)) return false;
+		let value = entryParams[key];
+		if (optional && (value === null || value === void 0 || value === false)) value = [];
+		if (repeat) {
+			if (!Array.isArray(value) || !optional && value.length === 0) return false;
+		} else if (typeof value !== "string") return false;
 		const actual = params[key];
-		if (Array.isArray(value)) return Array.isArray(actual) && value.join("/") === actual.join("/");
+		if (Array.isArray(value)) {
+			if (optional && value.length === 0 && actual === void 0) return true;
+			return Array.isArray(actual) && value.join("/") === actual.join("/");
+		}
 		return String(value) === String(actual);
 	});
 }
@@ -237,7 +254,9 @@ async function resolvePagesPageData(options) {
 			defaultLocale: options.i18n.defaultLocale ?? ""
 		});
 		const fallback = pathsResult?.fallback ?? false;
-		const isValidPath = (pathsResult?.paths ?? []).some((pathEntry) => matchesPagesStaticPath(pathEntry, options.params, options.routeUrl));
+		const paths = pathsResult?.paths ?? [];
+		const routeParams = getPagesRouteParams(options.routePattern);
+		const isValidPath = paths.some((pathEntry) => matchesPagesStaticPath(pathEntry, options.params, routeParams, options.routeUrl));
 		if (fallback === false && !isValidPath) return buildPagesNotFoundResult(options);
 		const isBotRequest = !!options.userAgent && isBotUserAgent(options.userAgent, options.htmlLimitedBots);
 		if (fallback === true && !isValidPath && !options.isDataReq && !isBotRequest) isFallback = true;
@@ -273,6 +292,7 @@ async function resolvePagesPageData(options) {
 			};
 			return {
 				kind: "render",
+				documentReqRes: sharedReqRes,
 				gsspRes: null,
 				isrRevalidateSeconds: null,
 				pageProps,
@@ -473,6 +493,7 @@ async function resolvePagesPageData(options) {
 	}
 	return {
 		kind: "render",
+		documentReqRes: sharedReqRes,
 		gsspRes,
 		isrRevalidateSeconds,
 		pageProps,
@@ -481,4 +502,4 @@ async function resolvePagesPageData(options) {
 	};
 }
 //#endregion
-export { renderPagesIsrHtml, resolvePagesPageData };
+export { getPagesRouteParams, matchesPagesStaticPath, renderPagesIsrHtml, resolvePagesPageData };

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

@@ -35,6 +35,7 @@ type VinextConfigSubset = {
   clientTraceMetadata?: readonly string[];
   disableOptimizedLoading: boolean;
 };
+declare function shouldEmitPagesClientTraceMetadata(pageModule: PagesPageModule, appComponent: unknown): boolean;
 /**
  * Options accepted by `createPagesPageHandler`.
  *
@@ -97,4 +98,4 @@ type RenderPageOptions = {
  */
 declare function createPagesPageHandler(opts: CreatePagesPageHandlerOptions): (request: Request, url: string, manifest: Record<string, string[]> | null | undefined, middlewareHeaders: Headers | null | undefined, options: RenderPageOptions | null | undefined) => Promise<Response>;
 //#endregion
-export { CreatePagesPageHandlerOptions, createPagesPageHandler };
+export { CreatePagesPageHandlerOptions, createPagesPageHandler, shouldEmitPagesClientTraceMetadata };

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

@@ -14,12 +14,18 @@ import { resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { buildPagesReadinessNextData } from "./pages-readiness.js";
 import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
+import { renderPagesPageResponse } from "./pages-page-response.js";
+import { hasPagesGetInitialProps } from "./pages-get-initial-props.js";
 import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
+import { resolvePagesPageData } from "./pages-page-data.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 shouldEmitPagesClientTraceMetadata(pageModule, appComponent) {
+	if (typeof pageModule.getServerSideProps === "function") return true;
+	if (typeof pageModule.getStaticProps === "function") return false;
+	return hasPagesGetInitialProps(pageModule.default) || hasPagesGetInitialProps(appComponent);
+}
 function buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales) {
 	return {
 		locale,
@@ -182,6 +188,12 @@ function createPagesPageHandler(opts) {
 					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + appendAssetDeploymentIdQuery(p.href) + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
 				} catch {}
 				const pagesResolvedUrl = (new URL(routeUrl, originalRequestUrl).pathname || "/") + originalRequestUrl.search;
+				const createPageReqRes = () => createPagesReqRes({
+					body: void 0,
+					query,
+					request,
+					url: originalRequestPathAndSearch
+				});
 				const pageDataResult = await resolvePagesPageData({
 					isDataReq,
 					err: err instanceof Error ? err : void 0,
@@ -189,14 +201,7 @@ function createPagesPageHandler(opts) {
 					buildId,
 					deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID,
 					htmlLimitedBots: vinextConfig.htmlLimitedBots,
-					createGsspReqRes() {
-						return createPagesReqRes({
-							body: void 0,
-							query,
-							request,
-							url: originalRequestPathAndSearch
-						});
-					},
+					createGsspReqRes: createPageReqRes,
 					createAppTree(appTreeProps) {
 						const el = createPageElement(PageComponent, AppComponent, appTreeProps);
 						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
@@ -264,6 +269,7 @@ function createPagesPageHandler(opts) {
 					};
 				}
 				const gsspRes = pageDataResult.gsspRes;
+				const documentReqRes = serializedPagesNextData.autoExport === true ? null : pageDataResult.documentReqRes ?? createPageReqRes();
 				const isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
 				const isFallbackRender = pageDataResult.isFallback === true;
 				if (isFallbackRender && typeof setSSRContext === "function") setSSRContext({
@@ -334,7 +340,8 @@ function createPagesPageHandler(opts) {
 					getFontLinks,
 					getFontStyles,
 					getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : void 0,
-					clientTraceMetadata: vinextConfig.clientTraceMetadata,
+					clientTraceMetadata: shouldEmitPagesClientTraceMetadata(pageModule, AppComponent) ? vinextConfig.clientTraceMetadata : void 0,
+					documentReqRes,
 					gsspRes,
 					isrCacheKey: pageIsrCacheKey,
 					expireSeconds: vinextConfig.expireTime,
@@ -400,4 +407,4 @@ function createPagesPageHandler(opts) {
 	return renderPage;
 }
 //#endregion
-export { createPagesPageHandler };
+export { createPagesPageHandler, shouldEmitPagesClientTraceMetadata };

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

@@ -45,9 +45,15 @@ type PagesI18nRenderContext = {
   domainLocales?: unknown;
 };
 type PagesGsspResponse = {
+  headersSent?: boolean;
   statusCode: number;
   getHeaders(): Record<string, string | number | boolean | string[]>;
 };
+type PagesDocumentReqRes = {
+  req: unknown;
+  res: PagesGsspResponse;
+  responsePromise?: Promise<Response>;
+};
 type RenderPagesPageResponseOptions = {
   assetTags: string;
   buildId: string | null;
@@ -80,6 +86,7 @@ type RenderPagesPageResponseOptions = {
    */
   clientTraceMetadata?: readonly string[] | undefined;
   setDocumentInitialHead?: ((head: ReactNode[]) => void) | undefined;
+  documentReqRes?: PagesDocumentReqRes | null;
   gsspRes: PagesGsspResponse | null;
   isrCacheKey: (router: string, pathname: string) => string;
   expireSeconds?: number;

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

@@ -197,11 +197,14 @@ async function renderPagesPageResponse(options) {
 		scriptNonce: options.scriptNonce,
 		context: {
 			err: options.err,
+			req: options.documentReqRes?.req,
+			res: options.documentReqRes?.res,
 			pathname: options.routePattern,
 			query: options.query ?? options.params,
 			asPath: options.routeUrl
 		}
 	});
+	if (options.documentReqRes?.res.headersSent && options.documentReqRes.responsePromise) return options.documentReqRes.responsePromise;
 	let bodyStream;
 	if (documentRenderPage.status === "rendered") bodyStream = new ReadableStream({ start(controller) {
 		controller.enqueue(new TextEncoder().encode(documentRenderPage.bodyHtml));
@@ -230,7 +233,7 @@ async function renderPagesPageResponse(options) {
 	const shellPrefix = shellHtml.slice(0, markerIndex);
 	const shellSuffix = shellHtml.slice(markerIndex + 25);
 	const responseHeaders = new Headers({ "Content-Type": "text/html" });
-	const finalStatus = applyGsspHeaders(responseHeaders, options.gsspRes, options.statusCode);
+	const finalStatus = applyGsspHeaders(responseHeaders, options.gsspRes ?? options.documentReqRes?.res ?? null, options.statusCode);
 	let responseBodyStream = bodyStream;
 	if (!options.scriptNonce && options.isrRevalidateSeconds !== null && options.isrRevalidateSeconds > 0) {
 		const cacheBodyStreamPair = bodyStream.tee();

package/dist/server/pages-request-pipeline.d.ts

@@ -34,11 +34,13 @@ type PagesPipelineDeps = {
   hadBasePath: boolean;
   isDataReq: boolean;
   isDataRequest: boolean;
+  hasMiddleware: boolean;
   ctx?: unknown;
   rawSearch?: string;
   matchPageRoute?: ((pathname: string, request: Request) => {
     route: {
       isDynamic: boolean;
+      pattern?: string;
     };
   } | null) | null;
   runMiddleware?: ((request: Request, ctx: unknown, opts: {

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

@@ -1,4 +1,5 @@
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
+import { patternToNextFormat } from "../routing/route-validation.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";
@@ -141,6 +142,13 @@ async function runPagesRequest(request, deps) {
 	});
 	let resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 	const matchResolvedPathname = (p) => i18nConfig ? normalizeDefaultLocalePathname(p, i18nConfig, { hostname: requestHostname }) : p;
+	const matchedPathnameForRoute = (routePattern) => {
+		const matchedPathname = routePattern ? patternToNextFormat(routePattern) : resolvedPathname;
+		if (!i18nConfig) return matchedPathname;
+		const resolvedLocale = resolvedPathname.split("/", 3)[1];
+		if (resolvedLocale && i18nConfig.locales.includes(resolvedLocale)) return matchedPathname === "/" ? `/${resolvedLocale}` : `/${resolvedLocale}${matchedPathname}`;
+		return matchResolvedPathname(matchedPathname);
+	};
 	if (configHeaders.length) applyConfigHeadersToHeaderRecord(middlewareHeaders, {
 		configHeaders,
 		pathname: matchPathname,
@@ -268,12 +276,28 @@ async function runPagesRequest(request, deps) {
 			if (fallbackFilesystemResult) return fallbackFilesystemResult;
 			const fallbackApiResult = await handleResolvedApiRoute();
 			if (fallbackApiResult) return fallbackApiResult;
+			renderPageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
 			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);
+		const matchedPathHeaders = { ...middlewareHeaders };
+		if ((isDataReq || isDataRequest) && deps.hasMiddleware && !renderPageMatch && response.status === 404 && (middlewareStatus === void 0 || middlewareStatus === 200 || middlewareStatus === 404)) {
+			const headers = new Headers(response.headers);
+			headers.set("content-type", "application/json");
+			headers.set("x-nextjs-matched-path", matchResolvedPathname(pathname));
+			return {
+				type: "response",
+				response: mergeHeaders(new Response("{}", {
+					status: 200,
+					headers
+				}), matchedPathHeaders, void 0),
+				defaultContentType: "application/json"
+			};
+		}
+		if ((isDataReq || isDataRequest) && renderPageMatch && (middlewareStatus ?? response.status) === 200) matchedPathHeaders["x-nextjs-matched-path"] = matchedPathnameForRoute(renderPageMatch?.route.pattern);
+		const merged = mergeHeaders(response, matchedPathHeaders, middlewareStatus);
 		if (merged !== response) merged.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
 		return {
 			type: "response",

package/dist/server/pages-router-entry.d.ts

@@ -0,0 +1,30 @@
+//#region src/server/pages-router-entry.d.ts
+/**
+ * Router-specific Cloudflare Worker entry point for vinext Pages Router.
+ *
+ * New projects should usually use the router-selected entry in wrangler.jsonc:
+ *   "main": "vinext/server/fetch-handler"
+ *
+ * This Pages Router entry remains available for existing configs and for custom
+ * workers that need to opt into the Pages Router handler explicitly:
+ *   "main": "vinext/server/pages-router-entry"
+ *
+ * Or import and delegate to it from a custom worker:
+ *   import handler from "vinext/server/pages-router-entry";
+ *   return handler.fetch(request, env, ctx);
+ */
+type AssetFetcher = {
+  fetch(request: Request): Promise<Response> | Response;
+};
+type PagesWorkerEnv = {
+  ASSETS?: AssetFetcher;
+} & Record<string, unknown>;
+type PagesWorkerExecutionContext = {
+  waitUntil?(promise: Promise<unknown>): void;
+  passThroughOnException?(): void;
+};
+declare const _default: {
+  fetch(request: Request, env?: PagesWorkerEnv, ctx?: PagesWorkerExecutionContext): Promise<Response>;
+};
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,108 @@
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { notFoundStaticAssetResponse } from "./http-error-responses.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { finalizeMissingStaticAssetResponse } from "./worker-utils.js";
+import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
+import * as pagesEntry from "virtual:vinext-server-entry";
+//#region src/server/pages-router-entry.ts
+/**
+* Router-specific Cloudflare Worker entry point for vinext Pages Router.
+*
+* New projects should usually use the router-selected entry in wrangler.jsonc:
+*   "main": "vinext/server/fetch-handler"
+*
+* This Pages Router entry remains available for existing configs and for custom
+* workers that need to opt into the Pages Router handler explicitly:
+*   "main": "vinext/server/pages-router-entry"
+*
+* Or import and delegate to it from a custom worker:
+*   import handler from "vinext/server/pages-router-entry";
+*   return handler.fetch(request, env, ctx);
+*/
+const { handleApiRoute, hasMiddleware, matchPageRoute, normalizeDataRequest, renderPage, runMiddleware, vinextConfig } = pagesEntry;
+const basePath = vinextConfig?.basePath ?? "";
+const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
+const trailingSlash = vinextConfig?.trailingSlash ?? false;
+const i18nConfig = vinextConfig?.i18n ?? null;
+const configRedirects = vinextConfig?.redirects ?? [];
+const configRewrites = vinextConfig?.rewrites ?? {
+	beforeFiles: [],
+	afterFiles: [],
+	fallback: []
+};
+const configHeaders = vinextConfig?.headers ?? [];
+const imageConfig = vinextConfig?.images ? {
+	qualities: vinextConfig.images.qualities,
+	dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
+	dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
+	contentDispositionType: vinextConfig.images.contentDispositionType,
+	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
+} : void 0;
+var pages_router_entry_default = { async fetch(request, env, ctx) {
+	return handleRequest(request, env, ctx);
+} };
+async function handleRequest(request, env, ctx) {
+	registerConfiguredCacheAdapters(env);
+	registerConfiguredImageOptimizer(env);
+	try {
+		let pathname = new URL(request.url).pathname;
+		if (isOpenRedirectShaped(pathname)) return new Response("This page could not be found", { status: 404 });
+		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
+		request = cloneRequestWithHeaders(request, filterInternalHeaders(request.headers));
+		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
+		{
+			const stripped = stripBasePath(pathname, basePath);
+			if (stripped !== pathname) {
+				const strippedUrl = new URL(request.url);
+				strippedUrl.pathname = stripped;
+				request = cloneRequestWithUrl(request, strippedUrl.toString());
+				pathname = stripped;
+			}
+		}
+		const dataNorm = normalizeDataRequest(request);
+		if (dataNorm.notFoundResponse) return dataNorm.notFoundResponse;
+		const isDataReq = dataNorm.isDataReq;
+		if (isDataReq) {
+			request = dataNorm.request;
+			pathname = dataNorm.normalizedPathname;
+		}
+		if (isImageOptimizationPath(pathname) && env?.ASSETS) {
+			const allowedWidths = [...vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES];
+			return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(env.ASSETS.fetch(new Request(new URL(assetPath, request.url)))), allowedWidths, imageConfig);
+		}
+		const deps = {
+			basePath,
+			trailingSlash,
+			i18nConfig,
+			configRedirects,
+			configRewrites,
+			configHeaders,
+			hadBasePath,
+			isDataReq,
+			isDataRequest: isDataReq,
+			hasMiddleware,
+			ctx,
+			matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
+			runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
+			renderPage: typeof renderPage === "function" ? (req, resolvedUrl, options, stagedHeaders) => renderPage(req, resolvedUrl, null, ctx, stagedHeaders, options) : null,
+			handleApi: typeof handleApiRoute === "function" ? (req, apiUrl) => handleApiRoute(req, apiUrl, ctx) : null,
+			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase) => {
+				if (!env?.ASSETS) return false;
+				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(env.ASSETS.fetch(assetRequest)));
+			}
+		};
+		const result = await runPagesRequest(request, deps);
+		if (result.type === "response") return finalizeMissingStaticAssetResponse(result.response, missingBuildAsset);
+		return missingBuildAsset ? notFoundStaticAssetResponse() : new Response("This page could not be found", { status: 404 });
+	} catch (error) {
+		console.error("[vinext] Worker error:", error);
+		return new Response("Internal Server Error", { status: 500 });
+	}
+}
+//#endregion
+export { pages_router_entry_default as default };

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

@@ -7,11 +7,13 @@ type PrerenderManifestRoute = {
   path?: string;
   router?: string;
   fallback?: boolean;
+  headers?: Record<string, string>;
 };
 type PrerenderManifest = {
   buildId?: string;
   trailingSlash?: boolean;
   routes?: PrerenderManifestRoute[];
+  pregeneratedConcretePaths?: Array<[string, string[]]>;
 };
 declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
 declare function getRenderedAppRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
@@ -30,4 +32,4 @@ declare function isFallbackShellArtifactPath(pathname: string, route?: Prerender
  */
 declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest): Array<[string, string[]]>;
 //#endregion
-export { buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };
+export { PrerenderManifest, buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };

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

@@ -1,4 +1,4 @@
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "./headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
 //#region src/server/prerender-route-params.ts
 function isPrerenderRouteParams(value) {

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

@@ -74,7 +74,7 @@ declare function mergeResponseHeaders(middlewareHeaders: Record<string, string |
  * arguments in (headers, response) order. The request path now calls
  * `runPagesRequest`, which uses `mergeHeaders` directly; this wrapper is retained
  * only for its existing tests and any external callers, so there is a single
- * implementation to keep in sync. (deploy.ts still emits its own generated copy.)
+ * implementation to keep in sync. The init-owned Cloudflare Worker template delegates here.
  */
 declare function mergeWebResponse(middlewareHeaders: Record<string, string | string[]>, response: Response, statusOverride?: number): Response;
 /**