@aeolus-fleet/console 0.34.0 → 0.36.0

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

@@ -13,12 +13,12 @@ const _client = require("react-server-dom-webpack/client");
 const _static = require("react-server-dom-webpack/static");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _varyparams = require("../app-render/vary-params");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _manifestssingleton = require("../app-render/manifests-singleton");
 const _encryption = require("../app-render/encryption");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _createerrorhandler = require("../app-render/create-error-handler");
-const _errortelemetryutils = require("../../lib/error-telemetry-utils");
 const _stringhash = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/string-hash"));
 const _constants = require("./constants");
 const _constants1 = require("../../lib/constants");
@@ -28,8 +28,10 @@ const _approuterheaders = require("../../client/components/app-router-headers");
 const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
 const _headers = require("../web/spec-extension/adapters/headers");
 const _usecacheerrors = require("./use-cache-errors");
+const _usecachemessages = require("./use-cache-messages");
 const _dynamicrendering = require("../app-render/dynamic-rendering");
 const _searchparams = require("../request/search-params");
+const _cachestore = require("../resume-data-cache/cache-store");
 const _lazyresult = require("../lib/lazy-result");
 const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
 const _stagedrendering = require("../app-render/staged-rendering");
@@ -82,6 +84,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const nextVersion = "16.4.2";
 /**
  * Encapsulates a pending cache invocation for deduping. Manages lazy stream
  * tee-ing (via fork()) and metadata access for both intra-request and
@@ -169,12 +172,14 @@ function ignoreReject() {}
  * (specific key on warm path, coarse key on cold path). Entries live only for
  * the duration of the leader's invocation.
  */ const crossRequestPendingCacheInvocations = new Map();
-const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
-const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? console.debug.bind(console, 'use-cache:') : undefined;
+// Prevent duplicate background revalidations for the same key until generation
+// and cache writes finish.
+const backgroundRevalidations = new Map();
+// The first argument at each call site is the full directive that produced
+// the invocation, e.g. "'use cache'" or "'use cache: remote'".
+const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? console.debug.bind(console) : 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
@@ -275,7 +280,7 @@ function computePrivateCacheKeyRequestSuffix(cookies, headers) {
         headers: relevantHeaders
     });
 }
-function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult) {
+function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult, logPrefix) {
     if (!(resumeDataCache == null ? void 0 : resumeDataCache.mutable)) {
         return pendingCacheResult;
     }
@@ -286,7 +291,7 @@ function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCache
     // use the coarse key (without root param suffix). Unlike the cache handler,
     // the RDC doesn't need root-param-specific keys for isolation.
     resumeDataCache.cache.set(serializedCacheKey, rdcResult);
-    debug == null ? void 0 : debug('Resume Data Cache entry saved', serializedCacheKey);
+    debug == null ? void 0 : debug(logPrefix, 'Resume Data Cache entry saved', serializedCacheKey);
     return savedCacheResult;
 }
 /**
@@ -301,11 +306,15 @@ function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCache
  * resume from the entry. Constructs a `CollectedCacheResult` from a forked
  * stream branch of the shared entry and the awaited metadata.
  *
- * The `cache.has()` guard avoids redundant saves when the intra-request leader
- * already saved to the same RDC. Without it, this would needlessly tee the
- * stream and overwrite an equivalent RDC entry.
- */ function saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheEntry, resumeDataCache) {
-    if (!(resumeDataCache == null ? void 0 : resumeDataCache.mutable) || resumeDataCache.cache.has(serializedCacheKey)) {
+ * An existing entry avoids redundant saves when the intra-request leader
+ * already saved to the same RDC. A marker, however, can be replaced by a
+ * successful fill.
+ */ function saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheEntry, resumeDataCache, logPrefix) {
+    if (!(resumeDataCache == null ? void 0 : resumeDataCache.mutable)) {
+        return;
+    }
+    const existingEntry = resumeDataCache.cache.get(serializedCacheKey);
+    if (existingEntry !== undefined && existingEntry !== _cachestore.FALLBACK_PARAMS && existingEntry !== _cachestore.RUNTIME_DATA && existingEntry !== _cachestore.SESSION_DATA) {
         return;
     }
     const rdcResult = sharedCacheEntry.pendingMetadata.then((metadata)=>({
@@ -323,20 +332,20 @@ function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCache
             dynamicNestedCacheError: metadata.dynamicNestedCacheError
         }));
     resumeDataCache.cache.set(serializedCacheKey, rdcResult);
-    debug == null ? void 0 : debug('Resume Data Cache entry saved by joiner', serializedCacheKey);
+    debug == null ? void 0 : debug(logPrefix, 'Resume Data Cache entry saved by joiner', serializedCacheKey);
 }
 /**
  * Completes a join onto another invocation's entry, whether that invocation is
  * still filling or has already finished: forks the stream, saves to this
  * invocation's RDC if the leader had none, and balances the cache signal read
  * once the entry is fully collected.
- */ function serveJoinedCacheEntry(sharedCacheEntry, serializedCacheKey, resumeDataCache, cacheContext, cacheSignal) {
+ */ function serveJoinedCacheEntry(sharedCacheEntry, serializedCacheKey, resumeDataCache, cacheContext, cacheSignal, logPrefix) {
     const stream = sharedCacheEntry.fork();
     // If the leader was nested inside another cache (no accessible RDC), it
     // couldn't save to the RDC. This joiner may be top-level with an RDC, in
     // which case it must save here; otherwise the RDC lookup during the final
     // prerender will miss.
-    saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheEntry, resumeDataCache);
+    saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheEntry, resumeDataCache, logPrefix);
     // End the cache read after collection and metadata propagation, not when the
     // value stream becomes available. This does not wait for handler persistence.
     // A failed collection or propagation must still end the read so it cannot
@@ -349,12 +358,12 @@ function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCache
     }).catch(ignoreReject);
     return stream;
 }
-function saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams) {
+function saveToCacheHandler(cacheHandler, id, cacheHandlerKeyBase, savedCacheResult, rootParams) {
     // Write the entry to the cache handler. With root params, this is a redirect
     // entry at the coarse key plus the actual entry at the specific key;
     // otherwise just the entry at the coarse key. Both set calls are fired
     // together and awaited in parallel.
-    const combinedSetPromise = savedCacheResult.then(async (collectedResult)=>{
+    return savedCacheResult.then(async (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
@@ -369,7 +378,10 @@ function saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, sa
         let coarseEntry = fullEntry;
         if (rootParamNames && rootParamNames.size > 0 && rootParams) {
             const specificKey = cacheHandlerKeyBase + computeRootParamsCacheKeySuffix(rootParams, rootParamNames);
-            setPromises.push(cacheHandler.set(specificKey, Promise.resolve(fullEntry)));
+            setPromises.push(// Capture synchronous `set()` throws as rejected write promises.
+            new Promise((resolve)=>{
+                resolve(cacheHandler.set(specificKey, Promise.resolve(fullEntry)));
+            }));
             // The coarse key gets a redirect entry instead. On a cold server (empty
             // knownRootParamsByFunctionId), its tags tell a reader which root params
             // to include in the specific-key lookup.
@@ -396,18 +408,18 @@ function saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, sa
                 revalidate: fullEntry.revalidate
             };
         }
-        setPromises.push(cacheHandler.set(cacheHandlerKeyBase, Promise.resolve(coarseEntry)));
-        await Promise.all(setPromises);
+        setPromises.push(// Capture synchronous `set()` throws as rejected write promises.
+        new Promise((resolve)=>{
+            resolve(cacheHandler.set(cacheHandlerKeyBase, Promise.resolve(coarseEntry)));
+        }));
+        // A failed write must not finish the operation while another write is
+        // pending.
+        for (const result of (await Promise.allSettled(setPromises))){
+            if (result.status === 'rejected') {
+                throw result.reason;
+            }
+        }
     });
-    workStore.pendingRevalidateWrites ??= [];
-    workStore.pendingRevalidateWrites.push(combinedSetPromise);
-    // A cross-request joiner reads its recomputed specific key only after it has
-    // awaited this entry's metadata, so gate the metadata on the writes landing:
-    // that guarantees the entry is present when the joiner re-reads. A failed
-    // write shouldn't reject the metadata (the joiner just misses and
-    // regenerates), so settle either way; a collection failure still propagates
-    // through `savedCacheResult`.
-    return combinedSetPromise.then(()=>savedCacheResult, ()=>savedCacheResult);
 }
 function generateCacheEntry(workStore, cacheContext, clientReferenceManifest, encodedArguments, fn, timeoutError, deadlockError) {
     // We need to run this inside a clean AsyncLocalStorage snapshot so that the cache
@@ -433,6 +445,7 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
         return {
             type: 'private-cache',
             phase: 'render',
+            consumerWillServerCache: true,
             implicitTags: outerWorkUnitStore == null ? void 0 : outerWorkUnitStore.implicitTags,
             revalidate: defaultCacheLife.revalidate,
             expire: defaultCacheLife.expire,
@@ -447,7 +460,7 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
             forceRevalidate: shouldForceRevalidate(workStore, outerWorkUnitStore),
             draftMode: (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, outerWorkUnitStore),
             rootParams: outerWorkUnitStore.rootParams,
-            readRootParamNames: process.env.__NEXT_DEV_SERVER ? new Set() : undefined,
+            readRootParamNames: new Set(),
             // Every private cache scope is its own work unit. Any cache keyed on
             // headers() or cookies() needs to be invalidated. Otherwise some
             // Next.js API semantics leak across render passes.
@@ -466,17 +479,27 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
                 break;
             case 'prerender-runtime':
             case 'prerender':
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 outerWorkUnitStore;
         }
+        let fallbackRootParamsPrerender = null;
+        if (outerWorkUnitStore.type === 'cache') {
+            fallbackRootParamsPrerender = outerWorkUnitStore.fallbackRootParamsPrerender;
+        } else if (outerWorkUnitStore.type === 'prerender') {
+            const { fallbackRouteParams } = outerWorkUnitStore;
+            if (fallbackRouteParams !== null && Object.keys(outerWorkUnitStore.rootParams).some((name)=>fallbackRouteParams.has(name))) {
+                fallbackRootParamsPrerender = outerWorkUnitStore;
+            }
+        }
         return {
             type: 'cache',
             phase: 'render',
+            fallbackRootParamsPrerender,
+            consumerWillServerCache: true,
             implicitTags: outerWorkUnitStore.implicitTags,
             revalidate: defaultCacheLife.revalidate,
             expire: defaultCacheLife.expire,
@@ -514,12 +537,11 @@ function createUseCacheStore(workStore, cacheContext, defaultCacheLife) {
         case 'unstable-cache':
         case 'request':
         case 'prerender':
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'prerender-runtime':
         case 'prerender-client':
         case 'validation-client':
-        case 'generate-static-params':
+        case 'build-time-generator':
             break;
         default:
             workUnitStore;
@@ -544,7 +566,8 @@ function generateCacheEntryWithCacheContext(workStore, cacheContext, clientRefer
     // Initialize the Store for this Cache entry.
     const cacheStore = createUseCacheStore(workStore, cacheContext, defaultCacheLife);
     return _workunitasyncstorageexternal.workUnitAsyncStorage.run(cacheStore, ()=>_dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.run({
-            abortController: new AbortController()
+            abortController: new AbortController(),
+            reason: null
         }, generateCacheEntryImpl, workStore, cacheContext, cacheStore, clientReferenceManifest, encodedArguments, fn, timeoutError, deadlockError));
 }
 function propagateCacheLifeAndTagsToRevalidateStore(revalidateStore, metadata) {
@@ -572,8 +595,14 @@ function propagateCacheStaleTimeToRequestStore(requestStore, metadata) {
 function propagateCacheEntryMetadata(cacheContext, metadata) {
     if (cacheContext.kind === 'private') {
         switch(cacheContext.outerWorkUnitStore.type){
-            case 'prerender-runtime':
             case 'private-cache':
+                if (metadata.readRootParamNames) {
+                    for (const paramName of metadata.readRootParamNames){
+                        cacheContext.outerWorkUnitStore.readRootParamNames.add(paramName);
+                    }
+                }
+            // fallthrough
+            case 'prerender-runtime':
                 propagateCacheLifeAndTagsToRevalidateStore(cacheContext.outerWorkUnitStore, metadata);
                 break;
             case 'request':
@@ -587,11 +616,6 @@ function propagateCacheEntryMetadata(cacheContext, metadata) {
     } else {
         switch(cacheContext.outerWorkUnitStore.type){
             case 'cache':
-                if (metadata.readRootParamNames) {
-                    for (const paramName of metadata.readRootParamNames){
-                        cacheContext.outerWorkUnitStore.readRootParamNames.add(paramName);
-                    }
-                }
                 // If this entry's cache life is dynamic, record this invocation as the
                 // origin to use as `cause` when the outer cache surfaces the
                 // nested-dynamic cache error. `??=` keeps the first occurrence so the
@@ -601,9 +625,14 @@ function propagateCacheEntryMetadata(cacheContext, metadata) {
                 }
             // fallthrough
             case 'private-cache':
+                if (metadata.readRootParamNames) {
+                    for (const paramName of metadata.readRootParamNames){
+                        cacheContext.outerWorkUnitStore.readRootParamNames.add(paramName);
+                    }
+                }
+            // fallthrough
             case 'prerender':
             case 'prerender-runtime':
-            case 'prerender-ppr':
             case 'prerender-legacy':
                 propagateCacheLifeAndTagsToRevalidateStore(cacheContext.outerWorkUnitStore, metadata);
                 break;
@@ -611,12 +640,20 @@ function propagateCacheEntryMetadata(cacheContext, metadata) {
                 propagateCacheStaleTimeToRequestStore(cacheContext.outerWorkUnitStore, metadata);
                 break;
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 cacheContext.outerWorkUnitStore;
         }
     }
+    if (metadata.readRootParamNames) {
+        const varyParamsAccumulator = (0, _workunitasyncstorageexternal.getVaryParamsAccumulator)(cacheContext.outerWorkUnitStore);
+        if (varyParamsAccumulator) {
+            for (const paramName of metadata.readRootParamNames){
+                (0, _varyparams.accumulateVaryParam)(varyParamsAccumulator.rootParams, paramName);
+            }
+        }
+    }
 }
 /**
  * Conditionally propagates cache life, tags, and root param names to the outer
@@ -628,10 +665,11 @@ function propagateCacheEntryMetadata(cacheContext, metadata) {
  * `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.
+ * Nested caches propagate root param names into the enclosing cache's
+ * `readRootParamNames` set. This propagation is never deferred. Prerender
+ * contexts also register known root param names when they read the resume
+ * data cache. A response accumulator records the consumed entry's root vary
+ * params to prevent segment reuse across different values.
  */ function maybePropagateCacheEntryMetadata(cacheContext, metadata) {
     const outerWorkUnitStore = cacheContext.outerWorkUnitStore;
     switch(outerWorkUnitStore.type){
@@ -642,7 +680,7 @@ function propagateCacheEntryMetadata(cacheContext, metadata) {
             }
         case 'request':
             {
-                if (process.env.NODE_ENV === 'development' && outerWorkUnitStore.cacheSignal) {
+                if (isValidationRender(outerWorkUnitStore) && outerWorkUnitStore.cacheSignal) {
                     break;
                 }
             // fallthrough
@@ -651,12 +689,11 @@ function propagateCacheEntryMetadata(cacheContext, metadata) {
         case 'cache':
         case 'unstable-cache':
         case 'prerender-legacy':
-        case 'prerender-ppr':
             {
                 propagateCacheEntryMetadata(cacheContext, metadata);
                 break;
             }
-        case 'generate-static-params':
+        case 'build-time-generator':
             break;
         default:
             {
@@ -740,7 +777,7 @@ async function collectResult(savedStream, workStore, cacheContext, innerCacheSto
         entry,
         hasExplicitRevalidate: innerCacheStore.explicitRevalidate !== undefined,
         hasExplicitExpire: innerCacheStore.explicitExpire !== undefined,
-        readRootParamNames: innerCacheStore.type === 'cache' || isPrivateCacheInDev ? innerCacheStore.readRootParamNames : undefined,
+        readRootParamNames: innerCacheStore.readRootParamNames,
         // The store accumulates this from nested public caches that propagated a
         // dynamic life into us.
         dynamicNestedCacheError: innerCacheStore.type === 'cache' ? innerCacheStore.dynamicNestedCacheError : undefined
@@ -767,7 +804,7 @@ async function collectResult(savedStream, workStore, cacheContext, innerCacheSto
 async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore, clientReferenceManifest, encodedArguments, fn, timeoutError, deadlockError) {
     const temporaryReferences = (0, _server.createTemporaryReferenceSet)();
     const outerWorkUnitStore = cacheContext.outerWorkUnitStore;
-    const [, , args] = typeof encodedArguments === 'string' ? await (0, _server.decodeReply)(encodedArguments, (0, _manifestssingleton.getServerModuleMap)(), {
+    const [, args] = typeof encodedArguments === 'string' ? await (0, _server.decodeReply)(encodedArguments, (0, _manifestssingleton.getServerModuleMap)(), {
         temporaryReferences
     }) : await (0, _server.decodeReplyFromAsyncIterable)({
         async *[Symbol.asyncIterator] () {
@@ -791,13 +828,12 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                         }
                     });
                     break;
-                case 'prerender-ppr':
                 case 'prerender-legacy':
                 case 'request':
                 case 'cache':
                 case 'private-cache':
                 case 'unstable-cache':
-                case 'generate-static-params':
+                case 'build-time-generator':
                     break;
                 default:
                     outerWorkUnitStore;
@@ -832,16 +868,27 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
     let stream;
     let devTimeoutAbortController;
     switch(outerWorkUnitStore.type){
+        case 'cache':
         case 'prerender-runtime':
         case 'prerender':
             {
-                var _dynamicAccessAsyncStorage_getStore;
+                const prerenderStore = outerWorkUnitStore.type === 'cache' ? outerWorkUnitStore.fallbackRootParamsPrerender : outerWorkUnitStore;
+                if (prerenderStore === null) {
+                    stream = (0, _server.renderToReadableStream)(resultPromise, clientReferenceManifest.clientModules, {
+                        environmentName: 'Cache',
+                        filterStackFrame,
+                        temporaryReferences,
+                        onError: handleError
+                    });
+                    break;
+                }
                 const timeoutAbortController = new AbortController();
                 const timer = setTimeout(()=>{
                     workStore.invalidDynamicUsageError = timeoutError;
                     timeoutAbortController.abort(timeoutError);
-                }, getUseCacheFillTimeoutMs(workStore, outerWorkUnitStore.type));
-                const dynamicAccessAbortSignal = (_dynamicAccessAsyncStorage_getStore = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore()) == null ? void 0 : _dynamicAccessAsyncStorage_getStore.abortController.signal;
+                }, getUseCacheFillTimeoutMs(workStore, prerenderStore.type));
+                const dynamicAccessStore = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
+                const dynamicAccessAbortSignal = dynamicAccessStore == null ? void 0 : dynamicAccessStore.abortController.signal;
                 const abortSignal = dynamicAccessAbortSignal ? AbortSignal.any([
                     dynamicAccessAbortSignal,
                     timeoutAbortController.signal
@@ -877,16 +924,49 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                         }
                     });
                 } else if (dynamicAccessAbortSignal == null ? void 0 : dynamicAccessAbortSignal.aborted) {
+                    var _getCacheSignal;
+                    const reason = (dynamicAccessStore == null ? void 0 : dynamicAccessStore.reason) ?? 'runtime';
+                    const makeHangingPromise = reason === 'fallback-params' ? _dynamicrenderingutils.makeFallbackParamsHangingPromise : _dynamicrenderingutils.makeURLDataHangingPromise;
+                    if (innerCacheStore.type === 'cache' && innerCacheStore.fallbackRootParamsPrerender !== null) {
+                        var _getCacheSignal1;
+                        // No entry is collected for an aborted fill. Still remember the
+                        // roots actually read so a concrete request won't join this result
+                        // under the coarse key. Propagate them through aborted parents too.
+                        addKnownRootParamNames(cacheContext.functionId, innerCacheStore.readRootParamNames);
+                        const hangingPromise = (0, _dynamicrenderingutils.trackPromiseUsed)(makeHangingPromise(prerenderStore.renderSignal, workStore.route, 'dynamic "use cache"', // The single wrapper below tracks access when consumed.
+                        null), ()=>{
+                            if (reason === 'fallback-params') {
+                                (0, _dynamicrenderingutils.trackFallbackParamsAccessed)(prerenderStore, 'dynamic "use cache"');
+                            } else {
+                                (0, _dynamicrenderingutils.trackURLDataAccessed)(prerenderStore, 'dynamic "use cache"');
+                            }
+                            // The result may also be consumed by a deduped invocation, so
+                            // record dependencies against the cache consuming it now.
+                            const consumer = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+                            if (consumer !== undefined && consumer.type === 'cache') {
+                                for (const name of innerCacheStore.readRootParamNames){
+                                    consumer.readRootParamNames.add(name);
+                                }
+                            }
+                            // Only a cache consuming this result must suspend. Do not share
+                            // cancellation with independent sibling cache fills.
+                            (0, _dynamicaccessasyncstorageexternal.abortOnDynamicAccess)(reason, dynamicAccessAbortSignal.reason);
+                        });
+                        (_getCacheSignal1 = (0, _workunitasyncstorageexternal.getCacheSignal)(outerWorkUnitStore)) == null ? void 0 : _getCacheSignal1.endRead();
+                        return {
+                            type: 'prerender-dynamic',
+                            reason: reason === 'fallback-params' ? _cachestore.FALLBACK_PARAMS : _cachestore.RUNTIME_DATA,
+                            hangingPromise
+                        };
+                    }
                     // If the prerender is aborted because of dynamic access (e.g. reading
                     // fallback params), we return a hanging promise. This essentially makes
                     // the "use cache" function dynamic.
-                    // The dynamic access is a fallback params read, which is runtime data.
-                    const hangingPromise = (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(outerWorkUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', outerWorkUnitStore);
-                    if (outerWorkUnitStore.cacheSignal) {
-                        outerWorkUnitStore.cacheSignal.endRead();
-                    }
+                    const hangingPromise = makeHangingPromise(prerenderStore.renderSignal, workStore.route, 'dynamic "use cache"', outerWorkUnitStore);
+                    (_getCacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(outerWorkUnitStore)) == null ? void 0 : _getCacheSignal.endRead();
                     return {
                         type: 'prerender-dynamic',
+                        reason: reason === 'fallback-params' ? _cachestore.FALLBACK_PARAMS : _cachestore.RUNTIME_DATA,
                         hangingPromise
                     };
                 } else {
@@ -958,7 +1038,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                                 // error actually surfaces (vs. being caught in userland) is
                                 // the consumer's decision, so the "surfaced" mark is left to
                                 // the outer handler.
-                                const digest = (0, _errortelemetryutils.createDigestWithErrorCode)(error, (0, _stringhash.default)(error.message + (error.stack || '')).toString());
+                                const digest = (0, _stringhash.default)(error.message + (error.stack || '')).toString();
                                 workStore.reactServerErrorsByDigest.set(digest, error);
                                 return digest;
                             }
@@ -981,11 +1061,7 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                             devTimeoutAbortController.signal
                         ]),
                         onProbeCompleted () {
-                            const error = deadlockError ?? Object.defineProperty(new _invarianterror.InvariantError('`deadlockError` should be constructed inside `cache()` before reaching the probe scheduler.'), "__NEXT_ERROR_CODE", {
-                                value: "E1182",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            const error = deadlockError ?? new _invarianterror.InvariantError('`deadlockError` should be constructed inside `cache()` before reaching the probe scheduler.');
                             workStore.invalidDynamicUsageError = error;
                             devRenderAbortController.abort(error);
                         }
@@ -994,12 +1070,10 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                 }
             }
         // fallthrough
-        case 'prerender-ppr':
         case 'prerender-legacy':
-        case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
             stream = (0, _server.renderToReadableStream)(resultPromise, clientReferenceManifest.clientModules, {
                 environmentName: 'Cache',
                 filterStackFrame,
@@ -1098,21 +1172,15 @@ function createTrackedReadableStream(stream, cacheSignal) {
 async function cache(kind, id, boundArgsLength, originalFn, args) {
     var _workUnitStore_implicitTags;
     const isPrivate = kind === 'private';
+    // The default handler kind corresponds to the bare 'use cache' directive.
+    const logPrefix = kind === 'default' ? `'use cache'` : `'use cache: ${kind}'`;
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (workStore === undefined) {
-        throw Object.defineProperty(new Error('"use cache" cannot be used outside of App Router. Expected a WorkStore.'), "__NEXT_ERROR_CODE", {
-            value: "E279",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('"use cache" cannot be used outside of App Router. Expected a WorkStore.');
     }
     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
-        });
+        throw new _invarianterror.InvariantError('"use cache" cannot be used outside of App Router. Expected a WorkUnitStore.');
     }
     // In a prerender, tasky IO may result in cache reads that start
     // after the prerender has already been aborted:
@@ -1135,7 +1203,6 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 }
                 break;
             }
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'prerender-client':
         case 'validation-client':
@@ -1143,7 +1210,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
             break;
         default:
             workUnitStore;
@@ -1163,11 +1230,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         } else {
             const handler = (0, _handlers.getCacheHandler)(kind);
             if (!handler) {
-                throw Object.defineProperty(new Error('Unknown cache handler: ' + kind), "__NEXT_ERROR_CODE", {
-                    value: "E248",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('Unknown cache handler: ' + kind);
             }
             // In development, a user-configured (custom) handler may be slow or
             // remote, so we read through a tiered handler that puts a built-in
@@ -1179,11 +1242,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 // same `setCacheHandler` call that makes `isCustomCacheHandler` true.
                 const tieredCacheHandler = (0, _handlers.getDevTieredCacheHandler)(kind);
                 if (!tieredCacheHandler) {
-                    throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a dev tiered cache handler for kind "${kind}".`), "__NEXT_ERROR_CODE", {
-                        value: "E1365",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new _invarianterror.InvariantError(`Expected a dev tiered cache handler for kind "${kind}".`);
                 }
                 cacheHandler = tieredCacheHandler;
             } else {
@@ -1191,7 +1250,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
             }
         }
     }
-    const timeoutError = new _usecacheerrors.UseCacheTimeoutError();
+    const timeoutError = new _usecacheerrors.UseCacheTimeoutError(workStore.route);
     Error.captureStackTrace(timeoutError, cache);
     (0, _dynamicrenderingutils.applyOwnerStack)(timeoutError);
     // Only ever thrown by the dev-server's hang-detection probe.
@@ -1202,7 +1261,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     // gate lets the error class drop out of the production runtime bundle.
     let deadlockError;
     if (process.env.__NEXT_DEV_SERVER) {
-        deadlockError = new _usecacheerrors.UseCacheDeadlockError();
+        deadlockError = new _usecacheerrors.UseCacheDeadlockError(workStore.route);
         Error.captureStackTrace(deadlockError, cache);
         (0, _dynamicrenderingutils.applyOwnerStack)(deadlockError);
     }
@@ -1220,36 +1279,23 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         switch(workUnitStore.type){
             // "use cache: private" is dynamic in prerendering contexts.
             case 'prerender':
-                // Private caches can read request data, which is runtime data.
-                return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression, workUnitStore);
-            case 'prerender-ppr':
-                return (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, workUnitStore.dynamicTracking);
+                // Private caches can read request data. At this point we don't know
+                // Whether it's going to use session data or URL data.
+                // TODO(app-shells): This could be narrowed (and thus optimized) if we checked whether URL data
+                // is included in the cache key, because it can only be passed in as arguments.
+                return (0, _dynamicrenderingutils.makeUnknownRuntimeDataHangingPromise)(workUnitStore.renderSignal, workStore.route, expression, workUnitStore);
             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: "E1020",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw 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.`);
             case 'unstable-cache':
                 {
-                    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: "E1016",
-                        enumerable: false,
-                        configurable: true
-                    }));
+                    throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createUseCachePrivateInsideUnstableCacheError)(workStore.route));
                 }
             case 'cache':
                 {
-                    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: "E1001",
-                        enumerable: false,
-                        configurable: true
-                    }));
+                    throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createUseCachePrivateInsidePublicUseCacheError)(workStore.route));
                 }
             case 'request':
             case 'prerender-runtime':
@@ -1263,33 +1309,20 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                     handlerKind: kind
                 };
                 break;
-            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: "E1008",
-                    enumerable: false,
-                    configurable: true
-                }));
+            case 'build-time-generator':
+                throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createUseCachePrivateOutsideRequestContextError)(workStore.route, workUnitStore.functionName));
             default:
                 workUnitStore;
                 // This is dead code, but without throwing an error here, TypeScript
                 // will assume that cacheContext is used before being assigned.
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected work unit store.`), "__NEXT_ERROR_CODE", {
-                    value: "E737",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Unexpected work unit store.`);
         }
     } else {
         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: "E1038",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw 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.`);
             case 'cache':
                 {
                     // Eagerly capture this invocation's call site while still synchronous
@@ -1318,14 +1351,13 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 }
             case 'prerender':
             case 'prerender-runtime':
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'request':
             case 'private-cache':
             // TODO: We should probably forbid nesting "use cache" inside
             // unstable_cache. (fallthrough)
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 cacheContext = {
                     kind: 'public',
                     outerWorkUnitStore: workUnitStore,
@@ -1340,27 +1372,12 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 workUnitStore;
                 // This is dead code, but without throwing an error here, TypeScript
                 // will assume that cacheContext is used before being assigned.
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected work unit store.`), "__NEXT_ERROR_CODE", {
-                    value: "E737",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Unexpected work unit store.`);
         }
     }
     // Get the clientReferenceManifest while we're still in the outer Context.
     // In case getClientReferenceManifestSingleton is implemented using AsyncLocalStorage.
     const clientReferenceManifest = (0, _manifestssingleton.getClientReferenceManifest)();
-    // Because the Action ID is not yet unique per implementation of that Action we can't
-    // safely reuse the results across builds yet. In the meantime we add the buildId to the
-    // arguments as a seed to ensure they're not reused. Remove this once Action IDs hash
-    // the implementation.
-    const buildId = workStore.deploymentId || workStore.buildId;
-    // In dev mode, when the HMR refresh hash is set, we include it in the
-    // cache key. This ensures that cache entries are not reused when server
-    // 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 = (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workUnitStore);
     const hangingInputAbortSignal = (0, _dynamicrendering.createHangingInputAbortSignal)(workUnitStore);
     if (cacheContext.kind === 'private') {
         const { outerWorkUnitStore } = cacheContext;
@@ -1368,7 +1385,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
             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 appropriate runtime stage. Private caches resolve in EarlyRuntime,
+                    // are resolved with a delay, in the appropriate runtime stage.
                     const stagedRendering = outerWorkUnitStore.stagedRendering;
                     if (stagedRendering) {
                         await stagedRendering.waitForStage(_dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.sessionData);
@@ -1377,9 +1394,9 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 }
             case 'request':
                 {
-                    if (process.env.NODE_ENV === 'development') {
+                    if (isValidationRender(outerWorkUnitStore)) {
                         // Similar to runtime prerenders, private caches should not resolve in the static stage
-                        // of a dev request, so we delay them.
+                        // of a validation request, so we delay them.
                         await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, outerWorkUnitStore, _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.sessionData);
                     }
                     break;
@@ -1419,10 +1436,14 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
             ...otherOuterArgs
         ];
         fn = ({
-            [name]: async ({ params: _innerParams, searchParams: innerSearchParams }, ...otherInnerArgs)=>originalFn.apply(null, [
+            [name]: async (_, ...otherInnerArgs)=>originalFn.apply(null, [
                     {
-                        params: outerParams,
-                        searchParams: innerSearchParams ?? // For public caches, search params are omitted from the cache
+                        params: props.params,
+                        searchParams: // Preserve the original search params, if this cache can access them.
+                        // Notably, in a runtime shell private caches can resolve, but search params
+                        // will be hanging, and we need to preserve the original proxied promise object
+                        // to trigger `dynamicAccessAbortSignal` when they're accessed.
+                        props.searchParams ?? // For public caches, search params are omitted from the cache
                         // key (and the serialized args) to avoid mismatches between
                         // prerendering and resuming a cached page that does not
                         // access search params. This is also the reason why we're not
@@ -1461,49 +1482,34 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     }
     if (boundArgsLength > 0) {
         if (args.length === 0) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected the "use cache" function ${JSON.stringify(fn.name)} to receive its encrypted bound arguments as the first argument.`), "__NEXT_ERROR_CODE", {
-                value: "E524",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected the "use cache" function ${JSON.stringify(fn.name)} to receive its encrypted bound arguments as the first argument.`);
         }
         const encryptedBoundArgs = args.shift();
         const boundArgs = await (0, _encryption.decryptActionBoundArgs)(id, encryptedBoundArgs);
         if (!Array.isArray(boundArgs)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected the bound arguments of "use cache" function ${JSON.stringify(fn.name)} to deserialize into an array, got ${typeof boundArgs} instead.`), "__NEXT_ERROR_CODE", {
-                value: "E581",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected the bound arguments of "use cache" function ${JSON.stringify(fn.name)} to deserialize into an array, got ${typeof boundArgs} instead.`);
         }
         if (boundArgsLength !== boundArgs.length) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected the "use cache" function ${JSON.stringify(fn.name)} to receive ${boundArgsLength} bound arguments, got ${boundArgs.length} instead.`), "__NEXT_ERROR_CODE", {
-                value: "E559",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected the "use cache" function ${JSON.stringify(fn.name)} to receive ${boundArgsLength} bound arguments, got ${boundArgs.length} instead.`);
         }
         args.unshift(boundArgs);
     }
     const temporaryReferences = (0, _client.createTemporaryReferenceSet)();
-    // The base serialized cache key doesn't include the cookies or headers that
-    // private caches are allowed to read. In production this is because private
-    // cache entries aren't stored in a cache handler, only in the Resume Data
-    // Cache (RDC): private caches are only used during dynamic requests and
-    // runtime prefetches; for dynamic requests the RDC is immutable and excludes
-    // private caches, and for runtime prefetches it's mutable but lives only as
-    // long as the request. In development private caches are persisted across
-    // requests, so `cacheHandlerKeyBase` (below) additionally scopes the handler
-    // key by the request's cookies and headers.
-    const cacheKeyParts = hmrRefreshHash ? [
-        buildId,
+    // The base serialized cache key doesn't include runtime env var state or the
+    // cookies and headers that private caches are allowed to read. Env var state
+    // only scopes the cache handler because the RDC must reuse entries across
+    // rendering phases. In production private cache entries aren't stored in a
+    // cache handler, only in the Resume Data Cache (RDC): private caches are only
+    // used during dynamic requests and runtime prefetches; for dynamic requests
+    // the RDC is immutable and excludes private caches, and for runtime prefetches
+    // it's mutable but lives only as long as the request. In development private
+    // caches are persisted across requests, so `cacheHandlerKeyBase` (below)
+    // additionally scopes the handler key by the request's cookies and headers.
+    const { implementationPart, runtimeEnvVarStateHash } = await computeCacheKeyImplementationPart(workStore, workUnitStore, id);
+    const cacheKeyParts = [
         id,
         args,
-        hmrRefreshHash
-    ] : [
-        buildId,
-        id,
-        args
+        implementationPart
     ];
     const encodeCacheKeyParts = ()=>(0, _client.encodeReply)(cacheKeyParts, {
             temporaryReferences,
@@ -1512,13 +1518,9 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     let encodedCacheKeyParts;
     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,
-        // effectively making the tracking below a no-op.
-        // However, a runtime prerender shares a lot of the semantics with a static prerender,
-        // and might need to follow this codepath in the future
-        // if we start using `dynamicAccessAsyncStorage` for other APIs.
-        //
+        // A runtime prerender may be a runtime shell, which does not have access to
+        // params/searchParams, so we want to apply the same dynamic access logic
+        // as we do in static prerenders.
         // fallthrough
         case 'prerender':
             if (!isPageOrLayoutSegmentFunction) {
@@ -1529,19 +1531,18 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 // layout), we assume 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.
-                const dynamicAccessAbortController = new AbortController();
-                encodedCacheKeyParts = await _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.run({
-                    abortController: dynamicAccessAbortController
-                }, encodeCacheKeyParts);
-                if (dynamicAccessAbortController.signal.aborted) {
-                    // The dynamic access is a fallback params read, which is runtime
-                    // data.
-                    return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
+                const dynamicAccessStore = {
+                    abortController: new AbortController(),
+                    reason: null
+                };
+                encodedCacheKeyParts = await _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.run(dynamicAccessStore, encodeCacheKeyParts);
+                if (dynamicAccessStore.abortController.signal.aborted) {
+                    const makeHangingPromise = dynamicAccessStore.reason === 'fallback-params' ? _dynamicrenderingutils.makeFallbackParamsHangingPromise : _dynamicrenderingutils.makeURLDataHangingPromise;
+                    return makeHangingPromise(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
                 }
                 break;
             }
         // fallthrough
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'request':
         // TODO(restart-on-cache-miss): We need to handle params/searchParams on page components.
@@ -1551,7 +1552,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
         case undefined:
             encodedCacheKeyParts = await encodeCacheKeyParts();
             break;
@@ -1584,11 +1585,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         if (result.type === 'prerender-dynamic') {
             // Unreachable in the probe: outer store is `'request'`-typed, which
             // never produces this variant.
-            throw Object.defineProperty(new _invarianterror.InvariantError('Unexpected `prerender-dynamic` result in `use cache` probe mode.'), "__NEXT_ERROR_CODE", {
-                value: "E1183",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Unexpected `prerender-dynamic` result in `use cache` probe mode.');
         }
         // We don't consume the returned stream — `pendingCacheResult` is what
         // completes when `collectResult` has drained `savedStream`. Cancel the
@@ -1615,12 +1612,11 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     const knownRootParamNames = knownRootParamsByFunctionId.get(id);
     // The coarse cache-handler key. With no root params read, it locates the
     // entry directly; otherwise it locates a redirect entry from which the
-    // specific key (this key + root params, computed below) is derived. For
-    // private caches in development (persisted in the built-in in-memory handler)
-    // it's additionally scoped by the request's cookies and headers, so entries
-    // for requests with different request data don't collide; keys derived from
-    // it inherit that scoping.
-    const cacheHandlerKeyBase = process.env.__NEXT_DEV_SERVER && cacheContext.kind === 'private' ? serializedCacheKey + computePrivateCacheKeyRequestSuffix(cacheContext.outerWorkUnitStore.cookies, cacheContext.outerWorkUnitStore.headers) : serializedCacheKey;
+    // specific key (this key + root params, computed below) is derived. It's
+    // scoped by runtime env var state and, for private caches in development
+    // (persisted in the built-in in-memory handler), the request's cookies and
+    // headers. Keys derived from it inherit that scoping.
+    const cacheHandlerKeyBase = serializedCacheKey + (runtimeEnvVarStateHash ?? '') + (process.env.__NEXT_DEV_SERVER && cacheContext.kind === 'private' ? computePrivateCacheKeyRequestSuffix(cacheContext.outerWorkUnitStore.cookies, cacheContext.outerWorkUnitStore.headers) : '');
     // 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.
@@ -1634,35 +1630,44 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     const resumeDataCache = (0, _workunitasyncstorageexternal.getResumeDataCache)(workUnitStore);
     const implicitTags = ((_workUnitStore_implicitTags = workUnitStore.implicitTags) == null ? void 0 : _workUnitStore_implicitTags.tags) ?? [];
     if (resumeDataCache) {
-        var _resumeDataCache_dynamicCacheKeys;
         // If this cache key was already determined to be dynamic during the
         // prospective prerender (e.g. because it accessed fallback params), we
         // return a hanging promise early to avoid trying to regenerate the entry,
         // which would be aborted anyway.
-        if ((_resumeDataCache_dynamicCacheKeys = resumeDataCache.dynamicCacheKeys) == null ? void 0 : _resumeDataCache_dynamicCacheKeys.has(serializedCacheKey)) {
+        let rdcEntry = resumeDataCache.cache.get(serializedCacheKey);
+        if (rdcEntry === _cachestore.FALLBACK_PARAMS || rdcEntry === _cachestore.RUNTIME_DATA || rdcEntry === _cachestore.SESSION_DATA) {
             switch(workUnitStore.type){
                 case 'prerender':
                 case 'prerender-runtime':
-                    // The cache key was marked dynamic because it depends on fallback
-                    // params, which are runtime data.
-                    return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
-                case 'prerender-ppr':
+                    {
+                        let makeHangingPromise;
+                        if (rdcEntry === _cachestore.FALLBACK_PARAMS) {
+                            makeHangingPromise = _dynamicrenderingutils.makeFallbackParamsHangingPromise;
+                        } else if (rdcEntry === _cachestore.SESSION_DATA) {
+                            makeHangingPromise = _dynamicrenderingutils.makeSessionDataHangingPromise;
+                        } else {
+                            makeHangingPromise = _dynamicrenderingutils.makeURLDataHangingPromise;
+                        }
+                        return makeHangingPromise(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
+                    }
                 case 'prerender-legacy':
                 case 'request':
                 case 'cache':
                 case 'private-cache':
                 case 'unstable-cache':
-                case 'generate-static-params':
+                case 'build-time-generator':
                     break;
                 default:
                     workUnitStore;
             }
+            // Requests may receive the in-memory cache too. Unlike a prerender, they
+            // can resolve these holes, so treat a marker as an ordinary cache miss.
+            rdcEntry = undefined;
         }
         const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
         if (cacheSignal) {
             cacheSignal.beginRead();
         }
-        const rdcEntry = resumeDataCache.cache.get(serializedCacheKey);
         if (rdcEntry !== undefined) {
             let rdcResult = await rdcEntry;
             // Check if the RDC entry should be discarded due to recently revalidated
@@ -1670,8 +1675,8 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
             // fresh data instead of stale RDC data.
             if (rdcResult !== undefined) {
                 const { timestamp } = rdcResult.entry;
-                if (rdcResult.entry.tags.some((tag)=>isRevalidatedAfter(tag, timestamp, workStore)) || implicitTags.some((tag)=>isRevalidatedAfter(tag, timestamp, workStore))) {
-                    debug == null ? void 0 : debug('discarding RDC entry due to recently revalidated tags', serializedCacheKey);
+                if (rdcResult.entry.tags.some((tag)=>isRevalidatedAfter(tag, timestamp, workStore, logPrefix)) || implicitTags.some((tag)=>isRevalidatedAfter(tag, timestamp, workStore, logPrefix))) {
+                    debug == null ? void 0 : debug(logPrefix, 'discarding RDC entry due to recently revalidated tags', serializedCacheKey);
                     rdcResult = undefined;
                 }
             }
@@ -1699,34 +1704,22 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                             // a potentially cached entry.
                             if (rdcResult.entry.revalidate === 0) {
                                 if (rdcResult.hasExplicitRevalidate === false && shouldReportNestedCacheError) {
-                                    throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheZeroRevalidateErrorMessage, {
-                                        cause: rdcResult.dynamicNestedCacheError
-                                    }), "__NEXT_ERROR_CODE", {
-                                        value: "E1245",
-                                        enumerable: false,
-                                        configurable: true
-                                    }));
+                                    throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createNestedCacheZeroRevalidateError)(workStore.route, rdcResult.dynamicNestedCacheError));
                                 }
-                                debug == null ? void 0 : debug('omitting entry', serializedCacheKey, 'from static shell due to revalidate: 0');
+                                debug == null ? void 0 : debug(logPrefix, 'omitting entry', serializedCacheKey, 'from static shell due to revalidate: 0');
                             } else {
                                 if (rdcResult.hasExplicitExpire === false && shouldReportNestedCacheError) {
-                                    throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheShortExpireErrorMessage, {
-                                        cause: rdcResult.dynamicNestedCacheError
-                                    }), "__NEXT_ERROR_CODE", {
-                                        value: "E1244",
-                                        enumerable: false,
-                                        configurable: true
-                                    }));
+                                    throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createNestedCacheShortExpireError)(workStore.route, rdcResult.dynamicNestedCacheError));
                                 }
-                                debug == null ? void 0 : debug('omitting entry', serializedCacheKey, 'from static shell due to short expire value:', rdcResult.entry.expire);
+                                debug == null ? void 0 : debug(logPrefix, 'omitting entry', serializedCacheKey, 'from static shell due to short expire value:', rdcResult.entry.expire);
                             }
                             if (cacheSignal) {
                                 cacheSignal.endRead();
                             }
                             // The entry is only excluded from *static* prerenders — the
-                            // 'prerender-runtime' case below serves it — so a runtime
-                            // prefetch would include this content.
-                            return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
+                            // 'prerender-runtime' case below serves it.
+                            // TODO(app-shells): Does this handle the MIN_SHELL_STALE case below correctly?
+                            return (0, _dynamicrenderingutils.makeSessionDataHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
                         case 'prerender-runtime':
                             {
                                 // In the final phase of a runtime prerender, we have to make
@@ -1740,28 +1733,16 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                             }
                         case 'request':
                             {
-                                if (process.env.NODE_ENV === 'development') {
+                                if (isValidationRender(workUnitStore)) {
                                     // These throws force an explicit cache life decision on an
                                     // outer cache that a nested cache would otherwise silently
                                     // shorten (see `shouldReportNestedCacheError` above). Otherwise
                                     // the short-lived entry is deferred as a dynamic hole below.
                                     if (rdcResult.entry.revalidate === 0 && rdcResult.hasExplicitRevalidate === false && shouldReportNestedCacheError) {
-                                        throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheZeroRevalidateErrorMessage, {
-                                            cause: rdcResult.dynamicNestedCacheError
-                                        }), "__NEXT_ERROR_CODE", {
-                                            value: "E1245",
-                                            enumerable: false,
-                                            configurable: true
-                                        }));
+                                        throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createNestedCacheZeroRevalidateError)(workStore.route, rdcResult.dynamicNestedCacheError));
                                     }
                                     if (rdcResult.entry.expire < _constants.MIN_PRERENDERABLE_EXPIRE && rdcResult.hasExplicitExpire === false && shouldReportNestedCacheError) {
-                                        throw wrapAsInvalidDynamicUsageError(Object.defineProperty(new Error(nestedCacheShortExpireErrorMessage, {
-                                            cause: rdcResult.dynamicNestedCacheError
-                                        }), "__NEXT_ERROR_CODE", {
-                                            value: "E1244",
-                                            enumerable: false,
-                                            configurable: true
-                                        }));
+                                        throw wrapAsInvalidDynamicUsageError((0, _usecachemessages.createNestedCacheShortExpireError)(workStore.route, rdcResult.dynamicNestedCacheError));
                                     }
                                     // A short-lived entry is a dynamic hole, excluded from the
                                     // static shell, so we end the cache signal read here (the
@@ -1777,12 +1758,11 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                                 }
                                 break;
                             }
-                        case 'prerender-ppr':
                         case 'prerender-legacy':
                         case 'cache':
                         case 'private-cache':
                         case 'unstable-cache':
-                        case 'generate-static-params':
+                        case 'build-time-generator':
                             break;
                         default:
                             workUnitStore;
@@ -1805,45 +1785,53 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         case 'prerender-runtime':
                             {
                                 const prerenderStore = workUnitStore;
-                                // The post-shell stage that the entry must be delayed to.
-                                let postShellStage;
-                                if (prerenderStore.type === 'prerender') {
-                                    postShellStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticLinkData;
-                                } else {
-                                    postShellStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
-                                }
-                                const stagedRendering = prerenderStore.stagedRendering;
-                                if (!isPrefetchable || // If the render ends before the post-shell stage (e.g. a
-                                // render that only produces an App Shell), the entry can't
-                                // be delayed and is omitted entirely.
-                                stagedRendering !== null && stagedRendering.finalStage !== null && stagedRendering.finalStage < postShellStage) {
-                                    debug == null ? void 0 : debug('omitting entry', serializedCacheKey, 'from shell due to short stale value:', rdcResult.entry.stale);
+                                if (!isPrefetchable) {
+                                    debug == null ? void 0 : debug(logPrefix, 'omitting entry', serializedCacheKey, 'from shell due to short stale value:', rdcResult.entry.stale);
                                     if (cacheSignal) {
                                         cacheSignal.endRead();
                                     }
-                                    if (isPrefetchable) {
-                                        // The entry was omitted only because this render ends
-                                        // before the post-shell stage; a render that reaches its
-                                        // post-shell stage would serve it.
-                                        return (0, _dynamicrenderingutils.makeStageHangingPromise)(prerenderStore.renderSignal, workStore.route, 'dynamic "use cache"', prerenderStore);
-                                    }
                                     // An unprefetchable entry (stale < MIN_PREFETCHABLE_STALE) is
-                                    // excluded from runtime prerenders too.
+                                    // excluded from all prerenders.
                                     return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(prerenderStore.renderSignal, workStore.route, 'dynamic "use cache"');
-                                }
-                                if (stagedRendering !== null) {
-                                    debug == null ? void 0 : debug('delaying entry', serializedCacheKey, 'until after the shell stage due to short stale value:', rdcResult.entry.stale);
-                                    await stagedRendering.waitForStage(postShellStage);
+                                } else {
+                                    // This entry is prefetchable, but exluded from shells.
+                                    const stagedRendering = prerenderStore.stagedRendering;
+                                    if (stagedRendering === null) {
+                                    // Prospective prerender (no staging): do not delay, because if we didn't
+                                    // have this entry in the RDC already, we wouldn't delay it either.
+                                    } else {
+                                        // Final prerender (with staging).
+                                        // This entry cannot be part of the shell, so we delay it to the prefetch.
+                                        let prefetchStage;
+                                        if (prerenderStore.type === 'prerender') {
+                                            prefetchStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticUrlData.static;
+                                        } else {
+                                            prefetchStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeUrlData;
+                                        }
+                                        if (// If the prerender ends before the prefetch stage (because
+                                        // render that only produces an App Shell), this cache
+                                        // should be omitted entirely.
+                                        stagedRendering.finalStage !== null && stagedRendering.finalStage < prefetchStage) {
+                                            debug == null ? void 0 : debug(logPrefix, 'omitting entry', serializedCacheKey, 'from shell due to short stale value:', rdcResult.entry.stale);
+                                            if (cacheSignal) {
+                                                cacheSignal.endRead();
+                                            }
+                                            // The entry was omitted only because this prerender ends
+                                            // before the prefetch stage. Neither static nor runtime
+                                            // app shells include it, so it does not count as a runtime
+                                            // data access.
+                                            return (0, _dynamicrenderingutils.makePrefetchHangingPromise)(prerenderStore.renderSignal, workStore.route, 'dynamic "use cache"');
+                                        } else {
+                                            debug == null ? void 0 : debug(logPrefix, 'delaying entry', serializedCacheKey, 'until the prefetch stage due to short stale value:', rdcResult.entry.stale);
+                                            await stagedRendering.waitForStage(prefetchStage);
+                                        }
+                                    }
                                 }
                                 break;
                             }
                         case 'request':
                             {
-                                // A request store in `next start` never delays caches — shells
-                                // are produced by separate (runtime) prerenders, which apply
-                                // the exclusions above. In dev, the request render is also used
-                                // to recover shells, so we delay the entry here to match.
-                                if (process.env.NODE_ENV === 'development') {
+                                if (isValidationRender(workUnitStore)) {
                                     // End the cache signal read (once, in case an earlier block
                                     // already did) so the delayed value isn't counted as a pending
                                     // read at a staged rendering boundary.
@@ -1851,31 +1839,29 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                                         cacheSignal.endRead();
                                         cacheSignalReadEnded = true;
                                     }
-                                    // An unprefetchable entry is excluded from prerenders, so it
-                                    // resolves in the dynamic stage. Otherwise, a dynamic request
-                                    // generally recovers a static shell, so the entry can resolve
-                                    // in the static link data stage. If we need to recover a
-                                    // session shell instead, as indicated by `needsSessionShell`,
-                                    // the entry must resolve after the session data stage that
-                                    // the shell includes.
                                     let stage;
                                     if (!isPrefetchable) {
+                                        // An unprefetchable entry is excluded from prerenders, so it
+                                        // resolves in the dynamic stage.
                                         stage = _stagedrendering.RenderStage.Dynamic;
-                                    } else if (workUnitStore.needsSessionShell) {
-                                        stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
                                     } else {
-                                        stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticLinkData;
+                                        // If the entry would be be excluded from the shell, treat it as
+                                        // if it were static URL data.
+                                        // (Note that this is still correct without PPF or in static shell validation,
+                                        // where we don't use runtime shells and include static URL data)
+                                        (0, _dynamicrenderingutils.trackIncompatibleShellContent)(workUnitStore, '"use cache" excluded from app shells due to a short staletime');
+                                        stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticUrlData[workUnitStore.needsRuntimeShell ? 'runtime' : 'static'];
                                     }
+                                    debug == null ? void 0 : debug(logPrefix, 'delaying entry', serializedCacheKey, `until after the ${_stagedrendering.RenderStage[stage]} stage due to short stale value:`, rdcResult.entry.stale);
                                     await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, stage);
                                 }
                                 break;
                             }
-                        case 'prerender-ppr':
                         case 'prerender-legacy':
                         case 'cache':
                         case 'private-cache':
                         case 'unstable-cache':
-                        case 'generate-static-params':
+                        case 'build-time-generator':
                             break;
                         default:
                             workUnitStore;
@@ -1883,7 +1869,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 }
             }
             if (rdcResult !== undefined) {
-                debug == null ? void 0 : debug('Resume Data Cache entry found', serializedCacheKey);
+                debug == null ? void 0 : debug(logPrefix, 'Resume Data Cache entry found', serializedCacheKey);
                 if (rdcResult.readRootParamNames && rdcResult.readRootParamNames.size > 0) {
                     addKnownRootParamNames(id, rdcResult.readRootParamNames);
                 }
@@ -1914,13 +1900,13 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 }
             } else {
                 // Entry was discarded (e.g. due to recently revalidated tags)
-                debug == null ? void 0 : debug('Resume Data Cache entry discarded', serializedCacheKey);
+                debug == null ? void 0 : debug(logPrefix, 'Resume Data Cache entry discarded', serializedCacheKey);
                 if (cacheSignal) {
                     cacheSignal.endRead();
                 }
             }
         } else {
-            debug == null ? void 0 : debug('Resume Data Cache entry not found', serializedCacheKey);
+            debug == null ? void 0 : debug(logPrefix, 'Resume Data Cache entry not found', serializedCacheKey, `(${resumeDataCache.cache.size} entries)`);
             if (cacheSignal) {
                 cacheSignal.endRead();
             }
@@ -1938,9 +1924,8 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         // also do here, this covers the case where params are transformed
                         // with an async function before being passed into the "use cache"
                         // function, which escapes the instrumentation.
-                        // The cache key depends on fallback params, which are runtime
-                        // data.
-                        return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
+                        // The cache key depends on fallback params, which are URL data.
+                        return (0, _dynamicrenderingutils.makeURLDataHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
                     }
                 // fallthrough
                 case 'prerender-runtime':
@@ -1953,25 +1938,18 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         // already handled by the early return above. We return a hanging
                         // promise so this becomes a dynamic hole rather than generating a
                         // broken cache entry that gets aborted.
-                        console.warn(Object.defineProperty(new Error(`Unexpected cache miss after cache warming phase during prerendering. This is likely caused by non-deterministic arguments that differ between the cache warming phase and the final prerender phase (e.g. unstable array order). Ensure that arguments passed to cached functions are deterministic.`), "__NEXT_ERROR_CODE", {
-                            value: "E1163",
-                            enumerable: false,
-                            configurable: true
-                        }));
+                        console.warn(new _usecacheerrors.UnexpectedCacheMissError(workStore.route));
                         // This is an anomaly (non-deterministic cache key), so we can't
-                        // know whether a runtime prerender would resolve it. Treat it as
-                        // runtime data, conservatively: the cost is at most a redundant
-                        // runtime prefetch request.
-                        return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
+                        // know whether a runtime prerender would resolve it.
+                        return (0, _dynamicrenderingutils.makeUnknownRuntimeDataHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
                     }
                     break;
-                case 'prerender-ppr':
                 case 'prerender-legacy':
                 case 'request':
                 case 'cache':
                 case 'private-cache':
                 case 'unstable-cache':
-                case 'generate-static-params':
+                case 'build-time-generator':
                     break;
                 default:
                     workUnitStore;
@@ -1996,10 +1974,16 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         if (joinedInvocation) {
             const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
             cacheSignal == null ? void 0 : cacheSignal.beginRead();
-            debug == null ? void 0 : debug('joining intra-request invocation', serializedCacheKey);
+            debug == null ? void 0 : debug(logPrefix, 'joining intra-request invocation', serializedCacheKey);
             const sharedCacheResult = await joinedInvocation;
             if (sharedCacheResult.type === 'prerender-dynamic') {
-                debug == null ? void 0 : debug('joined invocation is prerender-dynamic', serializedCacheKey);
+                debug == null ? void 0 : debug(logPrefix, 'joined invocation is prerender-dynamic', serializedCacheKey);
+                if (resumeDataCache == null ? void 0 : resumeDataCache.mutable) {
+                    // A nested-cache leader has no RDC. This consumer must carry the
+                    // omission reason into the final prerender instead of leaving an
+                    // unexplained miss that loses the fallback's prefetch hint.
+                    resumeDataCache.cache.set(serializedCacheKey, sharedCacheResult.reason);
+                }
                 cacheSignal == null ? void 0 : cacheSignal.endRead();
                 return sharedCacheResult.hangingPromise;
             }
@@ -2010,9 +1994,9 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
             // against an unchanged entry timestamp only repeats the answer the leader
             // already got.
             const metadata = completedInvocation === undefined ? undefined : await sharedCacheResult.entry.pendingMetadata;
-            if (metadata !== undefined && shouldDiscardCacheEntry(metadata, workStore, workUnitStore, implicitTags, 0)) {
+            if (metadata !== undefined && shouldDiscardCacheEntry(metadata, workStore, workUnitStore, implicitTags, 0, logPrefix)) {
                 var _workStore_completedCacheInvocations1;
-                debug == null ? void 0 : debug('discarding completed invocation', serializedCacheKey);
+                debug == null ? void 0 : debug(logPrefix, 'discarding completed invocation', serializedCacheKey);
                 (_workStore_completedCacheInvocations1 = workStore.completedCacheInvocations) == null ? void 0 : _workStore_completedCacheInvocations1.delete(serializedCacheKey);
                 // This can take the signal's count to zero. The leader path below opens
                 // a read again synchronously, before it awaits anything, which is what
@@ -2020,8 +2004,8 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 // while a fill is still about to start.
                 cacheSignal == null ? void 0 : cacheSignal.endRead();
             } else {
-                debug == null ? void 0 : debug('joined invocation resolved with cached entry', serializedCacheKey);
-                stream = serveJoinedCacheEntry(sharedCacheResult.entry, serializedCacheKey, resumeDataCache, cacheContext, cacheSignal);
+                debug == null ? void 0 : debug(logPrefix, 'joined invocation resolved with cached entry', serializedCacheKey);
+                stream = serveJoinedCacheEntry(sharedCacheResult.entry, serializedCacheKey, resumeDataCache, cacheContext, cacheSignal, logPrefix);
             }
         }
     }
@@ -2029,7 +2013,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     // cross-request pending invocation, or become the leader for both.
     if (stream === undefined) {
         const resolvableSharedCacheResult = new ResolvableSharedCacheResult();
-        debug == null ? void 0 : debug('registering as intra-request invocation leader', serializedCacheKey);
+        debug == null ? void 0 : debug(logPrefix, 'registering as intra-request invocation leader', serializedCacheKey);
         const intraRequestPendingCacheInvocations = workStore.pendingCacheInvocations ??= new Map();
         // Retain the completed entry for the rest of the request where a later
         // invocation would otherwise repeat real work: private caches have no cache
@@ -2064,7 +2048,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 if (crossRequestPendingCacheInvocation) {
                     const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
                     cacheSignal == null ? void 0 : cacheSignal.beginRead();
-                    debug == null ? void 0 : debug('joining pending cross-request invocation', cacheHandlerKey);
+                    debug == null ? void 0 : debug(logPrefix, 'joining pending cross-request invocation', cacheHandlerKey);
                     const sharedCacheResult = await crossRequestPendingCacheInvocation;
                     if (sharedCacheResult.type === 'cached') {
                         // Verify root params before forking the stream. The shared
@@ -2082,21 +2066,21 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         if (updatedRootParamNames && rootParams) {
                             const newCacheHandlerKey = cacheHandlerKeyBase + computeRootParamsCacheKeySuffix(rootParams, updatedRootParamNames);
                             if (newCacheHandlerKey !== cacheHandlerKey) {
-                                debug == null ? void 0 : debug('cross-request root param mismatch, retrying', cacheHandlerKey, '→', newCacheHandlerKey);
+                                debug == null ? void 0 : debug(logPrefix, 'cross-request root param mismatch, retrying', cacheHandlerKey, '→', newCacheHandlerKey);
                                 cacheSignal == null ? void 0 : cacheSignal.endRead();
                                 cacheHandlerKey = newCacheHandlerKey;
                                 continue; // stream is not used → retry with new key
                             }
                         }
                         // Key matches — safe to fork.
-                        debug == null ? void 0 : debug('cross-request invocation matched, forking result', cacheHandlerKey);
+                        debug == null ? void 0 : debug(logPrefix, 'cross-request invocation matched, forking result', cacheHandlerKey);
                         cacheSignal == null ? void 0 : cacheSignal.endRead();
                         stream = sharedCacheResult.entry.fork();
                         maybePropagateCacheEntryMetadata(cacheContext, metadata);
                         // The cross-request leader belongs to a different request with its
                         // own RDC. Save to this request's RDC so its final prerender can
                         // resume from the entry.
-                        saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheResult.entry, resumeDataCache);
+                        saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheResult.entry, resumeDataCache, logPrefix);
                         // Resolve for intra-request joiners in this request. They get
                         // a fork from the same SharedCacheEntry.
                         resolvableSharedCacheResult.resolve(sharedCacheResult);
@@ -2107,15 +2091,15 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         if (updatedRootParamNames && rootParams) {
                             const newCacheHandlerKey = cacheHandlerKeyBase + computeRootParamsCacheKeySuffix(rootParams, updatedRootParamNames);
                             if (newCacheHandlerKey !== cacheHandlerKey) {
-                                debug == null ? void 0 : debug('cross-request root param mismatch, retrying', cacheHandlerKey, '→', newCacheHandlerKey);
+                                debug == null ? void 0 : debug(logPrefix, 'cross-request root param mismatch, retrying', cacheHandlerKey, '→', newCacheHandlerKey);
                                 cacheSignal == null ? void 0 : cacheSignal.endRead();
                                 cacheHandlerKey = newCacheHandlerKey;
                                 continue;
                             }
                         }
-                        debug == null ? void 0 : debug('cross-request invocation is prerender-dynamic', cacheHandlerKey);
+                        debug == null ? void 0 : debug(logPrefix, 'cross-request invocation is prerender-dynamic', cacheHandlerKey);
                         if (resumeDataCache == null ? void 0 : resumeDataCache.mutable) {
-                            resumeDataCache.dynamicCacheKeys.add(serializedCacheKey);
+                            resumeDataCache.cache.set(serializedCacheKey, sharedCacheResult.reason);
                         }
                         cacheSignal == null ? void 0 : cacheSignal.endRead();
                         resolvableSharedCacheResult.resolve(sharedCacheResult);
@@ -2124,7 +2108,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 }
                 // No pending cross-request invocation — become the leader.
                 if (!skipCrossRequestDedupe) {
-                    debug == null ? void 0 : debug('registering as cross-request invocation leader', cacheHandlerKey);
+                    debug == null ? void 0 : debug(logPrefix, 'registering as cross-request invocation leader', cacheHandlerKey);
                     resolvableSharedCacheResult.registerIn(crossRequestPendingCacheInvocations, cacheHandlerKey);
                 }
                 const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
@@ -2138,8 +2122,13 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                     await lazyRefreshTags;
                 }
                 let entry;
+                let observedRevalidation;
                 // We ignore existing cache entries when force revalidating.
                 if (cacheHandler && !shouldForceRevalidate(workStore, workUnitStore)) {
+                    // Record an existing revalidation before `get()` so a stale result
+                    // does not start another revalidation. The existing revalidation may
+                    // finish and remove its map entry before the lookup returns.
+                    observedRevalidation = backgroundRevalidations.get(cacheHandlerKey);
                     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
@@ -2154,6 +2143,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         if (paramNames.size > 0) {
                             addKnownRootParamNames(id, paramNames);
                             cacheHandlerKey = cacheHandlerKeyBase + computeRootParamsCacheKeySuffix(rootParams, paramNames);
+                            observedRevalidation = backgroundRevalidations.get(cacheHandlerKey);
                             entry = await cacheHandler.get(cacheHandlerKey, implicitTags);
                         }
                     }
@@ -2174,8 +2164,8 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                             }
                         }
                     }
-                    if (shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags, implicitTagsExpiration)) {
-                        debug == null ? void 0 : debug('discarding expired entry', cacheHandlerKey);
+                    if (shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags, implicitTagsExpiration, logPrefix)) {
+                        debug == null ? void 0 : debug(logPrefix, 'discarding expired entry', cacheHandlerKey);
                         entry = undefined;
                     }
                 }
@@ -2190,26 +2180,27 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                             // 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');
+                                debug == null ? void 0 : debug(logPrefix, '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);
+                                debug == null ? void 0 : debug(logPrefix, 'omitting entry', cacheHandlerKey, 'from static shell due to short expire value:', entry.expire);
                             }
                             if (cacheSignal) {
                                 cacheSignal.endRead();
                             }
-                            // The entry is only excluded from *static* prerenders — the
-                            // 'prerender-runtime' case below serves it — so a runtime
-                            // prefetch would include this content.
-                            const hangingPromise = (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
-                            debug == null ? void 0 : debug('leader resolved as prerender-dynamic', cacheHandlerKey);
+                            // The entry is only excluded from *static* prerenders. A runtime
+                            // shell or prefetch would include this content.
+                            // TODO(app-shells): Does this handle the MIN_SHELL_STALE case below correctly?
+                            const hangingPromise = (0, _dynamicrenderingutils.makeSessionDataHangingPromise)(workUnitStore.renderSignal, workStore.route, 'dynamic "use cache"', workUnitStore);
+                            debug == null ? void 0 : debug(logPrefix, 'leader resolved as prerender-dynamic', cacheHandlerKey);
                             resolvableSharedCacheResult.resolve({
                                 type: 'prerender-dynamic',
+                                reason: _cachestore.SESSION_DATA,
                                 hangingPromise
                             });
                             return hangingPromise;
                         case 'request':
                             {
-                                if (process.env.NODE_ENV === 'development') {
+                                if (isValidationRender(workUnitStore)) {
                                     // A short-lived entry is a dynamic hole, excluded from the
                                     // static shell, so we end the cache signal read here (the
                                     // prerender case does the same) to avoid this cache hit being
@@ -2220,34 +2211,33 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                                         cacheSignal.endRead();
                                         cacheSignalReadEnded = true;
                                     }
+                                    const stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.sessionData;
+                                    debug == null ? void 0 : debug(logPrefix, 'delaying entry', serializedCacheKey, `until after the ${_stagedrendering.RenderStage[stage]} stage due to short expire value:`, entry.expire);
                                     await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.sessionData);
                                 }
                                 break;
                             }
                         case 'prerender-runtime':
-                        case 'prerender-ppr':
                         case 'prerender-legacy':
                         case 'cache':
                         case 'private-cache':
                         case 'unstable-cache':
-                        case 'generate-static-params':
+                        case 'build-time-generator':
                             break;
                         default:
                             workUnitStore;
                     }
                 }
                 if (entry !== undefined && entry.stale < _constants.MIN_SHELL_STALE) {
+                    const isPrefetchable = entry.stale >= _constants.MIN_PREFETCHABLE_STALE;
                     switch(workUnitStore.type){
                         case 'request':
                             {
                                 // Same as the resume data cache read path: the entry's stale
                                 // time is short enough that it's excluded from shells, or, if
                                 // it's below `MIN_PREFETCHABLE_STALE`, from prerenders
-                                // entirely. A request store in `next start` never delays
-                                // caches — shells are produced by separate (runtime)
-                                // prerenders. In dev, the request render is also used to
-                                // recover shells, so we delay the entry here to match.
-                                if (process.env.NODE_ENV === 'development') {
+                                // entirely.
+                                if (isValidationRender(workUnitStore)) {
                                     // End the cache signal read (once, in case the expire block
                                     // above already did) so the delayed value isn't counted as a
                                     // pending read at a staged rendering boundary.
@@ -2255,33 +2245,31 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                                         cacheSignal.endRead();
                                         cacheSignalReadEnded = true;
                                     }
-                                    // An unprefetchable entry is excluded from prerenders, so it
-                                    // resolves in the dynamic stage. Otherwise, a dynamic request
-                                    // generally recovers a static shell, so the entry can resolve
-                                    // in the static link data stage. If we need to recover a
-                                    // session shell instead, as indicated by `needsSessionShell`,
-                                    // the entry must resolve after the session data stage that
-                                    // the shell includes.
                                     let stage;
-                                    if (entry.stale < _constants.MIN_PREFETCHABLE_STALE) {
+                                    if (!isPrefetchable) {
+                                        // An unprefetchable entry is excluded from prerenders, so it
+                                        // resolves in the dynamic stage.
                                         stage = _stagedrendering.RenderStage.Dynamic;
-                                    } else if (workUnitStore.needsSessionShell) {
-                                        stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
                                     } else {
-                                        stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticLinkData;
+                                        // If the entry would be be excluded from the shell, treat it as
+                                        // if it were static URL data.
+                                        // (Note that this is still correct without PPF or in static shell validation,
+                                        // where we don't use runtime shells and include static URL data)
+                                        (0, _dynamicrenderingutils.trackIncompatibleShellContent)(workUnitStore, '"use cache" excluded from app shells due to a short staletime');
+                                        stage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticUrlData[workUnitStore.needsRuntimeShell ? 'runtime' : 'static'];
                                     }
+                                    debug == null ? void 0 : debug(logPrefix, 'delaying entry', serializedCacheKey, `until after the ${_stagedrendering.RenderStage[stage]} stage due to short stale value:`, entry.stale);
                                     await (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, stage);
                                 }
                                 break;
                             }
                         case 'prerender':
                         case 'prerender-runtime':
-                        case 'prerender-ppr':
                         case 'prerender-legacy':
                         case 'cache':
                         case 'private-cache':
                         case 'unstable-cache':
-                        case 'generate-static-params':
+                        case 'build-time-generator':
                             break;
                         default:
                             workUnitStore;
@@ -2294,12 +2282,11 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                 // 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, _constants.MIN_PRERENDERABLE_EXPIRE) : entry.expire) * 1000 || workStore.isStaticGeneration && currentTime > entry.timestamp + entry.revalidate * 1000) {
+                currentTime > entry.timestamp + (process.env.__NEXT_DEV_SERVER ? Math.max(entry.expire, _constants.MIN_PRERENDERABLE_EXPIRE) : entry.expire) * 1000 || (0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore) && currentTime > entry.timestamp + entry.revalidate * 1000) {
                     // Miss. Generate a new result.
-                    // If the cache entry is stale and we're prerendering, we don't want
-                    // to use the stale entry since it would unnecessarily need to shorten
-                    // the lifetime of the prerender. We're not time constrained here so
-                    // we can re-generated it now.
+                    // If the cache entry is stale and its consumer will persist the
+                    // result in a server cache, don't persist the stale entry into a new
+                    // cache. We're not time constrained here, so regenerate it now.
                     // 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 might include request specific
@@ -2309,10 +2296,10 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                     // aka "Sync" Local Storage.
                     if (entry) {
                         if (currentTime > entry.timestamp + entry.expire * 1000) {
-                            debug == null ? void 0 : debug('entry is expired', cacheHandlerKey);
+                            debug == null ? void 0 : debug(logPrefix, 'entry is expired', cacheHandlerKey);
                         }
-                        if (workStore.isStaticGeneration && currentTime > entry.timestamp + entry.revalidate * 1000) {
-                            debug == null ? void 0 : debug('static generation, entry is stale', cacheHandlerKey);
+                        if ((0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore) && currentTime > entry.timestamp + entry.revalidate * 1000) {
+                            debug == null ? void 0 : debug(logPrefix, 'foreground revalidation, entry is stale', cacheHandlerKey);
                         }
                     }
                     if (cacheSignal && cacheSignalReadEnded) {
@@ -2327,9 +2314,9 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                     }
                     const result = await generateCacheEntry(workStore, cacheContext, clientReferenceManifest, encodedCacheKeyParts, fn, timeoutError, deadlockError);
                     if (result.type === 'prerender-dynamic') {
-                        debug == null ? void 0 : debug('leader resolved as prerender-dynamic (generation)', cacheHandlerKey);
+                        debug == null ? void 0 : debug(logPrefix, 'leader resolved as prerender-dynamic (generation)', cacheHandlerKey);
                         if (resumeDataCache == null ? void 0 : resumeDataCache.mutable) {
-                            resumeDataCache.dynamicCacheKeys.add(serializedCacheKey);
+                            resumeDataCache.cache.set(serializedCacheKey, result.reason);
                         }
                         resolvableSharedCacheResult.resolve(result);
                         return result.hangingPromise;
@@ -2338,12 +2325,14 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                     let pendingWrite;
                     // When draft mode is enabled, we must not save the cache entry.
                     if (!workStore.isDraftMode) {
-                        const savedCacheResult = saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult);
+                        const savedCacheResult = saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult, logPrefix);
                         if (cacheHandler) {
-                            pendingWrite = saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams);
+                            pendingWrite = saveToCacheHandler(cacheHandler, id, cacheHandlerKeyBase, savedCacheResult, rootParams);
+                            workStore.pendingRevalidateWrites ??= [];
+                            workStore.pendingRevalidateWrites.push(pendingWrite);
                         }
                     }
-                    debug == null ? void 0 : debug('leader resolved with generated entry', cacheHandlerKey);
+                    debug == null ? void 0 : debug(logPrefix, 'leader resolved with generated entry', cacheHandlerKey);
                     const pendingMetadata = pendingCacheResult.then((collected)=>({
                             tags: collected.entry.tags,
                             revalidate: collected.entry.revalidate,
@@ -2410,7 +2399,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         // already ended for a short-lived deferral.)
                         cacheSignal == null ? void 0 : cacheSignal.endRead();
                     }
-                    debug == null ? void 0 : debug('leader resolved with cache handler hit', cacheHandlerKey);
+                    debug == null ? void 0 : debug(logPrefix, 'leader resolved with cache handler hit', cacheHandlerKey);
                     const sharedCacheEntry = new SharedCacheEntry(stream, Promise.resolve(entryMetadata), undefined);
                     stream = sharedCacheEntry.fork();
                     resolvableSharedCacheResult.resolve({
@@ -2440,34 +2429,49 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                             case 'private-cache':
                             case 'prerender':
                             case 'prerender-runtime':
-                            case 'prerender-ppr':
                             case 'prerender-legacy':
                             case 'unstable-cache':
-                            case 'generate-static-params':
+                            case 'build-time-generator':
                                 break;
                             default:
                                 workUnitStore;
                         }
                     }
-                    if (shouldTriggerBackgroundRevalidation) {
+                    if (shouldTriggerBackgroundRevalidation && // The revalidation observed before the lookup may have finished.
+                    observedRevalidation === undefined && // A new revalidation may have started since the lookup began.
+                    !backgroundRevalidations.has(cacheHandlerKey)) {
                         const revalidateCacheHandlerKey = cacheHandlerKey;
-                        const revalidatePromise = 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.
-                        {
-                            ...cacheContext,
-                            skipPropagation: true
-                        }, clientReferenceManifest, encodedCacheKeyParts, fn, timeoutError, deadlockError).then(async (result)=>{
+                        // Defer the call so synchronous setup errors reject the background
+                        // task instead of failing the stale response. This also lets us
+                        // register the task before generation starts.
+                        const revalidatePromise = Promise.resolve().then(()=>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.
+                            {
+                                ...cacheContext,
+                                skipPropagation: true
+                            }, clientReferenceManifest, encodedCacheKeyParts, fn, timeoutError, deadlockError)).then(async (result)=>{
                             if (result.type === 'cached') {
                                 const { stream: ignoredStream, pendingCacheResult } = result;
-                                const savedCacheResult = saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult);
-                                if (cacheHandler) {
-                                    saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams);
+                                const savedCacheResult = saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult, logPrefix);
+                                const pendingWrite = cacheHandler ? saveToCacheHandler(cacheHandler, id, cacheHandlerKeyBase, savedCacheResult, rootParams) : savedCacheResult.then(()=>{});
+                                for (const completion of (await Promise.allSettled([
+                                    ignoredStream.cancel(),
+                                    pendingWrite
+                                ]))){
+                                    if (completion.status === 'rejected') {
+                                        throw completion.reason;
+                                    }
                                 }
-                                await ignoredStream.cancel();
                             }
-                        }).catch((error)=>{
-                            debug == null ? void 0 : debug('background cache revalidation failed for', revalidateCacheHandlerKey, error);
+                        }).finally(()=>{
+                            if (backgroundRevalidations.get(revalidateCacheHandlerKey) === revalidatePromise) {
+                                backgroundRevalidations.delete(revalidateCacheHandlerKey);
+                            }
+                        });
+                        backgroundRevalidations.set(revalidateCacheHandlerKey, revalidatePromise);
+                        revalidatePromise.catch((error)=>{
+                            debug == null ? void 0 : debug(logPrefix, 'background cache revalidation failed for', revalidateCacheHandlerKey, error);
                         });
                         workStore.pendingRevalidateWrites ??= [];
                         workStore.pendingRevalidateWrites.push(revalidatePromise);
@@ -2492,7 +2496,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         // to be added to the consumer. Instead, we'll wait for any ClientReference to be emitted
         // which themselves will handle the preloading.
         moduleLoading: null,
-        moduleMap: isEdgeRuntime ? clientReferenceManifest.edgeRscModuleMapping : clientReferenceManifest.rscModuleMapping,
+        moduleMap: (0, _manifestssingleton.getRscModuleMappingForUseCache)(),
         serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
     };
     return (0, _client.createFromReadableStream)(stream, {
@@ -2503,6 +2507,82 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         environmentName: 'Cache'
     });
 }
+/**
+ * This returns cache key parts that cover everything that can affect the result of the cached
+ * function (apart from the arguments). The implementation part is used by both the RDC and cache
+ * handler, while the runtime env var state hash is only used by the cache handler. The RDC is
+ * per-page and must reuse entries across rendering phases even if an env var changes between them.
+ *
+ * The parts cover:
+ * - codeHash: the code itself that generates the return value
+ *    - Notably, this excludes the following modules.  Those are included via the Next.js version anyway:
+ *    - react, react-dom, private-next-rsc-server-reference, private-next-rsc-cache-wrapper
+ * - runtimeEnvVarsRead: the keys and values of runtime environment variables that the code reads
+ * - runtimeEnvVarExistence: the unset/falsy/truthy state of runtime environment variables used in boolean contexts
+ * - the version of Next.js (to account for RSC wire format changes, or use-cache-wrapper.ts changes)
+ *
+ * In case that granular information isn't available, fall back to
+ * buildId/deploymentId/hmrRefreshHash, which is a correct hash but over-invalidates way too often.
+ */ async function computeCacheKeyImplementationPart(workStore, workUnitStore, id) {
+    var _getServerActionsManifest_node_id_workers_normalizeWorkerPageName, _getServerActionsManifest_node_id_workers;
+    let durability = workStore.durableUseCacheEntries ? (_getServerActionsManifest_node_id_workers = (0, _manifestssingleton.getServerActionsManifest)().node[id].workers) == null ? void 0 : (_getServerActionsManifest_node_id_workers_normalizeWorkerPageName = _getServerActionsManifest_node_id_workers[(0, _manifestssingleton.normalizeWorkerPageName)(workStore.page)]) == null ? void 0 : _getServerActionsManifest_node_id_workers_normalizeWorkerPageName.durability : undefined;
+    if (durability) {
+        // use cache is only supported in Node.js runtime. So we can use the Node.js crypto module here.
+        const crypto = require('crypto');
+        let runtimeEnvVarStateHash = crypto// Hash the env var values, to not leak secrets into the cache key.
+        .createHash('sha256').update([
+            ...durability.runtimeEnvVarsRead.map((k)=>{
+                // Make sure not to stringify `undefined` and `"undefined"` to the same value.
+                return process.env[k] != null ? `${k}==${process.env[k]}` : k;
+            }),
+            ...durability.runtimeEnvVarsExistence.map((k)=>{
+                const value = process.env[k];
+                const state = value == null ? 'unset' : value ? 'truthy' : 'falsy';
+                return `${k}~=${state}`;
+            })
+        ].join('\0') ?? '').digest('hex');
+        // The env var state is added to the cache handler key separately so it
+        // doesn't affect RDC lookups between rendering phases.
+        return {
+            implementationPart: [
+                durability.codeHash,
+                nextVersion
+            ],
+            runtimeEnvVarStateHash
+        };
+    } else {
+        // Because the Action ID is not yet unique per implementation of that Action we can't
+        // safely reuse the results across builds yet. In the meantime we add the buildId to the
+        // arguments as a seed to ensure they're not reused. Remove this once Action IDs hash
+        // the implementation.
+        const buildId = workStore.deploymentId || workStore.buildId;
+        // In dev mode, when the HMR refresh hash is set, we include it in the
+        // cache key. This ensures that cache entries are not reused when server
+        // 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 = (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workUnitStore);
+        // otherwise fall back to buildId and/or the HMR hash.
+        return {
+            implementationPart: hmrRefreshHash ? [
+                buildId,
+                hmrRefreshHash
+            ] : [
+                buildId
+            ],
+            runtimeEnvVarStateHash: undefined
+        };
+    }
+}
+/**
+ * A request store in `next start` never delays caches.
+ * We only apply delays when the render will be used for
+ * validation purposes.
+ */ function isValidationRender(requestStore) {
+    return !!(process.env.__NEXT_CACHE_COMPONENTS && // In dev we're always running validation.
+    (process.env.__NEXT_DEV_SERVER || // Build-time instant validation also uses a 'request' store.
+    requestStore.validationSamples));
+}
 /**
  * Returns `true` if the `'use cache'` function is the page component itself,
  * or `generateMetadata`/`generateViewport` in a page file.
@@ -2532,10 +2612,9 @@ function shouldForceRevalidate(workStore, workUnitStore) {
             case 'prerender':
             case 'prerender-client':
             case 'validation-client':
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;
@@ -2543,11 +2622,11 @@ function shouldForceRevalidate(workStore, workUnitStore) {
     }
     return false;
 }
-function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags, implicitTagsExpiration) {
+function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags, implicitTagsExpiration, logPrefix) {
     // If the cache entry was created before any of the implicit tags were
     // revalidated last, we need to discard it.
     if (entry.timestamp <= implicitTagsExpiration) {
-        debug == null ? void 0 : debug('entry was created at', entry.timestamp, 'before implicit tags were revalidated at', implicitTagsExpiration);
+        debug == null ? void 0 : debug(logPrefix, 'entry was created at', entry.timestamp, 'before implicit tags were revalidated at', implicitTagsExpiration);
         return true;
     }
     // During prerendering, we ignore recently revalidated tags. In dev mode, we
@@ -2561,25 +2640,24 @@ function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags,
         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':
+        case 'build-time-generator':
             break;
         default:
             workUnitStore;
     }
     // If the cache entry contains revalidated tags that the cache handler might
     // not know about yet, we need to discard it.
-    if (entry.tags.some((tag)=>isRevalidatedAfter(tag, entry.timestamp, workStore))) {
+    if (entry.tags.some((tag)=>isRevalidatedAfter(tag, entry.timestamp, workStore, logPrefix))) {
         return true;
     }
     // Finally, if any of the implicit tags have been revalidated recently, we
     // also need to discard the cache entry.
-    if (implicitTags.some((tag)=>isRevalidatedAfter(tag, entry.timestamp, workStore))) {
+    if (implicitTags.some((tag)=>isRevalidatedAfter(tag, entry.timestamp, workStore, logPrefix))) {
         return true;
     }
     return false;
@@ -2588,13 +2666,13 @@ function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags,
  * Whether `tag` was revalidated after an entry created at `entryTimestamp`,
  * which makes that entry stale. An entry produced after the revalidation
  * already reflects it and is still usable.
- */ function isRevalidatedAfter(tag, entryTimestamp, workStore) {
+ */ function isRevalidatedAfter(tag, entryTimestamp, workStore, logPrefix) {
     const { previouslyRevalidatedTags, pendingRevalidatedTags, requestStartTime } = workStore;
     // Was the tag previously revalidated (e.g. by a redirecting server action)?
     // That happened in an earlier request and carries no timestamp of its own, so
     // it counts as having happened when this request started.
     if (entryTimestamp <= requestStartTime && previouslyRevalidatedTags.includes(tag)) {
-        debug == null ? void 0 : debug('tag', tag, 'was previously revalidated');
+        debug == null ? void 0 : debug(logPrefix, 'tag', tag, 'was previously revalidated');
         return true;
     }
     // It could also have been revalidated by the currently running server action.
@@ -2602,7 +2680,7 @@ function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags,
     // remote cache handler yet, so we read it from the pending tags in the work
     // store.
     if (pendingRevalidatedTags == null ? void 0 : pendingRevalidatedTags.some((item)=>item.tag === tag && item.revalidatedAt > entryTimestamp)) {
-        debug == null ? void 0 : debug('tag', tag, 'was just revalidated');
+        debug == null ? void 0 : debug(logPrefix, 'tag', tag, 'was just revalidated');
         return true;
     }
     return false;