@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/lib/incremental-cache/index.js

@@ -29,7 +29,7 @@ const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-
 const _invarianterror = require("../../../shared/lib/invariant-error");
 const _serverutils = require("../../server-utils");
 const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
-const _detachedpromise = require("../../../lib/detached-promise");
+const _promisewithresolvers = require("../../../shared/lib/promise-with-resolvers");
 const _tagsmanifestexternal = require("./tags-manifest.external");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -88,8 +88,7 @@ async function hashString(cacheString) {
 const MAIN_KEY_PREFIX = 'v4';
 class IncrementalCache {
     static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
-    constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, getPrerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys, locales }){
-        var _this_prerenderManifest_preview, _this_prerenderManifest;
+    constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, previewProps, prerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys, locales }){
         this.locks = new Map();
         this.hasCustomCacheHandler = Boolean(CurCacheHandler);
         const cacheHandlersSymbol = Symbol.for('@next/cache-handlers');
@@ -125,17 +124,17 @@ class IncrementalCache {
         this[minimalModeKey] = minimalMode;
         this.requestHeaders = requestHeaders;
         this.allowedRevalidateHeaderKeys = allowedRevalidateHeaderKeys;
-        this.prerenderManifest = getPrerenderManifest();
+        this.previewProps = previewProps;
+        this.prerenderManifest = prerenderManifest;
         this.locales = locales;
         this.cacheControls = new _sharedcachecontrolsexternal.SharedCacheControls(this.prerenderManifest, locales);
         this.fetchCacheKeyPrefix = fetchCacheKeyPrefix;
         let revalidatedTags = [];
-        if (requestHeaders[_constants.PRERENDER_REVALIDATE_HEADER] === ((_this_prerenderManifest = this.prerenderManifest) == null ? void 0 : (_this_prerenderManifest_preview = _this_prerenderManifest.preview) == null ? void 0 : _this_prerenderManifest_preview.previewModeId)) {
+        if (requestHeaders[_constants.PRERENDER_REVALIDATE_HEADER] === this.previewProps.previewModeId) {
             this.isOnDemandRevalidate = true;
         }
         if (minimalMode) {
-            var _this_prerenderManifest_preview1, _this_prerenderManifest1;
-            revalidatedTags = this.revalidatedTags = (0, _serverutils.getPreviouslyRevalidatedTags)(requestHeaders, (_this_prerenderManifest1 = this.prerenderManifest) == null ? void 0 : (_this_prerenderManifest_preview1 = _this_prerenderManifest1.preview) == null ? void 0 : _this_prerenderManifest_preview1.previewModeId);
+            revalidatedTags = this.revalidatedTags = (0, _serverutils.getPreviouslyRevalidatedTags)(requestHeaders, this.previewProps.previewModeId);
         }
         if (CurCacheHandler) {
             this.cacheHandler = new CurCacheHandler({
@@ -179,7 +178,7 @@ class IncrementalCache {
         }
         // Create a new detached promise that will represent this lock
         // The resolve function (unlock) will be returned to the caller
-        const { resolve, promise } = new _detachedpromise.DetachedPromise();
+        const { resolve, promise } = (0, _promisewithresolvers.createPromiseWithResolvers)();
         if (IncrementalCache.debug) {
             console.log('IncrementalCache: successfully locked', cacheKey);
         }
@@ -269,11 +268,7 @@ class IncrementalCache {
                 bodyType = 'text/plain;charset=UTF-8';
             } else {
                 body;
-                throw Object.defineProperty(new Error(`Unsupported body type: ${typeof body}`), "__NEXT_ERROR_CODE", {
-                    value: "E1443",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Unsupported body type: ${typeof body}`);
             }
         }
         const headers = typeof (init.headers || {}).keys === 'function' ? Object.fromEntries(init.headers) : Object.assign({}, init.headers);
@@ -371,11 +366,7 @@ class IncrementalCache {
             }
             if (((_cacheData_value1 = cacheData.value) == null ? void 0 : _cacheData_value1.kind) !== _responsecache.CachedRouteKind.FETCH) {
                 var _cacheData_value2;
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Expected cached value for cache key ${JSON.stringify(cacheKey)} to be a "FETCH" kind, got ${JSON.stringify((_cacheData_value2 = cacheData.value) == null ? void 0 : _cacheData_value2.kind)} instead.`), "__NEXT_ERROR_CODE", {
-                    value: "E653",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Expected cached value for cache key ${JSON.stringify(cacheKey)} to be a "FETCH" kind, got ${JSON.stringify((_cacheData_value2 = cacheData.value) == null ? void 0 : _cacheData_value2.kind)} instead.`);
             }
             const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
             const combinedTags = [
@@ -428,15 +419,18 @@ class IncrementalCache {
                 }
             };
         } else if ((cacheData == null ? void 0 : (_cacheData_value = cacheData.value) == null ? void 0 : _cacheData_value.kind) === _responsecache.CachedRouteKind.FETCH) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected cached value for cache key ${JSON.stringify(cacheKey)} not to be a ${JSON.stringify(ctx.kind)} kind, got "FETCH" instead.`), "__NEXT_ERROR_CODE", {
-                value: "E652",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected cached value for cache key ${JSON.stringify(cacheKey)} not to be a ${JSON.stringify(ctx.kind)} kind, got "FETCH" instead.`);
         }
         let entry = null;
         const { isFallback } = ctx;
-        const cacheControl = this.cacheControls.get(cacheKey, ctx.route);
+        let cacheControl = this.cacheControls.get(cacheKey, ctx.route);
+        // The stored lifetime belongs to this entry, which another instance may
+        // have replaced with a different lifetime. Prefer it over this process's
+        // remembered lifetime, and update the route so revalidation uses it too.
+        if (cacheData == null ? void 0 : cacheData.cacheControl) {
+            cacheControl = cacheData.cacheControl;
+            this.cacheControls.set(storageKey, cacheControl);
+        }
         let isStale;
         let revalidateAfter;
         if ((cacheData == null ? void 0 : cacheData.lastModified) === -1) {
@@ -542,11 +536,7 @@ class IncrementalCache {
         !ctx.isImplicitBuildTimeCache) {
             const warningText = `Failed to set Next.js data cache for ${ctx.fetchUrl || pathname}, items over 2MB can not be cached (${itemSize} bytes)`;
             if (this.dev) {
-                throw Object.defineProperty(new Error(warningText), "__NEXT_ERROR_CODE", {
-                    value: "E1003",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(warningText);
             }
             console.warn(warningText);
             return;

package/app/node_modules/next/dist/server/lib/incremental-cache/memory-cache.external.js

@@ -33,11 +33,7 @@ function getMemoryCache(maxMemoryCacheSize) {
             } else if (value.kind === _types.CachedRouteKind.REDIRECT) {
                 valueSize = JSON.stringify(value.props).length;
             } else if (value.kind === _types.CachedRouteKind.IMAGE) {
-                throw Object.defineProperty(new Error('invariant image should not be incremental-cache'), "__NEXT_ERROR_CODE", {
-                    value: "E501",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('invariant image should not be incremental-cache');
             } else if (value.kind === _types.CachedRouteKind.FETCH) {
                 valueSize = JSON.stringify(value.data || '').length;
             } else if (value.kind === _types.CachedRouteKind.APP_ROUTE) {

package/app/node_modules/next/dist/server/lib/lru-cache.js

@@ -91,11 +91,7 @@ class LRUCache {
    */ set(key, value) {
         const size = (this.calculateSize == null ? void 0 : this.calculateSize.call(this, value, key)) ?? 1;
         if (size <= 0) {
-            throw Object.defineProperty(new Error(`LRUCache: calculateSize returned ${size}, but size must be > 0. ` + `Items with size 0 would never be evicted, causing unbounded cache growth.`), "__NEXT_ERROR_CODE", {
-                value: "E1045",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`LRUCache: calculateSize returned ${size}, but size must be > 0. ` + `Items with size 0 would never be evicted, causing unbounded cache growth.`);
         }
         if (size > this.maxSize) {
             console.warn('Single item size exceeds maxSize');

package/app/node_modules/next/dist/server/lib/mock-request.js

@@ -40,11 +40,7 @@ class MockedRequest extends _stream.default.Readable {
         this.socket = new Proxy({}, {
             get: (_target, prop)=>{
                 if (prop !== 'encrypted' && prop !== 'remoteAddress') {
-                    throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
-                        value: "E52",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error('Method not implemented');
                 }
                 if (prop === 'remoteAddress') return undefined;
                 // For this mock request, always ensure we just respond with the encrypted
@@ -92,53 +88,25 @@ class MockedRequest extends _stream.default.Readable {
     // The following methods are not implemented as they are not used in the
     // Next.js codebase.
     get aborted() {
-        throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E52",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented');
     }
     get complete() {
-        throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E52",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented');
     }
     get trailers() {
-        throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E52",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented');
     }
     get trailersDistinct() {
-        throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E52",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented');
     }
     get rawTrailers() {
-        throw Object.defineProperty(new Error('Method not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E52",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented');
     }
     get rawHeaders() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     setTimeout() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
 }
 class MockedResponse extends _stream.default.Writable {
@@ -200,11 +168,7 @@ class MockedResponse extends _stream.default.Writable {
         if (this.maximumResponseBody !== undefined) {
             this.totalSize += buffer.byteLength;
             if (this.totalSize > this.maximumResponseBody) {
-                const error = Object.defineProperty(new Error(`Response body exceeded maximum size of ${this.maximumResponseBody} bytes`), "__NEXT_ERROR_CODE", {
-                    value: "E1171",
-                    enumerable: false,
-                    configurable: true
-                });
+                const error = new Error(`Response body exceeded maximum size of ${this.maximumResponseBody} bytes`);
                 error.code = 'ERR_MAX_BODY_SIZE_EXCEEDED';
                 this.destroy(error);
                 return true;
@@ -316,109 +280,49 @@ class MockedResponse extends _stream.default.Writable {
     // The following methods are not implemented as they are not used in the
     // Next.js codebase.
     get strictContentLength() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     writeEarlyHints() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     get req() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     assignSocket() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     detachSocket() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     writeContinue() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     writeProcessing() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     get upgrading() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     get chunkedEncoding() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     get shouldKeepAlive() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     get useChunkedEncodingByDefault() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     get sendDate() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     setTimeout() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     addTrailers() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
     setHeaders() {
-        throw Object.defineProperty(new Error('Method not implemented.'), "__NEXT_ERROR_CODE", {
-            value: "E41",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Method not implemented.');
     }
 }
 function createRequestResponseMocks({ url, headers = {}, method = 'GET', bodyReadable, resWriter, socket = null, maximumResponseBody }) {

package/app/node_modules/next/dist/server/lib/module-loader/node-module-loader.js

@@ -14,11 +14,7 @@ class NodeModuleLoader {
             // Need to `await` to cover the case that route is marked ESM modules by ESM escalation.
             return await (process.env.NEXT_MINIMAL ? __non_webpack_require__(id) : require(id));
         }
-        throw Object.defineProperty(new Error('NodeModuleLoader is not supported in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E25",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('NodeModuleLoader is not supported in edge runtime.');
     }
 }
 

package/app/node_modules/next/dist/server/lib/patch-fetch.js

@@ -46,6 +46,34 @@ const _cloneresponse = require("./clone-response");
 const _stagedrendering = require("../app-render/staged-rendering");
 const _encodeheadersafe = require("./encode-header-safe");
 const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
+/**
+ * Whether fetch cache configuration needs to be processed for the current work
+ * unit before an origin fetch. Static prerender stores use it for dynamic
+ * access tracking. Cache scopes apply it to their own cache policy, regardless
+ * of which outer work unit created them. Development staged renders additionally
+ * coordinate dynamic fetches with the dynamic render stage.
+ */ function shouldProcessFetchConfigForWorkUnit(workUnitStore) {
+    if (!workUnitStore) {
+        return false;
+    }
+    switch(workUnitStore.type){
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-legacy':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+            return true;
+        case 'request':
+            return Boolean(process.env.NODE_ENV === 'development' && process.env.__NEXT_CACHE_COMPONENTS && workUnitStore.stagedRendering);
+        case 'prerender-runtime':
+        case 'validation-client':
+        case 'build-time-generator':
+            return false;
+        default:
+            return workUnitStore;
+    }
+}
 const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
 function isFetchPatched() {
     return globalThis[NEXT_PATCH_SYMBOL] === true;
@@ -60,11 +88,7 @@ function validateRevalidate(revalidateVal, route) {
         } else if (typeof revalidateVal === 'number' && !isNaN(revalidateVal) && revalidateVal > -1) {
             normalizedRevalidate = revalidateVal;
         } else if (typeof revalidateVal !== 'undefined') {
-            throw Object.defineProperty(new Error(`Invalid revalidate value "${revalidateVal}" on "${route}", must be a non-negative number or false`), "__NEXT_ERROR_CODE", {
-                value: "E179",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Invalid revalidate value "${revalidateVal}" on "${route}", must be a non-negative number or false`);
         }
         return normalizedRevalidate;
     } catch (err) {
@@ -322,7 +346,6 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     // TODO: Stop accumulating tags in client prerender. (fallthrough)
                     case 'prerender-client':
                     case 'validation-client':
-                    case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'cache':
                     case 'private-cache':
@@ -330,7 +353,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'request':
                     case 'unstable-cache':
-                    case 'generate-static-params':
+                    case 'build-time-generator':
                         break;
                     default:
                         workUnitStore;
@@ -360,12 +383,11 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     case 'prerender-client':
                     case 'validation-client':
                     case 'prerender-runtime':
-                    case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'request':
                     case 'cache':
                     case 'private-cache':
-                    case 'generate-static-params':
+                    case 'build-time-generator':
                         break;
                     default:
                         workUnitStore;
@@ -467,12 +489,11 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
                         }
                         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;
@@ -487,11 +508,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 case 'only-no-store':
                     {
                         if (currentFetchCacheConfig === 'force-cache' || typeof finalRevalidate !== 'undefined' && finalRevalidate > 0) {
-                            throw Object.defineProperty(new Error(`cache: 'force-cache' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-no-store'`), "__NEXT_ERROR_CODE", {
-                                value: "E448",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new Error(`cache: 'force-cache' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-no-store'`);
                         }
                         cacheReason = 'fetchCache = only-no-store';
                         break;
@@ -499,11 +516,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 case 'only-cache':
                     {
                         if (currentFetchCacheConfig === 'no-store') {
-                            throw Object.defineProperty(new Error(`cache: 'no-store' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-cache'`), "__NEXT_ERROR_CODE", {
-                                value: "E521",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new Error(`cache: 'no-store' used on fetch for ${fetchUrl} with 'export const fetchCache = 'only-cache'`);
                         }
                         break;
                     }
@@ -579,12 +592,11 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                     await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
                                 }
                                 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;
@@ -616,10 +628,9 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     case 'prerender-client':
                     case 'validation-client':
                     case 'prerender-runtime':
-                    case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'unstable-cache':
-                    case 'generate-static-params':
+                    case 'build-time-generator':
                         break;
                     default:
                         workUnitStore;
@@ -719,12 +730,11 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                     return createCachedPrerenderResponse(res, cacheKey, incrementalCacheConfig, incrementalCache, normalizedRevalidate, handleUnlock);
                                 }
                             // fallthrough
-                            case 'prerender-ppr':
                             case 'prerender-legacy':
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
-                            case 'generate-static-params':
+                            case 'build-time-generator':
                             case undefined:
                                 return createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheConfig, incrementalCache, serverComponentsHmrCache, normalizedRevalidate, input, handleUnlock, getRequestMeta('signal'));
                             default:
@@ -777,12 +787,11 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                     await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
                                 }
                                 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;
@@ -796,9 +805,9 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         cacheReasonOverride = 'cache-control: no-cache (hard refresh)';
                     }
                     if ((entry == null ? void 0 : entry.value) && entry.value.kind === _responsecache.CachedRouteKind.FETCH) {
-                        // when stale and is revalidating we wait for fresh data
-                        // so the revalidated entry has the updated data
-                        if (workStore.isStaticGeneration && entry.isStale) {
+                        // If the consumer will persist this result in a server cache,
+                        // wait for fresh data so it doesn't persist a stale value.
+                        if ((0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore) && entry.isStale) {
                             isForegroundRevalidate = true;
                         } else {
                             if (entry.isStale) {
@@ -845,8 +854,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     return response;
                 }
             }
-            if ((workStore.isStaticGeneration || process.env.NODE_ENV === 'development' && process.env.__NEXT_CACHE_COMPONENTS && workUnitStore && // eslint-disable-next-line no-restricted-syntax
-            workUnitStore.type === 'request' && workUnitStore.stagedRendering) && init && typeof init === 'object') {
+            if (init && typeof init === 'object' && shouldProcessFetchConfigForWorkUnit(workUnitStore)) {
                 const { cache } = init;
                 // Delete `cache` property as Cloudflare Workers will throw an error
                 if (isEdgeRuntime) delete init.cache;
@@ -872,12 +880,11 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                     await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);
                                 }
                                 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;
@@ -906,8 +913,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                 case 'private-cache':
                                 case 'unstable-cache':
                                 case 'prerender-legacy':
-                                case 'prerender-ppr':
-                                case 'generate-static-params':
+                                case 'build-time-generator':
                                     break;
                                 default:
                                     workUnitStore;

package/app/node_modules/next/dist/server/lib/postponed-request-body.js

@@ -30,11 +30,7 @@ function getMaxPostponedStateSize(configuredMaxPostponedStateSize) {
     const maxPostponedStateSize = configuredMaxPostponedStateSize ?? _sizelimit.DEFAULT_MAX_POSTPONED_STATE_SIZE;
     const maxPostponedStateSizeBytes = (0, _sizelimit.parseMaxPostponedStateSize)(configuredMaxPostponedStateSize);
     if (maxPostponedStateSizeBytes === undefined) {
-        throw Object.defineProperty(new Error(INVALID_MAX_POSTPONED_STATE_SIZE_ERROR_MESSAGE), "__NEXT_ERROR_CODE", {
-            value: "E977",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(INVALID_MAX_POSTPONED_STATE_SIZE_ERROR_MESSAGE);
     }
     return {
         maxPostponedStateSize,

package/app/node_modules/next/dist/server/lib/render-server.js

@@ -54,11 +54,7 @@ function clearModuleContext(target) {
 async function getServerField(dir, field) {
     const initialization = await initializations[dir];
     if (!initialization) {
-        throw Object.defineProperty(new Error('Invariant cant propagate server field, no app initialized'), "__NEXT_ERROR_CODE", {
-            value: "E116",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant cant propagate server field, no app initialized');
     }
     const { server } = initialization;
     let wrappedServer = server['server']// NextServer.server is private
@@ -68,11 +64,7 @@ async function getServerField(dir, field) {
 async function propagateServerField(dir, field, value) {
     const initialization = await initializations[dir];
     if (!initialization) {
-        throw Object.defineProperty(new Error('Invariant cant propagate server field, no app initialized'), "__NEXT_ERROR_CODE", {
-            value: "E116",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant cant propagate server field, no app initialized');
     }
     const { server } = initialization;
     let wrappedServer = server['server'];