fix: skip page RSC ISR caching for dynamic requests (#629)

* fix: skip page RSC ISR caching for dynamic requests

* test: align page ISR assertions with helper extraction

Author: southpolesteve

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

@@ -365,6 +365,7 @@ import { readAppRouteHandlerCacheResponse as __readAppRouteHandlerCacheResponse
 import {
   finalizeAppPageHtmlCacheResponse as __finalizeAppPageHtmlCacheResponse,
   readAppPageCacheResponse as __readAppPageCacheResponse,
+  scheduleAppPageRscCacheWrite as __scheduleAppPageRscCacheWrite,
 } from ${JSON.stringify(appPageCachePath)};
 import {
   buildAppPageHtmlResponse as __buildAppPageHtmlResponse,
@@ -2792,7 +2793,9 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
     // The RSC stream is consumed lazily - components render when chunks are read.
     // If we clear context now, headers()/cookies() will fail during rendering.
     // Context will be cleared when the next request starts (via runWithRequestContext).
+    const __dynamicUsedInRsc = consumeDynamicUsage();
     const __rscResponsePolicy = __resolveAppPageRscResponsePolicy({
+      dynamicUsedDuringBuild: __dynamicUsedInRsc,
       isDynamicError,
       isForceDynamic,
       isForceStatic,
@@ -2814,21 +2817,22 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
     // For ISR-eligible RSC requests in production: write rscData to its own key.
     // HTML is stored under a separate key (written by the HTML path below) so
     // these writes never race or clobber each other.
-    if (process.env.NODE_ENV === "production" && __isrRscDataPromise) {
-      const __isrKeyRsc = __isrRscKey(cleanPathname);
-      const __revalSecsRsc = revalidateSeconds;
-      const __rscWritePromise = (async () => {
-        try {
-          const __rscDataForCache = await __isrRscDataPromise;
-          const __pageTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-          await __isrSet(__isrKeyRsc, { kind: "APP_PAGE", html: "", rscData: __rscDataForCache, headers: undefined, postponed: undefined, status: 200 }, __revalSecsRsc, __pageTags);
-          __isrDebug?.("RSC cache written", __isrKeyRsc);
-        } catch (__rscWriteErr) {
-          console.error("[vinext] ISR RSC cache write error:", __rscWriteErr);
-        }
-      })();
-      _getRequestExecutionContext()?.waitUntil(__rscWritePromise);
-    }
+    __scheduleAppPageRscCacheWrite({
+      capturedRscDataPromise: process.env.NODE_ENV === "production" ? __isrRscDataPromise : null,
+      cleanPathname,
+      consumeDynamicUsage,
+      dynamicUsedDuringBuild: __dynamicUsedInRsc,
+      getPageTags() {
+        return __pageCacheTags(cleanPathname, getCollectedFetchTags());
+      },
+      isrDebug: __isrDebug,
+      isrRscKey: __isrRscKey,
+      isrSet: __isrSet,
+      revalidateSeconds,
+      waitUntil(promise) {
+        _getRequestExecutionContext()?.waitUntil(promise);
+      },
+    });
     return __rscResponse;
   }
 

packages/vinext/src/server/app-page-cache.ts

@@ -49,6 +49,19 @@ export interface FinalizeAppPageHtmlCacheResponseOptions {
   waitUntil?: (promise: Promise<void>) => void;
 }
 
+export interface ScheduleAppPageRscCacheWriteOptions {
+  capturedRscDataPromise: Promise<ArrayBuffer> | null;
+  cleanPathname: string;
+  consumeDynamicUsage: () => boolean;
+  dynamicUsedDuringBuild: boolean;
+  getPageTags: () => string[];
+  isrDebug?: AppPageDebugLogger;
+  isrRscKey: (pathname: string) => string;
+  isrSet: AppPageCacheSetter;
+  revalidateSeconds: number;
+  waitUntil?: (promise: Promise<void>) => void;
+}
+
 function buildAppPageCacheControl(
   cacheState: BuildAppPageCachedResponseOptions["cacheState"],
   revalidateSeconds: number,
@@ -250,3 +263,42 @@ export function finalizeAppPageHtmlCacheResponse(
     headers: response.headers,
   });
 }
+
+export function scheduleAppPageRscCacheWrite(
+  options: ScheduleAppPageRscCacheWriteOptions,
+): boolean {
+  const capturedRscDataPromise = options.capturedRscDataPromise;
+  if (!capturedRscDataPromise || options.dynamicUsedDuringBuild) {
+    return false;
+  }
+
+  const rscKey = options.isrRscKey(options.cleanPathname);
+  const cachePromise = (async () => {
+    try {
+      const rscData = await capturedRscDataPromise;
+
+      // Two-phase dynamic detection:
+      // 1. dynamicUsedDuringBuild catches searchParams-driven opt-in before the
+      //    RSC response is sent.
+      // 2. consumeDynamicUsage() here catches APIs that fire while the RSC
+      //    stream is consumed (headers(), cookies(), noStore()).
+      if (options.consumeDynamicUsage()) {
+        options.isrDebug?.("RSC cache write skipped (dynamic usage during render)", rscKey);
+        return;
+      }
+
+      await options.isrSet(
+        rscKey,
+        buildAppPageCacheValue("", rscData, 200),
+        options.revalidateSeconds,
+        options.getPageTags(),
+      );
+      options.isrDebug?.("RSC cache written", rscKey);
+    } catch (cacheError) {
+      console.error("[vinext] ISR RSC cache write error:", cacheError);
+    }
+  })();
+
+  options.waitUntil?.(cachePromise);
+  return true;
+}

packages/vinext/src/server/app-page-response.ts

@@ -15,15 +15,19 @@ export interface AppPageResponsePolicy {
   cacheState?: "MISS" | "STATIC";
 }
 
-export interface ResolveAppPageRscResponsePolicyOptions {
+interface ResolveAppPageResponsePolicyBaseOptions {
   isDynamicError: boolean;
   isForceDynamic: boolean;
   isForceStatic: boolean;
   isProduction: boolean;
   revalidateSeconds: number | null;
 }
 
-export interface ResolveAppPageHtmlResponsePolicyOptions extends ResolveAppPageRscResponsePolicyOptions {
+export interface ResolveAppPageRscResponsePolicyOptions extends ResolveAppPageResponsePolicyBaseOptions {
+  dynamicUsedDuringBuild: boolean;
+}
+
+export interface ResolveAppPageHtmlResponsePolicyOptions extends ResolveAppPageResponsePolicyBaseOptions {
   dynamicUsedDuringRender: boolean;
 }
 
@@ -74,7 +78,7 @@ function applyTimingHeader(headers: Headers, timing?: AppPageResponseTiming): vo
 export function resolveAppPageRscResponsePolicy(
   options: ResolveAppPageRscResponsePolicyOptions,
 ): AppPageResponsePolicy {
-  if (options.isForceDynamic) {
+  if (options.isForceDynamic || options.dynamicUsedDuringBuild) {
     return { cacheControl: NO_STORE_CACHE_CONTROL };
   }