fix(app-router): avoid runtime route-tree prefetch sizing

packages/vinext/src/config/next-config.ts

@@ -150,6 +150,13 @@ export type MdxOptions = {
   recmaPlugins?: unknown[];
 };
 
+export type PrefetchInliningConfig =
+  | false
+  | {
+      maxBundleSize: number;
+      maxSize: number;
+    };
+
 export type NextConfig = {
   /** Additional env variables */
   env?: Record<string, string>;
@@ -302,6 +309,12 @@ export type NextConfig = {
      * `useRouter().experimental_gesturePush()`.
      */
     gestureTransition?: boolean;
+    /**
+     * Enables App Router Segment Cache prefetch inlining. When provided as an
+     * object, thresholds are resolved with Next.js defaults and non-finite
+     * values are clamped to Number.MAX_SAFE_INTEGER.
+     */
+    prefetchInlining?: boolean | { maxBundleSize?: number; maxSize?: number };
     [key: string]: unknown;
   };
   /**
@@ -368,11 +381,10 @@ export type ResolvedNextConfig = {
    */
   gestureTransition: boolean;
   /**
-   * Whether `experimental.prefetchInlining` is configured. Next.js uses this
-   * with the Segment Cache to fetch the route tree before the bundled inlined
-   * segment payload.
+   * Resolved `experimental.prefetchInlining` config. Next.js normalizes `true`
+   * and partial object config into concrete thresholds.
    */
-  prefetchInlining: boolean;
+  prefetchInlining: PrefetchInliningConfig;
   redirects: NextRedirect[];
   rewrites: {
     beforeFiles: NextRewrite[];
@@ -1334,6 +1346,21 @@ function resolveStaleTimes(experimental: Record<string, unknown> | undefined): {
   };
 }
 
+function normalizePrefetchInliningConfig(value: unknown): PrefetchInliningConfig {
+  if (!value) return false;
+  const raw = isUnknownRecord(value) ? value : null;
+  const maxSize = raw ? (raw.maxSize ?? 2048) : 2048;
+  const maxBundleSize = raw ? (raw.maxBundleSize ?? 10240) : 10240;
+  const normalizedMaxSize = Number(maxSize);
+  const normalizedMaxBundleSize = Number(maxBundleSize);
+  return {
+    maxBundleSize: Number.isFinite(normalizedMaxBundleSize)
+      ? normalizedMaxBundleSize
+      : Number.MAX_SAFE_INTEGER,
+    maxSize: Number.isFinite(normalizedMaxSize) ? normalizedMaxSize : Number.MAX_SAFE_INTEGER,
+  };
+}
+
 /**
  * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
  * Awaits async functions for redirects/rewrites/headers.
@@ -1503,8 +1530,7 @@ export async function resolveNextConfig(
     : [];
   const inlineCss = experimental?.inlineCss === true;
   const globalNotFound = experimental?.globalNotFound === true;
-  const prefetchInlining =
-    experimental?.prefetchInlining === true || isUnknownRecord(experimental?.prefetchInlining);
+  const prefetchInlining = normalizePrefetchInliningConfig(experimental?.prefetchInlining);
 
   // Validate experimental.appShells co-flags. Next.js requires all of the
   // following to be enabled when appShells is true:
@@ -1517,7 +1543,7 @@ export async function resolveNextConfig(
     if (!config.cacheComponents) {
       missingCoFlags.push("cacheComponents");
     }
-    if (experimental?.prefetchInlining !== true) {
+    if (!prefetchInlining) {
       missingCoFlags.push("experimental.prefetchInlining");
     }
     if (experimental?.varyParams !== true) {

packages/vinext/src/entries/app-rsc-entry.ts

@@ -16,6 +16,7 @@ import type {
   NextI18nConfig,
   NextRedirect,
   NextRewrite,
+  PrefetchInliningConfig,
 } from "../config/next-config.js";
 import type { ImageConfig } from "../server/image-optimization.js";
 import type { AppRoute } from "../routing/app-router.js";
@@ -164,6 +165,8 @@ type AppRouterConfig = {
   globalNotFound?: boolean;
   /** Enables Next.js Cache Components semantics for App Router document HTML. */
   cacheComponents?: boolean;
+  /** Resolved `experimental.prefetchInlining` thresholds. */
+  prefetchInlining?: PrefetchInliningConfig;
   /** Whether the RSC build discovered any server references. Defaults to true. */
   hasServerActions?: boolean;
   /** Internationalization routing config for middleware matcher locale handling. */
@@ -227,6 +230,7 @@ export function generateRscEntry(
   const cacheMaxMemorySize = config?.cacheMaxMemorySize;
   const inlineCss = config?.inlineCss === true;
   const cacheComponents = config?.cacheComponents === true;
+  const prefetchInlining = config?.prefetchInlining ?? false;
   const hasServerActions = config?.hasServerActions !== false;
   const i18nConfig = config?.i18n ?? null;
   const hasPagesDir = config?.hasPagesDir ?? false;
@@ -706,6 +710,7 @@ export default createAppRscHandler({
   basePath: __basePath,
   buildId: process.env.__VINEXT_BUILD_ID ?? null,
   ensureRouteLoaded: __ensureRouteLoaded,
+  prefetchInlining: ${JSON.stringify(prefetchInlining)},
   clearRequestContext() {
     __clearRequestContext();
   },

packages/vinext/src/index.ts

@@ -3308,6 +3308,7 @@ export default function vinext(options: VinextOptions = {}): PluginOption[] {
               inlineCss: nextConfig?.inlineCss,
               globalNotFound: nextConfig?.globalNotFound,
               cacheComponents: nextConfig?.cacheComponents,
+              prefetchInlining: nextConfig?.prefetchInlining,
               hasServerActions,
               i18n: nextConfig?.i18n,
               imageConfig: {

packages/vinext/src/server/app-browser-entry.ts

@@ -503,6 +503,7 @@ async function learnOptimisticRouteTemplatesFromPrefetchCache(options: {
     if (optimisticRouteTemplateSources.has(sourceKey)) continue;
     if (optimisticRouteTemplateLearning.has(sourceKey)) continue;
     if (!isSettledPrefetchCacheEntry(entry)) continue;
+    if (entry.prefetchKind === "route-tree") continue;
 
     const promise = learnOptimisticRouteTemplateFromPrefetch({
       cacheKey,