Revert "[Segment Cache] Add "client-only" option (#77655)"

This reverts commit 713caf6.

Author: huozhi

packages/next/src/client/components/segment-cache-impl/cache.ts

@@ -1028,7 +1028,6 @@ export async function fetchRouteOnCacheMiss(
 
       writeDynamicTreeResponseIntoCache(
         Date.now(),
-        task,
         response,
         serverData,
         entry,
@@ -1247,10 +1246,6 @@ export async function fetchSegmentPrefetchesUsingDynamicRequest(
       prefetchStream
     ) as Promise<NavigationFlightResponse>)
 
-    // Since we did not set the prefetch header, the response from the server
-    // will never contain dynamic holes.
-    const isResponsePartial = false
-
     // Aside from writing the data into the cache, this function also returns
     // the entries that were fulfilled, so we can streamingly update their sizes
     // in the LRU as more data comes in.
@@ -1259,7 +1254,6 @@ export async function fetchSegmentPrefetchesUsingDynamicRequest(
       task,
       response,
       serverData,
-      isResponsePartial,
       route,
       spawnedEntries
     )
@@ -1275,7 +1269,6 @@ export async function fetchSegmentPrefetchesUsingDynamicRequest(
 
 function writeDynamicTreeResponseIntoCache(
   now: number,
-  task: PrefetchTask,
   response: Response,
   serverData: NavigationFlightResponse,
   entry: PendingRouteCacheEntry,
@@ -1318,43 +1311,16 @@ function writeDynamicTreeResponseIntoCache(
     staleTimeHeaderSeconds !== null
       ? parseInt(staleTimeHeaderSeconds, 10) * 1000
       : STATIC_STALETIME_MS
-
-  // If the response contains dynamic holes, then we must conservatively assume
-  // that any individual segment might contain dynamic holes, and also the
-  // head. If it did not contain dynamic holes, then we can assume every segment
-  // and the head is completely static.
-  const isResponsePartial =
-    response.headers.get(NEXT_DID_POSTPONE_HEADER) === '1'
-
-  const fulfilledEntry = fulfillRouteCacheEntry(
+  fulfillRouteCacheEntry(
     entry,
     convertRootFlightRouterStateToRouteTree(flightRouterState),
     flightData.head,
-    isResponsePartial,
+    flightData.isHeadPartial,
     now + staleTimeMs,
     couldBeIntercepted,
     canonicalUrl,
     routeIsPPREnabled
   )
-
-  // If the server sent segment data as part of the response, we should write
-  // it into the cache to prevent a second, redundant prefetch request.
-  //
-  // TODO: When `clientSegmentCache` is enabled, the server does not include
-  // segment data when responding to a route tree prefetch request. However,
-  // when `clientSegmentCache` is set to "client-only", and PPR is enabled (or
-  // the page is fully static), the normal check is bypassed and the server
-  // responds with the full page. This is a temporary situation until we can
-  // remove the "client-only" option. Then, we can delete this function call.
-  writeDynamicRenderResponseIntoCache(
-    now,
-    task,
-    response,
-    serverData,
-    isResponsePartial,
-    fulfilledEntry,
-    null
-  )
 }
 
 function rejectSegmentEntriesIfStillPending(
@@ -1377,19 +1343,16 @@ function writeDynamicRenderResponseIntoCache(
   task: PrefetchTask,
   response: Response,
   serverData: NavigationFlightResponse,
-  isResponsePartial: boolean,
   route: FulfilledRouteCacheEntry,
-  spawnedEntries: Map<string, PendingSegmentCacheEntry> | null
+  spawnedEntries: Map<string, PendingSegmentCacheEntry>
 ): Array<FulfilledSegmentCacheEntry> | null {
   if (serverData.b !== getAppBuildId()) {
     // The server build does not match the client. Treat as a 404. During
     // an actual navigation, the router will trigger an MPA navigation.
     // TODO: Consider moving the build ID to a response header so we can check
     // it before decoding the response, and so there's one way of checking
     // across all response types.
-    if (spawnedEntries !== null) {
-      rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000)
-    }
+    rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000)
     return null
   }
   const flightDatas = normalizeFlightData(serverData.f)
@@ -1432,7 +1395,6 @@ function writeDynamicRenderResponseIntoCache(
         route,
         now + staleTimeMs,
         seedData,
-        isResponsePartial,
         segmentKey,
         spawnedEntries
       )
@@ -1446,14 +1408,11 @@ function writeDynamicRenderResponseIntoCache(
   // segments we're marking as rejected here. We should mark on the segment
   // somehow that the reason for the rejection is because of a non-PPR prefetch.
   // That way a per-segment prefetch knows to disregard the rejection.
-  if (spawnedEntries !== null) {
-    const fulfilledEntries = rejectSegmentEntriesIfStillPending(
-      spawnedEntries,
-      now + 10 * 1000
-    )
-    return fulfilledEntries
-  }
-  return null
+  const fulfilledEntries = rejectSegmentEntriesIfStillPending(
+    spawnedEntries,
+    now + 10 * 1000
+  )
+  return fulfilledEntries
 }
 
 function writeSeedDataIntoCache(
@@ -1462,9 +1421,8 @@ function writeSeedDataIntoCache(
   route: FulfilledRouteCacheEntry,
   staleAt: number,
   seedData: CacheNodeSeedData,
-  isResponsePartial: boolean,
   key: string,
-  entriesOwnedByCurrentTask: Map<string, PendingSegmentCacheEntry> | null
+  entriesOwnedByCurrentTask: Map<string, PendingSegmentCacheEntry>
 ) {
   // This function is used to write the result of a dynamic server request
   // (CacheNodeSeedData) into the prefetch cache. It's used in cases where we
@@ -1473,15 +1431,12 @@ function writeSeedDataIntoCache(
   // dynamic data into being static) and when prefetching a PPR-disabled route
   const rsc = seedData[1]
   const loading = seedData[3]
-  const isPartial = rsc === null || isResponsePartial
+  const isPartial = rsc === null
 
   // We should only write into cache entries that are owned by us. Or create
   // a new one and write into that. We must never write over an entry that was
   // created by a different task, because that causes data races.
-  const ownedEntry =
-    entriesOwnedByCurrentTask !== null
-      ? entriesOwnedByCurrentTask.get(key)
-      : undefined
+  const ownedEntry = entriesOwnedByCurrentTask.get(key)
   if (ownedEntry !== undefined) {
     fulfillSegmentCacheEntry(ownedEntry, rsc, loading, staleAt, isPartial)
   } else {
@@ -1526,7 +1481,6 @@ function writeSeedDataIntoCache(
           route,
           staleAt,
           childSeedData,
-          isResponsePartial,
           encodeChildSegmentKey(
             key,
             parallelRouteKey,

packages/next/src/export/index.ts

@@ -391,10 +391,7 @@ async function exportAppImpl(
       clientTraceMetadata: nextConfig.experimental.clientTraceMetadata,
       expireTime: nextConfig.expireTime,
       dynamicIO: nextConfig.experimental.dynamicIO ?? false,
-      clientSegmentCache:
-        nextConfig.experimental.clientSegmentCache === 'client-only'
-          ? 'client-only'
-          : Boolean(nextConfig.experimental.clientSegmentCache),
+      clientSegmentCache: nextConfig.experimental.clientSegmentCache ?? false,
       inlineCss: nextConfig.experimental.inlineCss ?? false,
       authInterrupts: !!nextConfig.experimental.authInterrupts,
     },

packages/next/src/server/app-render/app-render.tsx

@@ -4220,17 +4220,7 @@ async function collectSegmentData(
   // decomposed into a separate stream per segment.
 
   const clientReferenceManifest = renderOpts.clientReferenceManifest
-  if (
-    !clientReferenceManifest ||
-    // Do not generate per-segment data unless the experimental Segment Cache
-    // flag is enabled.
-    //
-    // We also skip generating segment data if flag is set to "client-only",
-    // rather than true. (The "client-only" option only affects the behavior of
-    // the client-side implementation; per-segment prefetches are intentionally
-    // disabled in that configuration).
-    renderOpts.experimental.clientSegmentCache !== true
-  ) {
+  if (!clientReferenceManifest || !renderOpts.experimental.clientSegmentCache) {
     return
   }
 

packages/next/src/server/app-render/types.ts

@@ -213,7 +213,7 @@ export interface RenderOptsPartial {
     expireTime: number | undefined
     clientTraceMetadata: string[] | undefined
     dynamicIO: boolean
-    clientSegmentCache: boolean | 'client-only'
+    clientSegmentCache: boolean
     inlineCss: boolean
     authInterrupts: boolean
   }

packages/next/src/server/base-server.ts

@@ -605,9 +605,7 @@ export default abstract class Server<
         clientTraceMetadata: this.nextConfig.experimental.clientTraceMetadata,
         dynamicIO: this.nextConfig.experimental.dynamicIO ?? false,
         clientSegmentCache:
-          this.nextConfig.experimental.clientSegmentCache === 'client-only'
-            ? 'client-only'
-            : Boolean(this.nextConfig.experimental.clientSegmentCache),
+          this.nextConfig.experimental.clientSegmentCache ?? false,
         inlineCss: this.nextConfig.experimental.inlineCss ?? false,
         authInterrupts: !!this.nextConfig.experimental.authInterrupts,
       },

packages/next/src/server/config-schema.ts

@@ -299,9 +299,7 @@ export const configSchema: zod.ZodType<NextConfig> = z.lazy(() =>
         memoryBasedWorkersCount: z.boolean().optional(),
         craCompat: z.boolean().optional(),
         caseSensitiveRoutes: z.boolean().optional(),
-        clientSegmentCache: z
-          .union([z.boolean(), z.literal('client-only')])
-          .optional(),
+        clientSegmentCache: z.boolean().optional(),
         disableOptimizedLoading: z.boolean().optional(),
         disablePostcssPresetEnv: z.boolean().optional(),
         dynamicIO: z.boolean().optional(),

packages/next/src/server/config-shared.ts

@@ -269,7 +269,7 @@ export interface ExperimentalConfig {
   prerenderEarlyExit?: boolean
   linkNoTouchStart?: boolean
   caseSensitiveRoutes?: boolean
-  clientSegmentCache?: boolean | 'client-only'
+  clientSegmentCache?: boolean
   appDocumentPreloading?: boolean
   preloadEntriesOnStart?: boolean
   /** @default true */