@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.4

package/assets/standalone/node_modules/next/dist/server/use-cache/use-cache-wrapper.js

@@ -19,6 +19,7 @@ const _encryption = require("../app-render/encryption");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _createerrorhandler = require("../app-render/create-error-handler");
 const _constants = require("./constants");
+const _constants1 = require("../../lib/constants");
 const _handlers = require("./handlers");
 const _usecacheerrors = require("./use-cache-errors");
 const _dynamicrendering = require("../app-render/dynamic-rendering");
@@ -72,6 +73,98 @@ const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? console.debug.bind(console, 'use-cache:') : undefined;
 const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
 const findSourceMapURL = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').findSourceMapURLDEV : undefined;
+const nestedCacheZeroRevalidateErrorMessage = `A "use cache" with zero \`revalidate\` is nested inside another "use cache" ` + `that has no explicit \`cacheLife\`, which is not allowed during ` + `prerendering. Add \`cacheLife()\` to the outer \`"use cache"\` to choose ` + `whether it should be prerendered (with non-zero \`revalidate\`) or remain ` + `dynamic (with zero \`revalidate\`). Read more: ` + `https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife`;
+const nestedCacheShortExpireErrorMessage = `A "use cache" with short \`expire\` (under 5 minutes) is nested inside ` + `another "use cache" that has no explicit \`cacheLife\`, which is not ` + `allowed during prerendering. Add \`cacheLife()\` to the outer \`"use cache"\` ` + `to choose whether it should be prerendered (with longer \`expire\`) or remain ` + `dynamic (with short \`expire\`). Read more: ` + `https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife`;
+// Tracks which root params each cache function has historically read. Used to
+// compute the specific cache key upfront on subsequent invocations. In-memory
+// only — after server restart, the coarse-key redirect entry in the cache
+// handler provides fallback.
+const knownRootParamsByFunctionId = new Map();
+function addKnownRootParamNames(id, names) {
+    const existing = knownRootParamsByFunctionId.get(id);
+    if (existing) {
+        for (const name of names){
+            existing.add(name);
+        }
+        return existing;
+    }
+    const created = new Set(names);
+    knownRootParamsByFunctionId.set(id, created);
+    return created;
+}
+function computeRootParamsCacheKeySuffix(rootParams, paramNames) {
+    if (paramNames.size === 0) {
+        return '';
+    }
+    return JSON.stringify([
+        ...paramNames
+    ].sort().map((paramName)=>[
+            paramName,
+            rootParams[paramName]
+        ]));
+}
+function saveToResumeDataCache(prerenderResumeDataCache, serializedCacheKey, pendingCacheResult) {
+    if (!prerenderResumeDataCache) {
+        return pendingCacheResult;
+    }
+    const split = clonePendingCacheResult(pendingCacheResult);
+    const savedCacheResult = getNthCacheResult(split, 0);
+    const rdcResult = getNthCacheResult(split, 1);
+    // The RDC is per-page and root params are fixed within a page, so we always
+    // use the coarse key (without root param suffix). Unlike the cache handler,
+    // the RDC doesn't need root-param-specific keys for isolation.
+    prerenderResumeDataCache.cache.set(serializedCacheKey, rdcResult);
+    return savedCacheResult;
+}
+function saveToCacheHandler(cacheHandler, workStore, id, serializedCacheKey, savedCacheResult, rootParams) {
+    const pendingCoarseEntry = savedCacheResult.then((collectedResult)=>{
+        const { entry: fullEntry, readRootParamNames } = collectedResult;
+        // Use the combined set (union of all historically observed reads) for both
+        // the specific key and the redirect entry's tags. The read path computes
+        // cacheHandlerKey from this same union (knownRootParamsByFunctionId), so
+        // the write path must use the identical set to land on the same specific
+        // key. If we used only the current invocation's reads, a function that
+        // conditionally reads different root params across invocations would
+        // scatter entries across different specific keys, making previous entries
+        // unreachable from the read path's union-based lookup.
+        const rootParamNames = readRootParamNames ? addKnownRootParamNames(id, readRootParamNames) : knownRootParamsByFunctionId.get(id);
+        if (rootParamNames && rootParamNames.size > 0 && rootParams) {
+            const specificKey = serializedCacheKey + computeRootParamsCacheKeySuffix(rootParams, rootParamNames);
+            const specificSetPromise = cacheHandler.set(specificKey, Promise.resolve(fullEntry));
+            workStore.pendingRevalidateWrites ??= [];
+            workStore.pendingRevalidateWrites.push(specificSetPromise);
+            // Return a redirect entry for the coarse key. On a cold server (empty
+            // knownRootParamsByFunctionId), this entry's tags tell us which root
+            // params to include in the specific key for the follow-up lookup.
+            const rootParamTags = [
+                ...rootParamNames
+            ].map((paramName)=>_constants1.NEXT_CACHE_ROOT_PARAM_TAG_ID + paramName);
+            return {
+                value: new ReadableStream({
+                    start (controller) {
+                        // Single byte so the entry has non-zero size in LRU caches.
+                        controller.enqueue(new Uint8Array([
+                            0
+                        ]));
+                        controller.close();
+                    }
+                }),
+                tags: [
+                    ...fullEntry.tags,
+                    ...rootParamTags
+                ],
+                stale: fullEntry.stale,
+                timestamp: fullEntry.timestamp,
+                expire: fullEntry.expire,
+                revalidate: fullEntry.revalidate
+            };
+        }
+        return fullEntry;
+    });
+    const promise = cacheHandler.set(serializedCacheKey, pendingCoarseEntry);
+    workStore.pendingRevalidateWrites ??= [];
+    workStore.pendingRevalidateWrites.push(promise);
+}
 function generateCacheEntry(workStore, cacheContext, clientReferenceManifest, encodedArguments, fn, timeoutError) {
     // We need to run this inside a clean AsyncLocalStorage snapshot so that the cache
     // generation cannot read anything from the context we're currently executing which
@@ -104,11 +197,10 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
             explicitExpire: undefined,
             explicitStale: undefined,
             tags: null,
-            hmrRefreshHash: (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workStore, outerWorkUnitStore),
-            isHmrRefresh: (0, _workunitasyncstorageexternal.isHmrRefresh)(workStore, outerWorkUnitStore),
-            serverComponentsHmrCache: (0, _workunitasyncstorageexternal.getServerComponentsHmrCache)(workStore, outerWorkUnitStore),
+            hmrRefreshHash: (0, _workunitasyncstorageexternal.getHmrRefreshHash)(outerWorkUnitStore),
+            isHmrRefresh: (0, _workunitasyncstorageexternal.isHmrRefresh)(outerWorkUnitStore),
+            serverComponentsHmrCache: (0, _workunitasyncstorageexternal.getServerComponentsHmrCache)(outerWorkUnitStore),
             forceRevalidate: shouldForceRevalidate(workStore, outerWorkUnitStore),
-            runtimeStagePromise: (0, _workunitasyncstorageexternal.getRuntimeStagePromise)(outerWorkUnitStore),
             draftMode: (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, outerWorkUnitStore),
             rootParams: outerWorkUnitStore.rootParams,
             headers: outerWorkUnitStore.headers,
@@ -117,27 +209,26 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
     } else {
         let useCacheOrRequestStore;
         const outerWorkUnitStore = cacheContext.outerWorkUnitStore;
-        if (outerWorkUnitStore) {
-            switch(outerWorkUnitStore == null ? void 0 : outerWorkUnitStore.type){
-                case 'cache':
-                case 'private-cache':
-                case 'request':
-                    useCacheOrRequestStore = outerWorkUnitStore;
-                    break;
-                case 'prerender-runtime':
-                case 'prerender':
-                case 'prerender-ppr':
-                case 'prerender-legacy':
-                case 'unstable-cache':
-                    break;
-                default:
-                    outerWorkUnitStore;
-            }
+        switch(outerWorkUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+            case 'request':
+                useCacheOrRequestStore = outerWorkUnitStore;
+                break;
+            case 'prerender-runtime':
+            case 'prerender':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                break;
+            default:
+                outerWorkUnitStore;
         }
         return {
             type: 'cache',
             phase: 'render',
-            implicitTags: outerWorkUnitStore == null ? void 0 : outerWorkUnitStore.implicitTags,
+            implicitTags: outerWorkUnitStore.implicitTags,
             revalidate: defaultCacheLife.revalidate,
             expire: defaultCacheLife.expire,
             stale: defaultCacheLife.stale,
@@ -145,11 +236,13 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
             explicitExpire: undefined,
             explicitStale: undefined,
             tags: null,
-            hmrRefreshHash: outerWorkUnitStore && (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workStore, outerWorkUnitStore),
+            hmrRefreshHash: (0, _workunitasyncstorageexternal.getHmrRefreshHash)(outerWorkUnitStore),
             isHmrRefresh: (useCacheOrRequestStore == null ? void 0 : useCacheOrRequestStore.isHmrRefresh) ?? false,
             serverComponentsHmrCache: useCacheOrRequestStore == null ? void 0 : useCacheOrRequestStore.serverComponentsHmrCache,
             forceRevalidate: shouldForceRevalidate(workStore, outerWorkUnitStore),
-            draftMode: outerWorkUnitStore && (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, outerWorkUnitStore)
+            draftMode: (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, outerWorkUnitStore),
+            rootParams: outerWorkUnitStore.rootParams,
+            readRootParamNames: new Set()
         };
     }
 }
@@ -195,7 +288,12 @@ function propagateCacheLifeAndTagsToRevalidateStore(revalidateStore, entry) {
         revalidateStore.expire = entry.expire;
     }
 }
-function propagateCacheLifeAndTags(cacheContext, entry) {
+function propagateCacheStaleTimeToRequestStore(requestStore, entry) {
+    if (requestStore.stale !== undefined && requestStore.stale > entry.stale) {
+        requestStore.stale = entry.stale;
+    }
+}
+function propagateCacheEntryMetadata(cacheContext, entry, readRootParamNames) {
     if (cacheContext.kind === 'private') {
         switch(cacheContext.outerWorkUnitStore.type){
             case 'prerender-runtime':
@@ -203,15 +301,22 @@ function propagateCacheLifeAndTags(cacheContext, entry) {
                 propagateCacheLifeAndTagsToRevalidateStore(cacheContext.outerWorkUnitStore, entry);
                 break;
             case 'request':
+                propagateCacheStaleTimeToRequestStore(cacheContext.outerWorkUnitStore, entry);
+                break;
             case undefined:
                 break;
             default:
                 cacheContext.outerWorkUnitStore;
         }
     } else {
-        var _cacheContext_outerWorkUnitStore;
-        switch((_cacheContext_outerWorkUnitStore = cacheContext.outerWorkUnitStore) == null ? void 0 : _cacheContext_outerWorkUnitStore.type){
+        switch(cacheContext.outerWorkUnitStore.type){
             case 'cache':
+                if (readRootParamNames) {
+                    for (const paramName of readRootParamNames){
+                        cacheContext.outerWorkUnitStore.readRootParamNames.add(paramName);
+                    }
+                }
+            // fallthrough
             case 'private-cache':
             case 'prerender':
             case 'prerender-runtime':
@@ -220,14 +325,62 @@ function propagateCacheLifeAndTags(cacheContext, entry) {
                 propagateCacheLifeAndTagsToRevalidateStore(cacheContext.outerWorkUnitStore, entry);
                 break;
             case 'request':
+                propagateCacheStaleTimeToRequestStore(cacheContext.outerWorkUnitStore, entry);
+                break;
             case 'unstable-cache':
-            case undefined:
+            case 'generate-static-params':
                 break;
             default:
                 cacheContext.outerWorkUnitStore;
         }
     }
 }
+/**
+ * Conditionally propagates cache life, tags, and root param names to the outer
+ * context. During prerenders (`prerender` / `prerender-runtime`) and dev
+ * cache-filling requests, propagation is deferred because the entry might be
+ * omitted from the final prerender due to short expire/stale times. If omitted,
+ * it should not affect the prerender. The final decision happens when the entry
+ * is read from the resume data cache in the final render phase — at that point
+ * `propagateCacheEntryMetadata` is called unconditionally (after the omission
+ * checks have already filtered out short-lived entries).
+ *
+ * Note: Root param names are only propagated when the outer context is a
+ * `cache` store (i.e. an enclosing `"use cache"` function), which is never
+ * deferred. For prerender contexts, root param names are tracked separately
+ * via `addKnownRootParamNames` in the resume data cache read path.
+ */ function maybePropagateCacheEntryMetadata(cacheContext, entry, readRootParamNames) {
+    const outerWorkUnitStore = cacheContext.outerWorkUnitStore;
+    switch(outerWorkUnitStore.type){
+        case 'prerender':
+        case 'prerender-runtime':
+            {
+                break;
+            }
+        case 'request':
+            {
+                if (process.env.NODE_ENV === 'development' && outerWorkUnitStore.cacheSignal) {
+                    break;
+                }
+            // fallthrough
+            }
+        case 'private-cache':
+        case 'cache':
+        case 'unstable-cache':
+        case 'prerender-legacy':
+        case 'prerender-ppr':
+            {
+                propagateCacheEntryMetadata(cacheContext, entry, readRootParamNames);
+                break;
+            }
+        case 'generate-static-params':
+            break;
+        default:
+            {
+                outerWorkUnitStore;
+            }
+    }
+}
 async function collectResult(savedStream, workStore, cacheContext, innerCacheStore, startTime, errors) {
     // We create a buffered stream that collects all chunks until the end to
     // ensure that RSC has finished rendering and therefore we have collected
@@ -280,42 +433,19 @@ async function collectResult(savedStream, workStore, cacheContext, innerCacheSto
         stale: collectedStale,
         tags: collectedTags === null ? [] : collectedTags
     };
-    if (cacheContext.outerWorkUnitStore) {
-        const outerWorkUnitStore = cacheContext.outerWorkUnitStore;
-        // Propagate cache life & tags to the parent context if appropriate.
-        switch(outerWorkUnitStore.type){
-            case 'prerender':
-            case 'prerender-runtime':
-                {
-                    break;
-                }
-            case 'request':
-                {
-                    if (process.env.NODE_ENV === 'development' && outerWorkUnitStore.cacheSignal) {
-                        break;
-                    }
-                // fallthrough
-                }
-            case 'private-cache':
-            case 'cache':
-            case 'unstable-cache':
-            case 'prerender-legacy':
-            case 'prerender-ppr':
-                {
-                    propagateCacheLifeAndTags(cacheContext, entry);
-                    break;
-                }
-            default:
-                {
-                    outerWorkUnitStore;
-                }
-        }
-        const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(outerWorkUnitStore);
+    if (!cacheContext.skipPropagation) {
+        maybePropagateCacheEntryMetadata(cacheContext, entry, innerCacheStore.type === 'cache' ? innerCacheStore.readRootParamNames : undefined);
+        const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(cacheContext.outerWorkUnitStore);
         if (cacheSignal) {
             cacheSignal.endRead();
         }
     }
-    return entry;
+    return {
+        entry,
+        hasExplicitRevalidate: innerCacheStore.explicitRevalidate !== undefined,
+        hasExplicitExpire: innerCacheStore.explicitExpire !== undefined,
+        readRootParamNames: innerCacheStore.type === 'cache' ? innerCacheStore.readRootParamNames : undefined
+    };
 }
 async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore, clientReferenceManifest, encodedArguments, fn, timeoutError) {
     const temporaryReferences = (0, _server.createTemporaryReferenceSet)();
@@ -327,35 +457,33 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
             for (const entry of encodedArguments){
                 yield entry;
             }
-            if (outerWorkUnitStore) {
-                switch(outerWorkUnitStore.type){
-                    case 'prerender-runtime':
-                    case 'prerender':
-                        // The encoded arguments might contain hanging promises. In
-                        // this case we don't want to reject with "Error: Connection
-                        // closed.", so we intentionally keep the iterable alive.
-                        // This is similar to the halting trick that we do while
-                        // rendering.
-                        await new Promise((resolve)=>{
-                            if (outerWorkUnitStore.renderSignal.aborted) {
-                                resolve();
-                            } else {
-                                outerWorkUnitStore.renderSignal.addEventListener('abort', ()=>resolve(), {
-                                    once: true
-                                });
-                            }
-                        });
-                        break;
-                    case 'prerender-ppr':
-                    case 'prerender-legacy':
-                    case 'request':
-                    case 'cache':
-                    case 'private-cache':
-                    case 'unstable-cache':
-                        break;
-                    default:
-                        outerWorkUnitStore;
-                }
+            switch(outerWorkUnitStore.type){
+                case 'prerender-runtime':
+                case 'prerender':
+                    // The encoded arguments might contain hanging promises. In
+                    // this case we don't want to reject with "Error: Connection
+                    // closed.", so we intentionally keep the iterable alive. This
+                    // is similar to the halting trick that we do while rendering.
+                    await new Promise((resolve)=>{
+                        if (outerWorkUnitStore.renderSignal.aborted) {
+                            resolve();
+                        } else {
+                            outerWorkUnitStore.renderSignal.addEventListener('abort', ()=>resolve(), {
+                                once: true
+                            });
+                        }
+                    });
+                    break;
+                case 'prerender-ppr':
+                case 'prerender-legacy':
+                case 'request':
+                case 'cache':
+                case 'private-cache':
+                case 'unstable-cache':
+                case 'generate-static-params':
+                    break;
+                default:
+                    outerWorkUnitStore;
             }
         }
     }, (0, _manifestssingleton.getServerModuleMap)(), {
@@ -373,7 +501,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
     // digests are handled correctly. Error formatting and reporting is not
     // necessary here; the errors are encoded in the stream, and will be reported
     // in the "Server" environment.
-    const handleError = (0, _createerrorhandler.createReactServerErrorHandler)(workStore.dev, workStore.isBuildTimePrerendering ?? false, workStore.reactServerErrorsByDigest, (error)=>{
+    const handleError = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', workStore.isBuildTimePrerendering ?? false, workStore.reactServerErrorsByDigest, (error)=>{
         // In production, we log the original error here. It gets a digest that
         // can be used to associate the error with the obfuscated error that might
         // be logged if the error is caught. In development, we prefer logging the
@@ -385,7 +513,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
         errors.push(error);
     });
     let stream;
-    switch(outerWorkUnitStore == null ? void 0 : outerWorkUnitStore.type){
+    switch(outerWorkUnitStore.type){
         case 'prerender-runtime':
         case 'prerender':
             var _dynamicAccessAsyncStorage_getStore;
@@ -461,7 +589,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case undefined:
+        case 'generate-static-params':
             stream = (0, _server.renderToReadableStream)(resultPromise, clientReferenceManifest.clientModules, {
                 environmentName: 'Cache',
                 filterStackFrame,
@@ -473,7 +601,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
             return outerWorkUnitStore;
     }
     const [returnStream, savedStream] = stream.tee();
-    const pendingCacheEntry = collectResult(savedStream, workStore, cacheContext, innerCacheStore, startTime, errors);
+    const pendingCacheResult = collectResult(savedStream, workStore, cacheContext, innerCacheStore, startTime, errors);
     if (process.env.NODE_ENV === 'development') {
         // Name the stream for React DevTools.
         // @ts-expect-error
@@ -485,7 +613,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
         // erroring we cannot return a stale-if-error version but it allows
         // streaming back the result earlier.
         stream: returnStream,
-        pendingCacheEntry
+        pendingCacheResult
     };
 }
 function cloneCacheEntry(entry) {
@@ -504,11 +632,28 @@ function cloneCacheEntry(entry) {
         clonedEntry
     ];
 }
-async function clonePendingCacheEntry(pendingCacheEntry) {
-    const entry = await pendingCacheEntry;
-    return cloneCacheEntry(entry);
+function cloneCacheResult(result) {
+    const [entryA, entryB] = cloneCacheEntry(result.entry);
+    return [
+        {
+            entry: entryA,
+            hasExplicitRevalidate: result.hasExplicitRevalidate,
+            hasExplicitExpire: result.hasExplicitExpire,
+            readRootParamNames: result.readRootParamNames
+        },
+        {
+            entry: entryB,
+            hasExplicitRevalidate: result.hasExplicitRevalidate,
+            hasExplicitExpire: result.hasExplicitExpire,
+            readRootParamNames: result.readRootParamNames
+        }
+    ];
 }
-async function getNthCacheEntry(split, i) {
+async function clonePendingCacheResult(pendingCacheResult) {
+    const result = await pendingCacheResult;
+    return cloneCacheResult(result);
+}
+async function getNthCacheResult(split, i) {
     return (await split)[i];
 }
 async function encodeFormData(formData) {
@@ -552,8 +697,8 @@ function createTrackedReadableStream(stream, cacheSignal) {
         }
     });
 }
-async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
-    let args = Array.prototype.slice.call(argsObj);
+async function cache(kind, id, boundArgsLength, originalFn, args) {
+    var _workUnitStore_implicitTags;
     const isPrivate = kind === 'private';
     // Private caches are currently only stored in the Resume Data Cache (RDC),
     // and not in cache handlers.
@@ -581,12 +726,19 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
         });
     }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore === undefined) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('"use cache" cannot be used outside of App Router. Expected a WorkUnitStore.'), "__NEXT_ERROR_CODE", {
+            value: "E1135",
+            enumerable: false,
+            configurable: true
+        });
+    }
     const name = originalFn.name;
     let fn = originalFn;
     let cacheContext;
     if (isPrivate) {
         const expression = '"use cache: private"';
-        switch(workUnitStore == null ? void 0 : workUnitStore.type){
+        switch(workUnitStore.type){
             // "use cache: private" is dynamic in prerendering contexts.
             case 'prerender':
                 return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression);
@@ -595,8 +747,9 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
             case 'prerender-legacy':
                 return (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, workUnitStore);
             case 'prerender-client':
+            case 'validation-client':
                 throw Object.defineProperty(new _invarianterror.InvariantError(`${expression} must not be used within a client component. Next.js should be preventing ${expression} from being allowed in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                    value: "E741",
+                    value: "E1020",
                     enumerable: false,
                     configurable: true
                 });
@@ -604,7 +757,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 {
                     throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(// TODO: Add a link to an error documentation page when we have one.
                     `${expression} must not be used within \`unstable_cache()\`.`), "__NEXT_ERROR_CODE", {
-                        value: "E744",
+                        value: "E1016",
                         enumerable: false,
                         configurable: true
                     }), workStore);
@@ -613,7 +766,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 {
                     throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(// TODO: Add a link to an error documentation page when we have one.
                     `${expression} must not be used within "use cache". It can only be nested inside of another ${expression}.`), "__NEXT_ERROR_CODE", {
-                        value: "E735",
+                        value: "E1001",
                         enumerable: false,
                         configurable: true
                     }), workStore);
@@ -623,13 +776,14 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
             case 'private-cache':
                 cacheContext = {
                     kind: 'private',
-                    outerWorkUnitStore: workUnitStore
+                    outerWorkUnitStore: workUnitStore,
+                    skipPropagation: false
                 };
                 break;
-            case undefined:
+            case 'generate-static-params':
                 throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(// TODO: Add a link to an error documentation page when we have one.
                 `${expression} cannot be used outside of a request context.`), "__NEXT_ERROR_CODE", {
-                    value: "E754",
+                    value: "E1008",
                     enumerable: false,
                     configurable: true
                 }), workStore);
@@ -644,11 +798,12 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 });
         }
     } else {
-        switch(workUnitStore == null ? void 0 : workUnitStore.type){
+        switch(workUnitStore.type){
             case 'prerender-client':
+            case 'validation-client':
                 const expression = '"use cache"';
                 throw Object.defineProperty(new _invarianterror.InvariantError(`${expression} must not be used within a client component. Next.js should be preventing ${expression} from being allowed in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                    value: "E741",
+                    value: "E1038",
                     enumerable: false,
                     configurable: true
                 });
@@ -662,10 +817,11 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
             // TODO: We should probably forbid nesting "use cache" inside
             // unstable_cache. (fallthrough)
             case 'unstable-cache':
-            case undefined:
+            case 'generate-static-params':
                 cacheContext = {
                     kind: 'public',
-                    outerWorkUnitStore: workUnitStore
+                    outerWorkUnitStore: workUnitStore,
+                    skipPropagation: false
                 };
                 break;
             default:
@@ -692,17 +848,20 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
     // components have been edited. This is a very coarse approach. But it's
     // also only a temporary solution until Action IDs are unique per
     // implementation. Remove this once Action IDs hash the implementation.
-    const hmrRefreshHash = workUnitStore && (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workStore, workUnitStore);
-    const hangingInputAbortSignal = workUnitStore ? (0, _dynamicrendering.createHangingInputAbortSignal)(workUnitStore) : undefined;
+    const hmrRefreshHash = (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workUnitStore);
+    const hangingInputAbortSignal = (0, _dynamicrendering.createHangingInputAbortSignal)(workUnitStore);
     if (cacheContext.kind === 'private') {
         const { outerWorkUnitStore } = cacheContext;
         switch(outerWorkUnitStore.type){
             case 'prerender-runtime':
                 {
                     // In a runtime prerender, we have to make sure that APIs that would hang during a static prerender
-                    // are resolved with a delay, in the runtime stage. Private caches are one of these.
-                    if (outerWorkUnitStore.runtimeStagePromise) {
-                        await outerWorkUnitStore.runtimeStagePromise;
+                    // are resolved with a delay, in the appropriate runtime stage. Private caches read from
+                    // Segments not using runtime prefetch resolve at EarlyRuntime,
+                    // while runtime-prefetchable segments resolve at Runtime.
+                    const stagedRendering = outerWorkUnitStore.stagedRendering;
+                    if (stagedRendering) {
+                        await stagedRendering.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering));
                     }
                     break;
                 }
@@ -710,8 +869,11 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 {
                     if (process.env.NODE_ENV === 'development') {
                         // Similar to runtime prerenders, private caches should not resolve in the static stage
-                        // of a dev request, so we delay them.
-                        await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, outerWorkUnitStore, _stagedrendering.RenderStage.Runtime);
+                        // of a dev request, so we delay them. We pick the appropriate runtime stage based on
+                        // whether we're in the early or late stages.
+                        const stagedRendering = outerWorkUnitStore.stagedRendering;
+                        const stage = stagedRendering ? (0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering) : _stagedrendering.RenderStage.Runtime;
+                        await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, outerWorkUnitStore, stage);
                     }
                     break;
                 }
@@ -760,7 +922,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                         // using a hanging promise for search params. For cached pages
                         // that do access them, which is an invalid dynamic usage, we
                         // need to ensure that an error is shown.
-                        (0, _searchparams.makeErroringSearchParamsForUseCache)(workStore)
+                        (0, _searchparams.makeErroringSearchParamsForUseCache)()
                     },
                     ...otherInnerArgs
                 ])
@@ -840,7 +1002,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
             signal: hangingInputAbortSignal
         });
     let encodedCacheKeyParts;
-    switch(workUnitStore == null ? void 0 : workUnitStore.type){
+    switch(workUnitStore.type){
         case 'prerender-runtime':
         // We're currently only using `dynamicAccessAsyncStorage` for params,
         // which are always available in a runtime prerender, so they will never hang,
@@ -879,6 +1041,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
+        case 'generate-static-params':
         case undefined:
             encodedCacheKeyParts = await encodeCacheKeyParts();
             break;
@@ -887,20 +1050,36 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
     }
     const serializedCacheKey = typeof encodedCacheKeyParts === 'string' ? // Convert it to an ArrayBuffer if it wants to.
     encodedCacheKeyParts : await encodeFormData(encodedCacheKeyParts);
+    // If we already know which root params this function reads, include them in
+    // the cache handler key for a direct hit (skipping the redirect entry).
+    // rootParams is undefined when nested inside unstable_cache.
+    const rootParams = workUnitStore.rootParams;
+    const knownRootParamNames = knownRootParamsByFunctionId.get(id);
+    let cacheHandlerKey = knownRootParamNames && rootParams ? serializedCacheKey + computeRootParamsCacheKeySuffix(rootParams, knownRootParamNames) : serializedCacheKey;
     let stream = undefined;
     // Get an immutable and mutable versions of the resume data cache.
-    const prerenderResumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore) : null;
-    const renderResumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getRenderResumeDataCache)(workUnitStore) : null;
+    const prerenderResumeDataCache = (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore);
+    const renderResumeDataCache = (0, _workunitasyncstorageexternal.getRenderResumeDataCache)(workUnitStore);
+    const implicitTags = ((_workUnitStore_implicitTags = workUnitStore.implicitTags) == null ? void 0 : _workUnitStore_implicitTags.tags) ?? [];
     if (renderResumeDataCache) {
-        const cacheSignal = workUnitStore ? (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore) : null;
+        const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
         if (cacheSignal) {
             cacheSignal.beginRead();
         }
-        const cachedEntry = renderResumeDataCache.cache.get(serializedCacheKey);
-        if (cachedEntry !== undefined) {
-            const existingEntry = await cachedEntry;
-            if (workUnitStore !== undefined && existingEntry !== undefined) {
-                if (existingEntry.revalidate === 0 || existingEntry.expire < _constants.DYNAMIC_EXPIRE) {
+        const rdcEntry = renderResumeDataCache.cache.get(serializedCacheKey);
+        if (rdcEntry !== undefined) {
+            let rdcResult = await rdcEntry;
+            // Check if the RDC entry should be discarded due to recently revalidated
+            // tags. When a server action calls updateTag(), the re-render should see
+            // fresh data instead of stale RDC data.
+            if (rdcResult !== undefined) {
+                if (rdcResult.entry.tags.some((tag)=>isRecentlyRevalidatedTag(tag, workStore)) || implicitTags.some((tag)=>isRecentlyRevalidatedTag(tag, workStore))) {
+                    debug == null ? void 0 : debug('discarding RDC entry due to recently revalidated tags', serializedCacheKey);
+                    rdcResult = undefined;
+                }
+            }
+            if (rdcResult !== undefined) {
+                if (rdcResult.entry.revalidate === 0 || rdcResult.entry.expire < _constants.DYNAMIC_EXPIRE) {
                     switch(workUnitStore.type){
                         case 'prerender':
                             // In a Dynamic I/O prerender, if the cache entry has
@@ -909,6 +1088,25 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                             // generating static pages for such data. It's better to leave
                             // a dynamic hole that can be filled in during the resume with
                             // a potentially cached entry.
+                            if (rdcResult.entry.revalidate === 0) {
+                                if (rdcResult.hasExplicitRevalidate === false) {
+                                    throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheZeroRevalidateErrorMessage), "__NEXT_ERROR_CODE", {
+                                        value: "E1000",
+                                        enumerable: false,
+                                        configurable: true
+                                    }), workStore);
+                                }
+                                debug == null ? void 0 : debug('omitting entry', serializedCacheKey, 'from static shell due to revalidate: 0');
+                            } else {
+                                if (rdcResult.hasExplicitExpire === false) {
+                                    throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheShortExpireErrorMessage), "__NEXT_ERROR_CODE", {
+                                        value: "E1009",
+                                        enumerable: false,
+                                        configurable: true
+                                    }), workStore);
+                                }
+                                debug == null ? void 0 : debug('omitting entry', serializedCacheKey, 'from static shell due to short expire value:', rdcResult.entry.expire);
+                            }
                             if (cacheSignal) {
                                 cacheSignal.endRead();
                             }
@@ -917,22 +1115,39 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                             {
                                 // In the final phase of a runtime prerender, we have to make
                                 // sure that APIs that would hang during a static prerender
-                                // are resolved with a delay, in the runtime stage.
-                                if (workUnitStore.runtimeStagePromise) {
-                                    await workUnitStore.runtimeStagePromise;
+                                // are resolved with a delay, in the appropriate runtime stage.
+                                const stagedRendering = workUnitStore.stagedRendering;
+                                if (stagedRendering) {
+                                    await stagedRendering.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering));
                                 }
                                 break;
                             }
                         case 'request':
                             {
                                 if (process.env.NODE_ENV === 'development') {
+                                    if (rdcResult.entry.revalidate === 0 && rdcResult.hasExplicitRevalidate === false) {
+                                        throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheZeroRevalidateErrorMessage), "__NEXT_ERROR_CODE", {
+                                            value: "E1000",
+                                            enumerable: false,
+                                            configurable: true
+                                        }), workStore);
+                                    }
+                                    if (rdcResult.entry.expire < _constants.DYNAMIC_EXPIRE && rdcResult.hasExplicitExpire === false) {
+                                        throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheShortExpireErrorMessage), "__NEXT_ERROR_CODE", {
+                                            value: "E1009",
+                                            enumerable: false,
+                                            configurable: true
+                                        }), workStore);
+                                    }
                                     // We delay the cache here so that it doesn't resolve in the static task --
                                     // in a regular static prerender, it'd be a hanging promise, and we need to reflect that,
                                     // so it has to resolve later.
                                     // TODO(restart-on-cache-miss): Optimize this to avoid unnecessary restarts.
                                     // We don't end the cache read here, so this will always appear as a cache miss in the static stage,
                                     // and thus will cause a restart even if all caches are filled.
-                                    await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, _stagedrendering.RenderStage.Runtime);
+                                    const stagedRendering = workUnitStore.stagedRendering;
+                                    const stage = stagedRendering ? (0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering) : _stagedrendering.RenderStage.Runtime;
+                                    await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, stage);
                                 }
                                 break;
                             }
@@ -941,18 +1156,20 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                         case 'cache':
                         case 'private-cache':
                         case 'unstable-cache':
+                        case 'generate-static-params':
                             break;
                         default:
                             workUnitStore;
                     }
                 }
-                if (existingEntry.stale < _constants.RUNTIME_PREFETCH_DYNAMIC_STALE) {
+                if (rdcResult.entry.stale < _constants.RUNTIME_PREFETCH_DYNAMIC_STALE) {
                     switch(workUnitStore.type){
                         case 'prerender-runtime':
                             // In a runtime prerender, if the cache entry will become
                             // stale in less then 30 seconds, we consider this cache entry
                             // dynamic as it's not worth prefetching. It's better to leave
                             // a dynamic hole that can be filled during the navigation.
+                            debug == null ? void 0 : debug('omitting entry', serializedCacheKey, 'from runtime shell due to short stale value:', rdcResult.entry.stale);
                             if (cacheSignal) {
                                 cacheSignal.endRead();
                             }
@@ -976,67 +1193,82 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                         case 'cache':
                         case 'private-cache':
                         case 'unstable-cache':
+                        case 'generate-static-params':
                             break;
                         default:
                             workUnitStore;
                     }
                 }
             }
-            // We want to make sure we only propagate cache life & tags if the
-            // entry was *not* omitted from the prerender. So we only do this
-            // after the above early returns.
-            propagateCacheLifeAndTags(cacheContext, existingEntry);
-            const [streamA, streamB] = existingEntry.value.tee();
-            existingEntry.value = streamB;
-            if (cacheSignal) {
-                // When we have a cacheSignal we need to block on reading the cache
-                // entry before ending the read.
-                stream = createTrackedReadableStream(streamA, cacheSignal);
+            if (rdcResult !== undefined) {
+                debug == null ? void 0 : debug('Resume Data Cache entry found', serializedCacheKey);
+                if (prerenderResumeDataCache) {
+                    prerenderResumeDataCache.cache.set(serializedCacheKey, rdcEntry);
+                }
+                if (rdcResult.readRootParamNames && rdcResult.readRootParamNames.size > 0) {
+                    addKnownRootParamNames(id, rdcResult.readRootParamNames);
+                }
+                // We want to make sure we only propagate cache life & tags if the
+                // entry was *not* omitted from the prerender. So we only do this
+                // after the above early returns.
+                propagateCacheEntryMetadata(cacheContext, rdcResult.entry, rdcResult.readRootParamNames);
+                const [streamA, streamB] = rdcResult.entry.value.tee();
+                rdcResult.entry.value = streamB;
+                if (cacheSignal) {
+                    // When we have a cacheSignal we need to block on reading the cache
+                    // entry before ending the read.
+                    stream = createTrackedReadableStream(streamA, cacheSignal);
+                } else {
+                    stream = streamA;
+                }
             } else {
-                stream = streamA;
+                // Entry was discarded (e.g. due to recently revalidated tags)
+                debug == null ? void 0 : debug('Resume Data Cache entry discarded', serializedCacheKey);
+                if (cacheSignal) {
+                    cacheSignal.endRead();
+                }
             }
         } else {
+            debug == null ? void 0 : debug('Resume Data Cache entry not found', serializedCacheKey);
             if (cacheSignal) {
                 cacheSignal.endRead();
             }
-            if (workUnitStore) {
-                switch(workUnitStore.type){
-                    case 'prerender':
-                        // If `allowEmptyStaticShell` is true, and thus a prefilled
-                        // resume data cache was provided, then a cache miss means that
-                        // params were part of the cache key. In this case, we can make
-                        // this cache function a dynamic hole in the shell (or produce
-                        // an empty shell if there's no parent suspense boundary).
-                        // Currently, this also includes layouts and pages that don't
-                        // read params, which will be improved when we implement
-                        // NAR-136. Otherwise, we assume that if params are passed
-                        // explicitly into a "use cache" function, that the params are
-                        // also accessed. This allows us to abort early, and treat the
-                        // function as dynamic, instead of waiting for the timeout to be
-                        // reached. Compared to the instrumentation-based params bailout
-                        // we do here, this also covers the case where params are
-                        // transformed with an async function, before being passed into
-                        // the "use cache" function, which escapes the instrumentation.
-                        if (workUnitStore.allowEmptyStaticShell) {
-                            return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"');
-                        }
-                        break;
-                    case 'prerender-runtime':
-                    case 'prerender-ppr':
-                    case 'prerender-legacy':
-                    case 'request':
-                    case 'cache':
-                    case 'private-cache':
-                    case 'unstable-cache':
-                        break;
-                    default:
-                        workUnitStore;
-                }
+            switch(workUnitStore.type){
+                case 'prerender':
+                    // If `allowEmptyStaticShell` is true, and thus a prefilled resume
+                    // data cache was provided, then a cache miss means that params were
+                    // part of the cache key. In this case, we can make this cache
+                    // function a dynamic hole in the shell (or produce an empty shell if
+                    // there's no parent suspense boundary). Currently, this also includes
+                    // layouts and pages that don't read params, which will be improved
+                    // when we implement NAR-136. Otherwise, we assume that if params are
+                    // passed explicitly into a "use cache" function, that the params are
+                    // also accessed. This allows us to abort early, and treat the
+                    // function as dynamic, instead of waiting for the timeout to be
+                    // reached. Compared to the instrumentation-based params bailout we do
+                    // here, this also covers the case where params are transformed with
+                    // an async function, before being passed into the "use cache"
+                    // function, which escapes the instrumentation.
+                    if (workUnitStore.allowEmptyStaticShell) {
+                        return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"');
+                    }
+                    break;
+                case 'prerender-runtime':
+                case 'prerender-ppr':
+                case 'prerender-legacy':
+                case 'request':
+                case 'cache':
+                case 'private-cache':
+                case 'unstable-cache':
+                case 'generate-static-params':
+                    break;
+                default:
+                    workUnitStore;
             }
         }
     }
     if (stream === undefined) {
-        const cacheSignal = workUnitStore ? (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore) : null;
+        const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
         if (cacheSignal) {
             // Either the cache handler or the generation can be using I/O at this point.
             // We need to track when they start and when they complete.
@@ -1049,14 +1281,27 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
         let entry;
         // We ignore existing cache entries when force revalidating.
         if (cacheHandler && !shouldForceRevalidate(workStore, workUnitStore)) {
-            var _workUnitStore_implicitTags;
-            entry = await cacheHandler.get(serializedCacheKey, (workUnitStore == null ? void 0 : (_workUnitStore_implicitTags = workUnitStore.implicitTags) == null ? void 0 : _workUnitStore_implicitTags.tags) ?? []);
+            entry = await cacheHandler.get(cacheHandlerKey, implicitTags);
+            // Check if this is a redirect entry (coarse key → specific key). Redirect
+            // entries have private tags encoding the root param names (one tag per
+            // param name, prefixed with _N_RP_).
+            if (entry && rootParams) {
+                const paramNames = new Set();
+                for (const tag of entry.tags){
+                    if (tag.startsWith(_constants1.NEXT_CACHE_ROOT_PARAM_TAG_ID)) {
+                        paramNames.add(tag.slice(_constants1.NEXT_CACHE_ROOT_PARAM_TAG_ID.length));
+                    }
+                }
+                if (paramNames.size > 0) {
+                    addKnownRootParamNames(id, paramNames);
+                    cacheHandlerKey = serializedCacheKey + computeRootParamsCacheKeySuffix(rootParams, paramNames);
+                    entry = await cacheHandler.get(cacheHandlerKey, implicitTags);
+                }
+            }
         }
         if (entry) {
-            var _workUnitStore_implicitTags1;
-            const implicitTags = (workUnitStore == null ? void 0 : (_workUnitStore_implicitTags1 = workUnitStore.implicitTags) == null ? void 0 : _workUnitStore_implicitTags1.tags) ?? [];
             let implicitTagsExpiration = 0;
-            if (workUnitStore == null ? void 0 : workUnitStore.implicitTags) {
+            if (workUnitStore.implicitTags) {
                 const lazyExpiration = workUnitStore.implicitTags.expirationsByCacheKind.get(kind);
                 if (lazyExpiration) {
                     const expiration = (0, _lazyresult.isResolvedLazyResult)(lazyExpiration) ? lazyExpiration.value : await lazyExpiration;
@@ -1071,12 +1316,12 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 }
             }
             if (shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags, implicitTagsExpiration)) {
-                debug == null ? void 0 : debug('discarding expired entry', serializedCacheKey);
+                debug == null ? void 0 : debug('discarding expired entry', cacheHandlerKey);
                 entry = undefined;
             }
         }
         const currentTime = performance.timeOrigin + performance.now();
-        if (workUnitStore !== undefined && entry !== undefined && (entry.revalidate === 0 || entry.expire < _constants.DYNAMIC_EXPIRE)) {
+        if (entry !== undefined && (entry.revalidate === 0 || entry.expire < _constants.DYNAMIC_EXPIRE)) {
             switch(workUnitStore.type){
                 case 'prerender':
                     // In a Dynamic I/O prerender, if the cache entry has revalidate:
@@ -1085,6 +1330,11 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                     // pages for such data. It's better to leave a dynamic hole that
                     // can be filled in during the resume with a potentially cached
                     // entry.
+                    if (entry.revalidate === 0) {
+                        debug == null ? void 0 : debug('omitting entry', cacheHandlerKey, 'from static shell due to revalidate: 0');
+                    } else {
+                        debug == null ? void 0 : debug('omitting entry', cacheHandlerKey, 'from static shell due to short expire value:', entry.expire);
+                    }
                     if (cacheSignal) {
                         cacheSignal.endRead();
                     }
@@ -1098,7 +1348,9 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                             // TODO(restart-on-cache-miss): Optimize this to avoid unnecessary restarts.
                             // We don't end the cache read here, so this will always appear as a cache miss in the static stage,
                             // and thus will cause a restart even if all caches are filled.
-                            await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, _stagedrendering.RenderStage.Runtime);
+                            const stagedRendering = workUnitStore.stagedRendering;
+                            const stage = stagedRendering ? (0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering) : _stagedrendering.RenderStage.Runtime;
+                            await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, stage);
                         }
                         break;
                     }
@@ -1108,6 +1360,7 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 case 'cache':
                 case 'private-cache':
                 case 'unstable-cache':
+                case 'generate-static-params':
                     break;
                 default:
                     workUnitStore;
@@ -1125,32 +1378,22 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
             // pop out of any stack specific contexts as well - aka "Sync" Local Storage.
             if (entry) {
                 if (currentTime > entry.timestamp + entry.expire * 1000) {
-                    debug == null ? void 0 : debug('entry is expired', serializedCacheKey);
+                    debug == null ? void 0 : debug('entry is expired', cacheHandlerKey);
                 }
                 if (workStore.isStaticGeneration && currentTime > entry.timestamp + entry.revalidate * 1000) {
-                    debug == null ? void 0 : debug('static generation, entry is stale', serializedCacheKey);
+                    debug == null ? void 0 : debug('static generation, entry is stale', cacheHandlerKey);
                 }
             }
             const result = await generateCacheEntry(workStore, cacheContext, clientReferenceManifest, encodedCacheKeyParts, fn, timeoutError);
             if (result.type === 'prerender-dynamic') {
                 return result.hangingPromise;
             }
-            const { stream: newStream, pendingCacheEntry } = result;
+            const { stream: newStream, pendingCacheResult } = result;
             // When draft mode is enabled, we must not save the cache entry.
             if (!workStore.isDraftMode) {
-                let savedCacheEntry;
-                if (prerenderResumeDataCache) {
-                    // Create a clone that goes into the cache scope memory cache.
-                    const split = clonePendingCacheEntry(pendingCacheEntry);
-                    savedCacheEntry = getNthCacheEntry(split, 0);
-                    prerenderResumeDataCache.cache.set(serializedCacheKey, getNthCacheEntry(split, 1));
-                } else {
-                    savedCacheEntry = pendingCacheEntry;
-                }
+                const savedCacheResult = saveToResumeDataCache(prerenderResumeDataCache, serializedCacheKey, pendingCacheResult);
                 if (cacheHandler) {
-                    const promise = cacheHandler.set(serializedCacheKey, savedCacheEntry);
-                    workStore.pendingRevalidateWrites ??= [];
-                    workStore.pendingRevalidateWrites.push(promise);
+                    saveToCacheHandler(cacheHandler, workStore, id, serializedCacheKey, savedCacheResult, rootParams);
                 }
             }
             stream = newStream;
@@ -1164,11 +1407,11 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                     configurable: true
                 });
             }
-            propagateCacheLifeAndTags(cacheContext, entry);
+            maybePropagateCacheEntryMetadata(cacheContext, entry, knownRootParamsByFunctionId.get(id));
             // We want to return this stream, even if it's stale.
             stream = entry.value;
-            // If we have a cache scope, we need to clone the entry and set it on
-            // the inner cache scope.
+            // If we have a resume data cache, we need to clone the entry and add it
+            // to the resume data cache.
             if (prerenderResumeDataCache) {
                 const [entryLeft, entryRight] = cloneCacheEntry(entry);
                 if (cacheSignal) {
@@ -1176,7 +1419,20 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 } else {
                     stream = entryLeft.value;
                 }
-                prerenderResumeDataCache.cache.set(serializedCacheKey, Promise.resolve(entryRight));
+                // The RDC is per-page and root params are fixed within a page, so we
+                // always use the coarse key (without root param suffix).
+                prerenderResumeDataCache.cache.set(serializedCacheKey, Promise.resolve({
+                    entry: entryRight,
+                    // For pre-existing entries from cache handlers we don't know
+                    // whether they had explicit cache life values or not. But we only
+                    // need this information during prerendering when we produce new
+                    // entries, where the cache life of an inner cache may be propagated
+                    // to the outer one. In that case we use the RDC. So it's safe to
+                    // set this to undefined here.
+                    hasExplicitRevalidate: undefined,
+                    hasExplicitExpire: undefined,
+                    readRootParamNames: knownRootParamNames
+                }));
             } else {
                 // If we're not regenerating we need to signal that we've finished
                 // putting the entry into the cache scope at this point. Otherwise we do
@@ -1187,25 +1443,19 @@ async function cache(kind, id, boundArgsLength, originalFn, argsObj) {
                 // If this is stale, and we're not in a prerender (i.e. this is
                 // dynamic render), then we should warm up the cache with a fresh
                 // revalidated entry.
-                const result = await generateCacheEntry(workStore, // This is not running within the context of this unit.
+                const result = await generateCacheEntry(workStore, // The background revalidation preserves the outer store for reading
+                // (e.g. implicitTags) but skips propagation of cache life and tags
+                // back to the outer scope.
                 {
                     kind: cacheContext.kind,
-                    outerWorkUnitStore: undefined
+                    outerWorkUnitStore: cacheContext.outerWorkUnitStore,
+                    skipPropagation: true
                 }, clientReferenceManifest, encodedCacheKeyParts, fn, timeoutError);
                 if (result.type === 'cached') {
-                    const { stream: ignoredStream, pendingCacheEntry } = result;
-                    let savedCacheEntry;
-                    if (prerenderResumeDataCache) {
-                        const split = clonePendingCacheEntry(pendingCacheEntry);
-                        savedCacheEntry = getNthCacheEntry(split, 0);
-                        prerenderResumeDataCache.cache.set(serializedCacheKey, getNthCacheEntry(split, 1));
-                    } else {
-                        savedCacheEntry = pendingCacheEntry;
-                    }
+                    const { stream: ignoredStream, pendingCacheResult } = result;
+                    const savedCacheResult = saveToResumeDataCache(prerenderResumeDataCache, serializedCacheKey, pendingCacheResult);
                     if (cacheHandler) {
-                        const promise = cacheHandler.set(serializedCacheKey, savedCacheEntry);
-                        workStore.pendingRevalidateWrites ??= [];
-                        workStore.pendingRevalidateWrites.push(promise);
+                        saveToCacheHandler(cacheHandler, workStore, id, serializedCacheKey, savedCacheResult, rootParams);
                     }
                     await ignoredStream.cancel();
                 }
@@ -1254,7 +1504,7 @@ function shouldForceRevalidate(workStore, workUnitStore) {
     if (workStore.isOnDemandRevalidate || workStore.isDraftMode) {
         return true;
     }
-    if (workStore.dev && workUnitStore) {
+    if (process.env.__NEXT_DEV_SERVER) {
         switch(workUnitStore.type){
             case 'request':
                 return workUnitStore.headers.get('cache-control') === 'no-cache';
@@ -1264,9 +1514,11 @@ function shouldForceRevalidate(workStore, workUnitStore) {
             case 'prerender-runtime':
             case 'prerender':
             case 'prerender-client':
+            case 'validation-client':
             case 'prerender-ppr':
             case 'prerender-legacy':
             case 'unstable-cache':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;
@@ -1286,22 +1538,22 @@ function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags,
     // the affected cache entries, and we don't want to discard those again during
     // the prerender validation. During build-time prerendering, there will never
     // be any pending revalidated tags.
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-                return false;
-            case 'prerender-runtime':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-            case 'request':
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                break;
-            default:
-                workUnitStore;
-        }
+    switch(workUnitStore.type){
+        case 'prerender':
+            return false;
+        case 'prerender-runtime':
+        case 'prerender-client':
+        case 'validation-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+        case 'request':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'generate-static-params':
+            break;
+        default:
+            workUnitStore;
     }
     // If the cache entry contains revalidated tags that the cache handler might
     // not know about yet, we need to discard it.