vinext 0.0.52 → 0.0.54

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

@@ -1,6 +1,6 @@
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { pagesRouter } from "../routing/pages-router.js";
-import { normalizePathSeparators } from "./runtime-entry-module.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { findFileWithExts } from "./pages-entry-helpers.js";
 //#region src/entries/pages-client-entry.ts
 /**
@@ -14,10 +14,11 @@ import { findFileWithExts } from "./pages-entry-helpers.js";
 *
 * Extracted from index.ts.
 */
-async function generateClientEntry(pagesDir, nextConfig, fileMatcher) {
+async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options = {}) {
 	const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
 	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
 	const hasApp = appFilePath !== null;
+	const appPrefetchRoutes = options.appPrefetchRoutes ?? [];
 	const loaderEntries = pageRoutes.map((r) => {
 		const absPath = normalizePathSeparators(r.filePath);
 		const nextFormatPattern = patternToNextFormat(r.pattern);
@@ -46,6 +47,42 @@ import { wrapWithRouterContext } from "next/router";
 const pageLoaders = {
 ${loaderEntries.join(",\n")}
 };
+${hasApp ? `
+const appLoader = () => import(${JSON.stringify(appFileBase)});
+` : `
+const appLoader = undefined;
+`}
+// Expose the code-split loader manifest on window so client-side
+// _next/data navigations in shims/router.ts can resolve the correct page
+// chunk for any route. Without this, navigateClient() would have to extract
+// the chunk URL from an HTML response — the whole point of switching to the
+// JSON data endpoint is to avoid that round trip.
+//
+// Keys are route patterns in Next.js bracket format (matching __NEXT_DATA__.page
+// and the keys of pageLoaders above). The patterns list is the same as
+// Object.keys(pageLoaders), exposed separately so navigateClient() can iterate
+// it without re-keying the map. Ordering is the insertion order of pageRoutes,
+// which pagesRouter() has already sorted by specificity (static → dynamic →
+// catch-all → optional catch-all) via compareRoutes — so matchPagesPattern()
+// can iterate in order and trust the first match.
+window.__VINEXT_PAGE_LOADERS__ = pageLoaders;
+window.__VINEXT_PAGE_PATTERNS__ = Object.keys(pageLoaders);
+window.__VINEXT_APP_LOADER__ = appLoader;
+// Expose the App Router prefetch manifest so Pages Router \`<Link>\`s and
+// \`Router.prefetch\` can detect when a prefetch target is actually an App
+// Router route, and mark it on \`Router.components[urlPathname]\` with
+// \`{ __appRouter: true }\`. Mirrors Next.js's \`_bfl\`-driven marker write at
+// .nextjs-ref/packages/next/src/shared/lib/router/router.ts:2525, which the
+// Next.js deploy test
+//   test/e2e/app-dir/app/index.test.ts → "should successfully detect app
+//   route during prefetch"
+// asserts via \`window.next.router.components[<path>]\`. Issue #1526.
+//
+// In a hybrid Pages + App Router build, this entry runs when the user lands
+// on a Pages Router page. The App Router browser entry sets the same global
+// when the user lands on an App Router page (see app-browser-entry.ts) — the
+// two writes do not race because only one entry executes per page load.
+window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(appPrefetchRoutes)};
 
 async function hydrate() {
   const nextData = window.__NEXT_DATA__;
@@ -71,7 +108,7 @@ async function hydrate() {
   let element;
   ${hasApp ? `
   try {
-    const appModule = await import(${JSON.stringify(appFileBase)});
+    const appModule = await appLoader();
     const AppComponent = appModule.default;
     window.__VINEXT_APP__ = AppComponent;
     element = React.createElement(AppComponent, { Component: PageComponent, pageProps });

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

@@ -1 +1 @@
-{"version":3,"file":"pages-client-entry.js","names":["pagesPatternToNextFormat"],"sources":["../../src/entries/pages-client-entry.ts"],"sourcesContent":["/**\n * Pages Router client hydration entry generator.\n *\n * Generates the virtual client entry module (`virtual:vinext-client-entry`).\n * This is the entry point for `vite build` (client bundle). It maps route\n * patterns to dynamic imports of page modules so Vite code-splits each page\n * into its own chunk. At runtime it reads __NEXT_DATA__ to determine which\n * page to hydrate.\n *\n * Extracted from index.ts.\n */\nimport {\n  pagesRouter,\n  patternToNextFormat as pagesPatternToNextFormat,\n  type Route,\n} from \"../routing/pages-router.js\";\nimport { createValidFileMatcher } from \"../routing/file-matcher.js\";\nimport { type ResolvedNextConfig } from \"../config/next-config.js\";\nimport { findFileWithExts } from \"./pages-entry-helpers.js\";\nimport { normalizePathSeparators } from \"./runtime-entry-module.js\";\n\nexport async function generateClientEntry(\n  pagesDir: string,\n  nextConfig: ResolvedNextConfig,\n  fileMatcher: ReturnType<typeof createValidFileMatcher>,\n): Promise<string> {\n  const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);\n\n  const appFilePath = findFileWithExts(pagesDir, \"_app\", fileMatcher);\n  const hasApp = appFilePath !== null;\n\n  // Build a map of route pattern -> dynamic import.\n  // Keys must use Next.js bracket format (e.g. \"/user/[id]\") to match\n  // __NEXT_DATA__.page which is set via patternToNextFormat() during SSR.\n  const loaderEntries = pageRoutes.map((r: Route) => {\n    const absPath = normalizePathSeparators(r.filePath);\n    const nextFormatPattern = pagesPatternToNextFormat(r.pattern);\n    // JSON.stringify safely escapes quotes, backslashes, and special chars in\n    // both the route pattern and the absolute file path.\n    // lgtm[js/bad-code-sanitization]\n    return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;\n  });\n\n  const appFileBase = appFilePath ? normalizePathSeparators(appFilePath) : undefined;\n\n  return `\nimport \"vinext/instrumentation-client\";\nimport React from \"react\";\nimport { hydrateRoot } from \"react-dom/client\";\nimport { installPagesRouterRuntime } from \"vinext/pages-router-runtime\";\n// Statically import next/router as the very first vinext shim so that\n// (a) installWindowNext runs at top-level — \\`window.next.router\\` is\n//     available to test harnesses and third-party scripts BEFORE\n//     hydrate() resolves (see .nextjs-ref/packages/next/src/client/next.ts\n//     line 13, which also sets window.next as a top-level side effect),\n// and (b) the popstate handler is registered before\n//     installPagesRouterRuntime() runs, removing the race window where a\n//     popstate event could fire between hydration and runtime install.\n//\n// Mirrors Next.js's bootstrap order: client/next.ts statically imports\n// from './' before calling initialize/hydrate, so window.next is set up\n// before any async work.\nimport { wrapWithRouterContext } from \"next/router\";\n\nconst pageLoaders = {\n${loaderEntries.join(\",\\n\")}\n};\n\nasync function hydrate() {\n  const nextData = window.__NEXT_DATA__;\n  if (!nextData) {\n    console.error(\"[vinext] No __NEXT_DATA__ found\");\n    return;\n  }\n\n  const { pageProps } = nextData.props;\n  const loader = pageLoaders[nextData.page];\n  if (!loader) {\n    console.error(\"[vinext] No page loader for route:\", nextData.page);\n    return;\n  }\n\n  const pageModule = await loader();\n  const PageComponent = pageModule.default;\n  if (!PageComponent) {\n    console.error(\"[vinext] Page module has no default export\");\n    return;\n  }\n\n  let element;\n  ${\n    hasApp\n      ? `\n  try {\n    const appModule = await import(${JSON.stringify(appFileBase!)});\n    const AppComponent = appModule.default;\n    window.__VINEXT_APP__ = AppComponent;\n    element = React.createElement(AppComponent, { Component: PageComponent, pageProps });\n  } catch {\n    element = React.createElement(PageComponent, pageProps);\n  }\n  `\n      : `\n  element = React.createElement(PageComponent, pageProps);\n  `\n  }\n\n  // Wrap with RouterContext.Provider so next/router and next/compat/router work during hydration.\n  element = wrapWithRouterContext(element);\n\n  const container = document.getElementById(\"__next\");\n  if (!container) {\n    console.error(\"[vinext] No #__next element found\");\n    return;\n  }\n\n  const root = hydrateRoot(container, element);\n  window.__VINEXT_ROOT__ = root;\n  installPagesRouterRuntime();\n  const hydratedAt = performance.now();\n  window.__VINEXT_HYDRATED_AT = hydratedAt;\n  window.__NEXT_HYDRATED = true;\n  window.__NEXT_HYDRATED_AT = hydratedAt;\n  window.__NEXT_HYDRATED_CB?.();\n}\n\nhydrate();\n`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,eAAsB,oBACpB,UACA,YACA,aACiB;CACjB,MAAM,aAAa,MAAM,YAAY,UAAU,YAAY,gBAAgB,YAAY;CAEvF,MAAM,cAAc,iBAAiB,UAAU,QAAQ,YAAY;CACnE,MAAM,SAAS,gBAAgB;CAK/B,MAAM,gBAAgB,WAAW,KAAK,MAAa;EACjD,MAAM,UAAU,wBAAwB,EAAE,SAAS;EACnD,MAAM,oBAAoBA,oBAAyB,EAAE,QAAQ;EAI7D,OAAO,KAAK,KAAK,UAAU,kBAAkB,CAAC,iBAAiB,KAAK,UAAU,QAAQ,CAAC;GACvF;CAEF,MAAM,cAAc,cAAc,wBAAwB,YAAY,GAAG,KAAA;CAEzE,OAAO;;;;;;;;;;;;;;;;;;;;EAoBP,cAAc,KAAK,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IA0BxB,SACI;;qCAE6B,KAAK,UAAU,YAAa,CAAC;;;;;;;MAQ1D;;IAGL"}
+{"version":3,"file":"pages-client-entry.js","names":["pagesPatternToNextFormat"],"sources":["../../src/entries/pages-client-entry.ts"],"sourcesContent":["/**\n * Pages Router client hydration entry generator.\n *\n * Generates the virtual client entry module (`virtual:vinext-client-entry`).\n * This is the entry point for `vite build` (client bundle). It maps route\n * patterns to dynamic imports of page modules so Vite code-splits each page\n * into its own chunk. At runtime it reads __NEXT_DATA__ to determine which\n * page to hydrate.\n *\n * Extracted from index.ts.\n */\nimport {\n  pagesRouter,\n  patternToNextFormat as pagesPatternToNextFormat,\n  type Route,\n} from \"../routing/pages-router.js\";\nimport { createValidFileMatcher } from \"../routing/file-matcher.js\";\nimport { type ResolvedNextConfig } from \"../config/next-config.js\";\nimport type { VinextLinkPrefetchRoute } from \"../client/vinext-next-data.js\";\nimport { findFileWithExts } from \"./pages-entry-helpers.js\";\nimport { normalizePathSeparators } from \"../utils/path.js\";\n\nexport async function generateClientEntry(\n  pagesDir: string,\n  nextConfig: ResolvedNextConfig,\n  fileMatcher: ReturnType<typeof createValidFileMatcher>,\n  options: { appPrefetchRoutes?: readonly VinextLinkPrefetchRoute[] } = {},\n): Promise<string> {\n  const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);\n\n  const appFilePath = findFileWithExts(pagesDir, \"_app\", fileMatcher);\n  const hasApp = appFilePath !== null;\n  const appPrefetchRoutes = options.appPrefetchRoutes ?? [];\n\n  // Build a map of route pattern -> dynamic import.\n  // Keys must use Next.js bracket format (e.g. \"/user/[id]\") to match\n  // __NEXT_DATA__.page which is set via patternToNextFormat() during SSR.\n  const loaderEntries = pageRoutes.map((r: Route) => {\n    const absPath = normalizePathSeparators(r.filePath);\n    const nextFormatPattern = pagesPatternToNextFormat(r.pattern);\n    // JSON.stringify safely escapes quotes, backslashes, and special chars in\n    // both the route pattern and the absolute file path.\n    // lgtm[js/bad-code-sanitization]\n    return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;\n  });\n\n  const appFileBase = appFilePath ? normalizePathSeparators(appFilePath) : undefined;\n\n  return `\nimport \"vinext/instrumentation-client\";\nimport React from \"react\";\nimport { hydrateRoot } from \"react-dom/client\";\nimport { installPagesRouterRuntime } from \"vinext/pages-router-runtime\";\n// Statically import next/router as the very first vinext shim so that\n// (a) installWindowNext runs at top-level — \\`window.next.router\\` is\n//     available to test harnesses and third-party scripts BEFORE\n//     hydrate() resolves (see .nextjs-ref/packages/next/src/client/next.ts\n//     line 13, which also sets window.next as a top-level side effect),\n// and (b) the popstate handler is registered before\n//     installPagesRouterRuntime() runs, removing the race window where a\n//     popstate event could fire between hydration and runtime install.\n//\n// Mirrors Next.js's bootstrap order: client/next.ts statically imports\n// from './' before calling initialize/hydrate, so window.next is set up\n// before any async work.\nimport { wrapWithRouterContext } from \"next/router\";\n\nconst pageLoaders = {\n${loaderEntries.join(\",\\n\")}\n};\n${\n  hasApp\n    ? `\nconst appLoader = () => import(${JSON.stringify(appFileBase!)});\n`\n    : `\nconst appLoader = undefined;\n`\n}\n// Expose the code-split loader manifest on window so client-side\n// _next/data navigations in shims/router.ts can resolve the correct page\n// chunk for any route. Without this, navigateClient() would have to extract\n// the chunk URL from an HTML response — the whole point of switching to the\n// JSON data endpoint is to avoid that round trip.\n//\n// Keys are route patterns in Next.js bracket format (matching __NEXT_DATA__.page\n// and the keys of pageLoaders above). The patterns list is the same as\n// Object.keys(pageLoaders), exposed separately so navigateClient() can iterate\n// it without re-keying the map. Ordering is the insertion order of pageRoutes,\n// which pagesRouter() has already sorted by specificity (static → dynamic →\n// catch-all → optional catch-all) via compareRoutes — so matchPagesPattern()\n// can iterate in order and trust the first match.\nwindow.__VINEXT_PAGE_LOADERS__ = pageLoaders;\nwindow.__VINEXT_PAGE_PATTERNS__ = Object.keys(pageLoaders);\nwindow.__VINEXT_APP_LOADER__ = appLoader;\n// Expose the App Router prefetch manifest so Pages Router \\`<Link>\\`s and\n// \\`Router.prefetch\\` can detect when a prefetch target is actually an App\n// Router route, and mark it on \\`Router.components[urlPathname]\\` with\n// \\`{ __appRouter: true }\\`. Mirrors Next.js's \\`_bfl\\`-driven marker write at\n// .nextjs-ref/packages/next/src/shared/lib/router/router.ts:2525, which the\n// Next.js deploy test\n//   test/e2e/app-dir/app/index.test.ts → \"should successfully detect app\n//   route during prefetch\"\n// asserts via \\`window.next.router.components[<path>]\\`. Issue #1526.\n//\n// In a hybrid Pages + App Router build, this entry runs when the user lands\n// on a Pages Router page. The App Router browser entry sets the same global\n// when the user lands on an App Router page (see app-browser-entry.ts) — the\n// two writes do not race because only one entry executes per page load.\nwindow.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(appPrefetchRoutes)};\n\nasync function hydrate() {\n  const nextData = window.__NEXT_DATA__;\n  if (!nextData) {\n    console.error(\"[vinext] No __NEXT_DATA__ found\");\n    return;\n  }\n\n  const { pageProps } = nextData.props;\n  const loader = pageLoaders[nextData.page];\n  if (!loader) {\n    console.error(\"[vinext] No page loader for route:\", nextData.page);\n    return;\n  }\n\n  const pageModule = await loader();\n  const PageComponent = pageModule.default;\n  if (!PageComponent) {\n    console.error(\"[vinext] Page module has no default export\");\n    return;\n  }\n\n  let element;\n  ${\n    hasApp\n      ? `\n  try {\n    const appModule = await appLoader();\n    const AppComponent = appModule.default;\n    window.__VINEXT_APP__ = AppComponent;\n    element = React.createElement(AppComponent, { Component: PageComponent, pageProps });\n  } catch {\n    element = React.createElement(PageComponent, pageProps);\n  }\n  `\n      : `\n  element = React.createElement(PageComponent, pageProps);\n  `\n  }\n\n  // Wrap with RouterContext.Provider so next/router and next/compat/router work during hydration.\n  element = wrapWithRouterContext(element);\n\n  const container = document.getElementById(\"__next\");\n  if (!container) {\n    console.error(\"[vinext] No #__next element found\");\n    return;\n  }\n\n  const root = hydrateRoot(container, element);\n  window.__VINEXT_ROOT__ = root;\n  installPagesRouterRuntime();\n  const hydratedAt = performance.now();\n  window.__VINEXT_HYDRATED_AT = hydratedAt;\n  window.__NEXT_HYDRATED = true;\n  window.__NEXT_HYDRATED_AT = hydratedAt;\n  window.__NEXT_HYDRATED_CB?.();\n}\n\nhydrate();\n`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAsBA,eAAsB,oBACpB,UACA,YACA,aACA,UAAsE,EAAE,EACvD;CACjB,MAAM,aAAa,MAAM,YAAY,UAAU,YAAY,gBAAgB,YAAY;CAEvF,MAAM,cAAc,iBAAiB,UAAU,QAAQ,YAAY;CACnE,MAAM,SAAS,gBAAgB;CAC/B,MAAM,oBAAoB,QAAQ,qBAAqB,EAAE;CAKzD,MAAM,gBAAgB,WAAW,KAAK,MAAa;EACjD,MAAM,UAAU,wBAAwB,EAAE,SAAS;EACnD,MAAM,oBAAoBA,oBAAyB,EAAE,QAAQ;EAI7D,OAAO,KAAK,KAAK,UAAU,kBAAkB,CAAC,iBAAiB,KAAK,UAAU,QAAQ,CAAC;GACvF;CAEF,MAAM,cAAc,cAAc,wBAAwB,YAAY,GAAG,KAAA;CAEzE,OAAO;;;;;;;;;;;;;;;;;;;;EAoBP,cAAc,KAAK,MAAM,CAAC;;EAG1B,SACI;iCAC2B,KAAK,UAAU,YAAa,CAAC;IAExD;;EAGL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CA+B0C,KAAK,UAAU,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;IAyBzE,SACI;;;;;;;;;MAUA;;IAGL"}

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

@@ -1,5 +1,6 @@
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
-import { normalizePathSeparators, resolveEntryPath } from "./runtime-entry-module.js";
+import { normalizePathSeparators } from "../utils/path.js";
+import { resolveEntryPath } from "./runtime-entry-module.js";
 import { isProxyFile } from "../server/middleware.js";
 import { findFileWithExts } from "./pages-entry-helpers.js";
 //#region src/entries/pages-server-entry.ts
@@ -18,7 +19,9 @@ const _routeTriePath = resolveEntryPath("../routing/route-trie.js", import.meta.
 const _pagesI18nPath = resolveEntryPath("../server/pages-i18n.js", import.meta.url);
 const _pagesPageResponsePath = resolveEntryPath("../server/pages-page-response.js", import.meta.url);
 const _pagesPageDataPath = resolveEntryPath("../server/pages-page-data.js", import.meta.url);
+const _pagesPageMethodPath = resolveEntryPath("../server/pages-page-method.js", import.meta.url);
 const _pagesDataRoutePath = resolveEntryPath("../server/pages-data-route.js", import.meta.url);
+const _pagesDefault404Path = resolveEntryPath("../server/pages-default-404.js", import.meta.url);
 const _pagesNodeCompatPath = resolveEntryPath("../server/pages-node-compat.js", import.meta.url);
 const _pagesApiRoutePath = resolveEntryPath("../server/pages-api-route.js", import.meta.url);
 const _isrCachePath = resolveEntryPath("../server/isr-cache.js", import.meta.url);
@@ -46,9 +49,12 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 	const apiRouteEntries = apiRoutes.map((r, i) => `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: api_${i} }`);
 	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
 	const docFilePath = findFileWithExts(pagesDir, "_document", fileMatcher);
+	const errorFilePath = findFileWithExts(pagesDir, "_error", fileMatcher);
 	const appAssetPathJson = appFilePath !== null ? JSON.stringify(normalizePathSeparators(appFilePath)) : "null";
 	const appImportCode = appFilePath !== null ? `import { default as AppComponent } from ${JSON.stringify(normalizePathSeparators(appFilePath))};` : `const AppComponent = null;`;
 	const docImportCode = docFilePath !== null ? `import { default as DocumentComponent } from ${JSON.stringify(normalizePathSeparators(docFilePath))};` : `const DocumentComponent = null;`;
+	const errorAssetPathJson = errorFilePath !== null ? JSON.stringify(normalizePathSeparators(errorFilePath)) : "null";
+	const errorImportCode = errorFilePath !== null ? `import * as ErrorPageModule from ${JSON.stringify(normalizePathSeparators(errorFilePath))};` : `const ErrorPageModule = null;`;
 	const i18nConfigJson = nextConfig?.i18n ? JSON.stringify({
 		locales: nextConfig.i18n.locales,
 		defaultLocale: nextConfig.i18n.defaultLocale,
@@ -69,6 +75,8 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 		headers: nextConfig?.headers ?? [],
 		expireTime: nextConfig?.expireTime,
 		i18n: nextConfig?.i18n ?? null,
+		disableOptimizedLoading: nextConfig?.disableOptimizedLoading === true,
+		clientTraceMetadata: nextConfig?.clientTraceMetadata,
 		images: {
 			deviceSizes: nextConfig?.images?.deviceSizes,
 			imageSizes: nextConfig?.images?.imageSizes,
@@ -93,19 +101,44 @@ if (typeof _instrumentation.onRequestError === "function") {
 	const middlewareImportCode = middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};` : "";
 	const middlewareExportCode = middlewarePath ? `
 export async function runMiddleware(request, ctx, options) {
-  return __runGeneratedMiddleware({
+  // Auto-detect /_next/data/<buildId>/<page>.json requests so user-written
+  // worker entries don't need to know about the data endpoint protocol.
+  // Mismatched buildId → JSON 404 short-circuit. Matched → middleware sees
+  // the normalized page path via the request URL, and the worker sees the
+  // normalized URL via result.rewriteUrl (if middleware didn't already
+  // rewrite to something else).
+  const __dataNorm = __normalizePagesDataRequest(request);
+  if (__dataNorm.notFoundResponse) {
+    return { continue: false, response: __dataNorm.notFoundResponse };
+  }
+  const __result = await __runGeneratedMiddleware({
     basePath: vinextConfig.basePath,
     ctx,
     i18nConfig,
-    isDataRequest: options?.isDataRequest === true,
+    isDataRequest: options?.isDataRequest === true || __dataNorm.isDataReq,
     isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
     module: middlewareModule,
-    request,
+    request: __dataNorm.request,
     trailingSlash: vinextConfig.trailingSlash,
   });
+  if (__dataNorm.isDataReq && __result.continue && !__result.rewriteUrl && !__result.redirectUrl) {
+    return { ...__result, rewriteUrl: __dataNorm.normalizedPathname + __dataNorm.search };
+  }
+  return __result;
 }
 ` : `
-export async function runMiddleware() { return { continue: true }; }
+export async function runMiddleware(request) {
+  // Even without user middleware, the data-endpoint URL must be normalized so
+  // the worker pipeline sees the page path. Mismatched buildId → JSON 404.
+  const __dataNorm = __normalizePagesDataRequest(request);
+  if (__dataNorm.notFoundResponse) {
+    return { continue: false, response: __dataNorm.notFoundResponse };
+  }
+  if (__dataNorm.isDataReq) {
+    return { continue: true, rewriteUrl: __dataNorm.normalizedPathname + __dataNorm.search };
+  }
+  return { continue: true };
+}
 `;
 	return `
 import ${JSON.stringify(_serverGlobalsPath)};
@@ -142,7 +175,9 @@ import {
 } from ${JSON.stringify(_isrCachePath)};
 import { getScriptNonceFromHeaderSources as __getScriptNonceFromHeaderSources } from ${JSON.stringify(_cspPath)};
 import { resolvePagesPageData as __resolvePagesPageData } from ${JSON.stringify(_pagesPageDataPath)};
-import { buildNextDataJsonResponse as __buildNextDataJsonResponse, buildNextDataNotFoundResponse as __buildNextDataNotFoundResponse } from ${JSON.stringify(_pagesDataRoutePath)};
+import { resolvePagesPageMethodResponse as __resolvePagesPageMethodResponse } from ${JSON.stringify(_pagesPageMethodPath)};
+import { buildNextDataJsonResponse as __buildNextDataJsonResponse, buildNextDataNotFoundResponse as __buildNextDataNotFoundResponse, isNextDataPathname as __isNextDataPathname, parseNextDataPathname as __parseNextDataPathname } from ${JSON.stringify(_pagesDataRoutePath)};
+import { buildDefaultPagesNotFoundResponse as __buildDefaultPagesNotFoundResponse } from ${JSON.stringify(_pagesDefault404Path)};
 import { renderPagesPageResponse as __renderPagesPageResponse } from ${JSON.stringify(_pagesPageResponsePath)};
 ${instrumentationImportCode}
 ${middlewareImportCode}
@@ -156,6 +191,7 @@ const i18nConfig = ${i18nConfigJson};
 // match _next/data requests against the embedded buildId without needing
 // to load next.config.js at runtime.
 export const buildId = ${buildIdJson};
+const __hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
 
 // Full resolved config for production server (embedded at build time)
 export const vinextConfig = ${vinextConfigJson};
@@ -178,6 +214,40 @@ function isrCacheKey(router, pathname) {
   return __sharedIsrCacheKey(router, pathname, buildId || undefined);
 }
 
+/**
+ * Detect and normalize /_next/data/<buildId>/<page>.json requests in one
+ * place so user-written worker entries don't need to know about the data
+ * endpoint protocol. Returns the normalized request (with the page path as
+ * its URL), an isDataReq flag, and notFoundResponse when the buildId in
+ * the URL does not match this server's buildId — callers should return that
+ * response immediately so a stale client falls back to a hard navigation.
+ */
+function __normalizePagesDataRequest(request) {
+  const reqUrl = new URL(request.url);
+  if (!__isNextDataPathname(reqUrl.pathname)) {
+    return { isDataReq: false, request, normalizedPathname: null, search: "", notFoundResponse: null };
+  }
+  const dataMatch = buildId ? __parseNextDataPathname(reqUrl.pathname, buildId) : null;
+  if (!dataMatch) {
+    return {
+      isDataReq: false,
+      request,
+      normalizedPathname: null,
+      search: "",
+      notFoundResponse: __buildNextDataNotFoundResponse(),
+    };
+  }
+  const normalizedUrl = new URL(reqUrl);
+  normalizedUrl.pathname = dataMatch.pagePathname;
+  return {
+    isDataReq: true,
+    request: new Request(normalizedUrl, request),
+    normalizedPathname: dataMatch.pagePathname,
+    search: reqUrl.search,
+    notFoundResponse: null,
+  };
+}
+
 async function renderToStringAsync(element) {
   const stream = await renderToReadableStream(element);
   await stream.allReady;
@@ -204,11 +274,22 @@ ${apiImports.join("\n")}
 
 ${appImportCode}
 ${docImportCode}
+${errorImportCode}
 
 export const pageRoutes = [
 ${pageRouteEntries.join(",\n")}
 ];
 const _pageRouteTrie = _buildRouteTrie(pageRoutes);
+const _errorPageRoute = ErrorPageModule
+  ? {
+      pattern: "/_error",
+      patternParts: ["_error"],
+      isDynamic: false,
+      params: [],
+      module: ErrorPageModule,
+      filePath: ${errorAssetPathJson},
+    }
+  : null;
 
 const apiRoutes = [
 ${apiRouteEntries.join(",\n")}
@@ -240,7 +321,14 @@ export function matchPageRoute(url, request) {
 }
 
 function parseQuery(url) {
-  const qs = url.split("?")[1];
+  // Per RFC 3986 only the first "?" separates path from query, so additional
+  // "?" chars belong to the query string (e.g. /linker?href=/about?hello=world
+  // has query "href=/about?hello=world"). split("?")[1] would drop everything
+  // after the second "?" and strip embedded query strings from values.
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) return {};
+  const hashIndex = url.indexOf("#", queryIndex + 1);
+  const qs = hashIndex === -1 ? url.slice(queryIndex + 1) : url.slice(queryIndex + 1, hashIndex);
   if (!qs) return {};
   const p = new URLSearchParams(qs);
   const q = {};
@@ -268,14 +356,39 @@ function patternToNextFormat(pattern) {
     .replace(/:([^\\/]+?)(?=\\/|$)/g, "[$1]");
 }
 
-function collectAssetTags(manifest, moduleIds, scriptNonce) {
+function resolveSsrManifest(manifest) {
   // Fall back to embedded manifest (set by vinext:cloudflare-build for Workers)
-  const m = (manifest && Object.keys(manifest).length > 0)
+  return (manifest && Object.keys(manifest).length > 0)
     ? manifest
     : (typeof globalThis !== "undefined" && globalThis.__VINEXT_SSR_MANIFEST__) || null;
+}
+
+function getManifestFilesForModule(manifest, moduleId) {
+  if (!manifest || !moduleId) return null;
+
+  var files = manifest[moduleId];
+  if (files) return files;
+
+  for (var key in manifest) {
+    if (moduleId.endsWith("/" + key) || moduleId === key) {
+      return manifest[key];
+    }
+  }
+  return null;
+}
+
+function collectAssetTags(manifest, moduleIds, scriptNonce) {
+  const m = resolveSsrManifest(manifest);
   const tags = [];
   const seen = new Set();
   const nonceAttr = __createNonceAttribute(scriptNonce);
+  // Mirrors Next.js \`_document\` behaviour: when \`experimental.disableOptimizedLoading\`
+  // is false (the default), page scripts are emitted with \`defer\` in <head>. See
+  // .nextjs-ref/packages/next/src/pages/_document.tsx getScripts() — \`defer={!disableOptimizedLoading}\`.
+  // vinext always emits \`type="module"\` (which already defers implicitly), but
+  // upstream tests (e.g. test/e2e/optimized-loading) assert the literal \`defer\`
+  // attribute, and adding it preserves parity without changing browser behaviour.
+  const deferAttr = vinextConfig.disableOptimizedLoading ? "" : " defer";
 
   // Load the set of lazy chunk filenames (only reachable via dynamic imports).
   // These should NOT get <link rel="modulepreload"> or <script type="module">
@@ -289,7 +402,7 @@ function collectAssetTags(manifest, moduleIds, scriptNonce) {
     const entry = globalThis.__VINEXT_CLIENT_ENTRY__;
     seen.add(entry);
     tags.push('<link rel="modulepreload"' + nonceAttr + ' href="/' + entry + '" />');
-    tags.push('<script type="module"' + nonceAttr + ' src="/' + entry + '" crossorigin><\/script>');
+    tags.push('<script type="module"' + deferAttr + nonceAttr + ' src="/' + entry + '" crossorigin><\/script>');
   }
   if (m) {
     // Always inject shared chunks (framework, vinext runtime, entry) and
@@ -305,18 +418,7 @@ function collectAssetTags(manifest, moduleIds, scriptNonce) {
       // Collect assets for the requested page modules
       for (var mi = 0; mi < moduleIds.length; mi++) {
         var id = moduleIds[mi];
-        var files = m[id];
-        if (!files) {
-          // Absolute path didn't match — try matching by suffix.
-          // Manifest keys are relative (e.g. "pages/about.tsx") while
-          // moduleIds may be absolute (e.g. "/home/.../pages/about.tsx").
-          for (var mk in m) {
-            if (id.endsWith("/" + mk) || id === mk) {
-              files = m[mk];
-              break;
-            }
-          }
-        }
+        var files = getManifestFilesForModule(m, id);
         if (files) {
           for (var fi = 0; fi < files.length; fi++) allFiles.push(files[fi]);
         }
@@ -370,20 +472,55 @@ function collectAssetTags(manifest, moduleIds, scriptNonce) {
         // (React.lazy, next/dynamic) and should only be fetched on demand.
         if (lazySet && lazySet.has(tf)) continue;
         tags.push('<link rel="modulepreload"' + nonceAttr + ' href="/' + tf + '" />');
-        tags.push('<script type="module"' + nonceAttr + ' src="/' + tf + '" crossorigin><\/script>');
+        tags.push('<script type="module"' + deferAttr + nonceAttr + ' src="/' + tf + '" crossorigin><\/script>');
       }
     }
   }
   return tags.join("\\n  ");
 }
 
+function resolveClientModuleUrl(manifest, moduleId) {
+  const files = getManifestFilesForModule(resolveSsrManifest(manifest), moduleId);
+  if (!files) return undefined;
+  for (var i = 0; i < files.length; i++) {
+    var file = files[i];
+    if (!file || !file.endsWith(".js")) continue;
+    if (file.charAt(0) !== "/") file = "/" + file;
+    return file;
+  }
+  return undefined;
+}
+
 export async function renderPage(request, url, manifest, ctx, middlewareHeaders, options) {
   if (ctx) return _runWithExecutionContext(ctx, () => _renderPage(request, url, manifest, middlewareHeaders, options));
   return _renderPage(request, url, manifest, middlewareHeaders, options);
 }
 
 async function _renderPage(request, url, manifest, middlewareHeaders, options) {
-  const isDataReq = !!(options && options.isDataReq);
+  let isDataReq = !!(options && options.isDataReq);
+  // Auto-detect /_next/data/... requests by inspecting the incoming request
+  // URL. The worker pipeline does not need to know about the data endpoint
+  // protocol — when it forwards an unrewritten data URL as the url arg, we
+  // normalize it to the page path here.
+  if (!isDataReq) {
+    const __dataNorm = __normalizePagesDataRequest(request);
+    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 : undefined;
+  const asPath = options && typeof options.asPath === "string" ? options.asPath : undefined;
+  const renderErrorPageOnMiss = !(options && options.renderErrorPageOnMiss === false);
+  // Guard against infinite recursion when the user's custom 500/error page
+  // itself throws during render. When this flag is set, the catch block below
+  // returns the plain "Internal Server Error" text response instead of trying
+  // to render an error page again. Fixes #1458.
+  const isInternalErrorRender = !!(options && options.__isInternalErrorRender);
   const localeInfo = i18nConfig
     ? resolvePagesI18nRequest(
         url,
@@ -405,13 +542,35 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
     return new Response(null, { status: 307, headers: { Location: localeInfo.redirectUrl } });
   }
 
-  const match = matchRoute(routeUrl, pageRoutes);
+  // Internal error render path: caller has pinned a specific route (the
+  // user's pages/500 or pages/_error) to render in response to an SSR throw.
+  // Skip route matching so we don't accidentally double-route, and skip the
+  // missing-route 404 fallback. See catch block below. Fixes #1458.
+  let match = options && options.__forcedRoute
+    ? { route: options.__forcedRoute, params: {} }
+    : matchRoute(routeUrl, pageRoutes);
+  let renderStatusCodeOverride = statusCode;
+  let renderAsPath = asPath;
   if (!match) {
     if (isDataReq) {
       return __buildNextDataNotFoundResponse();
     }
-    return new Response("<!DOCTYPE html><html><body><h1>404 - Page not found</h1></body></html>",
-      { status: 404, headers: { "Content-Type": "text/html" } });
+    if (!renderErrorPageOnMiss) {
+      return __buildDefaultPagesNotFoundResponse();
+    }
+    const notFoundMatch = matchRoute("/404", pageRoutes);
+    // matchRoute may match a catch-all (e.g. [...slug]); only use the explicit pages/404 route.
+    if (notFoundMatch && notFoundMatch.route.pattern === "/404") {
+      match = notFoundMatch;
+      renderStatusCodeOverride = 404;
+      renderAsPath = routeUrl;
+    } else if (_errorPageRoute) {
+      match = { route: _errorPageRoute, params: {} };
+      renderStatusCodeOverride = 404;
+      renderAsPath = routeUrl;
+    } else {
+      return __buildDefaultPagesNotFoundResponse();
+    }
   }
 
   const { route, params } = match;
@@ -422,12 +581,13 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
     ensureFetchPatch();
     try {
       const routePattern = patternToNextFormat(route.pattern);
+      const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : undefined);
       const query = mergeRouteParamsIntoQuery(parseQuery(routeUrl), params);
       if (typeof setSSRContext === "function") {
         setSSRContext({
           pathname: routePattern,
           query,
-          asPath: routeUrl,
+          asPath: renderAsPath || routeUrl,
           locale: locale,
           locales: i18nConfig ? i18nConfig.locales : undefined,
           defaultLocale: currentDefaultLocale,
@@ -450,6 +610,31 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
       if (!PageComponent) {
         return new Response("Page has no default export", { status: 500 });
       }
+
+      // Refs #1463: reject non-GET/HEAD methods on static (no
+      // getServerSideProps) Pages routes with 405 + Allow: GET, HEAD.
+      // Skip for error/status pages (/_error, /404, /500), data requests
+      // (those go through the JSON envelope path and have their own shape),
+      // and renders that are already an error-page miss-render override.
+      // Mirrors Next.js's base-server.ts L2277 carve-outs.
+      if (
+        !isDataReq &&
+        routePattern !== "/_error" &&
+        routePattern !== "/404" &&
+        routePattern !== "/500" &&
+        renderStatusCodeOverride === undefined
+      ) {
+        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);
       // Build font Link header early so it's available for ISR cached responses too.
       // Font preloads are module-level state populated at import time and persist across requests.
@@ -470,7 +655,7 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
             setSSRContext({
               pathname: routePattern,
               query,
-              asPath: routeUrl,
+              asPath: renderAsPath || routeUrl,
               locale: locale,
               locales: i18nConfig ? i18nConfig.locales : undefined,
               defaultLocale: currentDefaultLocale,
@@ -508,6 +693,13 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
         isrGet,
         isrSet,
         expireSeconds: vinextConfig.expireTime,
+        // The vinext build phase boots the prod server with VINEXT_PRERENDER=1
+        // and fetches every statically-generated page through it. That hit is
+        // the "build" prerender for revalidateReason; runtime hits are not.
+        // Mirrors Next.js's \`renderOpts.isBuildTimePrerendering\`. See
+        // \`.nextjs-ref/packages/next/src/server/render.tsx\` and
+        // \`packages/vinext/src/build/prerender.ts\`.
+        isBuildTimePrerendering: typeof process !== "undefined" && process.env && process.env.VINEXT_PRERENDER === "1",
         pageModule,
         params,
         query,
@@ -529,12 +721,21 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
         safeJsonStringify,
         sanitizeDestination: sanitizeDestinationLocal,
         scriptNonce,
+        statusCode: renderStatusCode,
         triggerBackgroundRegeneration,
+        vinext: {
+          pageModuleUrl,
+          appModuleUrl,
+          hasMiddleware: __hasMiddleware,
+        },
       });
       if (pageDataResult.kind === "response") {
         return pageDataResult.response;
       }
       let pageProps = pageDataResult.pageProps;
+      if (routePattern === "/_error" && typeof renderStatusCode === "number") {
+        pageProps = { ...pageProps, statusCode: renderStatusCode };
+      }
       var gsspRes = pageDataResult.gsspRes;
       let isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
       const isFallbackRender = pageDataResult.isFallback === true;
@@ -547,7 +748,7 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
         setSSRContext({
           pathname: routePattern,
           query,
-          asPath: routeUrl,
+          asPath: renderAsPath || routeUrl,
           locale: locale,
           locales: i18nConfig ? i18nConfig.locales : undefined,
           defaultLocale: currentDefaultLocale,
@@ -564,14 +765,33 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
       // cookies set on the gsspRes by getServerSideProps are forwarded so
       // middleware/auth flows work the same as the HTML page.
       if (isDataReq) {
-        const init = {};
-        if (gsspRes && gsspRes.headers) {
-          init.headers = {};
-          for (const [k, v] of Object.entries(gsspRes.headers)) {
+        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 === undefined || v === null) continue;
             init.headers[k] = Array.isArray(v) ? v.join(", ") : String(v);
           }
         }
+        if (gsspRes) {
+          // Default Cache-Control for gSSP-driven _next/data responses,
+          // matching Next.js's pages-handler.ts (revalidate: 0 →
+          // getCacheControlHeader). Skip when gSSP already set one via
+          // res.setHeader (case-insensitive). Mirrors the HTML branch in
+          // pages-page-response.ts and the dev-server branch. Fixes #1461.
+          var 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);
       }
 
@@ -624,6 +844,7 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
           }
         },
         getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : undefined,
+        clientTraceMetadata: vinextConfig.clientTraceMetadata,
         gsspRes,
         isrCacheKey,
         expireSeconds: vinextConfig.expireTime,
@@ -649,6 +870,12 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
         routeUrl,
         safeJsonStringify,
         scriptNonce,
+        statusCode: renderStatusCode,
+        vinext: {
+          pageModuleUrl,
+          appModuleUrl,
+          hasMiddleware: __hasMiddleware,
+        },
       });
     } catch (e) {
       console.error("[vinext] SSR error:", e);
@@ -657,6 +884,37 @@ async function _renderPage(request, url, manifest, middlewareHeaders, options) {
         { path: url, method: request.method, headers: Object.fromEntries(request.headers.entries()) },
         { routerKind: "Pages Router", routePath: route.pattern, routeType: "render" },
       ).catch(() => { /* ignore reporting errors */ });
+      // Data (_next/data) requests can't render HTML, and avoid recursion if
+      // we're already in the middle of rendering the error page itself.
+      // Mirrors Next.js base-server.ts which renders /500 (or _error) when
+      // SSR throws. Fixes #1458.
+      if (!isInternalErrorRender && !isDataReq) {
+        // Look for an explicit pages/500.tsx first, then fall back to _error.
+        // Only match the literal /500 pattern — never a catch-all/dynamic route.
+        let errorRoute = null;
+        for (var __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,
+            });
+          } catch (errorPageErr) {
+            console.error("[vinext] Error page render failed:", errorPageErr);
+          }
+        }
+      }
       return new Response("Internal Server Error", { status: 500 });
     }
   });