@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/request/search-params.js

@@ -36,13 +36,13 @@ const _workasyncstorageexternal = require("../app-render/work-async-storage.exte
 const _varyparams = require("../app-render/vary-params");
 const _reflect = require("../web/spec-extension/adapters/reflect");
 const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
 const _reflectutils = require("../../shared/lib/utils/reflect-utils");
 const _utils = require("./utils");
-const _stagedrendering = require("../app-render/staged-rendering");
 function createSearchParamsFromClient(underlyingSearchParams) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
@@ -60,10 +60,6 @@ function createSearchParamsFromClient(underlyingSearchParams) {
             case 'prerender-ppr':
             case 'prerender-legacy':
                 return createStaticPrerenderSearchParams(workStore, workUnitStore);
-            case 'validation-client':
-                {
-                    return createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore);
-                }
             case 'prerender-runtime':
                 throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
                     value: "E769",
@@ -84,21 +80,26 @@ function createSearchParamsFromClient(underlyingSearchParams) {
                     enumerable: false,
                     configurable: true
                 });
+            case 'validation-client':
+                {
+                    if (workUnitStore.validationSamples) {
+                        return createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore);
+                    }
+                    return makeUntrackedSearchParams(underlyingSearchParams);
+                }
             case 'request':
-                // Client searchParams are not runtime prefetchable
-                const isRuntimePrefetchable = false;
-                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore, isRuntimePrefetchable);
+                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore);
             default:
                 workUnitStore;
         }
     }
     (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
 }
-function createServerSearchParamsForMetadata(underlyingSearchParams, isRuntimePrefetchable) {
+function createServerSearchParamsForMetadata(underlyingSearchParams) {
     const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
-    return createServerSearchParamsForServerPage(underlyingSearchParams, metadataVaryParamsAccumulator, isRuntimePrefetchable);
+    return createServerSearchParamsForServerPage(underlyingSearchParams, metadataVaryParamsAccumulator);
 }
-function createServerSearchParamsForServerPage(underlyingSearchParams, varyParamsAccumulator, isRuntimePrefetchable) {
+function createServerSearchParamsForServerPage(underlyingSearchParams, varyParamsAccumulator) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
         throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
@@ -136,9 +137,9 @@ function createServerSearchParamsForServerPage(underlyingSearchParams, varyParam
                     configurable: true
                 });
             case 'prerender-runtime':
-                return createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
+                return createRuntimePrerenderSearchParams(underlyingSearchParams, workStore, workUnitStore, varyParamsAccumulator);
             case 'request':
-                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore, isRuntimePrefetchable);
+                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore);
             default:
                 workUnitStore;
         }
@@ -166,7 +167,7 @@ function createPrerenderSearchParamsForClientPage() {
             case 'prerender-client':
                 // We're prerendering in a mode that aborts (cacheComponents) and should stall
                 // the promise to ensure the RSC side is considered dynamic
-                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`');
+                return (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`', workUnitStore);
             case 'validation-client':
                 throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a client validation.'), "__NEXT_ERROR_CODE", {
                     value: "E1061",
@@ -223,39 +224,77 @@ function createStaticPrerenderSearchParams(workStore, prerenderStore) {
             return prerenderStore;
     }
 }
-function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
-    const underlyingSearchParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingSearchParams)(varyParamsAccumulator, underlyingSearchParams) : underlyingSearchParams;
-    const result = makeUntrackedSearchParams(underlyingSearchParamsWithVarying);
+function createRuntimePrerenderSearchParams(underlyingSearchParams, workStore, workUnitStore, varyParamsAccumulator) {
+    const userspaceSearchParams = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingSearchParams)(varyParamsAccumulator, underlyingSearchParams) : underlyingSearchParams;
+    const result = makeUntrackedSearchParams(userspaceSearchParams);
     const { stagedRendering } = workUnitStore;
     if (!stagedRendering) {
+        // If there's no staging, we're in a prospective runtime prerender.
+        if (workUnitStore.isSessionShell) {
+            // If we're warming up for a session shell, search params should hang,
+            // because they'll be a hanging input in the final prerender.
+            return makeHangingSearchParams(workStore, workUnitStore);
+        }
         return result;
     }
-    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
-    return stagedRendering.waitForStage(stage).then(()=>result);
+    // Unlike `createRuntimePrerenderParams`, which uses `delayUntilStage`, we
+    // resolve with `waitForStage(...).then(...)` here. Switching search params to
+    // `delayUntilStage` drops the source code frame from the instant-validation
+    // "URL data outside of Suspense" error when a page awaits `searchParams` at
+    // the top level (params, read via a nested component, is unaffected). See the
+    // `missing suspense around search params` cases in the instant-validation
+    // `suspense-boundaries` tests. The underlying reason in React's async I/O
+    // await tracking isn't understood yet. TODO: align search params with params
+    // on `delayUntilStage` once resolved.
+    const searchParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
+    return stagedRendering.waitForStage(searchParamsStage).then(()=>result);
 }
-function createRenderSearchParams(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
+function createRenderSearchParams(underlyingSearchParams, workStore, requestStore) {
+    const { asyncApiPromises, validationSamples } = requestStore;
+    if (asyncApiPromises) {
+        let userspaceSearchParams = underlyingSearchParams;
+        if (validationSamples) {
+            userspaceSearchParams = createSearchParamsProxyForInstantValidation(workStore, validationSamples, underlyingSearchParams);
+        }
+        return createStagedRenderSearchParams(workStore, asyncApiPromises, underlyingSearchParams, userspaceSearchParams);
+    }
+    // No staged rendering = no cacheComponents, or cacheComponents prod without cachedNavigations
     if (workStore.forceStatic) {
         // When using forceStatic we override all other logic and always just return an empty
         // dictionary object.
         return Promise.resolve({});
+    }
+    if (process.env.NODE_ENV === 'development') {
+        // Semantically we only need the dev tracking when running in `next dev`
+        // but since you would never use next dev with production NODE_ENV we use this
+        // as a proxy so we can statically exclude this code from production builds.
+        return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore);
     } else {
-        if (process.env.NODE_ENV === 'development') {
-            // Semantically we only need the dev tracking when running in `next dev`
-            // but since you would never use next dev with production NODE_ENV we use this
-            // as a proxy so we can statically exclude this code from production builds.
-            return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
-        } else if (requestStore.asyncApiPromises) {
-            if (requestStore.validationSamples) {
-                const { createExhaustiveSearchParamsProxy } = require('../app-render/instant-validation/instant-samples');
-                const declaredKeys = new Set(Object.keys(requestStore.validationSamples.searchParams ?? {}));
-                underlyingSearchParams = createExhaustiveSearchParamsProxy(underlyingSearchParams, declaredKeys, workStore.route);
-            }
-            return (isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedSearchParamsParent : requestStore.asyncApiPromises.sharedSearchParamsParent).then(()=>underlyingSearchParams);
-        } else {
-            return makeUntrackedSearchParams(underlyingSearchParams);
-        }
+        return makeUntrackedSearchParams(underlyingSearchParams);
+    }
+}
+function createStagedRenderSearchParams(workStore, asyncApiPromises, underlyingSearchParams, userspaceSearchParams) {
+    const trigger = asyncApiPromises.sharedSearchParamsParent;
+    if (process.env.NODE_ENV === 'development') {
+        // We wrap each instance of searchParams in a `new Promise()`.
+        // This is important when all awaits are in third party which would otherwise
+        // track all the way to the internal params.
+        const promise = new Promise((resolve, reject)=>{
+            trigger.then(()=>resolve(userspaceSearchParams), reject);
+        });
+        // @ts-expect-error
+        promise.displayName = 'searchParams';
+        promise.catch(ignoreReject);
+        return instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore);
+    } else {
+        return (0, _dynamicrenderingutils.makePromiseFromTrigger)(trigger, userspaceSearchParams);
     }
 }
+function createSearchParamsProxyForInstantValidation(workStore, validationSamples, underlyingSearchParams) {
+    const { createExhaustiveSearchParamsProxy } = require('../app-render/instant-validation/instant-samples');
+    const declaredKeys = new Set(Object.keys(validationSamples.searchParams ?? {}));
+    return createExhaustiveSearchParamsProxy(underlyingSearchParams, declaredKeys, workStore.route);
+}
 const CachedSearchParams = new WeakMap();
 const CachedSearchParamsForUseCache = new WeakMap();
 function makeHangingSearchParams(workStore, prerenderStore) {
@@ -263,10 +302,20 @@ function makeHangingSearchParams(workStore, prerenderStore) {
     if (cachedSearchParams) {
         return cachedSearchParams;
     }
-    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`');
-    const proxiedPromise = new Proxy(promise, {
+    const promise = (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`', // This promise is created for every page whether or not it reads search
+    // params, so recording the access at creation would mark every render.
+    // The access is tracked in the proxy traps below instead.
+    null);
+    const trackSearchParamsAccessed = ()=>{
+        // Record against the store that's active at access time: the promise is
+        // created while the RSC payload is constructed, but typically accessed
+        // later, during the render, under a different store.
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        (0, _dynamicrenderingutils.trackRuntimeDataAccessed)(workUnitStore ?? prerenderStore);
+    };
+    const proxyHandler = {
         get (target, prop, receiver) {
-            if (Object.hasOwn(promise, prop)) {
+            if (Object.hasOwn(target, prop)) {
                 // The promise has this property directly. we must return it.
                 // We know it isn't a dynamic access because it can only be something
                 // that was previously written to the promise and thus not an underlying searchParam value
@@ -274,14 +323,39 @@ function makeHangingSearchParams(workStore, prerenderStore) {
             }
             switch(prop){
                 case 'then':
+                case 'catch':
+                case 'finally':
                     {
-                        const expression = '`await searchParams`, `searchParams.then`, or similar';
-                        (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
-                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                        const originalMethod = _reflect.ReflectAdapter.get(target, prop, receiver);
+                        return ({
+                            [prop]: (...args)=>{
+                                const expression = '`await searchParams`, `searchParams.then`, or similar';
+                                trackSearchParamsAccessed();
+                                (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
+                                // Mirror `makeHangingParams`: when this never-resolving promise
+                                // is awaited while a `use cache` key is being encoded
+                                // (dynamicAccessAsyncStorage is set), abort so the surrounding
+                                // cache bails out to a dynamic hole instead of hanging on it.
+                                // Without this, a private cache that reads `searchParams` would
+                                // stall the App Shell cache-warming render. Re-wrapping the
+                                // result propagates the same behavior to promises derived via
+                                // `.then`/`.catch`/`.finally` that are then passed into a cache.
+                                const dynamicAccessStore = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
+                                if (dynamicAccessStore) {
+                                    dynamicAccessStore.abortController.abort(Object.defineProperty(new Error('Accessed `searchParams` during prerendering.'), "__NEXT_ERROR_CODE", {
+                                        value: "E1449",
+                                        enumerable: false,
+                                        configurable: true
+                                    }));
+                                }
+                                return new Proxy(originalMethod.apply(target, args), proxyHandler);
+                            }
+                        })[prop];
                     }
                 case 'status':
                     {
                         const expression = '`use(searchParams)`, `searchParams.status`, or similar';
+                        trackSearchParamsAccessed();
                         (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
                         return _reflect.ReflectAdapter.get(target, prop, receiver);
                     }
@@ -291,7 +365,8 @@ function makeHangingSearchParams(workStore, prerenderStore) {
                     }
             }
         }
-    });
+    };
+    const proxiedPromise = new Proxy(promise, proxyHandler);
     CachedSearchParams.set(prerenderStore, proxiedPromise);
     return proxiedPromise;
 }
@@ -372,40 +447,21 @@ function makeUntrackedSearchParams(underlyingSearchParams) {
     CachedSearchParams.set(underlyingSearchParams, promise);
     return promise;
 }
-function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
-    if (requestStore.asyncApiPromises) {
-        // Do not cache the resulting promise. If we do, we'll only show the first "awaited at"
-        // across all segments that receive searchParams.
-        return makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
-    } else {
-        const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
-        if (cachedSearchParams) {
-            return cachedSearchParams;
-        }
-        const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
-        CachedSearchParams.set(requestStore, promise);
-        return promise;
+function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore) {
+    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
     }
+    const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
+    CachedSearchParams.set(requestStore, promise);
+    return promise;
 }
-function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
+function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore) {
     const promiseInitialized = {
         current: false
     };
     const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized);
-    let promise;
-    if (requestStore.asyncApiPromises) {
-        // We wrap each instance of searchParams in a `new Promise()`.
-        // This is important when all awaits are in third party which would otherwise
-        // track all the way to the internal params.
-        const sharedSearchParamsParent = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedSearchParamsParent : requestStore.asyncApiPromises.sharedSearchParamsParent;
-        promise = new Promise((resolve, reject)=>{
-            sharedSearchParamsParent.then(()=>resolve(proxiedUnderlying), reject);
-        });
-        // @ts-expect-error
-        promise.displayName = 'searchParams';
-    } else {
-        promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _stagedrendering.RenderStage.Runtime);
-    }
+    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData);
     promise.then(()=>{
         promiseInitialized.current = true;
     }, // If we're in staged rendering, this promise will reject if the render

package/dist/node_modules/next/dist/server/request/utils.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    isRequestAPICallableInsideAfter: null,
+    isRequestApiAllowedInCurrentPhase: null,
     throwForSearchParamsAccessInUseCache: null,
     throwWithStaticGenerationBailoutErrorWithDynamicError: null
 });
@@ -14,8 +14,8 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    isRequestAPICallableInsideAfter: function() {
-        return isRequestAPICallableInsideAfter;
+    isRequestApiAllowedInCurrentPhase: function() {
+        return isRequestApiAllowedInCurrentPhase;
     },
     throwForSearchParamsAccessInUseCache: function() {
         return throwForSearchParamsAccessInUseCache;
@@ -25,6 +25,7 @@ _export(exports, {
     }
 });
 const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
+const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
 const _aftertaskasyncstorageexternal = require("../app-render/after-task-async-storage.external");
 function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
     throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
@@ -43,9 +44,41 @@ function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
     workStore.invalidDynamicUsageError ??= error;
     throw error;
 }
-function isRequestAPICallableInsideAfter() {
-    const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
-    return (afterTaskStore == null ? void 0 : afterTaskStore.rootTaskSpawnPhase) === 'action';
+function isRequestApiAllowedInCurrentPhase(workUnitStore) {
+    switch(workUnitStore.phase){
+        case 'action':
+        case 'render':
+            {
+                // The request is still in progress. The API may be disallowed for other reasons,
+                // but not because of phase.
+                return true;
+            }
+        case 'after':
+            {
+                // The request has finished.
+                // If we're in a Route Handler or a Server Action,
+                // request APIs can be called everywhere, even in after().
+                const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
+                if (actionStore && (actionStore.isAppRoute || actionStore.isAction)) {
+                    return true;
+                }
+                const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
+                if (afterTaskStore) {
+                    // We're in an `after` callback. Request APIs are callable if
+                    // the `after()` call happened in an action phase:
+                    // - in a Route Handler
+                    // - in a Server Action's body (but not the render after)
+                    //
+                    // TODO(after): Is it even possible to have `phase === 'action'` but no `actionStore`?
+                    // We should revisit this setup and simplify this.
+                    return afterTaskStore.rootTaskSpawnPhase === 'action';
+                }
+                // Otherwise, we must be in a page, in the `after` phase.
+                // We don't allow calling request APIs here because we'd miss
+                // them during prerendering and wouldn't know that the page is dynamic.
+                return false;
+            }
+    }
 }
 
 //# sourceMappingURL=utils.js.map

package/dist/node_modules/next/dist/server/response-cache/index.js

@@ -175,6 +175,13 @@ class ResponseCache {
             if (waitUntil) waitUntil(promise);
             return promise;
         });
+        if (this.minimal_mode && (response == null ? void 0 : response.cacheControl)) {
+            const cacheKey = createCacheKey(key, invocationID);
+            this.cache.set(cacheKey, {
+                entry: response,
+                expiresAt: Date.now() + this.ttl
+            });
+        }
         return (0, _utils.toResponseCacheEntry)(response);
     }
     /**
@@ -195,7 +202,12 @@ class ResponseCache {
                 isRoutePPREnabled: context.isRoutePPREnabled,
                 isFallback: context.isFallback
             }) : null;
-            if (previousIncrementalCacheEntry && !context.isOnDemandRevalidate) {
+            // `isStale === -1` signals that the entry is past its `expire` (either
+            // via an expired tag or, with `cacheLife({ expire })`, past the route's
+            // expire time in the prerender manifest). In that case we must NOT
+            // early-resolve with the stale value — instead we fall through to a
+            // blocking revalidation so the response returned to the user is fresh.
+            if (previousIncrementalCacheEntry && !context.isOnDemandRevalidate && previousIncrementalCacheEntry.isStale !== -1) {
                 resolve(previousIncrementalCacheEntry);
                 resolved = true;
                 if (!previousIncrementalCacheEntry.isStale || context.isPrefetch) {
@@ -203,8 +215,18 @@ class ResponseCache {
                     return previousIncrementalCacheEntry;
                 }
             }
-            // Revalidate the cache entry
-            const incrementalResponseCacheEntry = await this.revalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, previousIncrementalCacheEntry !== null && !context.isOnDemandRevalidate, undefined, context.invocationID);
+            // Revalidate the cache entry.
+            //
+            // A prefetch request that missed must run its own response generator
+            // rather than joining an in-flight revalidation through the batcher. A
+            // background revalidation may be regenerating the concrete (non-fallback)
+            // entry for this route — e.g. an ISR fallback-shell upgrade scheduled by
+            // an earlier prefetch sub-request. Joining it would serve that concrete
+            // result to the prefetch instead of the fallback shell, and which segment
+            // wins would depend purely on request timing. Running the generator
+            // directly lets every prefetch segment take the same fallback-shell path,
+            // independent of any concurrent background upgrade.
+            const incrementalResponseCacheEntry = context.isPrefetch && previousIncrementalCacheEntry === null ? await this.handleRevalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, resolved) : await this.revalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, resolved);
             // Handle null response
             if (!incrementalResponseCacheEntry) {
                 // Remove the cache item if it was set so we don't use it again.
@@ -242,15 +264,15 @@ class ResponseCache {
    * @param waitUntil - Optional function to register background work.
    * @param invocationID - The invocation ID for cache key scoping.
    * @returns The revalidated cache entry.
-   */ async revalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved, waitUntil, invocationID) {
+   */ async revalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved, waitUntil) {
         return this.revalidateBatcher.batch(key, ()=>{
-            const promise = this.handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved, invocationID);
+            const promise = this.handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved);
             // We need to ensure background revalidates are passed to waitUntil.
             if (waitUntil) waitUntil(promise);
             return promise;
         });
     }
-    async handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved, invocationID) {
+    async handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved) {
         try {
             // Generate the response cache entry using the response generator.
             const responseCacheEntry = await responseGenerator({
@@ -267,24 +289,14 @@ class ResponseCache {
                 isMiss: !previousIncrementalCacheEntry
             });
             // We want to persist the result only if it has a cache control value
-            // defined.
-            if (incrementalResponseCacheEntry.cacheControl) {
-                if (this.minimal_mode) {
-                    // Set TTL expiration for cache hit validation. Entries are validated
-                    // by invocationID when available, with TTL as a fallback for providers
-                    // that don't send x-invocation-id. Memory is managed by LRU eviction.
-                    const cacheKey = createCacheKey(key, invocationID);
-                    this.cache.set(cacheKey, {
-                        entry: incrementalResponseCacheEntry,
-                        expiresAt: Date.now() + this.ttl
-                    });
-                } else {
-                    await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
-                        cacheControl: incrementalResponseCacheEntry.cacheControl,
-                        isRoutePPREnabled,
-                        isFallback
-                    });
-                }
+            // defined. The minimal mode LRU write is handled in get() so that
+            // every caller — including batched invocations — populates the cache.
+            if (incrementalResponseCacheEntry.cacheControl && !this.minimal_mode) {
+                await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
+                    cacheControl: incrementalResponseCacheEntry.cacheControl,
+                    isRoutePPREnabled,
+                    isFallback
+                });
             }
             return incrementalResponseCacheEntry;
         } catch (err) {

package/dist/node_modules/next/dist/server/resume-data-cache/cache-store.js

@@ -44,7 +44,12 @@ function parseUseCacheCacheStore(entries) {
             },
             hasExplicitRevalidate,
             hasExplicitExpire,
-            readRootParamNames: readRootParamNames ? new Set(readRootParamNames) : undefined
+            readRootParamNames: readRootParamNames ? new Set(readRootParamNames) : undefined,
+            // Serialized RDC entries are non-dynamic by construction (the
+            // serializer drops dynamic entries), so this is never produced from the
+            // wire — the throw path that consumes it is only reachable for dynamic
+            // entries, which only exist in the in-memory RDC.
+            dynamicNestedCacheError: undefined
         }));
     }
     return store;
@@ -52,7 +57,7 @@ function parseUseCacheCacheStore(entries) {
 async function serializeUseCacheCacheStore(entries, isCacheComponentsEnabled) {
     return Promise.all(Array.from(entries).map(([key, value])=>{
         return value.then(async ({ entry, hasExplicitRevalidate, hasExplicitExpire, readRootParamNames })=>{
-            if (isCacheComponentsEnabled && (entry.revalidate === 0 || entry.expire < _constants.DYNAMIC_EXPIRE)) {
+            if (isCacheComponentsEnabled && (entry.revalidate === 0 || entry.expire < _constants.MIN_PRERENDERABLE_EXPIRE)) {
                 // The entry was omitted from the prerender result, and subsequently
                 // does not need to be included in the serialized RDC.
                 return null;

package/dist/node_modules/next/dist/server/resume-data-cache/resume-data-cache.js

@@ -53,17 +53,23 @@ async function stringifyResumeDataCache(resumeDataCache, isCacheComponentsEnable
 function createPrerenderResumeDataCache(source) {
     if (source) {
         return {
+            mutable: true,
             cache: new Map(source.cache),
             fetch: new Map(source.fetch),
             encryptedBoundArgs: new Map(source.encryptedBoundArgs),
-            decryptedBoundArgs: new Map(source.decryptedBoundArgs)
+            decryptedBoundArgs: new Map(source.decryptedBoundArgs),
+            imageResponses: new Map(source.imageResponses),
+            dynamicCacheKeys: source.dynamicCacheKeys ? new Set(source.dynamicCacheKeys) : new Set()
         };
     } else {
         return {
+            mutable: true,
             cache: new Map(),
             fetch: new Map(),
             encryptedBoundArgs: new Map(),
-            decryptedBoundArgs: new Map()
+            decryptedBoundArgs: new Map(),
+            imageResponses: new Map(),
+            dynamicCacheKeys: new Set()
         };
     }
 }
@@ -76,16 +82,26 @@ function createRenderResumeDataCache(resumeDataCacheOrPersistedCache, maxPostpon
         });
     } else {
         if (typeof resumeDataCacheOrPersistedCache !== 'string') {
-            // If the cache is already a prerender or render cache, we can return it
-            // directly. For the former, we're just performing a type change.
-            return resumeDataCacheOrPersistedCache;
+            // If the cache is already read-only, return it directly. Otherwise we
+            // perform a type change by overriding the discriminator — the underlying
+            // Map references are still shared, but callers should treat the result
+            // as immutable.
+            if (!resumeDataCacheOrPersistedCache.mutable) {
+                return resumeDataCacheOrPersistedCache;
+            }
+            return {
+                ...resumeDataCacheOrPersistedCache,
+                mutable: false
+            };
         }
         if (resumeDataCacheOrPersistedCache === 'null') {
             return {
+                mutable: false,
                 cache: new Map(),
                 fetch: new Map(),
                 encryptedBoundArgs: new Map(),
-                decryptedBoundArgs: new Map()
+                decryptedBoundArgs: new Map(),
+                imageResponses: new Map()
             };
         }
         // This should be a compressed string. Let's decompress it using zlib.
@@ -113,10 +129,12 @@ function createRenderResumeDataCache(resumeDataCacheOrPersistedCache, maxPostpon
             throw err;
         }
         return {
+            mutable: false,
             cache: (0, _cachestore.parseUseCacheCacheStore)(Object.entries(json.store.cache)),
             fetch: new Map(Object.entries(json.store.fetch)),
             encryptedBoundArgs: new Map(Object.entries(json.store.encryptedBoundArgs)),
-            decryptedBoundArgs: new Map()
+            decryptedBoundArgs: new Map(),
+            imageResponses: new Map()
         };
     }
 }

package/dist/node_modules/next/dist/server/revalidation-utils.js

@@ -106,9 +106,8 @@ async function revalidateTags(tagsWithProfile, incrementalCache, workStore) {
                 // Profile is already a cacheLife configuration object
                 cacheLife = profile;
             } else if (typeof profile === 'string') {
-                var _workStore_cacheLifeProfiles;
                 // Profile is a string key, look it up in workStore
-                cacheLife = workStore == null ? void 0 : (_workStore_cacheLifeProfiles = workStore.cacheLifeProfiles) == null ? void 0 : _workStore_cacheLifeProfiles[profile];
+                cacheLife = workStore == null ? void 0 : workStore.cacheLifeProfiles[profile];
                 if (!cacheLife) {
                     throw Object.defineProperty(new Error(`Invalid profile provided "${profile}" must be configured under cacheLife in next.config or be "max"`), "__NEXT_ERROR_CODE", {
                         value: "E873",

package/dist/node_modules/next/dist/server/route-modules/app-page/module.js

@@ -119,15 +119,29 @@ class AppPageRouteModule extends _routemodule.RouteModule {
             parsedUrl.pathname = this.normalizers.rsc.normalize(parsedUrl.pathname || '/', true);
             // Mark the request as a RSC request.
             req.headers[_approuterheaders.RSC_HEADER] = '1';
-            (0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
         } else {
             super.normalizeUrl(req, parsedUrl);
         }
+        // Minimal adapters can bypass base-server request normalization and invoke
+        // route modules directly, so derive RSC/prefetch metadata from headers.
+        (0, _normalizerequesturl.applyAppPageRscRequestMetaFromHeaders)(req);
         (0, _normalizerequesturl.normalizeAppPageRequestUrl)(req, parsedUrl.pathname || '/');
     }
     render(req, res, context) {
         return (0, _apprender.renderToHTMLOrFlight)(req, res, context.page, context.query, context.fallbackRouteParams, context.renderOpts, context.serverComponentsHmrCache, context.sharedContext);
     }
+    /**
+   * Worker entry point for dev Cache Components dev validation. The dev
+   * validation worker reloads this route's module and calls this so the whole
+   * validation runs inside the app-page bundle's React instance (the same one
+   * the user's client components resolve through `componentMod`), rebuilding
+   * the render context from the transported `message`. `componentMod` is the
+   * reloaded module the worker holds; it's passed in because the route module
+   * has no back-reference to it. Returns the validation errors for the worker
+   * to serialize and the main thread to deliver to the dev overlay.
+   */ runValidationInDev(componentMod, message, abortSignal) {
+        return (0, _apprender.runValidationInDevFromSnapshot)(message, componentMod, abortSignal);
+    }
     pathCouldBeIntercepted(resolvedPathname, interceptionRoutePatterns) {
         return (0, _interceptionroutes.isInterceptionRouteAppPath)(resolvedPathname) || interceptionRoutePatterns.some((regexp)=>{
             return regexp.test(resolvedPathname);