nextjs-cache-short-expire-dev/solution/gold.patch

diff --git a/packages/next/src/server/lib/cache-handlers/default.ts b/packages/next/src/server/lib/cache-handlers/default.ts
index 5a215994fe..0270c24b62 100644
--- a/packages/next/src/server/lib/cache-handlers/default.ts
+++ b/packages/next/src/server/lib/cache-handlers/default.ts
@@ -20,6 +20,7 @@ import {
   tagsManifest,
   type TagManifestEntry,
 } from '../incremental-cache/tags-manifest.external'
+import { MIN_PRERENDERABLE_EXPIRE } from '../../use-cache/constants'
 
 type PrivateCacheEntry = {
   entry: CacheEntry
@@ -83,10 +84,30 @@ export function createDefaultCacheHandler(maxSize: number): CacheHandler {
 
       const entry = privateEntry.entry
 
+      // A negative `expire` is an eviction sentinel: the tiered cache handler
+      // (dev-only) marks a front entry for deletion by overwriting it with a
+      // negative `expire`, since the cache-handler interface has no per-key
+      // delete. Treat it as missing here, independently of the minimum
+      // retention below (which would otherwise keep it alive). This is distinct
+      // from `revalidate = -1` below, which keeps serving the entry but forces
+      // a revalidation.
+      if (entry.expire < 0) {
+        debug?.('get', cacheKey, 'evicted')
+        return undefined
+      }
+
       // The dev server serves stale entries until they expire (see the file
-      // overview); production drops them once past the revalidate time.
+      // overview); production drops them once past the revalidate time. In dev,
+      // an entry is retained for at least `MIN_PRERENDERABLE_EXPIRE` so that
+      // entries with a short `expire` (for example a `cacheLife({ expire: 0 })`
+      // client-only cache) still linger long enough that a reload hits the
+      // cache. That minimum is the same threshold below which the "use cache"
+      // wrapper treats an entry as dynamic, so it only extends the retention of
+      // entries that are dynamic anyway. It affects retention only; the
+      // returned entry keeps its real `expire`, so staging decisions are
+      // unchanged.
       const maxAgeSeconds = process.env.__NEXT_DEV_SERVER
-        ? entry.expire
+        ? Math.max(entry.expire, MIN_PRERENDERABLE_EXPIRE)
         : entry.revalidate
 
       if (
diff --git a/packages/next/src/server/use-cache/handlers.ts b/packages/next/src/server/use-cache/handlers.ts
index 8217c381ee..d9edb00284 100644
--- a/packages/next/src/server/use-cache/handlers.ts
+++ b/packages/next/src/server/use-cache/handlers.ts
@@ -107,26 +107,25 @@ export function initializeCacheHandlers(cacheMaxMemorySize: number): boolean {
   // Create a set of the cache handlers.
   reference[handlersSetSymbol] = new Set(handlersMap.values())
 
-  // In development we add dedicated built-in in-memory handlers so that warm
-  // reloads are fast. These are always built-in handlers, never a
-  // user-configured one, and are gated on the dev server so production behaves
-  // exactly as configured.
+  // In development we add dedicated built-in in-memory handlers so that reloads
+  // are fast. These are always built-in handlers, never a user-configured one,
+  // and are gated on the dev server so production behaves exactly as
+  // configured.
   if (process.env.__NEXT_DEV_SERVER) {
     reference[memoryCacheDisabledSymbol] = cacheMaxMemorySize === 0
 
-    // Private caches are persisted here so warm reloads are fast. Private
-    // entries can hold data specific to the incoming request (for example,
-    // derived from its cookies or headers), so this is never the
-    // user-configured `default` alias. Sized so it still caches under
-    // `cacheMaxMemorySize: 0` (otherwise it would become the no-op stub and
-    // private reloads would miss).
+    // Private caches are persisted here so reloads are fast. Private entries
+    // can hold data specific to the incoming request (for example, derived from
+    // its cookies or headers), so this is never the user-configured `default`
+    // alias. Sized so it still caches under `cacheMaxMemorySize: 0` (otherwise
+    // it would become the no-op stub and private reloads would miss).
     reference[privateHandlerSymbol] = createDefaultCacheHandler(
       DEV_MEMORY_CACHE_SIZE
     )
 
     // Built-in front handlers, one per custom kind, and the tiered handlers
     // that place a front in front of a (possibly slow or remote) backing
-    // handler so warm reads resolve in a microtask, are both created per kind
+    // handler so cache hits resolve in a microtask, are both created per kind
     // in `setCacheHandler`.
     reference[devFrontHandlersSymbol] = new Map()
     reference[devTieredHandlersSymbol] = new Map()
@@ -178,7 +177,7 @@ export function isMemoryCacheDisabled(): boolean {
  * Whether `kind` is backed by a real user-configured handler rather than the
  * built-in in-memory default. Such a handler may be slow or remote, so in
  * development a built-in front handler is placed in front of it (see
- * `getDevTieredCacheHandler`) to keep warm reads microtask-fast. The presence
+ * `getDevTieredCacheHandler`) to keep cache hits microtask-fast. The presence
  * of a dev front handler is the signal, since front handlers are created
  * exactly for user-registered kinds. Always `false` in production.
  */
@@ -193,7 +192,7 @@ export function isCustomCacheHandler(kind: string): boolean {
 /**
  * Get the dev-only tiered cache handler for a custom `kind`: a fast built-in
  * in-memory front handler in front of the user-configured backing handler, so
- * warm reads resolve in a microtask. Returns `undefined` if there is none (a
+ * cache hits resolve in a microtask. Returns `undefined` if there is none (a
  * built-in kind, or production).
  */
 export function getDevTieredCacheHandler(
@@ -307,11 +306,14 @@ export function setCacheHandler(
   reference[handlersSetSymbol].add(cacheHandler)
 
   // A user-configured handler may be slow or remote. In development, give it a
-  // dedicated built-in in-memory front handler so warm reads resolve in a
+  // dedicated built-in in-memory front handler so cache hits resolve in a
   // microtask, and pair the two into a tiered handler the wrapper reads
   // through. Both are created alongside registration so their lifecycle matches
   // the backing handler's, and the front handler's presence is the signal that
-  // this kind is backed by a real handler (see `isCustomCacheHandler`).
+  // this kind is backed by a real handler (see `isCustomCacheHandler`). Being a
+  // built-in default handler, the front inherits the dev minimum retention, so
+  // a short-`expire` value still hits the front instead of falling through to
+  // the slow backing on every read.
   if (process.env.__NEXT_DEV_SERVER) {
     const frontHandler = createDefaultCacheHandler(DEV_MEMORY_CACHE_SIZE)
     reference[devFrontHandlersSymbol]?.set(kind, frontHandler)
diff --git a/packages/next/src/server/use-cache/tiered-cache-handler.ts b/packages/next/src/server/use-cache/tiered-cache-handler.ts
index a73ba7e920..a5e8b3eeac 100644
--- a/packages/next/src/server/use-cache/tiered-cache-handler.ts
+++ b/packages/next/src/server/use-cache/tiered-cache-handler.ts
@@ -14,7 +14,7 @@ export type CacheReadWriteHandler = Pick<CacheHandler, 'get' | 'set'>
 /**
  * Development-only. Puts a fast built-in in-memory `front` handler in front of
  * a slower or persistent user-configured `backing` handler. Its only job is to
- * guarantee that warm reads resolve in a microtask (so they aren't counted as
+ * guarantee that cache hits resolve in a microtask (so they aren't counted as
  * cache misses at a staged-render boundary, which would otherwise surface a
  * cold cache indicator), while keeping the front in sync with the backing.
  *
@@ -76,9 +76,9 @@ export function createTieredCacheHandler(
       const frontEntry = await front.get(cacheKey, softTags)
 
       if (frontEntry) {
-        // Warm hit: serve immediately (in a microtask). A background reconcile
+        // Cache hit: serve immediately (in a microtask). A background reconcile
         // keeps the front in sync with the backing for the next read;
-        // reconciles for the same key are serialized, so concurrent warm reads
+        // reconciles for the same key are serialized, so concurrent cache hits
         // don't hit the backing in parallel.
         scheduleBackgroundSync(cacheKey, () =>
           reconcileFrontFromBacking(
@@ -104,7 +104,7 @@ export function createTieredCacheHandler(
       }
 
       // Mirror this freshly read backing entry into the front so the next read
-      // is warm. The mirror is serialized per key: if a sync is already
+      // hits it. The mirror is serialized per key: if a sync is already
       // running, this chains after it, so the front converges to this read even
       // if the backing changed since that sync started.
       const [servedEntry, mirroredEntry] = cloneCacheEntry(backingEntry)
@@ -130,9 +130,9 @@ export function createTieredCacheHandler(
 }
 
 /**
- * After serving a warm front hit, consult the backing and mirror a newer entry
- * into the front for the next read. Runs in the background; failures are
- * non-fatal.
+ * After serving a cache hit from the front, consult the backing and mirror a
+ * newer entry into the front for the next read. Runs in the background;
+ * failures are non-fatal.
  */
 async function reconcileFrontFromBacking(
   front: CacheHandler,
@@ -186,17 +186,18 @@ async function mirrorIntoFront(
 
 /**
  * Build an already-expired copy of an entry, used to evict it from the front
- * handler (which has no per-key delete) once the backing no longer has it. In
- * dev the default handler treats an entry as missing once `now > timestamp +
- * expire * 1000`, so `expire: 0` against the original (past) timestamp makes
- * the next read a miss. The value is never read once the entry is expired, but
- * it must carry at least one byte because the built-in LRU cache refuses to
- * store size-0 entries.
+ * handler (which has no per-key delete) once the backing no longer has it. The
+ * default handler treats a negative `expire` as an eviction sentinel and
+ * reports the entry as missing on the next read. A negative `expire` is used
+ * rather than `0` because the dev front handler enforces a minimum retention,
+ * so a `0` `expire` would be kept alive by that minimum instead of evicted. The
+ * value is never read once the entry is evicted, but it must carry at least one
+ * byte because the built-in LRU cache refuses to store size-0 entries.
  */
 function toExpiredEntry(entry: CacheEntry): CacheEntry {
   return {
     ...entry,
-    expire: 0,
+    expire: -1,
     value: new ReadableStream({
       start(controller) {
         controller.enqueue(new Uint8Array(1))
diff --git a/packages/next/src/server/use-cache/use-cache-wrapper.ts b/packages/next/src/server/use-cache/use-cache-wrapper.ts
index 9dfddda9d4..3ca4a061e8 100644
--- a/packages/next/src/server/use-cache/use-cache-wrapper.ts
+++ b/packages/next/src/server/use-cache/use-cache-wrapper.ts
@@ -1092,12 +1092,17 @@ async function collectResult(
   // `MIN_PRERENDERABLE_EXPIRE` (5 minutes) caps how long an entry lingers in
   // the dedicated in-memory private handler. It is the shortest `expire` that
   // isn't treated as dynamic; a smaller `expire` would exclude the entry from
-  // prerenders. The size-0 case (`cacheMaxMemorySize: 0`) deliberately does NOT
-  // force this: it keeps its resolved cache life so that the cache entry can be
-  // considered prerenderable instead of being misread as a dynamic hole, and a
-  // separate dev revalidation (see the cache-hit path below) keeps its reloads
-  // showing a fresh value. Custom kinds keep their real cache life too, since
-  // their backing handler owns it.
+  // prerenders. Two other cases deliberately do NOT force this and keep their
+  // resolved cache life, relying instead on the dev handler's minimum retention
+  // and a dev revalidation (see the cache-hit path below) to keep reloads fast
+  // and fresh. The size-0 case (`cacheMaxMemorySize: 0`) keeps its life so the
+  // entry can be considered prerenderable instead of being misread as a dynamic
+  // hole. An explicit short-`expire` public cache (e.g. `cacheLife({ expire: 0
+  // })`) keeps its life so it stays correctly excluded from static prerenders
+  // via its real `expire` while a reload still hits the cache; forcing
+  // `revalidate: 0` here would instead corrupt the cache life propagated to an
+  // enclosing cache and trigger the nested-dynamic error. A cache backed by a
+  // custom handler keeps its real cache life too, since that handler owns it.
   const forceDynamicCacheLifeInDev = isPrivateCacheInDev
 
   // If cacheLife() was used to set an explicit revalidate/expire/stale time we
@@ -1640,7 +1645,7 @@ export async function cache(
     if (isPrivate) {
       // Private caches normally go to the Resume Data Cache (RDC), not a cache
       // handler. In development we additionally persist them in a dedicated
-      // built-in in-memory handler so that warm reloads are fast.
+      // built-in in-memory handler so that reloads are fast.
       if (process.env.__NEXT_DEV_SERVER) {
         cacheHandler = getPrivateCacheHandler()
       }
@@ -1652,7 +1657,7 @@ export async function cache(
 
       // In development, a user-configured (custom) handler may be slow or
       // remote, so we read through a tiered handler that puts a built-in
-      // in-memory front in front of it to keep warm reads microtask-fast.
+      // in-memory front in front of it to keep cache hits microtask-fast.
       // Built-in handlers (the default handler, and its size-0 replacement) are
       // already in-memory and used directly.
       if (process.env.__NEXT_DEV_SERVER && isCustomCacheHandler(kind)) {
@@ -2188,7 +2193,7 @@ export async function cache(
 
   let stream: undefined | ReadableStream = undefined
 
-  // Set when a short-lived warm hit ends its cache read up front (dev only) so
+  // Set when a short-lived cache hit ends its cache read up front (dev only) so
   // the static-shell boundary doesn't count it as a phantom miss. Once set, the
   // cache signal read is balanced, so serving must use a plain stream and skip
   // any trailing cacheSignal.endRead() call.
@@ -2945,7 +2950,19 @@ export async function cache(
 
         if (
           entry === undefined ||
-          currentTime > entry.timestamp + entry.expire * 1000 ||
+          // In dev, the built-in default handler retains a short-`expire` entry
+          // for at least `MIN_PRERENDERABLE_EXPIRE`, both when used directly
+          // and when fronting a custom cache handler. Apply that same minimum
+          // here so the retained entry is served and re-warmed in the
+          // background (below), rather than blocking to regenerate it on every
+          // read. The entry's real `expire` is untouched, so staging still
+          // treats it as dynamic.
+          currentTime >
+            entry.timestamp +
+              (process.env.__NEXT_DEV_SERVER
+                ? Math.max(entry.expire, MIN_PRERENDERABLE_EXPIRE)
+                : entry.expire) *
+                1000 ||
           (workStore.isStaticGeneration &&
             currentTime > entry.timestamp + entry.revalidate * 1000)
         ) {
@@ -3134,19 +3151,24 @@ export async function cache(
 
           // Trigger a background revalidation when the entry is stale (past its
           // `revalidate`), so the next read gets a fresh value without blocking
-          // this one. In development with the in-memory cache disabled
-          // (`cacheMaxMemorySize: 0`), built-in entries keep their resolved
-          // (potentially non-dynamic) cache life, so an entry read back from
-          // the dev in-memory cache is normally still fresh and wouldn't
-          // revalidate on its own; revalidate those on every dynamic request
-          // render too, so each reload still shows a fresh value.
+          // this one. Development additionally re-warms on every dynamic
+          // request render in two cases where the dev in-memory entry would
+          // otherwise read back as fresh, so a subsequent reload still shows a
+          // fresh value. The first is with the in-memory cache disabled
+          // (`cacheMaxMemorySize: 0`), where built-in entries keep their
+          // resolved (potentially non-dynamic) cache life. The second is a
+          // short-`expire` entry (an explicit dynamic or client-only cache,
+          // e.g. `cacheLife({ expire: 0 })`), which is retained for at least
+          // `MIN_PRERENDERABLE_EXPIRE` so it is served from the cache; this
+          // also covers custom handlers, re-executing and writing through to
+          // the backing.
           let shouldTriggerBackgroundRevalidation =
             currentTime > entry.timestamp + entry.revalidate * 1000
           if (
             !shouldTriggerBackgroundRevalidation &&
             process.env.__NEXT_DEV_SERVER &&
-            isMemoryCacheDisabled() &&
-            !isCustomCacheHandler(kind)
+            (entry.expire < MIN_PRERENDERABLE_EXPIRE ||
+              (isMemoryCacheDisabled() && !isCustomCacheHandler(kind)))
           ) {
             switch (workUnitStore.type) {
               case 'request':