vinext 0.1.4 → 0.1.6

package/README.md

@@ -404,7 +404,7 @@ These are deployed to Cloudflare Workers and updated on every push to `main`:
 | App Router (minimal)   | Minimal App Router on Workers                                                                                    | [app-router-cloudflare.vinext.workers.dev](https://app-router-cloudflare.vinext.workers.dev)     |
 | Pages Router (minimal) | Minimal Pages Router on Workers                                                                                  | [pages-router-cloudflare.vinext.workers.dev](https://pages-router-cloudflare.vinext.workers.dev) |
 | RealWorld API          | REST API routes example                                                                                          | [realworld-api-rest.vinext.workers.dev](https://realworld-api-rest.vinext.workers.dev)           |
-| Benchmarks Dashboard   | Build performance tracking over time (D1-backed)                                                                 | [benchmarks.vinext.workers.dev](https://benchmarks.vinext.workers.dev)                           |
+| Benchmarks Dashboard   | Build performance tracking over time (D1-backed)                                                                 | [vinext-web.vinext.workers.dev/benchmarks](https://vinext-web.vinext.workers.dev/benchmarks)     |
 | App Router + Nitro     | App Router deployed via Nitro (multi-platform)                                                                   | [examples/app-router-nitro](examples/app-router-nitro)                                           |
 
 ## API coverage
@@ -614,7 +614,7 @@ We measure three things:
 - **Client bundle size** — gzipped output of each build.
 - **Dev server cold start** — 10 runs, randomized execution order. Vite's dependency optimizer cache is cleared before each run.
 
-Benchmarks run on GitHub CI runners (2-core Ubuntu) on every merge to `main`. See the launch numbers in the [announcement blog post](https://blog.cloudflare.com/vinext/) and the latest results at **[benchmarks.vinext.workers.dev](https://benchmarks.vinext.workers.dev)**.
+Benchmarks run on GitHub CI runners (2-core Ubuntu) on every merge to `main`. See the launch numbers in the [announcement blog post](https://blog.cloudflare.com/vinext/) and the latest results at **[vinext-web.vinext.workers.dev/benchmarks](https://vinext-web.vinext.workers.dev/benchmarks)**.
 
 <details>
 <summary>Why the bundle size difference?</summary>

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/google-fonts/find-font-files-in-css.d.ts

@@ -0,0 +1,16 @@
+//#region src/build/google-fonts/find-font-files-in-css.d.ts
+/**
+ * Find all font files in the CSS response and determine which files should be preloaded.
+ * In Google Fonts responses, the @font-face's subset is above it in a comment.
+ * Walk through the CSS from top to bottom, keeping track of the current subset.
+ *
+ * Ported from Next.js:
+ * packages/font/src/google/find-font-files-in-css.ts
+ * https://github.com/vercel/next.js/blob/canary/packages/font/src/google/find-font-files-in-css.ts
+ */
+declare function findFontFilesInCss(css: string, subsetsToPreload?: string[]): {
+  googleFontFileUrl: string;
+  preloadFontFile: boolean;
+}[];
+//#endregion
+export { findFontFilesInCss };

package/dist/build/google-fonts/find-font-files-in-css.js

@@ -0,0 +1,28 @@
+//#region src/build/google-fonts/find-font-files-in-css.ts
+/**
+* Find all font files in the CSS response and determine which files should be preloaded.
+* In Google Fonts responses, the @font-face's subset is above it in a comment.
+* Walk through the CSS from top to bottom, keeping track of the current subset.
+*
+* Ported from Next.js:
+* packages/font/src/google/find-font-files-in-css.ts
+* https://github.com/vercel/next.js/blob/canary/packages/font/src/google/find-font-files-in-css.ts
+*/
+function findFontFilesInCss(css, subsetsToPreload) {
+	const fontFiles = [];
+	let currentSubset = "";
+	for (const line of css.split("\n")) {
+		const newSubset = /\/\* (.+?) \*\//.exec(line)?.[1];
+		if (newSubset) currentSubset = newSubset;
+		else {
+			const googleFontFileUrl = /src: url\((.+?)\)/.exec(line)?.[1];
+			if (googleFontFileUrl && !fontFiles.some((foundFile) => foundFile.googleFontFileUrl === googleFontFileUrl)) fontFiles.push({
+				googleFontFileUrl,
+				preloadFontFile: !!subsetsToPreload?.includes(currentSubset)
+			});
+		}
+	}
+	return fontFiles;
+}
+//#endregion
+export { findFontFilesInCss };

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";

package/dist/build/report.d.ts

@@ -117,7 +117,6 @@ declare function buildReportRows(options: {
  *   ○ Static  ◐ ISR  ƒ Dynamic  λ API
  */
 declare function formatBuildReport(rows: RouteRow[], routerLabel?: string): string;
-declare function findDir(root: string, ...candidates: string[]): string | null;
 /**
  * Scans the project at `root`, classifies all routes, and prints the
  * Next.js-style build report to stdout.
@@ -130,4 +129,4 @@ declare function printBuildReport(options: {
   prerenderResult?: PrerenderResult;
 }): Promise<void>;
 //#endregion
-export { RouteRow, RouteType, buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, findDir, formatBuildReport, getAppRouteRenderEntryPath, hasNamedExport, printBuildReport };
+export { RouteRow, RouteType, buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, formatBuildReport, getAppRouteRenderEntryPath, hasNamedExport, printBuildReport };

package/dist/build/report.js

@@ -1,5 +1,5 @@
+import { findDir } from "../utils/project.js";
 import fs from "node:fs";
-import path from "node:path";
 import { parseSync } from "vite";
 //#region src/build/report.ts
 /**
@@ -470,15 +470,6 @@ function formatBuildReport(rows, routerLabel = "app") {
 	}
 	return lines.join("\n");
 }
-function findDir(root, ...candidates) {
-	for (const candidate of candidates) {
-		const full = path.join(root, candidate);
-		try {
-			if (fs.statSync(full).isDirectory()) return full;
-		} catch {}
-	}
-	return null;
-}
 /**
 * Scans the project at `root`, classifies all routes, and prints the
 * Next.js-style build report to stdout.
@@ -510,4 +501,4 @@ async function printBuildReport(options) {
 	}
 }
 //#endregion
-export { buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, findDir, formatBuildReport, getAppRouteRenderEntryPath, hasNamedExport, printBuildReport };
+export { buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, formatBuildReport, getAppRouteRenderEntryPath, hasNamedExport, printBuildReport };

package/dist/build/run-prerender.js

@@ -1,7 +1,7 @@
+import { findDir } from "../utils/project.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { appRouter } from "../routing/app-router.js";
 import { scanMetadataFiles } from "../server/metadata-routes.js";
-import { findDir } from "./report.js";
 import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { startProdServer } from "../server/prod-server.js";

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/check.js

@@ -1,4 +1,4 @@
-import { detectPackageManager } from "./utils/project.js";
+import { detectPackageManager, findDir } from "./utils/project.js";
 import { normalizePathSeparators } from "./utils/path.js";
 import fs from "node:fs";
 import path from "node:path";
@@ -780,8 +780,8 @@ function checkLibraries(root) {
 */
 function checkConventions(root) {
 	const items = [];
-	const pagesDir = fs.existsSync(path.join(root, "pages")) ? path.join(root, "pages") : fs.existsSync(path.join(root, "src", "pages")) ? path.join(root, "src", "pages") : null;
-	const appDirPath = fs.existsSync(path.join(root, "app")) ? path.join(root, "app") : fs.existsSync(path.join(root, "src", "app")) ? path.join(root, "src", "app") : null;
+	const pagesDir = findDir(root, "pages", path.join("src", "pages"));
+	const appDirPath = findDir(root, "app", path.join("src", "app"));
 	const hasPages = pagesDir !== null;
 	const hasApp = appDirPath !== null;
 	const hasProxy = fs.existsSync(path.join(root, "proxy.ts")) || fs.existsSync(path.join(root, "proxy.js"));

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

@@ -11,6 +11,15 @@ type PagesRouterLinkRuntime = {
 };
 type PagesRouterLinkNavigation = {
   href: string;
+  /**
+   * Optional `as` mask — the browser-bar URL when it differs from `href`
+   * (a Pages Router route pattern, e.g. `<Link href="/posts/[id]" as="/posts/1">`).
+   * When present, `router.push/replace(href, as, ...)` is invoked with both
+   * values so the upstream (url, as) pair survives end-to-end. Mirrors
+   * Next.js's Link → Router contract: packages/next/src/client/link.tsx
+   * → router.push(href, as).
+   */
+  as?: string;
   replace: boolean;
   scroll: boolean;
   shallow?: boolean;
@@ -30,6 +39,7 @@ declare function resolvePagesRouterQueryOnlyHref(href: string, {
 }): string;
 declare function navigatePagesRouterLink(router: PagesRouterLinkRuntime, {
   href,
+  as,
   replace,
   scroll,
   shallow,

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

@@ -14,15 +14,15 @@ function resolvePagesRouterQueryOnlyHref(href, { asPath, basePath, fallbackHref,
 		return href;
 	}
 }
-async function navigatePagesRouterLink(router, { href, replace, scroll, shallow, locale, interpolateDynamicRoute = false }) {
+async function navigatePagesRouterLink(router, { href, as, 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);
+	if (replace) await router.replace(href, as, routerOptions);
+	else await router.push(href, as, routerOptions);
 }
 async function navigatePagesRouterLinkWithFallback({ router, loadRouter, navigation, fallback }) {
 	let pagesRouter = router;

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/deploy.js

@@ -1,4 +1,4 @@
-import { detectPackageManager as detectPackageManager$1, ensureESModule as ensureESModule$1, findInNodeModules, renameCJSConfigs as renameCJSConfigs$1 } from "./utils/project.js";
+import { detectPackageManager as detectPackageManager$1, ensureESModule as ensureESModule$1, findDir, findInNodeModules, hasAppDir, renameCJSConfigs as renameCJSConfigs$1 } from "./utils/project.js";
 import { parsePositiveIntegerArg } from "./cli-args.js";
 import { escapeRegExp } from "./utils/regex.js";
 import { loadNextConfig, resolveNextConfig } from "./config/next-config.js";
@@ -108,8 +108,8 @@ function formatMissingCloudflarePluginError(options) {
 	return `[vinext] Missing @cloudflare/vite-plugin in ${configRef}.\n\n  Cloudflare Workers builds require the cloudflare() plugin.\n  Add it to ${configRef}:\n\n    import { cloudflare } from "@cloudflare/vite-plugin";\n\n    export default defineConfig({\n      plugins: [\n        vinext(),\n        cloudflare(${cfArg}),\n      ],\n    });\n\n  Or delete ${configRef} and re-run \`vinext deploy\` to auto-generate it.`;
 }
 function detectProject(root) {
-	const hasApp = fs.existsSync(path.join(root, "app")) || fs.existsSync(path.join(root, "src", "app"));
-	const hasPages = fs.existsSync(path.join(root, "pages")) || fs.existsSync(path.join(root, "src", "pages"));
+	const hasApp = hasAppDir(root);
+	const hasPages = findDir(root, "pages", path.join("src", "pages")) !== null;
 	const isAppRouter = hasApp;
 	const isPagesRouter = !hasApp && hasPages;
 	const hasViteConfig = fs.existsSync(path.join(root, "vite.config.ts")) || fs.existsSync(path.join(root, "vite.config.js")) || fs.existsSync(path.join(root, "vite.config.mjs"));

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,7 +442,7 @@ const rootParamNamesMap = {
 ${rootParamNameEntries.join("\n")}
 };
 
-export default __createAppRscHandler({
+export default createAppRscHandler({
   basePath: __basePath,
   buildId: process.env.__VINEXT_BUILD_ID ?? null,
   ensureRouteLoaded: __ensureRouteLoaded,
@@ -652,7 +644,7 @@ export default __createAppRscHandler({
       renderMode,
     });
   },
-  dispatchMatchedRouteHandler({
+  async dispatchMatchedRouteHandler({
     cleanPathname,
     middlewareContext,
     params,
@@ -660,6 +652,8 @@ export default __createAppRscHandler({
     route,
     searchParams,
   }) {
+    const { dispatchAppRouteHandler: __dispatchAppRouteHandler } =
+      await __loadAppRouteHandlerDispatch();
     return __dispatchAppRouteHandler({
       basePath: __basePath,
       cleanPathname,
@@ -689,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
@@ -749,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
@@ -862,6 +866,7 @@ export default __createAppRscHandler({
   makeThenableParams,
   matchRoute,
   metadataRoutes,
+  middlewareFilePath: ${middlewarePath ? JSON.stringify(normalizePathSeparators(middlewarePath)) : "null"},
   middlewareModule: ${middlewarePath ? "middlewareModule" : "null"},
   publicFiles: __publicFiles,
   renderNotFound({ isRscRequest, matchedParams, middlewareContext, request, route, scriptNonce }) {

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

@@ -50,58 +50,68 @@ function registerRouteModules(routes, imports) {
 	for (const route of routes) {
 		if (route.pagePath) imports.getLazyLoaderVar(route.pagePath);
 		if (route.routePath) imports.getLazyLoaderVar(route.routePath);
-		for (const layout of route.layouts) imports.getImportVar(layout);
-		for (const tmpl of route.templates) imports.getImportVar(tmpl);
-		if (route.loadingPath) imports.getImportVar(route.loadingPath);
-		if (route.errorPath) imports.getImportVar(route.errorPath);
+		for (const layout of route.layouts) imports.getLazyLoaderVar(layout);
+		for (const tmpl of route.templates) imports.getLazyLoaderVar(tmpl);
+		if (route.loadingPath) imports.getLazyLoaderVar(route.loadingPath);
+		if (route.errorPath) imports.getLazyLoaderVar(route.errorPath);
 		if (route.layoutErrorPaths) {
-			for (const ep of route.layoutErrorPaths) if (ep) imports.getImportVar(ep);
+			for (const ep of route.layoutErrorPaths) if (ep) imports.getLazyLoaderVar(ep);
 		}
-		if (route.errorPaths) for (const ep of route.errorPaths) imports.getImportVar(ep);
-		if (route.notFoundPath) imports.getImportVar(route.notFoundPath);
+		if (route.errorPaths) for (const ep of route.errorPaths) imports.getLazyLoaderVar(ep);
+		if (route.notFoundPath) imports.getLazyLoaderVar(route.notFoundPath);
 		if (route.notFoundPaths) {
-			for (const nfp of route.notFoundPaths) if (nfp) imports.getImportVar(nfp);
+			for (const nfp of route.notFoundPaths) if (nfp) imports.getLazyLoaderVar(nfp);
 		}
-		if (route.forbiddenPath) imports.getImportVar(route.forbiddenPath);
+		if (route.forbiddenPath) imports.getLazyLoaderVar(route.forbiddenPath);
 		if (route.forbiddenPaths) {
-			for (const fp of route.forbiddenPaths) if (fp) imports.getImportVar(fp);
+			for (const fp of route.forbiddenPaths) if (fp) imports.getLazyLoaderVar(fp);
 		}
-		if (route.unauthorizedPath) imports.getImportVar(route.unauthorizedPath);
+		if (route.unauthorizedPath) imports.getLazyLoaderVar(route.unauthorizedPath);
 		if (route.unauthorizedPaths) {
-			for (const up of route.unauthorizedPaths) if (up) imports.getImportVar(up);
+			for (const up of route.unauthorizedPaths) if (up) imports.getLazyLoaderVar(up);
 		}
 		for (const slot of route.parallelSlots) {
-			if (slot.pagePath) imports.getImportVar(slot.pagePath);
-			if (slot.defaultPath) imports.getImportVar(slot.defaultPath);
-			if (slot.layoutPath) imports.getImportVar(slot.layoutPath);
-			if (slot.loadingPath) imports.getImportVar(slot.loadingPath);
-			if (slot.errorPath) imports.getImportVar(slot.errorPath);
+			if (slot.pagePath) imports.getLazyLoaderVar(slot.pagePath);
+			if (slot.defaultPath) imports.getLazyLoaderVar(slot.defaultPath);
+			if (slot.layoutPath) imports.getLazyLoaderVar(slot.layoutPath);
+			if (slot.loadingPath) imports.getLazyLoaderVar(slot.loadingPath);
+			if (slot.errorPath) imports.getLazyLoaderVar(slot.errorPath);
 			for (const ir of slot.interceptingRoutes) {
 				imports.getLazyLoaderVar(ir.pagePath);
-				for (const layoutPath of ir.layoutPaths) imports.getImportVar(layoutPath);
+				for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 			}
 		}
 		for (const ir of route.siblingIntercepts ?? []) {
 			imports.getLazyLoaderVar(ir.pagePath);
-			for (const layoutPath of ir.layoutPaths) imports.getImportVar(layoutPath);
+			for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 		}
 	}
 }
+function moduleArray(length) {
+	return `[${Array.from({ length }, () => "null").join(", ")}]`;
+}
+function lazyLoaderArray(filePaths, imports) {
+	return `[${filePaths.map((filePath) => filePath ? imports.getLazyLoaderVar(filePath) : "null").join(", ")}]`;
+}
 function buildRouteEntries(routes, imports) {
 	return routes.map((route, routeIdx) => {
 		const staticSiblings = route.isDynamic ? computeAppRouteStaticSiblings(routes, route) : [];
-		const layoutVars = route.layouts.map((l) => imports.getImportVar(l));
-		const templateVars = route.templates.map((t) => imports.getImportVar(t));
-		const notFoundVars = (route.notFoundPaths ?? []).map((nf) => nf ? imports.getImportVar(nf) : "null");
-		const forbiddenVars = (route.forbiddenPaths ?? []).map((fp) => fp ? imports.getImportVar(fp) : "null");
-		const unauthorizedVars = (route.unauthorizedPaths ?? []).map((up) => up ? imports.getImportVar(up) : "null");
+		const layoutLoaders = lazyLoaderArray(route.layouts, imports);
+		const templateLoaders = lazyLoaderArray(route.templates, imports);
+		const notFoundPaths = route.notFoundPaths ?? [];
+		const forbiddenPaths = route.forbiddenPaths ?? [];
+		const unauthorizedPaths = route.unauthorizedPaths ?? [];
+		const notFoundLoaders = lazyLoaderArray(notFoundPaths, imports);
+		const forbiddenLoaders = lazyLoaderArray(forbiddenPaths, imports);
+		const unauthorizedLoaders = lazyLoaderArray(unauthorizedPaths, imports);
 		const siblingInterceptEntries = (route.siblingIntercepts ?? []).map((ir) => `    {
       convention: ${JSON.stringify(ir.convention)},
       targetPattern: ${JSON.stringify(ir.targetPattern)},
       sourceMatchPattern: ${JSON.stringify(ir.sourceMatchPattern)},
       sourcePageSegments: ${JSON.stringify(ir.sourcePageSegments)},
       slotId: ${JSON.stringify(ir.slotId ?? null)},
-      interceptLayouts: [${ir.layoutPaths.map((l) => imports.getImportVar(l)).join(", ")}],
+      interceptLayouts: ${moduleArray(ir.layoutPaths.length)},
+      __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
       page: null,
       __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
       params: ${JSON.stringify(ir.params)},
@@ -112,7 +122,8 @@ function buildRouteEntries(routes, imports) {
           targetPattern: ${JSON.stringify(ir.targetPattern)},
           sourceMatchPattern: ${JSON.stringify(ir.sourceMatchPattern)},
           sourcePageSegments: ${JSON.stringify(ir.sourcePageSegments)},
-          interceptLayouts: [${ir.layoutPaths.map((layoutPath) => imports.getImportVar(layoutPath)).join(", ")}],
+          interceptLayouts: ${moduleArray(ir.layoutPaths.length)},
+          __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
           page: null,
           __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
           params: ${JSON.stringify(ir.params)},
@@ -120,11 +131,16 @@ function buildRouteEntries(routes, imports) {
 			return `      ${JSON.stringify(slot.key)}: {
         id: ${JSON.stringify(slot.id ?? null)},
         name: ${JSON.stringify(slot.name)},
-        page: ${slot.pagePath ? imports.getImportVar(slot.pagePath) : "null"},
-        default: ${slot.defaultPath ? imports.getImportVar(slot.defaultPath) : "null"},
-        layout: ${slot.layoutPath ? imports.getImportVar(slot.layoutPath) : "null"},
-        loading: ${slot.loadingPath ? imports.getImportVar(slot.loadingPath) : "null"},
-        error: ${slot.errorPath ? imports.getImportVar(slot.errorPath) : "null"},
+        page: null,
+        __loadPage: ${slot.pagePath ? imports.getLazyLoaderVar(slot.pagePath) : "null"},
+        default: null,
+        __loadDefault: ${slot.defaultPath ? imports.getLazyLoaderVar(slot.defaultPath) : "null"},
+        layout: null,
+        __loadLayout: ${slot.layoutPath ? imports.getLazyLoaderVar(slot.layoutPath) : "null"},
+        loading: null,
+        __loadLoading: ${slot.loadingPath ? imports.getLazyLoaderVar(slot.loadingPath) : "null"},
+        error: null,
+        __loadError: ${slot.errorPath ? imports.getLazyLoaderVar(slot.errorPath) : "null"},
         layoutIndex: ${slot.layoutIndex},
         routeSegments: ${JSON.stringify(slot.routeSegments)},
         slotPatternParts: ${slot.slotPatternParts ? JSON.stringify(slot.slotPatternParts) : "null"},
@@ -134,8 +150,10 @@ ${interceptEntries.join(",\n")}
         ],
       }`;
 		});
-		const layoutErrorVars = (route.layoutErrorPaths || []).map((ep) => ep ? imports.getImportVar(ep) : "null");
-		const errorVars = (route.errorPaths ?? []).map((ep) => imports.getImportVar(ep));
+		const layoutErrorPaths = route.layoutErrorPaths ?? [];
+		const errorPaths = route.errorPaths ?? [];
+		const layoutErrorLoaders = lazyLoaderArray(layoutErrorPaths, imports);
+		const errorLoaders = lazyLoaderArray(errorPaths, imports);
 		const loadPageField = route.pagePath ? imports.getLazyLoaderVar(route.pagePath) : "null";
 		const loadRouteHandlerField = route.routePath ? imports.getLazyLoaderVar(route.routePath) : "null";
 		return `  {
@@ -152,13 +170,17 @@ ${interceptEntries.join(",\n")}
     __loadPage: ${loadPageField},
     routeHandler: null,
     __loadRouteHandler: ${loadRouteHandlerField},
-    layouts: [${layoutVars.join(", ")}],
+    layouts: ${moduleArray(route.layouts.length)},
+    __loadLayouts: ${layoutLoaders},
     routeSegments: ${JSON.stringify(route.routeSegments)},
     templateTreePositions: ${JSON.stringify(route.templateTreePositions)},
     layoutTreePositions: ${JSON.stringify(route.layoutTreePositions)},
-    templates: [${templateVars.join(", ")}],
-    errors: [${layoutErrorVars.join(", ")}],
-    errorPaths: [${errorVars.join(", ")}],
+    templates: ${moduleArray(route.templates.length)},
+    __loadTemplates: ${templateLoaders},
+    errors: ${moduleArray(layoutErrorPaths.length)},
+    __loadErrors: ${layoutErrorLoaders},
+    errorPaths: ${moduleArray(errorPaths.length)},
+    __loadErrorPaths: ${errorLoaders},
     errorTreePositions: ${JSON.stringify(route.errorTreePositions ?? null)},
     slots: {
 ${slotEntries.join(",\n")}
@@ -166,14 +188,22 @@ ${slotEntries.join(",\n")}
     siblingIntercepts: [
 ${siblingInterceptEntries.join(",\n")}
     ],
-    loading: ${route.loadingPath ? imports.getImportVar(route.loadingPath) : "null"},
-    error: ${route.errorPath ? imports.getImportVar(route.errorPath) : "null"},
-    notFound: ${route.notFoundPath ? imports.getImportVar(route.notFoundPath) : "null"},
-    notFounds: [${notFoundVars.join(", ")}],
-    forbidden: ${route.forbiddenPath ? imports.getImportVar(route.forbiddenPath) : "null"},
-    forbiddens: [${forbiddenVars.join(", ")}],
-    unauthorized: ${route.unauthorizedPath ? imports.getImportVar(route.unauthorizedPath) : "null"},
-    unauthorizeds: [${unauthorizedVars.join(", ")}],
+    loading: null,
+    __loadLoading: ${route.loadingPath ? imports.getLazyLoaderVar(route.loadingPath) : "null"},
+    error: null,
+    __loadError: ${route.errorPath ? imports.getLazyLoaderVar(route.errorPath) : "null"},
+    notFound: null,
+    __loadNotFound: ${route.notFoundPath ? imports.getLazyLoaderVar(route.notFoundPath) : "null"},
+    notFounds: ${moduleArray(notFoundPaths.length)},
+    __loadNotFounds: ${notFoundLoaders},
+    forbidden: null,
+    __loadForbidden: ${route.forbiddenPath ? imports.getLazyLoaderVar(route.forbiddenPath) : "null"},
+    forbiddens: ${moduleArray(forbiddenPaths.length)},
+    __loadForbiddens: ${forbiddenLoaders},
+    unauthorized: null,
+    __loadUnauthorized: ${route.unauthorizedPath ? imports.getLazyLoaderVar(route.unauthorizedPath) : "null"},
+    unauthorizeds: ${moduleArray(unauthorizedPaths.length)},
+    __loadUnauthorizeds: ${unauthorizedLoaders},
   }`;
 	});
 }
@@ -217,7 +247,7 @@ function buildGenerateStaticParamsEntries(routes, imports, namesByPattern) {
 	const sourcesByPattern = /* @__PURE__ */ new Map();
 	for (const route of routes) {
 		if (!route.isDynamic) continue;
-		for (const [index, layoutPath] of route.layouts.entries()) appendStaticParamSource(sourcesByPattern, createRoutePatternPrefix(route.routeSegments, route.layoutTreePositions[index] ?? 0)?.pattern ?? null, `${imports.getImportVar(layoutPath)}?.generateStaticParams`);
+		for (const [index, layoutPath] of route.layouts.entries()) appendStaticParamSource(sourcesByPattern, createRoutePatternPrefix(route.routeSegments, route.layoutTreePositions[index] ?? 0)?.pattern ?? null, `{ load: ${imports.getLazyLoaderVar(layoutPath)} }`);
 		if (route.pagePath) appendStaticParamSource(sourcesByPattern, route.pattern, `{ load: ${imports.getLazyLoaderVar(route.pagePath)} }`);
 	}
 	return Array.from(sourcesByPattern.entries()).map(([pattern, sources]) => {

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

@@ -103,6 +103,7 @@ export async function runMiddleware(request, ctx, options) {
   return __runGeneratedMiddleware({
     basePath: vinextConfig.basePath,
     ctx,
+    filePath: ${JSON.stringify(normalizePathSeparators(middlewarePath))},
     i18nConfig,
     isDataRequest: options?.isDataRequest === true,
     isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
@@ -123,7 +124,8 @@ import { renderToReadableStream } from "react-dom/server.edge";
 import { resetSSRHead, getSSRHeadHTML, setDocumentInitialHead } from "next/head";
 import { flushPreloads } from "next/dynamic";
 import Router, { setSSRContext, wrapWithRouterContext, getPagesNavigationIsReadyFromSerializedState } from "next/router";
-import { _runWithCacheState, configureMemoryCacheHandler as __configureMemoryCacheHandler } from "next/cache";
+import { _runWithCacheState } from "vinext/shims/cache-request-state";
+import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
 import { registerConfiguredCacheAdapters as __registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { runWithPrivateCache } from "vinext/cache-runtime";
 import { ensureFetchPatch, runWithFetchCache } from "vinext/fetch-cache";