vinext 0.1.5 → 0.1.7

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/client-build-config.d.ts

@@ -26,12 +26,10 @@ declare function createClientAssetFileNames(assetsDir: string): (assetInfo: Clie
  *
  * Splits the client bundle into:
  * - "framework" — React, ReactDOM, and scheduler (loaded on every page)
- * - "vinext"    — vinext shims (router, head, link, etc.)
+ * - "vinext"    — shared vinext runtime shims
  *
- * All other vendor code is left to Rollup's default chunk-splitting
- * algorithm. Rollup automatically deduplicates shared modules into
- * common chunks based on the import graph — no manual intervention
- * needed.
+ * Route-owned client shims and all other vendor code are left to the bundler's
+ * graph-based chunking so they stay behind their client-reference boundaries.
  *
  * Why not split every npm package into its own chunk?
  * - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a
@@ -48,7 +46,7 @@ declare function createClientAssetFileNames(assetsDir: string): (assetInfo: Clie
  *   well: shared dependencies between routes get their own chunks,
  *   and route-specific code stays in route chunks.
  */
-declare function createClientManualChunks(shimsDir: string): (id: string) => string | undefined;
+declare function createClientManualChunks(shimsDir: string, preserveRouteBoundaries?: boolean): (id: string) => string | undefined;
 /**
  * Rollup output config with manualChunks for client code-splitting.
  * Used by both CLI builds and multi-environment builds.

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

@@ -1,4 +1,18 @@
 //#region src/build/client-build-config.ts
+const ROUTE_OWNED_CLIENT_SHIMS = new Set([
+	"compat-router",
+	"dynamic",
+	"dynamic-preload-chunks",
+	"form",
+	"image",
+	"layout-segment-context",
+	"legacy-image",
+	"link",
+	"offline",
+	"router",
+	"script",
+	"web-vitals"
+]);
 const NEXT_CLIENT_CSS_ASSET_FILE_NAMES = "css/[name].[hash:8][extname]";
 const NEXT_CLIENT_STATIC_MEDIA_FILE_NAMES = "media/[name].[hash:8][extname]";
 function joinAssetFileNamePattern(assetsDir, pattern) {
@@ -48,12 +62,10 @@ function getPackageName(id) {
 *
 * Splits the client bundle into:
 * - "framework" — React, ReactDOM, and scheduler (loaded on every page)
-* - "vinext"    — vinext shims (router, head, link, etc.)
+* - "vinext"    — shared vinext runtime shims
 *
-* All other vendor code is left to Rollup's default chunk-splitting
-* algorithm. Rollup automatically deduplicates shared modules into
-* common chunks based on the import graph — no manual intervention
-* needed.
+* Route-owned client shims and all other vendor code are left to the bundler's
+* graph-based chunking so they stay behind their client-reference boundaries.
 *
 * Why not split every npm package into its own chunk?
 * - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a
@@ -70,7 +82,7 @@ function getPackageName(id) {
 *   well: shared dependencies between routes get their own chunks,
 *   and route-specific code stays in route chunks.
 */
-function createClientManualChunks(shimsDir) {
+function createClientManualChunks(shimsDir, preserveRouteBoundaries = false) {
 	return function clientManualChunks(id) {
 		if (id.includes("node_modules")) {
 			const pkg = getPackageName(id);
@@ -78,7 +90,15 @@ function createClientManualChunks(shimsDir) {
 			if (pkg === "react" || pkg === "react-dom" || pkg === "scheduler") return "framework";
 			return;
 		}
-		if (id.startsWith(shimsDir)) return "vinext";
+		if (id.startsWith(shimsDir)) {
+			if (preserveRouteBoundaries) {
+				const relativeId = id.slice(shimsDir.length).split("?", 1)[0] ?? "";
+				const extensionIndex = relativeId.lastIndexOf(".");
+				const shimName = extensionIndex === -1 ? relativeId : relativeId.slice(0, extensionIndex);
+				if (ROUTE_OWNED_CLIENT_SHIMS.has(shimName)) return void 0;
+			}
+			return "vinext";
+		}
 	};
 }
 /**

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

@@ -306,7 +306,6 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 		for (const route of bundlePageRoutes) {
 			if (BLOCKED_PAGES.includes(route.pattern)) continue;
 			if (route.pattern === "/404") continue;
-			if (!routes.find((r) => r.filePath === route.filePath || r.pattern === route.pattern)) continue;
 			const { type, revalidate: classifiedRevalidate } = classifyPagesRoute(route.filePath);
 			if (type === "ssr") {
 				if (mode === "export") results.push({
@@ -648,7 +647,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					});
 					continue;
 				}
-				if (!Array.isArray(paramSets) || paramSets.length === 0) {
+				if (paramSets.length === 0) {
 					results.push({
 						route: route.pattern,
 						status: "skipped",

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

@@ -44,7 +44,8 @@ type AppRouterConfig = {
   reactMaxHeadersLength?: number; /** Maximum in-memory cache size in bytes. 0 disables the default memory cache. */
   cacheMaxMemorySize?: number; /** Inline app CSS into production HTML (from experimental.inlineCss). */
   inlineCss?: boolean; /** Enables Next.js Cache Components semantics for App Router document HTML. */
-  cacheComponents?: boolean; /** Internationalization routing config for middleware matcher locale handling. */
+  cacheComponents?: boolean; /** Whether the RSC build discovered any server references. Defaults to true. */
+  hasServerActions?: boolean; /** Internationalization routing config for middleware matcher locale handling. */
   i18n?: NextI18nConfig | null;
   imageConfig?: ImageConfig;
   /**

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

@@ -20,6 +20,8 @@ const middlewareRequestHeadersPath = resolveEntryPath("../server/middleware-requ
 const normalizePathModulePath = resolveEntryPath("../server/normalize-path.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 appMiddlewarePath = resolveEntryPath("../server/app-middleware.js", import.meta.url);
+const metadataRouteResponsePath = resolveEntryPath("../server/metadata-route-response.js", import.meta.url);
 const appServerActionExecutionPath = resolveEntryPath("../server/app-server-action-execution.js", import.meta.url);
 const appRscErrorsPath = resolveEntryPath("../server/app-rsc-errors.js", import.meta.url);
 const appPageExecutionPath = resolveEntryPath("../server/app-page-execution.js", import.meta.url);
@@ -73,6 +75,7 @@ function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, global
 	const cacheMaxMemorySize = config?.cacheMaxMemorySize;
 	const inlineCss = config?.inlineCss === true;
 	const cacheComponents = config?.cacheComponents === true;
+	const hasServerActions = config?.hasServerActions !== false;
 	const i18nConfig = config?.i18n ?? null;
 	const hasPagesDir = config?.hasPagesDir ?? false;
 	const publicFiles = config?.publicFiles ?? [];
@@ -93,12 +96,12 @@ async function __loadPrerenderPagesRoutes() {
 import ${JSON.stringify(serverGlobalsPath)};
 import {
   renderToReadableStream as _renderToReadableStream,
-  decodeAction,
+  ${hasServerActions ? `decodeAction,
   decodeFormState,
   decodeReply,
   loadServerAction,
-  createTemporaryReferenceSet,
-} from "@vitejs/plugin-rsc/rsc";
+  createTemporaryReferenceSet,` : ""}
+} from ${JSON.stringify(hasServerActions ? "@vitejs/plugin-rsc/rsc" : "@vitejs/plugin-rsc/react/rsc")};
 import { createClientManifest as _createClientManifest } from "@vitejs/plugin-rsc/core/rsc";
 import { prerender as _prerender } from "@vitejs/plugin-rsc/vendor/react-server-dom/static.edge";
 import { createRscPrerenderer, createRscRenderer } from ${JSON.stringify(rscStreamHintsPath)};
@@ -112,7 +115,8 @@ import { getNavigationContext as _getNavigationContext } from "next/navigation";
 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))};` : ""}
+${middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};
+import { applyAppMiddleware as __applyAppMiddleware } from ${JSON.stringify(appMiddlewarePath)};` : ""}
 ${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(normalizePathSeparators(instrumentationPath))};
 import { ensureInstrumentationRegistered as __ensureInstrumentationRegistered } from ${JSON.stringify(instrumentationRuntimePath)};` : ""}
 import { createAppRscHandler } from "vinext/server/app-rsc-handler";
@@ -123,7 +127,8 @@ ${hasPagesDir ? `import {
   applyRouteHandlerMiddlewareContext as __applyRouteHandlerMiddlewareContext,
 } from ${JSON.stringify(appRouteHandlerResponsePath)};` : ""}
 const __loadAppRouteHandlerDispatch = () => import(${JSON.stringify(appRouteHandlerDispatchPath)});
-const __loadAppServerActionExecution = () => import(${JSON.stringify(appServerActionExecutionPath)});
+${hasServerActions ? `const __loadAppServerActionExecution = () => import(${JSON.stringify(appServerActionExecutionPath)});` : ""}
+${(metadataRoutes?.length ?? 0) > 0 ? `const __loadMetadataRouteResponse = () => import(${JSON.stringify(metadataRouteResponsePath)});` : ""}
 import {
   sanitizeErrorForClient as __sanitizeErrorForClient,
 } from ${JSON.stringify(appRscErrorsPath)};
@@ -683,6 +688,7 @@ export default createAppRscHandler({
   ${instrumentationPath ? `ensureInstrumentation() {
     return __ensureInstrumentationRegistered(_instrumentation);
   },` : ""}
+  ${hasServerActions ? `
   async handleProgressiveActionRequest({
     actionId,
     cleanPathname,
@@ -860,13 +866,33 @@ export default createAppRscHandler({
       },
     });
   },
+  ` : ""}
   i18nConfig: __i18nConfig,
-  isMiddlewareProxy: ${JSON.stringify(middlewarePath ? isProxyFile(middlewarePath) : false)},
   ${hasPagesDir ? `loadPrerenderPagesRoutes: __loadPrerenderPagesRoutes,` : ""}
-  makeThenableParams,
+  ${(metadataRoutes?.length ?? 0) > 0 ? `async handleMetadataRouteRequest(cleanPathname) {
+    const { handleMetadataRouteRequest: __handleMetadataRouteRequest } =
+      await __loadMetadataRouteResponse();
+    return __handleMetadataRouteRequest({
+      metadataRoutes,
+      cleanPathname,
+      makeThenableParams,
+    });
+  },` : ""}
   matchRoute,
-  metadataRoutes,
-  middlewareModule: ${middlewarePath ? "middlewareModule" : "null"},
+  ${middlewarePath ? `runMiddleware({ cleanPathname, context, isDataRequest, request }) {
+    return __applyAppMiddleware({
+      basePath: __basePath,
+      cleanPathname,
+      context,
+      filePath: ${JSON.stringify(middlewarePath ? normalizePathSeparators(middlewarePath) : "")},
+      i18nConfig: __i18nConfig,
+      isDataRequest,
+      isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
+      module: middlewareModule,
+      request,
+      trailingSlash: __trailingSlash,
+    });
+  },` : ""}
   publicFiles: __publicFiles,
   renderNotFound({ isRscRequest, matchedParams, middlewareContext, request, route, scriptNonce }) {
     const __isEdge = route ? __isEdgeRuntime(__resolveAppPageSegmentConfig({ layouts: route.layouts, page: route.page }).runtime) : false;

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))},