vinext 0.1.3 → 0.1.5

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/css-url-assets.d.ts

@@ -10,7 +10,7 @@ type EmitRestoredCssUrlAsset = (asset: {
 /**
  * Append the private provenance marker to each relative asset `url()` in a CSS
  * source. Idempotent and side-effect free (only adds a query param), so it is
- * safe to run on every client-environment stylesheet, vendored CSS included.
+ * safe to run on every build-environment stylesheet, vendored CSS included.
  */
 declare function markCssUrlAssetReferences(code: string, id: string): string | null;
 /**

package/dist/build/css-url-assets.js

@@ -12,12 +12,14 @@
 * vitejs/vite#8632). The one native escape hatch is `this.emitFile({ fileName })`:
 * assets emitted with an explicit `fileName` are *never* deduped. So we:
 *
-*   1. mark — during the client CSS transform, tag each relative asset `url()`
-*      with a private `?vinext_css_url_asset=<source-basename>` query. This is
-*      the only durable carrier of per-reference provenance: once Rolldown
-*      dedupes, the emitted bundle cannot tell which `url()` came from which
-*      source, and the bundle metadata (`originalFileNames`) records the set of
-*      sources but not the mapping per reference.
+*   1. mark — during every production CSS transform, tag each relative asset
+*      `url()` with a private `?vinext_css_url_asset=<source-basename>` query.
+*      Using identical transformed CSS in server and client environments is
+*      required because the default CSS Modules scoped name hashes the full CSS
+*      text. The marker is also the only durable carrier of per-reference
+*      provenance: once Rolldown dedupes, the emitted bundle cannot tell which
+*      `url()` came from which source, and bundle metadata records the source
+*      set but not the mapping per reference.
 *
 *   2. restore — at `generateBundle`, read each marked reference's source
 *      basename back out. When it differs from the deduped output's basename,
@@ -109,7 +111,7 @@ function rewriteCssUrls(code, replace) {
 /**
 * Append the private provenance marker to each relative asset `url()` in a CSS
 * source. Idempotent and side-effect free (only adds a query param), so it is
-* safe to run on every client-environment stylesheet, vendored CSS included.
+* safe to run on every build-environment stylesheet, vendored CSS included.
 */
 function markCssUrlAssetReferences(code, id) {
 	if (!isCssRequest(id) || !code.includes("url(")) return null;

package/dist/build/prerender.js

@@ -1,8 +1,9 @@
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../server/headers.js";
 import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
+import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
-import { NoOpCacheHandler, _consumeRequestScopedCacheLife, getCacheHandler, setCacheHandler } from "../shims/cache.js";
+import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { BLOCKED_PAGES } from "../shims/constants.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
@@ -659,6 +660,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/cache/cache-adapters-virtual.js

@@ -29,7 +29,7 @@ function generateCacheAdaptersModule(cache) {
 	const lines = ["// vinext: generated from the `cache` option in your vinext() plugin config."];
 	if (data?.adapter) {
 		lines.push(`import __vinextDataAdapterFactory from ${JSON.stringify(data.adapter)};`);
-		lines.push(`import { setDataCacheHandler } from "vinext/shims/cache";`);
+		lines.push(`import { setDataCacheHandler } from "vinext/shims/cache-handler";`);
 	}
 	if (cdn?.adapter) {
 		lines.push(`import __vinextCdnAdapterFactory from ${JSON.stringify(cdn.adapter)};`);

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/cloudflare/src/cache/kv-data-adapter.runtime.d.ts

@@ -1,5 +1,5 @@
+import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../shims/cache-handler.js";
 import { ExecutionContextLike } from "../../../shims/request-context.js";
-import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../shims/cache.js";
 
 //#region ../cloudflare/src/cache/kv-data-adapter.runtime.d.ts
 type KVNamespace = {

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

@@ -18,7 +18,6 @@ const DEFAULT_EXPIRE_TIME = 31536e3;
 const DEFAULT_REACT_MAX_HEADERS_LENGTH = 6e3;
 const middlewareRequestHeadersPath = resolveEntryPath("../server/middleware-request-headers.js", import.meta.url);
 const normalizePathModulePath = resolveEntryPath("../server/normalize-path.js", import.meta.url);
-const appRscHandlerPath = resolveEntryPath("../server/app-rsc-handler.js", import.meta.url);
 const appRouteHandlerDispatchPath = resolveEntryPath("../server/app-route-handler-dispatch.js", import.meta.url);
 const appRouteHandlerResponsePath = resolveEntryPath("../server/app-route-handler-response.js", import.meta.url);
 const appServerActionExecutionPath = resolveEntryPath("../server/app-server-action-execution.js", import.meta.url);
@@ -110,29 +109,21 @@ const prerenderToReadableStream = createRscPrerenderer(async (model, options) =>
 );
 import { createElement } from "react";
 import { getNavigationContext as _getNavigationContext } from "next/navigation";
-import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "next/cache";
+import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
 import { headersContextFromRequest, getDraftModeCookieHeader, getAndClearPendingCookies, consumeDynamicUsage, consumeInvalidDynamicUsageError, setHeadersAccessPhase } from "next/headers";
 import { mergeMetadata, resolveModuleMetadata, mergeViewport, resolveModuleViewport } from "vinext/metadata";
 ${middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};` : ""}
 ${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(normalizePathSeparators(instrumentationPath))};
 import { ensureInstrumentationRegistered as __ensureInstrumentationRegistered } from ${JSON.stringify(instrumentationRuntimePath)};` : ""}
-import { createAppRscHandler as __createAppRscHandler } from ${JSON.stringify(appRscHandlerPath)};
+import { createAppRscHandler } from "vinext/server/app-rsc-handler";
 import { registerConfiguredCacheAdapters as __registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { decodePathParams as __decodePathParams } from ${JSON.stringify(normalizePathModulePath)};
 import { buildRequestHeadersFromMiddlewareResponse as __buildRequestHeadersFromMiddlewareResponse } from ${JSON.stringify(middlewareRequestHeadersPath)};
-import {
-  dispatchAppRouteHandler as __dispatchAppRouteHandler,
-} from ${JSON.stringify(appRouteHandlerDispatchPath)};
-import {
+${hasPagesDir ? `import {
   applyRouteHandlerMiddlewareContext as __applyRouteHandlerMiddlewareContext,
-} from ${JSON.stringify(appRouteHandlerResponsePath)};
-import {
-  handleProgressiveServerActionRequest as __handleProgressiveServerActionRequest,
-  handleServerActionRscRequest as __handleServerActionRscRequest,
-  isProgressiveServerActionRequest as __isProgressiveServerActionRequest,
-  readActionBodyWithLimit as __readBodyWithLimit,
-  readActionFormDataWithLimit as __readFormDataWithLimit,
-} from ${JSON.stringify(appServerActionExecutionPath)};
+} from ${JSON.stringify(appRouteHandlerResponsePath)};` : ""}
+const __loadAppRouteHandlerDispatch = () => import(${JSON.stringify(appRouteHandlerDispatchPath)});
+const __loadAppServerActionExecution = () => import(${JSON.stringify(appServerActionExecutionPath)});
 import {
   sanitizeErrorForClient as __sanitizeErrorForClient,
 } from ${JSON.stringify(appRscErrorsPath)};
@@ -198,7 +189,6 @@ import { clearAppRequestContext as __clearRequestContext, setAppNavigationContex
 __configureMemoryCacheHandler({ cacheMaxMemorySize: ${JSON.stringify(cacheMaxMemorySize)} });
 import { createAppPrerenderStaticParamsResolver as __createAppPrerenderStaticParamsResolver } from ${JSON.stringify(appPrerenderStaticParamsPath)};
 import { ensureAppRouteModulesLoaded as __ensureRouteLoaded } from ${JSON.stringify(appRouteModuleLoaderPath)};
-import { seedMemoryCacheFromPrerender as __seedMemoryCacheFromPrerender } from ${JSON.stringify(seedCachePath)};
 import {
   getRenderedConcreteUrlPathsForRoute as __getRenderedConcreteUrlPathsForRoute,
   initPregeneratedPathsFromGlobals as __initPregeneratedPathsFromGlobals,
@@ -408,7 +398,9 @@ export const __hasPagesDir = ${JSON.stringify(hasPagesDir)};
 export const getRenderedConcreteUrlPathsForRoute = __getRenderedConcreteUrlPathsForRoute;
 const __cacheComponents = ${JSON.stringify(cacheComponents)};
 
-export function seedMemoryCacheFromPrerender(serverDir) {
+export async function seedMemoryCacheFromPrerender(serverDir) {
+  const { seedMemoryCacheFromPrerender: __seedMemoryCacheFromPrerender } =
+    await import(${JSON.stringify(seedCachePath)});
   return __seedMemoryCacheFromPrerender(serverDir, {
     buildAppPageHtmlKey(pathname) {
       return __isrHtmlKey(pathname);
@@ -450,8 +442,9 @@ const rootParamNamesMap = {
 ${rootParamNameEntries.join("\n")}
 };
 
-export default __createAppRscHandler({
+export default createAppRscHandler({
   basePath: __basePath,
+  buildId: process.env.__VINEXT_BUILD_ID ?? null,
   ensureRouteLoaded: __ensureRouteLoaded,
   clearRequestContext() {
     __clearRequestContext();
@@ -651,7 +644,7 @@ export default __createAppRscHandler({
       renderMode,
     });
   },
-  dispatchMatchedRouteHandler({
+  async dispatchMatchedRouteHandler({
     cleanPathname,
     middlewareContext,
     params,
@@ -659,6 +652,8 @@ export default __createAppRscHandler({
     route,
     searchParams,
   }) {
+    const { dispatchAppRouteHandler: __dispatchAppRouteHandler } =
+      await __loadAppRouteHandlerDispatch();
     return __dispatchAppRouteHandler({
       basePath: __basePath,
       cleanPathname,
@@ -688,13 +683,18 @@ export default __createAppRscHandler({
   ${instrumentationPath ? `ensureInstrumentation() {
     return __ensureInstrumentationRegistered(_instrumentation);
   },` : ""}
-  handleProgressiveActionRequest({
+  async handleProgressiveActionRequest({
     actionId,
     cleanPathname,
     contentType,
     middlewareContext,
     request,
   }) {
+    const {
+      handleProgressiveServerActionRequest: __handleProgressiveServerActionRequest,
+      isProgressiveServerActionRequest: __isProgressiveServerActionRequest,
+      readActionFormDataWithLimit: __readFormDataWithLimit,
+    } = await __loadAppServerActionExecution();
     // A multipart form POST to a page is always a server-action attempt, so a
     // body that decodes to no action must surface as 404 action-not-found
     // (#1340). Route handlers run after this dispatch and accept raw multipart
@@ -748,6 +748,11 @@ export default __createAppRscHandler({
     request,
     searchParams,
   }) {
+    const {
+      handleServerActionRscRequest: __handleServerActionRscRequest,
+      readActionBodyWithLimit: __readBodyWithLimit,
+      readActionFormDataWithLimit: __readFormDataWithLimit,
+    } = await __loadAppServerActionExecution();
     const __actionMatch = matchRoute(cleanPathname);
     if (__actionMatch) await __ensureRouteLoaded(__actionMatch.route);
     const __actionIsEdgeRuntime = __actionMatch
@@ -867,9 +872,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");