vinext 0.1.3 → 0.1.4

package/dist/build/client-build-config.d.ts

@@ -7,6 +7,13 @@ type ClientAssetFileNameInfo = {
   readonly originalFileName?: string;
   readonly originalFileNames?: readonly string[];
 };
+type RscFrameworkModuleInfo = {
+  importers: string[];
+  isEntry: boolean;
+};
+type RscFrameworkManualChunksMeta = {
+  getModuleInfo(id: string): RscFrameworkModuleInfo | null;
+};
 /**
  * Routes client assets into Next-compatible subtrees: `.css` sources go to
  * `<assetsDir>/css/`, everything else to `<assetsDir>/media/`. Returned as a
@@ -80,18 +87,20 @@ declare function isRscFrameworkModule(id: string): boolean;
  * dedicated "framework" chunk in the RSC server build. Returns the bundler-
  * appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
  * `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
- * motivation (issue #1549).
+ * motivation (issue #1549). Framework modules that are only reachable through
+ * dynamic imports must stay out of the eager framework chunk (issue #2073).
  */
 declare function createRscFrameworkChunkOutputConfig(viteMajorVersion: number): {
   codeSplitting: {
     groups: {
       name: string;
       test: RegExp;
+      entriesAware: boolean;
     }[];
   };
   manualChunks?: undefined;
 } | {
-  manualChunks(id: string): string | undefined;
+  manualChunks(id: string, meta: RscFrameworkManualChunksMeta): string | undefined;
   codeSplitting?: undefined;
 };
 /**

package/dist/build/client-build-config.js

@@ -33,9 +33,10 @@ function createClientAssetFileNames(assetsDir) {
 * (node_modules/.pnpm/pkg@ver/node_modules/pkg).
 */
 function getPackageName(id) {
-	const nmIdx = id.lastIndexOf("node_modules/");
+	const normalizedId = id.replaceAll("\\", "/");
+	const nmIdx = normalizedId.lastIndexOf("node_modules/");
 	if (nmIdx === -1) return null;
-	const rest = id.slice(nmIdx + 13);
+	const rest = normalizedId.slice(nmIdx + 13);
 	if (rest.startsWith("@")) {
 		const parts = rest.split("/");
 		return parts.length >= 2 ? parts[0] + "/" + parts[1] : null;
@@ -153,20 +154,30 @@ function isRscFrameworkModule(id) {
 	const pkg = getPackageName(id);
 	return pkg !== null && FRAMEWORK_PACKAGES.includes(pkg);
 }
+function isStaticallyReachableFromEntry(id, meta, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(id)) return false;
+	visited.add(id);
+	const moduleInfo = meta.getModuleInfo(id);
+	if (!moduleInfo) return false;
+	if (moduleInfo.isEntry) return true;
+	return moduleInfo.importers.some((importer) => isStaticallyReachableFromEntry(importer, meta, visited));
+}
 /**
 * Output config that isolates React (and the RSC flight runtime) into a
 * dedicated "framework" chunk in the RSC server build. Returns the bundler-
 * appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
 * `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
-* motivation (issue #1549).
+* motivation (issue #1549). Framework modules that are only reachable through
+* dynamic imports must stay out of the eager framework chunk (issue #2073).
 */
 function createRscFrameworkChunkOutputConfig(viteMajorVersion) {
 	if (viteMajorVersion >= 8) return { codeSplitting: { groups: [{
 		name: "framework",
-		test: RSC_FRAMEWORK_CHUNK_TEST
+		test: RSC_FRAMEWORK_CHUNK_TEST,
+		entriesAware: true
 	}] } };
-	return { manualChunks(id) {
-		return isRscFrameworkModule(id) ? "framework" : void 0;
+	return { manualChunks(id, meta) {
+		return isRscFrameworkModule(id) && isStaticallyReachableFromEntry(id, meta) ? "framework" : void 0;
 	} };
 }
 /**

package/dist/build/prerender.js

@@ -659,6 +659,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				for (const params of paramSets) {
 					if (params === null || params === void 0) throw new Error(`generateStaticParams() for ${route.pattern} returned an entry with no params object.`);
 					const urlPath = buildUrlFromParams(route.pattern, params);
+					if (queuedRouteUrls.has(urlPath)) continue;
 					queuedRouteUrls.add(urlPath);
 					urlsToRender.push({
 						urlPath,

package/dist/client/pages-router-link-navigation.d.ts

@@ -3,23 +3,49 @@ type PagesRouterLinkTransitionOptions = {
   scroll?: boolean;
   shallow?: boolean;
   locale?: string | false;
+  _vinextInterpolateDynamicRoute?: boolean;
 };
 type PagesRouterLinkRuntime = {
   push(url: string, as?: string, options?: PagesRouterLinkTransitionOptions): Promise<boolean>;
   replace(url: string, as?: string, options?: PagesRouterLinkTransitionOptions): Promise<boolean>;
 };
+type PagesRouterLinkNavigation = {
+  href: string;
+  replace: boolean;
+  scroll: boolean;
+  shallow?: boolean;
+  locale?: string | false;
+  interpolateDynamicRoute?: boolean;
+};
+declare function resolvePagesRouterQueryOnlyHref(href: string, {
+  asPath,
+  basePath,
+  fallbackHref,
+  locales
+}: {
+  asPath?: string;
+  basePath: string;
+  fallbackHref: string;
+  locales?: readonly string[];
+}): string;
 declare function navigatePagesRouterLink(router: PagesRouterLinkRuntime, {
   href,
   replace,
   scroll,
   shallow,
-  locale
+  locale,
+  interpolateDynamicRoute
+}: PagesRouterLinkNavigation): Promise<void>;
+declare function navigatePagesRouterLinkWithFallback({
+  router,
+  loadRouter,
+  navigation,
+  fallback
 }: {
-  href: string;
-  replace: boolean;
-  scroll: boolean;
-  shallow?: boolean;
-  locale?: string | false;
+  router?: PagesRouterLinkRuntime;
+  loadRouter: () => Promise<PagesRouterLinkRuntime | undefined>;
+  navigation: PagesRouterLinkNavigation;
+  fallback: () => void;
 }): Promise<void>;
 //#endregion
-export { navigatePagesRouterLink };
+export { navigatePagesRouterLink, navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref };

package/dist/client/pages-router-link-navigation.js

@@ -1,12 +1,42 @@
+import { stripBasePath } from "../utils/base-path.js";
+import { getLocalePathPrefix } from "../utils/domain-locale.js";
 //#region src/client/pages-router-link-navigation.ts
-async function navigatePagesRouterLink(router, { href, replace, scroll, shallow, locale }) {
+function resolvePagesRouterQueryOnlyHref(href, { asPath, basePath, fallbackHref, locales }) {
+	if (!href.startsWith("?")) return href;
+	try {
+		const fallbackUrl = new URL(fallbackHref);
+		const base = new URL(asPath ?? `${stripBasePath(fallbackUrl.pathname, basePath)}${fallbackUrl.search}${fallbackUrl.hash}`, "http://vinext.local");
+		const locale = getLocalePathPrefix(base.pathname, locales);
+		if (locale) base.pathname = base.pathname.slice(locale.length + 1) || "/";
+		const resolved = new URL(href, base);
+		return resolved.href.slice(resolved.origin.length);
+	} catch {
+		return href;
+	}
+}
+async function navigatePagesRouterLink(router, { href, replace, scroll, shallow, locale, interpolateDynamicRoute = false }) {
 	const routerOptions = {
 		scroll,
 		locale
 	};
+	if (interpolateDynamicRoute) routerOptions._vinextInterpolateDynamicRoute = true;
 	if (shallow !== void 0) routerOptions.shallow = shallow;
 	if (replace) await router.replace(href, void 0, routerOptions);
 	else await router.push(href, void 0, routerOptions);
 }
+async function navigatePagesRouterLinkWithFallback({ router, loadRouter, navigation, fallback }) {
+	let pagesRouter = router;
+	if (!pagesRouter) try {
+		pagesRouter = await loadRouter();
+	} catch {
+		fallback();
+		return;
+	}
+	if (!pagesRouter) {
+		fallback();
+		return;
+	}
+	await navigatePagesRouterLink(pagesRouter, navigation);
+}
 //#endregion
-export { navigatePagesRouterLink };
+export { navigatePagesRouterLink, navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref };

package/dist/client/vinext-next-data.js

@@ -1,6 +1,8 @@
 import { isUnknownRecord } from "../utils/record.js";
 //#region src/client/vinext-next-data.ts
 function extractVinextNextDataJson(html) {
+	const canonical = /<script\b(?=[^>]*\bid=["']__NEXT_DATA__["'])(?=[^>]*\btype=["']application\/json["'])[^>]*>([\s\S]*?)<\/script>/.exec(html);
+	if (canonical) return canonical[1];
 	const assignment = /<script(?:\s[^>]*)?>\s*window\.__NEXT_DATA__\s*=\s*/.exec(html);
 	if (!assignment || assignment.index === void 0) return null;
 	let start = assignment.index + assignment[0].length;

package/dist/config/config-matchers.d.ts

@@ -148,6 +148,16 @@ declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx:
  * when evaluating rewrites, so this parameter is required.
  */
 declare function matchRewrite(pathname: string, rewrites: NextRewrite[], ctx: RequestContext, basePathState?: BasePathMatchState): string | null;
+/**
+ * Check whether a rewrite source can match a pathname without evaluating its
+ * request-dependent `has` / `missing` conditions.
+ *
+ * Dev uses this only as a conservative preflight before middleware runs. The
+ * conditions may become true after middleware overrides request headers, so
+ * evaluating them against the original request would incorrectly skip the
+ * Pages request pipeline for file-looking paths.
+ */
+declare function matchesRewriteSource(pathname: string, rewrite: NextRewrite, basePathState?: BasePathMatchState): boolean;
 /**
  * Sanitize a redirect/rewrite destination to collapse protocol-relative URLs.
  *
@@ -244,4 +254,4 @@ declare function applyLocaleToRoutes<T extends NextRedirect | NextRewrite>(route
   trailingSlash?: boolean;
 }): T[];
 //#endregion
-export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

package/dist/config/config-matchers.js

@@ -268,7 +268,7 @@ function isSafeRegex(pattern) {
 */
 function safeRegExp(pattern, flags) {
 	if (!isSafeRegex(pattern)) {
-		console.warn(`[vinext] Ignoring potentially unsafe regex pattern (ReDoS risk): ${pattern}\n  Patterns with nested quantifiers (e.g. (a+)+) can cause catastrophic backtracking.\n  Simplify the pattern to avoid nested repetition.`);
+		console.warn(`[vinext] Rejecting potentially unsafe regex pattern (ReDoS risk): ${pattern}\n  Patterns with nested quantifiers (e.g. (a+)+) can cause catastrophic backtracking.\n  Simplify the pattern to avoid nested repetition.`);
 		return null;
 	}
 	try {
@@ -718,6 +718,18 @@ function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT
 	return null;
 }
 /**
+* Check whether a rewrite source can match a pathname without evaluating its
+* request-dependent `has` / `missing` conditions.
+*
+* Dev uses this only as a conservative preflight before middleware runs. The
+* conditions may become true after middleware overrides request headers, so
+* evaluating them against the original request would incorrectly skip the
+* Pages request pipeline for file-looking paths.
+*/
+function matchesRewriteSource(pathname, rewrite, basePathState = _BASEPATH_DEFAULT) {
+	return shouldEvaluateRule(rewrite.basePath, basePathState) && matchConfigPattern(pathname, rewrite.source) !== null;
+}
+/**
 * Substitute all matched route params into a redirect/rewrite destination.
 *
 * Handles repeated params (e.g. `/api/:id/:id`) and catch-all suffix forms
@@ -1031,4 +1043,4 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 	return out;
 }
 //#endregion
-export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

package/dist/config/tsconfig-paths.js

@@ -38,6 +38,19 @@ function resolveTsconfigPathCandidate(candidate) {
 	for (const item of candidates) if (fs.existsSync(item) && fs.statSync(item).isFile()) return item;
 	return null;
 }
+/**
+* Normalize a tsconfig `extends` field into a list of specifier strings.
+*
+* TypeScript 5.0+ allows `extends` to be either a string or an array of
+* strings. Matches Next.js's handling in
+* packages/next/src/build/next-config-ts/transpile-config.ts, where parents
+* are iterated in order and later entries override earlier ones.
+*/
+function normalizeExtends(extendsField) {
+	if (typeof extendsField === "string") return [extendsField];
+	if (Array.isArray(extendsField)) return extendsField.filter((value) => typeof value === "string");
+	return [];
+}
 function resolveTsconfigExtends(configPath, specifier) {
 	const fromDir = path.dirname(configPath);
 	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\\")) return resolveTsconfigPathCandidate(path.resolve(fromDir, specifier));
@@ -87,7 +100,7 @@ function loadResolutionFromTsconfigFile(configPath, seen) {
 	}
 	if (!parsed) return emptyResolution();
 	let resolution = emptyResolution();
-	const extendsList = typeof parsed.extends === "string" ? [parsed.extends] : [];
+	const extendsList = normalizeExtends(parsed.extends);
 	for (const extendsSpecifier of extendsList) {
 		const extendedPath = resolveTsconfigExtends(configPath, extendsSpecifier);
 		if (extendedPath) {

package/dist/deploy.js

@@ -374,7 +374,7 @@ function generatePagesRouterWorkerEntry() {
  * Cloudflare Worker entry point -- auto-generated by vinext deploy.
  * Edit freely or delete to regenerate on next deploy.
  */
-import { runPagesRequest, wrapMiddlewareWithBasePath } from "vinext/server/pages-request-pipeline";
+import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "vinext/server/pages-request-pipeline";
 import type { PagesPipelineDeps } from "vinext/server/pages-request-pipeline";
 import { handleImageOptimization, DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath } from "vinext/server/image-optimization";
 import type { ImageConfig } from "vinext/server/image-optimization";
@@ -384,7 +384,7 @@ import { assetPrefixPathname, isNextStaticPath } from "vinext/utils/asset-prefix
 import { hasBasePath, stripBasePath } from "vinext/utils/base-path";
 
 // @ts-expect-error -- virtual module resolved by vinext at build time
-import { renderPage, handleApiRoute, runMiddleware, vinextConfig, matchPageRoute } from "virtual:vinext-server-entry";
+import { renderPage, handleApiRoute, runMiddleware, normalizeDataRequest, vinextConfig, matchPageRoute } from "virtual:vinext-server-entry";
 // @ts-expect-error -- virtual module resolved by vinext at build time
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 
@@ -448,11 +448,6 @@ export default {
         return notFoundStaticAssetResponse();
       }
 
-      // Capture x-nextjs-data before filterInternalHeaders strips it -- the
-      // middleware redirect protocol needs to know whether the inbound request
-      // was a _next/data fetch to emit x-nextjs-redirect instead of a 3xx.
-      const isDataRequest = request.headers.get("x-nextjs-data") === "1";
-
       // Strip internal headers from inbound requests so they cannot be
       // forged to influence routing or impersonate internal state.
       // Request.headers is immutable in Workers, so build a clean copy.
@@ -476,6 +471,14 @@ export default {
         }
       }
 
+      const dataNorm = normalizeDataRequest(request);
+      if (dataNorm.notFoundResponse) return dataNorm.notFoundResponse;
+      const isDataReq = dataNorm.isDataReq;
+      if (isDataReq) {
+        request = dataNorm.request;
+        pathname = dataNorm.normalizedPathname;
+      }
+
       // ── Image optimization via Cloudflare Images binding ──────────
       // Checked after basePath stripping so /<basePath>/_next/image works.
       if (isImageOptimizationPath(pathname)) {
@@ -504,12 +507,8 @@ export default {
         configRewrites,
         configHeaders,
         hadBasePath,
-        // The worker adapter does not do _next/data URL normalization (no
-        // buildId available at request time). isDataReq is used by the pipeline
-        // only for renderPage options and shouldDeferErrorPageOnMiss -- false
-        // is correct here.
-        isDataReq: false,
-        isDataRequest,
+        isDataReq,
+        isDataRequest: isDataReq,
         ctx,
         matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
         // Pass the original (pre-basePath-stripping) URL to middleware so that
@@ -527,6 +526,14 @@ export default {
         handleApi: typeof handleApiRoute === "function"
           ? (req, apiUrl) => handleApiRoute(req, apiUrl, ctx)
           : null,
+        serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase) => {
+          return fetchWorkerFilesystemRoute(
+            request,
+            requestPathname,
+            phase,
+            (assetRequest) => env.ASSETS.fetch(assetRequest),
+          );
+        },
       };
 
       const result = await runPagesRequest(request, deps);

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

@@ -452,6 +452,7 @@ ${rootParamNameEntries.join("\n")}
 
 export default __createAppRscHandler({
   basePath: __basePath,
+  buildId: process.env.__VINEXT_BUILD_ID ?? null,
   ensureRouteLoaded: __ensureRouteLoaded,
   clearRequestContext() {
     __clearRequestContext();
@@ -867,9 +868,9 @@ export default __createAppRscHandler({
     const __isEdge = route ? __isEdgeRuntime(__resolveAppPageSegmentConfig({ layouts: route.layouts, page: route.page }).runtime) : false;
     return __fallbackRenderer.renderNotFound(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, { isEdgeRuntime: __isEdge });
   },
-  ${hasPagesDir ? `async renderPagesFallback({ allowRscDocumentFallback, appRouteMatch, isRscRequest, matchKind, middlewareContext, pathname, request, url }) {
+  ${hasPagesDir ? `async renderPagesFallback({ allowRscDocumentFallback, appRouteMatch, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, url }) {
     return __renderPagesFallback(
-      { allowRscDocumentFallback, appRouteMatch, isRscRequest, matchKind, middlewareContext, pathname, request, url },
+      { allowRscDocumentFallback, appRouteMatch, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, url },
       {
         loadPagesEntry() {
           return import.meta.viteRsc.loadModule("ssr", "index");

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

@@ -50,19 +50,10 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 import "vinext/instrumentation-client";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
-// Statically import next/router as the very first vinext shim so that
-// (a) installWindowNext runs at top-level — \`window.next.router\` is
-//     available to test harnesses and third-party scripts BEFORE
-//     hydrate() resolves (see .nextjs-ref/packages/next/src/client/next.ts
-//     line 13, which also sets window.next as a top-level side effect),
-// and (b) the popstate handler is registered before
-//     installPagesRouterRuntime() runs, removing the race window where a
-//     popstate event could fire between hydration and runtime install.
-//
-// Mirrors Next.js's bootstrap order: client/next.ts statically imports
-// from './' before calling initialize/hydrate, so window.next is set up
-// before any async work.
-import Router, { wrapWithRouterContext } from "next/router";
+import Router, {
+  wrapWithRouterContext,
+  _initializePagesRouterReadyFromNextData,
+} from "next/router";
 
 const pageLoaders = {
 ${loaderEntries.join(",\n")}
@@ -110,6 +101,14 @@ window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(appPrefetchRoutes)};
 window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(pagesPrefetchRoutes)};
 window.__VINEXT_CLIENT_REWRITES__ = ${JSON.stringify(nextConfig.rewrites)};
 
+const nextDataElement = document.getElementById("__NEXT_DATA__");
+if (nextDataElement?.textContent) {
+  window.__NEXT_DATA__ = JSON.parse(nextDataElement.textContent);
+  window.__VINEXT_LOCALE__ = window.__NEXT_DATA__.locale;
+  window.__VINEXT_LOCALES__ = window.__NEXT_DATA__.locales;
+  window.__VINEXT_DEFAULT_LOCALE__ = window.__NEXT_DATA__.defaultLocale;
+}
+
 async function hydrate() {
   const nextData = window.__NEXT_DATA__;
   if (!nextData) {
@@ -117,6 +116,8 @@ async function hydrate() {
     return;
   }
 
+  _initializePagesRouterReadyFromNextData(nextData);
+
   let hydrateRootOptions;
   if (import.meta.env.DEV) {
     const overlay = await import("vinext/dev-error-overlay");

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

@@ -100,42 +100,19 @@ 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) {
-  // 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, buildId);
-  if (__dataNorm.notFoundResponse) {
-    return { continue: false, response: __dataNorm.notFoundResponse };
-  }
-  const __result = await __runGeneratedMiddleware({
+  return __runGeneratedMiddleware({
     basePath: vinextConfig.basePath,
     ctx,
     i18nConfig,
-    isDataRequest: options?.isDataRequest === true || __dataNorm.isDataReq,
+    isDataRequest: options?.isDataRequest === true,
     isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
     module: middlewareModule,
-    request: __dataNorm.request,
+    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(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, buildId);
-  if (__dataNorm.notFoundResponse) {
-    return { continue: false, response: __dataNorm.notFoundResponse };
-  }
-  if (__dataNorm.isDataReq) {
-    return { continue: true, rewriteUrl: __dataNorm.normalizedPathname + __dataNorm.search };
-  }
   return { continue: true };
 }
 `;
@@ -181,6 +158,9 @@ const i18nConfig = ${i18nConfigJson};
 // match _next/data requests against the embedded buildId without needing
 // to load next.config.js at runtime.
 export const buildId = ${buildIdJson};
+export function normalizeDataRequest(request) {
+  return __normalizePagesDataRequest(request, buildId);
+}
 const __hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
 
 // Full resolved config for production server (embedded at build time)