@semiont/frontend 0.3.2 → 0.3.4

package/standalone/apps/frontend/.next/server/chunks/{7246.js → 8569.js}

@@ -1,5 +1,5 @@
-exports.id = 7246;
-exports.ids = [7246];
+exports.id = 8569;
+exports.ids = [8569];
 exports.modules = {
 
 /***/ 330:
@@ -78,6 +78,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    compareAppPaths: function() {
+        return compareAppPaths;
+    },
     normalizeAppPath: function() {
         return normalizeAppPath;
     },
@@ -108,6 +111,13 @@ function normalizeAppPath(route) {
         return `${pathname}/${segment}`;
     }, ''));
 }
+function compareAppPaths(a, b) {
+    const aHasSlot = a.includes('/@');
+    const bHasSlot = b.includes('/@');
+    if (aHasSlot && !bHasSlot) return -1;
+    if (!aHasSlot && bHasSlot) return 1;
+    return a.localeCompare(b);
+}
 function normalizeRscURL(url) {
     return url.replace(/\.rsc($|\?)/, '$1');
 } //# sourceMappingURL=app-paths.js.map
@@ -286,6 +296,12 @@ _export(exports, {
     NEXT_HTML_REQUEST_ID_HEADER: function() {
         return NEXT_HTML_REQUEST_ID_HEADER;
     },
+    NEXT_INSTANT_PREFETCH_HEADER: function() {
+        return NEXT_INSTANT_PREFETCH_HEADER;
+    },
+    NEXT_INSTANT_TEST_COOKIE: function() {
+        return NEXT_INSTANT_TEST_COOKIE;
+    },
     NEXT_IS_PRERENDER_HEADER: function() {
         return NEXT_IS_PRERENDER_HEADER;
     },
@@ -332,6 +348,8 @@ const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh';
 const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__';
 const NEXT_URL = 'next-url';
 const RSC_CONTENT_TYPE_HEADER = 'text/x-component';
+const NEXT_INSTANT_PREFETCH_HEADER = 'next-instant-navigation-testing-prefetch';
+const NEXT_INSTANT_TEST_COOKIE = 'next-instant-navigation-testing';
 const FLIGHT_HEADERS = [
     RSC_HEADER,
     NEXT_ROUTER_STATE_TREE_HEADER,
@@ -501,6 +519,215 @@ class NextRequestAdapter {
 
 /***/ }),
 
+/***/ 9090:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+0 && (0);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+    },
+    ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+    },
+    RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+    },
+    appendMutableCookies: function() {
+        return appendMutableCookies;
+    },
+    areCookiesMutableInCurrentPhase: function() {
+        return areCookiesMutableInCurrentPhase;
+    },
+    createCookiesWithMutableAccessCheck: function() {
+        return createCookiesWithMutableAccessCheck;
+    },
+    getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+    },
+    responseCookiesToRequestCookies: function() {
+        return responseCookiesToRequestCookies;
+    }
+});
+const _cookies = __webpack_require__(98315);
+const _reflect = __webpack_require__(1212);
+const _workasyncstorageexternal = __webpack_require__(29294);
+const _actionrevalidationkind = __webpack_require__(26805);
+class ReadonlyRequestCookiesError extends Error {
+    constructor(){
+        super('Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options');
+    }
+    static callable() {
+        throw new ReadonlyRequestCookiesError();
+    }
+}
+class RequestCookiesAdapter {
+    static seal(cookies) {
+        return new Proxy(cookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    case 'clear':
+                    case 'delete':
+                    case 'set':
+                        return ReadonlyRequestCookiesError.callable;
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+    }
+}
+const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for('next.mutated.cookies');
+function getModifiedCookieValues(cookies) {
+    const modified = cookies[SYMBOL_MODIFY_COOKIE_VALUES];
+    if (!modified || !Array.isArray(modified) || modified.length === 0) {
+        return [];
+    }
+    return modified;
+}
+function appendMutableCookies(headers, mutableCookies) {
+    const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
+    if (modifiedCookieValues.length === 0) {
+        return false;
+    }
+    // Return a new response that extends the response with
+    // the modified cookies as fallbacks. `res` cookies
+    // will still take precedence.
+    const resCookies = new _cookies.ResponseCookies(headers);
+    const returnedCookies = resCookies.getAll();
+    // Set the modified cookies as fallbacks.
+    for (const cookie of modifiedCookieValues){
+        resCookies.set(cookie);
+    }
+    // Set the original cookies as the final values.
+    for (const cookie of returnedCookies){
+        resCookies.set(cookie);
+    }
+    return true;
+}
+class MutableRequestCookiesAdapter {
+    static wrap(cookies, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies.getAll()){
+            responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = new Set();
+        const updateResponseCookies = ()=>{
+            // TODO-APP: change method of getting workStore
+            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+            if (workStore) {
+                workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
+            }
+            const allCookies = responseCookies.getAll();
+            modifiedValues = allCookies.filter((c)=>modifiedCookies.has(c.name));
+            if (onUpdateCookies) {
+                const serializedCookies = [];
+                for (const cookie of modifiedValues){
+                    const tempCookies = new _cookies.ResponseCookies(new Headers());
+                    tempCookies.set(cookie);
+                    serializedCookies.push(tempCookies.toString());
+                }
+                onUpdateCookies(serializedCookies);
+            }
+        };
+        const wrappedCookies = new Proxy(responseCookies, {
+            get (target, prop, receiver) {
+                switch(prop){
+                    // A special symbol to get the modified cookie values
+                    case SYMBOL_MODIFY_COOKIE_VALUES:
+                        return modifiedValues;
+                    // TODO: Throw error if trying to set a cookie after the response
+                    // headers have been set.
+                    case 'delete':
+                        return function(...args) {
+                            modifiedCookies.add(typeof args[0] === 'string' ? args[0] : args[0].name);
+                            try {
+                                target.delete(...args);
+                                return wrappedCookies;
+                            } finally{
+                                updateResponseCookies();
+                            }
+                        };
+                    case 'set':
+                        return function(...args) {
+                            modifiedCookies.add(typeof args[0] === 'string' ? args[0] : args[0].name);
+                            try {
+                                target.set(...args);
+                                return wrappedCookies;
+                            } finally{
+                                updateResponseCookies();
+                            }
+                        };
+                    default:
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                }
+            }
+        });
+        return wrappedCookies;
+    }
+}
+function createCookiesWithMutableAccessCheck(requestStore) {
+    const wrappedCookies = new Proxy(requestStore.mutableCookies, {
+        get (target, prop, receiver) {
+            switch(prop){
+                case 'delete':
+                    return function(...args) {
+                        ensureCookiesAreStillMutable(requestStore, 'cookies().delete');
+                        target.delete(...args);
+                        return wrappedCookies;
+                    };
+                case 'set':
+                    return function(...args) {
+                        ensureCookiesAreStillMutable(requestStore, 'cookies().set');
+                        target.set(...args);
+                        return wrappedCookies;
+                    };
+                default:
+                    return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+        }
+    });
+    return wrappedCookies;
+}
+function areCookiesMutableInCurrentPhase(requestStore) {
+    return requestStore.phase === 'action';
+}
+/** Ensure that cookies() starts throwing on mutation
+ * if we changed phases and can no longer mutate.
+ *
+ * This can happen when going:
+ *   'render' -> 'after'
+ *   'action' -> 'render'
+ * */ function ensureCookiesAreStillMutable(requestStore, _callingExpression) {
+    if (!areCookiesMutableInCurrentPhase(requestStore)) {
+        // TODO: maybe we can give a more precise error message based on callingExpression?
+        throw new ReadonlyRequestCookiesError();
+    }
+}
+function responseCookiesToRequestCookies(responseCookies) {
+    const requestCookies = new _cookies.RequestCookies(new Headers());
+    for (const cookie of responseCookies.getAll()){
+        requestCookies.set(cookie);
+    }
+    return requestCookies;
+}
+
+//# sourceMappingURL=request-cookies.js.map
+
+/***/ }),
+
 /***/ 10033:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
@@ -519,9 +746,13 @@ const _detectdomainlocale = __webpack_require__(61383);
 const _formatnextpathnameinfo = __webpack_require__(37852);
 const _gethostname = __webpack_require__(57315);
 const _getnextpathnameinfo = __webpack_require__(29433);
-const REGEX_LOCALHOST_HOSTNAME = /(?!^https?:\/\/)(127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|\[::1\]|localhost)/;
+const REGEX_LOCALHOST_HOSTNAME = /^(?:127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|\[::1\]|localhost)$/;
 function parseURL(url, base) {
-    return new URL(String(url).replace(REGEX_LOCALHOST_HOSTNAME, 'localhost'), base && String(base).replace(REGEX_LOCALHOST_HOSTNAME, 'localhost'));
+    const parsed = new URL(String(url), base && String(base));
+    if (REGEX_LOCALHOST_HOSTNAME.test(parsed.hostname)) {
+        parsed.hostname = 'localhost';
+    }
+    return parsed;
 }
 const Internal = Symbol('NextURLInternal');
 class NextURL {
@@ -736,7 +967,7 @@ function getCacheControlHeader({ revalidate, expire }) {
     } else if (typeof revalidate === 'number') {
         return `s-maxage=${revalidate}${swrHeader}`;
     }
-    return `s-maxage=${_constants.CACHE_ONE_YEAR}${swrHeader}`;
+    return `s-maxage=${_constants.CACHE_ONE_YEAR_SECONDS}${swrHeader}`;
 }
 
 //# sourceMappingURL=cache-control.js.map
@@ -770,51 +1001,68 @@ const _invarianterror = __webpack_require__(96042);
 const _promisewithresolvers = __webpack_require__(23151);
 var RenderStage = /*#__PURE__*/ function(RenderStage) {
     RenderStage[RenderStage["Before"] = 1] = "Before";
-    RenderStage[RenderStage["Static"] = 2] = "Static";
-    RenderStage[RenderStage["Runtime"] = 3] = "Runtime";
-    RenderStage[RenderStage["Dynamic"] = 4] = "Dynamic";
-    RenderStage[RenderStage["Abandoned"] = 5] = "Abandoned";
+    RenderStage[RenderStage["EarlyStatic"] = 2] = "EarlyStatic";
+    RenderStage[RenderStage["Static"] = 3] = "Static";
+    RenderStage[RenderStage["EarlyRuntime"] = 4] = "EarlyRuntime";
+    RenderStage[RenderStage["Runtime"] = 5] = "Runtime";
+    RenderStage[RenderStage["Dynamic"] = 6] = "Dynamic";
+    RenderStage[RenderStage["Abandoned"] = 7] = "Abandoned";
     return RenderStage;
 }({});
 class StagedRenderingController {
-    constructor(abortSignal = null, hasRuntimePrefetch){
+    constructor(abortSignal, abandonController, shouldTrackSyncIO){
         this.abortSignal = abortSignal;
-        this.hasRuntimePrefetch = hasRuntimePrefetch;
+        this.abandonController = abandonController;
+        this.shouldTrackSyncIO = shouldTrackSyncIO;
         this.currentStage = 1;
-        this.staticInterruptReason = null;
-        this.runtimeInterruptReason = null;
+        this.syncInterruptReason = null;
         this.staticStageEndTime = Infinity;
         this.runtimeStageEndTime = Infinity;
+        this.staticStageListeners = [];
+        this.earlyRuntimeStageListeners = [];
         this.runtimeStageListeners = [];
         this.dynamicStageListeners = [];
+        this.staticStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.earlyRuntimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
         this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
         this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        this.mayAbandon = false;
         if (abortSignal) {
             abortSignal.addEventListener('abort', ()=>{
+                // Reject all stage promises that haven't already been resolved.
+                // If a promise was already resolved via advanceStage, the reject
+                // is a no-op. The ignoreReject handler suppresses unhandled
+                // rejection warnings for promises that no one is awaiting.
                 const { reason } = abortSignal;
-                if (this.currentStage < 3) {
-                    this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
-                    ;
-                    this.runtimeStagePromise.reject(reason);
-                }
-                if (this.currentStage < 4 || this.currentStage === 5) {
-                    this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
-                    ;
-                    this.dynamicStagePromise.reject(reason);
-                }
+                this.staticStagePromise.promise.catch(ignoreReject);
+                this.staticStagePromise.reject(reason);
+                this.earlyRuntimeStagePromise.promise.catch(ignoreReject);
+                this.earlyRuntimeStagePromise.reject(reason);
+                this.runtimeStagePromise.promise.catch(ignoreReject);
+                this.runtimeStagePromise.reject(reason);
+                this.dynamicStagePromise.promise.catch(ignoreReject);
+                this.dynamicStagePromise.reject(reason);
+            }, {
+                once: true
+            });
+        }
+        if (abandonController) {
+            abandonController.signal.addEventListener('abort', ()=>{
+                this.abandonRender();
             }, {
                 once: true
             });
-            this.mayAbandon = true;
         }
     }
     onStage(stage, callback) {
         if (this.currentStage >= stage) {
             callback();
         } else if (stage === 3) {
-            this.runtimeStageListeners.push(callback);
+            this.staticStageListeners.push(callback);
         } else if (stage === 4) {
+            this.earlyRuntimeStageListeners.push(callback);
+        } else if (stage === 5) {
+            this.runtimeStageListeners.push(callback);
+        } else if (stage === 6) {
             this.dynamicStageListeners.push(callback);
         } else {
             // This should never happen
@@ -825,57 +1073,81 @@ class StagedRenderingController {
             });
         }
     }
-    canSyncInterrupt() {
-        // If we haven't started the render yet, it can't be interrupted.
-        if (this.currentStage === 1) {
+    shouldTrackSyncInterrupt() {
+        if (!this.shouldTrackSyncIO) {
             return false;
         }
-        const boundaryStage = this.hasRuntimePrefetch ? 4 : 3;
-        return this.currentStage < boundaryStage;
+        switch(this.currentStage){
+            case 1:
+                // If we haven't started the render yet, it can't be interrupted.
+                return false;
+            case 2:
+            case 3:
+                return true;
+            case 4:
+                // EarlyRuntime is for runtime-prefetchable segments. Sync IO
+                // should error because it would abort a runtime prefetch.
+                return true;
+            case 5:
+                // Runtime is for non-prefetchable segments. Sync IO is fine there
+                // because in practice this segment will never be runtime prefetched
+                return false;
+            case 6:
+            case 7:
+                return false;
+            default:
+                return false;
+        }
     }
     syncInterruptCurrentStageWithReason(reason) {
         if (this.currentStage === 1) {
             return;
         }
-        // If Sync IO occurs during the initial (abandonable) render, we'll retry it,
-        // so we want a slightly different flow.
-        // See the implementation of `abandonRenderImpl` for more explanation.
-        if (this.mayAbandon) {
-            return this.abandonRenderImpl();
+        // If the render has already been abandoned, there's nothing to interrupt.
+        if (this.currentStage === 7) {
+            return;
+        }
+        // If Sync IO occurs during an abandonable render, we trigger the abandon.
+        // The abandon listener will call abandonRender which advances through
+        // stages to let caches fill before marking as Abandoned.
+        if (this.abandonController) {
+            this.abandonController.abort();
+            return;
+        }
+        if (this.abortSignal) {
+            // If this is an abortable render, we capture the interruption reason and stop advancing.
+            // We don't release any more promises.
+            // The caller is expected to abort the signal.
+            this.syncInterruptReason = reason;
+            this.currentStage = 7;
+            return;
         }
-        // If we're in the final render, we cannot abandon it. We need to advance to the Dynamic stage
-        // and capture the interruption reason.
+        // If we're in a non-abandonable & non-abortable render,
+        // we need to advance to the Dynamic stage and capture the interruption reason.
+        // (in dev, this will be the restarted render)
         switch(this.currentStage){
             case 2:
+            case 3:
+            case 4:
                 {
-                    this.staticInterruptReason = reason;
-                    this.advanceStage(4);
+                    // EarlyRuntime is for runtime-prefetchable segments. Sync IO here
+                    // means the prefetch would be aborted too early.
+                    this.syncInterruptReason = reason;
+                    this.advanceStage(6);
                     return;
                 }
-            case 3:
+            case 5:
                 {
-                    // We only error for Sync IO in the runtime stage if the route
-                    // is configured to use runtime prefetching.
-                    // We do this to reflect the fact that during a runtime prefetch,
-                    // Sync IO aborts aborts the render.
-                    // Note that `canSyncInterrupt` should prevent us from getting here at all
-                    // if runtime prefetching isn't enabled.
-                    if (this.hasRuntimePrefetch) {
-                        this.runtimeInterruptReason = reason;
-                        this.advanceStage(4);
-                    }
+                    // canSyncInterrupt returns false for Runtime, so we should
+                    // never get here. Defensive no-op.
                     return;
                 }
-            case 4:
-            case 5:
+            case 6:
             default:
         }
     }
-    getStaticInterruptReason() {
-        return this.staticInterruptReason;
-    }
-    getRuntimeInterruptReason() {
-        return this.runtimeInterruptReason;
+    getSyncInterruptReason() {
+        return this.syncInterruptReason;
     }
     getStaticStageEndTime() {
         return this.staticStageEndTime;
@@ -884,16 +1156,6 @@ class StagedRenderingController {
         return this.runtimeStageEndTime;
     }
     abandonRender() {
-        if (!this.mayAbandon) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('`abandonRender` called on a stage controller that cannot be abandoned.'), "__NEXT_ERROR_CODE", {
-                value: "E938",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        this.abandonRenderImpl();
-    }
-    abandonRenderImpl() {
         // In staged rendering, only the initial render is abandonable.
         // We can abandon the initial render if
         //   1. We notice a cache miss, and need to wait for caches to fill
@@ -901,24 +1163,33 @@ class StagedRenderingController {
         //      (this might be a lazy intitialization of a module,
         //       so we still want to restart in this case and see if it still occurs)
         // In either case, we'll be doing another render after this one,
-        // so we only want to unblock the Runtime stage, not Dynamic, because
+        // so we only want to unblock the next stage, not Dynamic, because
         // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
         const { currentStage } = this;
         switch(currentStage){
             case 2:
                 {
-                    this.currentStage = 5;
-                    this.resolveRuntimeStage();
-                    return;
+                    this.resolveStaticStage();
                 }
+            // intentional fallthrough
             case 3:
                 {
-                    this.currentStage = 5;
-                    return;
+                    this.resolveEarlyRuntimeStage();
                 }
+            // intentional fallthrough
             case 4:
-            case 1:
+                {
+                    this.resolveRuntimeStage();
+                }
+            // intentional fallthrough
             case 5:
+                {
+                    this.currentStage = 7;
+                    return;
+                }
+            case 6:
+            case 1:
+            case 7:
                 break;
             default:
                 {
@@ -935,15 +1206,37 @@ class StagedRenderingController {
         let currentStage = this.currentStage;
         this.currentStage = stage;
         if (currentStage < 3 && stage >= 3) {
+            this.resolveStaticStage();
+        }
+        if (currentStage < 4 && stage >= 4) {
+            this.resolveEarlyRuntimeStage();
+        }
+        if (currentStage < 5 && stage >= 5) {
             this.staticStageEndTime = performance.now() + performance.timeOrigin;
             this.resolveRuntimeStage();
         }
-        if (currentStage < 4 && stage >= 4) {
+        if (currentStage < 6 && stage >= 6) {
             this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
             this.resolveDynamicStage();
             return;
         }
     }
+    /** Fire the `onStage` listeners for the static stage and unblock any promises waiting for it. */ resolveStaticStage() {
+        const staticListeners = this.staticStageListeners;
+        for(let i = 0; i < staticListeners.length; i++){
+            staticListeners[i]();
+        }
+        staticListeners.length = 0;
+        this.staticStagePromise.resolve();
+    }
+    /** Fire the `onStage` listeners for the early runtime stage and unblock any promises waiting for it. */ resolveEarlyRuntimeStage() {
+        const earlyRuntimeListeners = this.earlyRuntimeStageListeners;
+        for(let i = 0; i < earlyRuntimeListeners.length; i++){
+            earlyRuntimeListeners[i]();
+        }
+        earlyRuntimeListeners.length = 0;
+        this.earlyRuntimeStagePromise.resolve();
+    }
     /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
         const runtimeListeners = this.runtimeStageListeners;
         for(let i = 0; i < runtimeListeners.length; i++){
@@ -964,9 +1257,17 @@ class StagedRenderingController {
         switch(stage){
             case 3:
                 {
-                    return this.runtimeStagePromise.promise;
+                    return this.staticStagePromise.promise;
                 }
             case 4:
+                {
+                    return this.earlyRuntimeStagePromise.promise;
+                }
+            case 5:
+                {
+                    return this.runtimeStagePromise.promise;
+                }
+            case 6:
                 {
                     return this.dynamicStagePromise.promise;
                 }
@@ -1368,6 +1669,39 @@ function isRequestAPICallableInsideAfter() {
 } //# sourceMappingURL=utils.js.map
 
 
+/***/ }),
+
+/***/ 26805:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+0 && (0);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ActionDidNotRevalidate: function() {
+        return ActionDidNotRevalidate;
+    },
+    ActionDidRevalidateDynamicOnly: function() {
+        return ActionDidRevalidateDynamicOnly;
+    },
+    ActionDidRevalidateStaticAndDynamic: function() {
+        return ActionDidRevalidateStaticAndDynamic;
+    }
+});
+const ActionDidNotRevalidate = 0;
+const ActionDidRevalidateStaticAndDynamic = 1;
+const ActionDidRevalidateDynamicOnly = 2; //# sourceMappingURL=action-revalidation-kind.js.map
+
+
 /***/ }),
 
 /***/ 27488:
@@ -1664,8 +1998,18 @@ class NextTracerImpl {
     getActiveScopeSpan() {
         return trace.getSpan(context == null ? void 0 : context.active());
     }
-    withPropagatedContext(carrier, fn, getter) {
+    withPropagatedContext(carrier, fn, getter, force = false) {
         const activeContext = context.active();
+        if (force) {
+            const remoteContext = propagation.extract(ROOT_CONTEXT, carrier, getter);
+            if (trace.getSpanContext(remoteContext)) {
+                return context.with(remoteContext, fn);
+            }
+            // Preserve the current active span while still merging any extracted
+            // baggage/context values from the carrier.
+            const mergedContext = propagation.extract(activeContext, carrier, getter);
+            return context.with(mergedContext, fn);
+        }
         if (trace.getSpanContext(activeContext)) {
             // Active span is already set, too late to propagate.
             return fn();
@@ -1851,6 +2195,14 @@ const ENCODED_TAGS = {
             109,
             108
         ]),
+        // <head
+        HEAD: new Uint8Array([
+            60,
+            104,
+            101,
+            97,
+            100
+        ]),
         // <body
         BODY: new Uint8Array([
             60,
@@ -2114,9 +2466,16 @@ class LRUCache {
    * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
    */ set(key, value) {
         const size = (this.calculateSize == null ? void 0 : this.calculateSize.call(this, value)) ?? 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
+            });
+        }
         if (size > this.maxSize) {
             console.warn('Single item size exceeds maxSize');
-            return;
+            return false;
         }
         const existing = this.cache.get(key);
         if (existing) {
@@ -2139,6 +2498,7 @@ class LRUCache {
             this.totalSize -= tail.size;
             this.onEvict == null ? void 0 : this.onEvict.call(this, tail.key, tail.data);
         }
+        return true;
     }
     /**
    * Checks if a key exists in the cache.
@@ -2359,8 +2719,8 @@ _export(exports, {
     APP_DIR_ALIAS: function() {
         return APP_DIR_ALIAS;
     },
-    CACHE_ONE_YEAR: function() {
-        return CACHE_ONE_YEAR;
+    CACHE_ONE_YEAR_SECONDS: function() {
+        return CACHE_ONE_YEAR_SECONDS;
     },
     DOT_NEXT_ALIAS: function() {
         return DOT_NEXT_ALIAS;
@@ -2410,6 +2770,9 @@ _export(exports, {
     NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER: function() {
         return NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER;
     },
+    NEXT_CACHE_ROOT_PARAM_TAG_ID: function() {
+        return NEXT_CACHE_ROOT_PARAM_TAG_ID;
+    },
     NEXT_CACHE_SOFT_TAG_MAX_LENGTH: function() {
         return NEXT_CACHE_SOFT_TAG_MAX_LENGTH;
     },
@@ -2431,12 +2794,18 @@ _export(exports, {
     NEXT_META_SUFFIX: function() {
         return NEXT_META_SUFFIX;
     },
+    NEXT_NAV_DEPLOYMENT_ID_HEADER: function() {
+        return NEXT_NAV_DEPLOYMENT_ID_HEADER;
+    },
     NEXT_QUERY_PARAM_PREFIX: function() {
         return NEXT_QUERY_PARAM_PREFIX;
     },
     NEXT_RESUME_HEADER: function() {
         return NEXT_RESUME_HEADER;
     },
+    NEXT_RESUME_STATE_LENGTH_HEADER: function() {
+        return NEXT_RESUME_STATE_LENGTH_HEADER;
+    },
     NON_STANDARD_NODE_ENV: function() {
         return NON_STANDARD_NODE_ENV;
     },
@@ -2543,15 +2912,18 @@ const ACTION_SUFFIX = '.action';
 const NEXT_DATA_SUFFIX = '.json';
 const NEXT_META_SUFFIX = '.meta';
 const NEXT_BODY_SUFFIX = '.body';
+const NEXT_NAV_DEPLOYMENT_ID_HEADER = 'x-nextjs-deployment-id';
 const NEXT_CACHE_TAGS_HEADER = 'x-next-cache-tags';
 const NEXT_CACHE_REVALIDATED_TAGS_HEADER = 'x-next-revalidated-tags';
 const NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER = 'x-next-revalidate-tag-token';
 const NEXT_RESUME_HEADER = 'next-resume';
+const NEXT_RESUME_STATE_LENGTH_HEADER = 'x-next-resume-state-length';
 const NEXT_CACHE_TAG_MAX_ITEMS = 128;
 const NEXT_CACHE_TAG_MAX_LENGTH = 256;
 const NEXT_CACHE_SOFT_TAG_MAX_LENGTH = 1024;
 const NEXT_CACHE_IMPLICIT_TAG_ID = '_N_T_';
-const CACHE_ONE_YEAR = 31536000;
+const NEXT_CACHE_ROOT_PARAM_TAG_ID = '_N_RP_';
+const CACHE_ONE_YEAR_SECONDS = 31536000;
 const INFINITE_CACHE = 0xfffffffe;
 const MIDDLEWARE_FILENAME = 'middleware';
 const MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
@@ -3078,63 +3450,6 @@ class HeadersAdapter extends Headers {
 
 //# sourceMappingURL=headers.js.map
 
-/***/ }),
-
-/***/ 42912:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-// In output: export mode, the build id is added to the start of the HTML
-// document, directly after the doctype declaration. During a prefetch, the
-// client performs a range request to get the build id, so it can check whether
-// the target page belongs to the same build.
-//
-// The first 64 bytes of the document are requested. The exact number isn't
-// too important; it must be larger than the build id + doctype + closing and
-// ending comment markers, but it doesn't need to match the end of the
-// comment exactly.
-//
-// Build ids are 21 bytes long in the default implementation, though this
-// can be overridden in the Next.js config. For the purposes of this check,
-// it's OK to only match the start of the id, so we'll truncate it if exceeds
-// a certain length.
-
-Object.defineProperty(exports, "__esModule", ({
-    value: true
-}));
-Object.defineProperty(exports, "insertBuildIdComment", ({
-    enumerable: true,
-    get: function() {
-        return insertBuildIdComment;
-    }
-}));
-const DOCTYPE_PREFIX = '<!DOCTYPE html>' // 15 bytes
-;
-const MAX_BUILD_ID_LENGTH = 24;
-function escapeBuildId(buildId) {
-    // If the build id is longer than the given limit, it's OK for our purposes
-    // to only match the beginning.
-    const truncated = buildId.slice(0, MAX_BUILD_ID_LENGTH);
-    // Replace hyphens with underscores so it doesn't break the HTML comment.
-    // (Unlikely, but if this did happen it would break the whole document.)
-    return truncated.replace(/-/g, '_');
-}
-function insertBuildIdComment(originalHtml, buildId) {
-    if (buildId.includes('-->') || // React always inserts a doctype at the start of the document. Skip if it
-    // isn't present. Shouldn't happen; suggests an issue elsewhere.
-    !originalHtml.startsWith(DOCTYPE_PREFIX)) {
-        // Return the original HTML unchanged. This means the document will not
-        // be prefetched.
-        // TODO: The build id comment is currently only used during prefetches, but
-        // if we eventually use this mechanism for regular navigations, we may need
-        // to error during build if we fail to insert it for some reason.
-        return originalHtml;
-    }
-    // The comment must be inserted after the doctype.
-    return originalHtml.replace(DOCTYPE_PREFIX, DOCTYPE_PREFIX + '<!--' + escapeBuildId(buildId) + '-->');
-} //# sourceMappingURL=output-export-prefetch-encoding.js.map
-
-
 /***/ }),
 
 /***/ 46352:
@@ -3372,8 +3687,15 @@ function selectWorkerForForwarding(actionId, pageName) {
     // Otherwise, grab the first worker that has a handler for this action id.
     return denormalizeWorkerPageName(Object.keys(workers)[0]);
 }
-function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest }) {
+function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest: rawServerActionsManifest }) {
     const existingSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
+    const serverActionsManifest = {
+        encryptionKey: rawServerActionsManifest.encryptionKey,
+        // Use null-prototypes for the action objects to prevent prototype pollution
+        // from affecting action ID lookups.
+        node: Object.assign(Object.create(null), rawServerActionsManifest.node),
+        edge: Object.assign(Object.create(null), rawServerActionsManifest.edge)
+    };
     if (existingSingleton) {
         existingSingleton.clientReferenceManifestsPerRoute.set((0, _apppaths.normalizeAppPath)(page), clientReferenceManifest);
         existingSingleton.serverActionsManifest = serverActionsManifest;
@@ -6113,6 +6435,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    DynamicHoleKind: function() {
+        return DynamicHoleKind;
+    },
     Postpone: function() {
         return Postpone;
     },
@@ -6143,18 +6468,21 @@ _export(exports, {
     createHangingInputAbortSignal: function() {
         return createHangingInputAbortSignal;
     },
+    createInstantValidationState: function() {
+        return createInstantValidationState;
+    },
     createRenderInBrowserAbortSignal: function() {
         return createRenderInBrowserAbortSignal;
     },
-    delayUntilRuntimeStage: function() {
-        return delayUntilRuntimeStage;
-    },
     formatDynamicAPIAccesses: function() {
         return formatDynamicAPIAccesses;
     },
     getFirstDynamicReason: function() {
         return getFirstDynamicReason;
     },
+    getNavigationDisallowedDynamicReasons: function() {
+        return getNavigationDisallowedDynamicReasons;
+    },
     getStaticShellDisallowedDynamicReasons: function() {
         return getStaticShellDisallowedDynamicReasons;
     },
@@ -6185,12 +6513,18 @@ _export(exports, {
     trackDynamicDataInDynamicRender: function() {
         return trackDynamicDataInDynamicRender;
     },
+    trackDynamicHoleInNavigation: function() {
+        return trackDynamicHoleInNavigation;
+    },
     trackDynamicHoleInRuntimeShell: function() {
         return trackDynamicHoleInRuntimeShell;
     },
     trackDynamicHoleInStaticShell: function() {
         return trackDynamicHoleInStaticShell;
     },
+    trackThrownErrorInNavigation: function() {
+        return trackThrownErrorInNavigation;
+    },
     useDynamicRouteParams: function() {
         return useDynamicRouteParams;
     },
@@ -6208,6 +6542,7 @@ const _boundaryconstants = __webpack_require__(71800);
 const _scheduler = __webpack_require__(31182);
 const _bailouttocsr = __webpack_require__(22105);
 const _invarianterror = __webpack_require__(96042);
+const _boundaryconstants1 = __webpack_require__(65452);
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -6251,6 +6586,7 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
             case 'prerender-legacy':
             case 'prerender-ppr':
             case 'request':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;
@@ -6286,6 +6622,8 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
             case 'request':
                 if (false) {}
                 break;
+            case 'generate-static-params':
+                break;
             default:
                 workUnitStore;
         }
@@ -6320,6 +6658,8 @@ function trackDynamicDataInDynamicRender(workUnitStore) {
         case 'prerender-legacy':
         case 'prerender-ppr':
         case 'prerender-client':
+        case 'validation-client':
+        case 'generate-static-params':
             break;
         case 'request':
             if (false) {}
@@ -6438,7 +6778,7 @@ function consumeDynamicAccess(serverDynamic, clientDynamic) {
 }
 function formatDynamicAPIAccesses(dynamicAccesses) {
     return dynamicAccesses.filter((access)=>typeof access.stack === 'string' && access.stack.length > 0).map(({ expression, stack })=>{
-        stack = stack.split('\n')// Remove the "Error: " prefix from the first line of the stack trace as
+        stack = stack.split('\n') // Remove the "Error: " prefix from the first line of the stack trace as
         // well as the first 4 lines of the stack trace which is the distance
         // from the user code and the `new Error().stack` call.
         .slice(4).filter((line)=>{
@@ -6502,21 +6842,23 @@ function createHangingInputAbortSignal(workUnitStore) {
                 // render the content of this cache as deeply as we can so that we can
                 // suspend as deeply as possible in the tree or not at all if we don't
                 // end up waiting for the input.
-                const runtimeStagePromise = (0, _workunitasyncstorageexternal.getRuntimeStagePromise)(workUnitStore);
-                if (runtimeStagePromise) {
-                    runtimeStagePromise.then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
+                if (workUnitStore.type === 'prerender-runtime' && workUnitStore.stagedRendering) {
+                    const { stagedRendering } = workUnitStore;
+                    stagedRendering.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering)).then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
                 } else {
                     (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
                 }
             }
             return controller.signal;
         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':
             return undefined;
         default:
             workUnitStore;
@@ -6556,6 +6898,10 @@ function useDynamicRouteParams(expression) {
                     }
                     break;
                 }
+            case 'validation-client':
+                {
+                    break;
+                }
             case 'prerender-runtime':
                 throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called during a runtime prerender. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
                     value: "E771",
@@ -6569,6 +6915,12 @@ function useDynamicRouteParams(expression) {
                     enumerable: false,
                     configurable: true
                 });
+            case 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called in \`generateStaticParams\`. Next.js should be preventing ${expression} from being included in server component files statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                    value: "E1130",
+                    enumerable: false,
+                    configurable: true
+                });
             case 'prerender-legacy':
             case 'request':
             case 'unstable-cache':
@@ -6589,6 +6941,10 @@ function useDynamicSearchParams(expression) {
         (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
     }
     switch(workUnitStore.type){
+        case 'validation-client':
+            // During instant validation we try to behave as close to client as possible,
+            // so this shouldn't hang during SSR.
+            return;
         case 'prerender-client':
             {
                 _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
@@ -6621,6 +6977,12 @@ function useDynamicSearchParams(expression) {
                 enumerable: false,
                 configurable: true
             });
+        case 'generate-static-params':
+            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called in \`generateStaticParams\`. Next.js should be preventing ${expression} from being included in server component files statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E1130",
+                enumerable: false,
+                configurable: true
+            });
         case 'request':
             return;
         default:
@@ -6646,6 +7008,7 @@ const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\
 const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
 const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
 const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+const hasInstantValidationBoundaryRegex = new RegExp(`\\n\\s+at ${_boundaryconstants1.INSTANT_VALIDATION_BOUNDARY_NAME}[\\n\\s]`);
 function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
     if (hasOutletRegex.test(componentStack)) {
         // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
@@ -6674,23 +7037,207 @@ function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation,
         return;
     } else {
         const message = `Route "${workStore.route}": Uncached data was accessed outside of ` + '<Suspense>. This delays the entire page from rendering, resulting in a ' + 'slow user experience. Learn more: ' + 'https://nextjs.org/docs/messages/blocking-route';
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1079",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     }
 }
-function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+var DynamicHoleKind = /*#__PURE__*/ function(DynamicHoleKind) {
+    /** We know that this hole is caused by runtime data. */ DynamicHoleKind[DynamicHoleKind["Runtime"] = 1] = "Runtime";
+    /** We know that this hole is caused by dynamic data. */ DynamicHoleKind[DynamicHoleKind["Dynamic"] = 2] = "Dynamic";
+    return DynamicHoleKind;
+}({});
+function createInstantValidationState(createInstantStack) {
+    return {
+        hasDynamicMetadata: false,
+        hasAllowedClientDynamicAboveBoundary: false,
+        dynamicMetadata: null,
+        hasDynamicViewport: false,
+        hasAllowedDynamic: false,
+        dynamicErrors: [],
+        validationPreventingErrors: [],
+        thrownErrorsOutsideBoundary: [],
+        createInstantStack
+    };
+}
+function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidation, clientDynamic, kind, boundaryState) {
     if (hasOutletRegex.test(componentStack)) {
         // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
         return;
-    } else if (hasMetadataRegex.test(componentStack)) {
-        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
-        dynamicValidation.dynamicMetadata = error;
-        return;
+    }
+    if (hasMetadataRegex.test(componentStack)) {
+        const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments.` : `Uncached data or \`connection()\` was accessed inside \`generateMetadata\`.`;
+        const message = `Route "${workStore.route}": ${usageDescription} Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1076",
+            enumerable: false,
+            configurable: true
+        }), componentStack, dynamicValidation.createInstantStack);
+        dynamicValidation.dynamicMetadata = error;
+        return;
+    }
+    if (hasViewportRegex.test(componentStack)) {
+        const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`.` : `Uncached data or \`connection()\` was accessed inside \`generateViewport\`.`;
+        const message = `Route "${workStore.route}": ${usageDescription} This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1086",
+            enumerable: false,
+            configurable: true
+        }), componentStack, dynamicValidation.createInstantStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+    }
+    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
+    if (!boundaryLocation) {
+        // We don't see the validation boundary in the component stack,
+        // so this hole must be coming from a shared parent.
+        // Shared parents are fully resolved and don't have RSC holes,
+        // but they can still suspend in a client component during SSR.
+        // If we managed to render all the validation boundaries, that means
+        // that the client holes aren't blocking validation and we can disregard them.
+        // Note that we don't even care whether they have suspense or not.
+        if (boundaryState.expectedIds.size === boundaryState.renderedIds.size) {
+            dynamicValidation.hasAllowedClientDynamicAboveBoundary = true;
+            dynamicValidation.hasAllowedDynamic = true // Holes outside the boundary contribute to allowing dynamic metadata
+            ;
+            return;
+        } else {
+            // TODO(instant-validation) TODO(NAR-787)
+            // If shared parents blocked us from validating, we should only log
+            // the errors from the innermost (segments), i.e. omit layouts whose
+            // slots managed to render (because clearly they didn't block validation)
+            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because a Client Component in a parent segment prevented the page from rendering.`;
+            const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                value: "E1082",
+                enumerable: false,
+                configurable: true
+            }), componentStack, dynamicValidation.createInstantStack);
+            dynamicValidation.validationPreventingErrors.push(error);
+            return;
+        }
+    } else {
+        // The hole originates inside the validation boundary.
+        //
+        // Check if we have a Suspense above the hole, but below the validation boundary.
+        // If we do, then this dynamic usage wouldn't block a navigation to this subtree.
+        // Conversely, if the nearest suspense is above the validation boundary, then this subtree would block.
+        //
+        // Note that in the component stack, children come before parents.
+        //
+        // Valid:
+        //   ...
+        //   at Suspense
+        //   ...
+        //   at __next_prefetch_validation_boundary__
+        //
+        // Invalid:
+        //   ...
+        //   at __next_prefetch_validation_boundary__
+        //   ...
+        //   at Suspense
+        //
+        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
+        if (suspenseLocation) {
+            if (suspenseLocation.index < boundaryLocation.index) {
+                dynamicValidation.hasAllowedDynamic = true;
+                return;
+            } else {
+            // invalid - fallthrough
+            }
+        }
+    }
+    if (clientDynamic.syncDynamicErrorWithStack) {
+        // This task was the task that called the sync error.
+        const syncError = clientDynamic.syncDynamicErrorWithStack;
+        if (dynamicValidation.createInstantStack !== null && syncError.cause === undefined) {
+            syncError.cause = dynamicValidation.createInstantStack();
+        }
+        dynamicValidation.dynamicErrors.push(syncError);
+        return;
+    }
+    const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`.` : `Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`.`;
+    const message = `Route "${workStore.route}": ${usageDescription} This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
+    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E1078",
+        enumerable: false,
+        configurable: true
+    }), componentStack, dynamicValidation.createInstantStack);
+    dynamicValidation.dynamicErrors.push(error);
+    return;
+}
+function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue, componentStack) {
+    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
+    if (!boundaryLocation) {
+        // There's no validation boundary on the component stack.
+        // This error may have blocked a boundary from rendering.
+        // Wrap the error to provide component context.
+        // This helps for errors from node_modules which would otherwise
+        // have no useful stack information due to ignore-listing,
+        // e.g. next/dynamic with `ssr: false`.
+        const error = addErrorContext(Object.defineProperty(new Error('An error occurred while attempting to validate instant UI. This error may be preventing the validation from completing.', {
+            cause: thrownValue
+        }), "__NEXT_ERROR_CODE", {
+            value: "E1118",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
+        dynamicValidation.thrownErrorsOutsideBoundary.push(error);
+    } else {
+        // There's validation boundary on the component stack,
+        // so we know this error didn't block a validation boundary from rendering.
+        // However, this error might be hiding be hiding dynamic content that would
+        // cause validation to fail.
+        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
+        if (suspenseLocation) {
+            if (suspenseLocation.index < boundaryLocation.index) {
+                // There's a Suspense below the validation boundary but above this error's location.
+                // This subtree can't fail instant validation because any potential
+                // dynamic holes would be guarded by the Suspense anyway,
+                // so we can allow this.
+                return;
+            } else {
+            // invalid - fallthrough
+            }
+        }
+        const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because an error prevented the target segment from rendering.`;
+        const error = addErrorContext(Object.defineProperty(new Error(message, {
+            cause: thrownValue
+        }), "__NEXT_ERROR_CODE", {
+            value: "E1112",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null // TODO(instant-validation-build): conflicting use of cause
+        );
+        dynamicValidation.validationPreventingErrors.push(error);
+    }
+}
+function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+    if (hasOutletRegex.test(componentStack)) {
+        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
+        return;
+    } else if (hasMetadataRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1080",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
+        dynamicValidation.dynamicMetadata = error;
+        return;
     } else if (hasViewportRegex.test(componentStack)) {
+        // TODO(instant-validation): If the page only has holes caused by runtime data,
+        // we won't find out if there's a suspense-above-body and error for dynamic viewport
+        // even if there is in fact a suspense-above-body
         const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1077",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -6709,12 +7256,15 @@ function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValida
         // This task was the task that called the sync error.
         dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
         return;
-    } else {
-        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
-        dynamicValidation.dynamicErrors.push(error);
-        return;
     }
+    const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
+    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E1084",
+        enumerable: false,
+        configurable: true
+    }), componentStack, null);
+    dynamicValidation.dynamicErrors.push(error);
+    return;
 }
 function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidation, clientDynamic) {
     if (hasOutletRegex.test(componentStack)) {
@@ -6722,12 +7272,20 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
         return;
     } else if (hasMetadataRegex.test(componentStack)) {
         const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1085",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicMetadata = error;
         return;
     } else if (hasViewportRegex.test(componentStack)) {
         const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1081",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -6748,7 +7306,11 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
         return;
     } else {
         const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
-        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1083",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     }
@@ -6756,16 +7318,17 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
 /**
  * In dev mode, we prefer using the owner stack, otherwise the provided
  * component stack is used.
- */ function createErrorWithComponentOrOwnerStack(message, componentStack) {
+ *
+ * Accepts an already-created Error so the SWC error-code plugin can see the
+ * `new Error(...)` call at each call site and auto-assign error codes.
+ */ function addErrorContext(error, componentStack, createInstantStack) {
     const ownerStack =  false ? 0 : null;
-    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    if (createInstantStack !== null) {
+        error.cause = createInstantStack();
+    }
     // TODO go back to owner stack here if available. This is temporarily using componentStack to get the right
     //
-    error.stack = error.name + ': ' + message + (ownerStack || componentStack);
+    error.stack = error.name + ': ' + error.message + (ownerStack || componentStack);
     return error;
 }
 var PreludeState = /*#__PURE__*/ function(PreludeState) {
@@ -6776,15 +7339,11 @@ var PreludeState = /*#__PURE__*/ function(PreludeState) {
 }({});
 function logDisallowedDynamicError(workStore, error) {
     console.error(error);
-    if (!workStore.dev) {
-        if (workStore.hasReadableErrorStacks) {
-            console.error(`To get a more detailed stack trace and pinpoint the issue, start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.`);
-        } else {
-            console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
+    if (true) {
+        console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
   - Start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.
   - Rerun the production build with \`next build --debug-prerender\` to generate better stack traces.`);
-        }
-    }
+    } else {}
 }
 function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
     if (serverDynamic.syncDynamicErrorWithStack) {
@@ -6830,8 +7389,8 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
         }
     }
 }
-function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation) {
-    if (dynamicValidation.hasSuspenseAboveBody) {
+function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation, configAllowsBlocking) {
+    if (configAllowsBlocking || dynamicValidation.hasSuspenseAboveBody) {
         // This route has opted into allowing fully dynamic rendering
         // by including a Suspense boundary above the body. In this case
         // a lack of a shell is not considered disallowed so we simply return
@@ -6868,14 +7427,85 @@ function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValid
     // We had a non-empty prelude and there are no dynamic holes
     return [];
 }
-function delayUntilRuntimeStage(prerenderStore, result) {
-    if (prerenderStore.runtimeStagePromise) {
-        return prerenderStore.runtimeStagePromise.then(()=>result);
+function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState) {
+    // If we have errors related to missing samples, those should take precedence over everything else.
+    if (validationSampleTracking) {
+        const { missingSampleErrors } = validationSampleTracking;
+        if (missingSampleErrors.length > 0) {
+            return missingSampleErrors;
+        }
+    }
+    const { validationPreventingErrors } = dynamicValidation;
+    if (validationPreventingErrors.length > 0) {
+        return validationPreventingErrors;
+    }
+    if (boundaryState.renderedIds.size < boundaryState.expectedIds.size) {
+        const { thrownErrorsOutsideBoundary, createInstantStack } = dynamicValidation;
+        if (thrownErrorsOutsideBoundary.length === 0) {
+            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering for an unknown reason.`;
+            const error = createInstantStack !== null ? createInstantStack() : new Error();
+            error.name = 'Error';
+            error.message = message;
+            return [
+                error
+            ];
+        } else if (thrownErrorsOutsideBoundary.length === 1) {
+            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering, likely due to the following error.`;
+            const error = createInstantStack !== null ? createInstantStack() : new Error();
+            error.name = 'Error';
+            error.message = message;
+            return [
+                error,
+                thrownErrorsOutsideBoundary[0]
+            ];
+        } else {
+            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering, likely due to one of the following errors.`;
+            const error = createInstantStack !== null ? createInstantStack() : new Error();
+            error.name = 'Error';
+            error.message = message;
+            return [
+                error,
+                ...thrownErrorsOutsideBoundary
+            ];
+        }
     }
-    return result;
-}
+    // NOTE: We don't care about Suspense above body here,
+    // we're only concerned with the validation boundary
+    if (prelude !== 0) {
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+            return dynamicErrors;
+        }
+        if (prelude === 1) {
+            // If a client component suspended prevented us from rendering a shell
+            // but didn't block validation, we don't require a prelude.
+            if (dynamicValidation.hasAllowedClientDynamicAboveBoundary) {
+                return [];
+            }
+            // If we ever get this far then we messed up the tracking of invalid dynamic.
+            return [
+                Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" failed to render during instant validation and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
+                    value: "E1055",
+                    enumerable: false,
+                    configurable: true
+                })
+            ];
+        }
+    } else {
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+            return dynamicErrors;
+        }
+        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicMetadata) {
+            return [
+                dynamicValidation.dynamicMetadata
+            ];
+        }
+    }
+    // We had a non-empty prelude and there are no dynamic holes
+    return [];
+} //# sourceMappingURL=dynamic-rendering.js.map
 
-//# sourceMappingURL=dynamic-rendering.js.map
 
 /***/ }),
 
@@ -7418,9 +8048,15 @@ _export(exports, {
     createDocumentClosingStream: function() {
         return createDocumentClosingStream;
     },
+    createInstantTestScriptInsertionTransformStream: function() {
+        return createInstantTestScriptInsertionTransformStream;
+    },
     createRootLayoutValidatorStream: function() {
         return createRootLayoutValidatorStream;
     },
+    createRuntimePrefetchTransformStream: function() {
+        return createRuntimePrefetchTransformStream;
+    },
     renderToInitialFizzStream: function() {
         return renderToInitialFizzStream;
     },
@@ -7447,7 +8083,6 @@ const _scheduler = __webpack_require__(31182);
 const _encodedtags = __webpack_require__(29898);
 const _uint8arrayhelpers = __webpack_require__(75099);
 const _constants1 = __webpack_require__(46596);
-const _outputexportprefetchencoding = __webpack_require__(42912);
 const _approuterheaders = __webpack_require__(7162);
 const _cachebustingsearchparam = __webpack_require__(36017);
 function voidCatch() {
@@ -7614,31 +8249,6 @@ function createBufferedTransformStream(options = {}) {
         }
     });
 }
-function createPrefetchCommentStream(isBuildTimePrerendering, buildId) {
-    // Insert an extra comment at the beginning of the HTML document. This must
-    // come after the DOCTYPE, which is inserted by React.
-    //
-    // The first chunk sent by React will contain the doctype. After that, we can
-    // pass through the rest of the chunks as-is.
-    let didTransformFirstChunk = false;
-    return new TransformStream({
-        transform (chunk, controller) {
-            if (isBuildTimePrerendering && !didTransformFirstChunk) {
-                didTransformFirstChunk = true;
-                const decoder = new TextDecoder('utf-8', {
-                    fatal: true
-                });
-                const chunkStr = decoder.decode(chunk, {
-                    stream: true
-                });
-                const updatedChunkStr = (0, _outputexportprefetchencoding.insertBuildIdComment)(chunkStr, buildId);
-                controller.enqueue(encoder.encode(updatedChunkStr));
-                return;
-            }
-            controller.enqueue(chunk);
-        }
-    });
-}
 function renderToInitialFizzStream({ ReactDOMServer, element, streamOptions }) {
     return (0, _tracer.getTracer)().trace(_constants.AppRenderSpan.renderToReadableStream, async ()=>ReactDOMServer.renderToReadableStream(element, streamOptions));
 }
@@ -7828,6 +8438,63 @@ function createClientResumeScriptInsertionTransformStream() {
         }
     });
 }
+function createInstantTestScriptInsertionTransformStream(requestId) {
+    // Kick off a fetch for the static RSC payload. This is the hydration
+    // source for the locked static shell — same as the __NEXT_CLIENT_RESUME
+    // fetch used for fallback routes, but with NEXT_INSTANT_PREFETCH_HEADER
+    // so the server returns static-only data.
+    //
+    // The fetch promise is stored as self.__next_instant_test, which doubles
+    // as the feature flag (truthy = instant test mode). The client processes
+    // this as a fallback prerender payload for hydration.
+    const segmentPath = '/_full';
+    const cacheBustingHeader = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
+    const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
+    // In dev mode, inject self.__next_r (request ID) so that HMR WebSocket
+    // and debug channel initialization don't crash. The static shell
+    // bypasses renderToFizzStream which normally injects this via
+    // bootstrapScriptContent.
+    const requestIdScript = requestId !== null ? `self.__next_r=${JSON.stringify(requestId)};` : '';
+    const INSTANT_TEST_SCRIPT = `<script>${requestIdScript}self.__next_instant_test=fetch(location.pathname+'?${searchStr}',{credentials:'same-origin',headers:{'${_approuterheaders.RSC_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}':'${segmentPath}','${_approuterheaders.NEXT_INSTANT_PREFETCH_HEADER}':'1'}})</script>`;
+    let didAlreadyInsert = false;
+    return new TransformStream({
+        transform (chunk, controller) {
+            if (didAlreadyInsert) {
+                // Already inserted the script into the head. Pass through.
+                controller.enqueue(chunk);
+                return;
+            }
+            // Find the opening <head tag (may have attributes like <head class="...">)
+            const headOpenIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HEAD);
+            if (headOpenIndex === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            // Find the closing > of the <head ...> tag
+            const headCloseAngle = chunk.indexOf(62, headOpenIndex + _encodedtags.ENCODED_TAGS.OPENING.HEAD.length);
+            if (headCloseAngle === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const encodedInsertion = encoder.encode(INSTANT_TEST_SCRIPT);
+            const insertionPoint = headCloseAngle + 1;
+            // e.g.
+            // chunk = <!DOCTYPE html><html><head><meta charset="utf-8">...
+            // insertion = <script>self.__next_instant_test=fetch(...)</script>
+            // output = <!DOCTYPE html><html><head> [ <script>...</script> ] <meta charset="utf-8">...
+            const insertedHeadContent = new Uint8Array(chunk.length + encodedInsertion.length);
+            insertedHeadContent.set(chunk.slice(0, insertionPoint));
+            insertedHeadContent.set(encodedInsertion, insertionPoint);
+            insertedHeadContent.set(chunk.slice(insertionPoint), insertionPoint + encodedInsertion.length);
+            controller.enqueue(insertedHeadContent);
+            didAlreadyInsert = true;
+        },
+        flush (controller) {
+            // Append closing tags so the browser can parse the full document.
+            controller.enqueue(_encodedtags.ENCODED_TAGS.CLOSED.BODY_AND_HTML);
+        }
+    });
+}
 // Suffix after main body content - scripts before </body>,
 // but wait for the major chunks to be enqueued.
 function createDeferredSuffixStream(suffix) {
@@ -7993,6 +8660,35 @@ function createStripDocumentClosingTagsTransform() {
         }
     });
 }
+function createHtmlDataDplIdTransformStream(dplId) {
+    let didTransform = false;
+    return new TransformStream({
+        transform (chunk, controller) {
+            if (didTransform) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const htmlTagIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HTML);
+            if (htmlTagIndex === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            // Insert the data-dpl-id attribute right after "<html "
+            const insertionPoint = htmlTagIndex + _encodedtags.ENCODED_TAGS.OPENING.HTML.length;
+            const attribute = ` data-dpl-id="${dplId}"`;
+            const encodedAttribute = encoder.encode(attribute);
+            const modifiedChunk = new Uint8Array(chunk.length + encodedAttribute.length);
+            // Copy everything before the insertion point
+            modifiedChunk.set(chunk.subarray(0, insertionPoint));
+            // Insert the attribute
+            modifiedChunk.set(encodedAttribute, insertionPoint);
+            // Copy everything after
+            modifiedChunk.set(chunk.subarray(insertionPoint), insertionPoint + encodedAttribute.length);
+            controller.enqueue(modifiedChunk);
+            didTransform = true;
+        }
+    });
+}
 function createRootLayoutValidatorStream() {
     let foundHtml = false;
     let foundBody = false;
@@ -8030,7 +8726,7 @@ function chainTransformers(readable, transformers) {
     }
     return stream;
 }
-async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, isBuildTimePrerendering, buildId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
+async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
     // Suffix itself might contain close tags at the end, so we need to split it.
     const suffixUnclosed = suffix ? suffix.split(CLOSE_TAG, 1)[0] : null;
     if (isStaticGeneration) {
@@ -8044,8 +8740,8 @@ async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isS
     return chainTransformers(renderStream, [
         // Buffer everything to avoid flushing too frequently
         createBufferedTransformStream(),
-        // Add build id comment to start of the HTML document (in export mode)
-        createPrefetchCommentStream(isBuildTimePrerendering, buildId),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
         // Transform metadata
         createMetadataTransformStream(getServerInsertedMetadata),
         // Insert suffix content
@@ -8062,50 +8758,183 @@ async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isS
         createHeadInsertionTransformStream(getServerInsertedHTML)
     ]);
 }
-async function continueDynamicPrerender(prerenderStream, { getServerInsertedHTML, getServerInsertedMetadata }) {
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream()).pipeThrough(createStripDocumentClosingTagsTransform())// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata));
-}
-async function continueStaticPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, isBuildTimePrerendering, buildId }) {
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Add build id comment to start of the HTML document (in export mode)
-    .pipeThrough(createPrefetchCommentStream(isBuildTimePrerendering, buildId))// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, true))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
-}
-async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, isBuildTimePrerendering, buildId }) {
+async function continueDynamicPrerender(prerenderStream, { getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        createStripDocumentClosingTagsTransform(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata)
+    ]);
+}
+async function continueStaticPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Add build id comment to start of the HTML document (in export mode)
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, true),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
+}
+async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
     // Same as `continueStaticPrerender`, but also inserts an additional script
     // to instruct the client to start fetching the hydration data as early
     // as possible.
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Add build id comment to start of the HTML document (in export mode)
-    .pipeThrough(createPrefetchCommentStream(isBuildTimePrerendering, buildId))// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Insert the client resume script into the head
-    .pipeThrough(createClientResumeScriptInsertionTransformStream())// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, true))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
-}
-async function continueDynamicHTMLResume(renderStream, { delayDataUntilFirstHtmlChunk, inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata }) {
-    return renderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, delayDataUntilFirstHtmlChunk))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Insert the client resume script into the head
+        createClientResumeScriptInsertionTransformStream(),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, true),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
+}
+async function continueDynamicHTMLResume(renderStream, { delayDataUntilFirstHtmlChunk, inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(renderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, delayDataUntilFirstHtmlChunk),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
 function createDocumentClosingStream() {
     return streamFromString(CLOSE_TAG);
 }
+function createRuntimePrefetchTransformStream(sentinel, isPartial, staleTime) {
+    const enc = new TextEncoder();
+    // Search for: [<sentinel>]
+    // Replace with: [<isPartial>,<staleTime>]
+    const search = enc.encode(`[${sentinel}]`);
+    const first = search[0];
+    const replace = enc.encode(`[${isPartial},${staleTime}]`);
+    const searchLen = search.length;
+    let currentChunk = null;
+    let found = false;
+    function processChunk(controller, nextChunk) {
+        if (found) {
+            if (nextChunk) {
+                controller.enqueue(nextChunk);
+            }
+            return;
+        }
+        if (currentChunk) {
+            // We can't search past the index that can contain a full match
+            let exclusiveUpperBound = currentChunk.length - (searchLen - 1);
+            if (nextChunk) {
+                // If we have any overflow bytes we can search up to the chunk's final byte
+                exclusiveUpperBound += Math.min(nextChunk.length, searchLen - 1);
+            }
+            if (exclusiveUpperBound < 1) {
+                // we can't match the current chunk.
+                controller.enqueue(currentChunk);
+                currentChunk = nextChunk // advance so we don't process this chunk again
+                ;
+                return;
+            }
+            let currentIndex = currentChunk.indexOf(first);
+            // check the current candidate match if it is within the bounds of our search space for the currentChunk
+            candidateLoop: while(-1 < currentIndex && currentIndex < exclusiveUpperBound){
+                // We already know index 0 matches because we used indexOf to find the candidateIndex so we start at index 1
+                let matchIndex = 1;
+                while(matchIndex < searchLen){
+                    const candidateIndex = currentIndex + matchIndex;
+                    const candidateValue = candidateIndex < currentChunk.length ? currentChunk[candidateIndex] : nextChunk[candidateIndex - currentChunk.length];
+                    if (candidateValue !== search[matchIndex]) {
+                        // No match, reset and continue the search from the next position
+                        currentIndex = currentChunk.indexOf(first, currentIndex + 1);
+                        continue candidateLoop;
+                    }
+                    matchIndex++;
+                }
+                // We found a complete match. currentIndex is our starting point to replace the value.
+                found = true;
+                // enqueue everything up to the match
+                controller.enqueue(currentChunk.subarray(0, currentIndex));
+                // enqueue the replacement value
+                controller.enqueue(replace);
+                // If there are bytes in the currentChunk after the match enqueue them
+                if (currentIndex + searchLen < currentChunk.length) {
+                    controller.enqueue(currentChunk.slice(currentIndex + searchLen));
+                }
+                // If we have a next chunk we enqueue it now
+                if (nextChunk) {
+                    // if replacement spills over to the next chunk we first exclude the replaced bytes
+                    const overflowBytes = currentIndex + searchLen - currentChunk.length;
+                    const truncatedChunk = overflowBytes > 0 ? nextChunk.subarray(overflowBytes) : nextChunk;
+                    controller.enqueue(truncatedChunk);
+                }
+                // We are now in found mode and don't need to track currentChunk anymore
+                currentChunk = null;
+                return;
+            }
+            // No match found in this chunk, emit it and wait for the next one
+            controller.enqueue(currentChunk);
+        }
+        // Advance to the next chunk
+        currentChunk = nextChunk;
+    }
+    return new TransformStream({
+        transform (chunk, controller) {
+            processChunk(controller, chunk);
+        },
+        flush (controller) {
+            processChunk(controller, null);
+        }
+    });
+}
 
 //# sourceMappingURL=node-web-streams-helper.js.map
 
 /***/ }),
 
+/***/ 65452:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({
+    value: true
+}));
+Object.defineProperty(exports, "INSTANT_VALIDATION_BOUNDARY_NAME", ({
+    enumerable: true,
+    get: function() {
+        return INSTANT_VALIDATION_BOUNDARY_NAME;
+    }
+}));
+const INSTANT_VALIDATION_BOUNDARY_NAME = '__next_instant_validation_boundary__';
+
+//# sourceMappingURL=boundary-constants.js.map
+
+/***/ }),
+
 /***/ 66849:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
@@ -8860,6 +9689,7 @@ async function toResponseCacheEntry(response) {
         isMiss: response.isMiss,
         isStale: response.isStale,
         cacheControl: response.cacheControl,
+        isFallback: response.isFallback,
         value: ((_response_value = response.value) == null ? void 0 : _response_value.kind) === _types.CachedRouteKind.PAGES ? {
             kind: _types.CachedRouteKind.PAGES,
             html: _renderresult.default.fromStatic(response.value.html, _constants.HTML_CONTENT_TYPE_HEADER),
@@ -9187,6 +10017,11 @@ _export(exports, {
 function indexOfUint8Array(a, b) {
     if (b.length === 0) return 0;
     if (a.length === 0 || b.length > a.length) return -1;
+    // Use Node's native implementation when available.
+    if (typeof Buffer !== 'undefined') {
+        const haystack = Buffer.isBuffer(a) ? a : Buffer.from(a.buffer, a.byteOffset, a.byteLength);
+        return haystack.indexOf(b);
+    }
     // start iterating through `a`
     for(let i = 0; i <= a.length - b.length; i++){
         let completeMatch = true;
@@ -9216,8 +10051,8 @@ function removeFromUint8Array(a, b) {
     if (tagIndex === 0) return a.subarray(b.length);
     if (tagIndex > -1) {
         const removed = new Uint8Array(a.length - b.length);
-        removed.set(a.slice(0, tagIndex));
-        removed.set(a.slice(tagIndex + b.length), tagIndex);
+        removed.set(a.subarray(0, tagIndex));
+        removed.set(a.subarray(tagIndex + b.length), tagIndex);
         return removed;
     } else {
         return a;
@@ -9300,22 +10135,6 @@ function cloneResponse(original) {
         enumerable: true,
         writable: false
     });
-    // The Fetch Standard allows users to skip consuming the response body by
-    // relying on garbage collection to release connection resources.
-    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
-    //
-    // To cancel the stream you then need to cancel both resulting branches.
-    // Teeing a stream will generally lock it for the duration, preventing other
-    // readers from locking it.
-    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
-    // cloned2 is stored in a react cache and cloned for subsequent requests.
-    // It is the original request, and is is garbage collected by a
-    // FinalizationRegistry in Undici, but since we're tee-ing the stream
-    // ourselves, we need to cancel clone1's stream (the response returned from
-    // our dedupe fetch) when clone1 is reclaimed, otherwise we leak memory.
-    if (registry && cloned1.body) {
-        registry.register(cloned1, new WeakRef(cloned1.body));
-    }
     const cloned2 = new Response(body2, {
         status: original.status,
         statusText: original.statusText,
@@ -9328,6 +10147,22 @@ function cloneResponse(original) {
         enumerable: true,
         writable: false
     });
+    // The Fetch Standard allows users to skip consuming the response body by
+    // relying on garbage collection to release connection resources.
+    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
+    //
+    // To cancel the stream you then need to cancel both resulting branches.
+    // Teeing a stream will generally lock it for the duration, preventing other
+    // readers from locking it.
+    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
+    if (registry) {
+        if (cloned1.body) {
+            registry.register(cloned1, new WeakRef(cloned1.body));
+        }
+        if (cloned2.body) {
+            registry.register(cloned2, new WeakRef(cloned2.body));
+        }
+    }
     return [
         cloned1,
         cloned2
@@ -10360,7 +11195,7 @@ async function createCachedPrerenderResponse(res, cacheKey, incrementalCacheCont
         statusText: res.statusText
     });
 }
-async function createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheContext, incrementalCache, serverComponentsHmrCache, revalidate, input, handleUnlock) {
+async function createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheContext, incrementalCache, serverComponentsHmrCache, revalidate, input, handleUnlock, signal) {
     // We're cloning the response using this utility because there exists a bug in
     // the undici library around response cloning. See the following pull request
     // for more details: https://github.com/vercel/next.js/pull/73274
@@ -10384,7 +11219,12 @@ async function createCachedDynamicResponse(workStore, res, cacheKey, incremental
                 revalidate
             }, incrementalCacheContext);
         }
-    }).catch((error)=>console.warn(`Failed to set fetch cache`, input, error)).finally(handleUnlock);
+    }).catch((error)=>{
+        // Don't warn if the request was aborted intentionally.
+        if (!(signal == null ? void 0 : signal.aborted)) {
+            console.warn(`Failed to set fetch cache`, input, error);
+        }
+    }).finally(handleUnlock);
     const pendingRevalidateKey = `cache-set-${cacheKey}`;
     const pendingRevalidates = workStore.pendingRevalidates ??= {};
     let pendingRevalidatePromise = Promise.resolve();
@@ -10487,6 +11327,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     case 'prerender-runtime':
                     // TODO: Stop accumulating tags in client prerender. (fallthrough)
                     case 'prerender-client':
+                    case 'validation-client':
                     case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'cache':
@@ -10495,6 +11336,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'request':
                     case 'unstable-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -10522,12 +11364,14 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'prerender':
                     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':
                         break;
                     default:
                         workUnitStore;
@@ -10539,8 +11383,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
             let cacheWarning;
             if (typeof currentFetchCacheConfig === 'string' && typeof currentFetchRevalidate !== 'undefined') {
                 // If the revalidate value conflicts with the cache value, we should warn the user and unset the conflicting values.
-                const isConflictingRevalidate = // revalidate: 0 and cache: force-cache
-                currentFetchCacheConfig === 'force-cache' && currentFetchRevalidate === 0 || // revalidate: >0 or revalidate: false and cache: no-store
+                const isConflictingRevalidate = currentFetchCacheConfig === 'force-cache' && currentFetchRevalidate === 0 || // revalidate: >0 or revalidate: false and cache: no-store
                 currentFetchCacheConfig === 'no-store' && (currentFetchRevalidate > 0 || currentFetchRevalidate === false);
                 if (isConflictingRevalidate) {
                     cacheWarning = `Specified "cache: ${currentFetchCacheConfig}" and "revalidate: ${currentFetchRevalidate}", only one should be specified.`;
@@ -10548,8 +11391,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     currentFetchRevalidate = undefined;
                 }
             }
-            const hasExplicitFetchCacheOptOut = // fetch config itself signals not to cache
-            currentFetchCacheConfig === 'no-cache' || currentFetchCacheConfig === 'no-store' || // the fetch isn't explicitly caching and the segment level cache config signals not to cache
+            const hasExplicitFetchCacheOptOut = currentFetchCacheConfig === 'no-cache' || currentFetchCacheConfig === 'no-store' || // the fetch isn't explicitly caching and the segment level cache config signals not to cache
             // note: `pageFetchCacheMode` is also set by being in an unstable_cache context.
             pageFetchCacheMode === 'force-no-store' || pageFetchCacheMode === 'only-no-store';
             // If no explicit fetch cache mode is set, but dynamic = `force-dynamic` is set,
@@ -10558,8 +11400,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
             // fine-grained. Top-level modes are responsible for setting reasonable defaults for the
             // other configurations.
             const noFetchConfigAndForceDynamic = !pageFetchCacheMode && !currentFetchCacheConfig && !currentFetchRevalidate && workStore.forceDynamic;
-            if (// force-cache was specified without a revalidate value. We set the revalidate value to false
-            // which will signal the cache to not revalidate
+            if (// which will signal the cache to not revalidate
             currentFetchCacheConfig === 'force-cache' && typeof currentFetchRevalidate === 'undefined') {
                 currentFetchRevalidate = false;
             } else if (hasExplicitFetchCacheOptOut || noFetchConfigAndForceDynamic) {
@@ -10585,8 +11426,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
          *    - A fetch revalidate value is not set in the fetch call (fetch(url, { revalidate: ... }))
          * - OR the fetch comes after a configuration that triggered dynamic rendering (e.g., reading cookies())
          *   and the fetch was considered uncacheable (e.g., POST method or has authorization headers)
-         */ const hasNoExplicitCacheConfig = // eslint-disable-next-line eqeqeq
-            pageFetchCacheMode == undefined && // eslint-disable-next-line eqeqeq
+         */ const hasNoExplicitCacheConfig = pageFetchCacheMode == undefined && // eslint-disable-next-line eqeqeq
             (currentFetchCacheConfig == undefined || // when considering whether to opt into the default "no-cache" fetch semantics,
             // a "default" cache config should be treated the same as no cache config
             currentFetchCacheConfig === 'default') && // eslint-disable-next-line eqeqeq
@@ -10618,6 +11458,8 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             cacheSignal = null;
                         }
                         return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
+                    case 'validation-client':
+                        break;
                     case 'request':
                         if (false) {}
                         break;
@@ -10626,6 +11468,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                     case 'cache':
                     case 'private-cache':
                     case 'unstable-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -10697,8 +11540,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
             } else if (!cacheReason) {
                 cacheReason = `revalidate: ${finalRevalidate}`;
             }
-            if (// when force static is configured we don't bail from
-            // `revalidate: 0` values
+            if (// `revalidate: 0` values
             !(workStore.forceStatic && finalRevalidate === 0) && // we don't consider autoNoCache to switch to dynamic for ISR
             !autoNoCache && // If the revalidate value isn't currently set or the value is less
             // than the current revalidate value, we should update the revalidate
@@ -10712,6 +11554,12 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'prerender':
                             case 'prerender-client':
                             case 'prerender-runtime':
+                            // If we're in an instant validation, a dynamic fetch won't
+                            // have time to resolve during the validation prerender anyway,
+                            // so we leave it hanging. This can cause false negatives in shared parents,
+                            // but we accept that for now, because client data fetching is non-idiomatic.
+                            // eslint-disable-next-line no-fallthrough
+                            case 'validation-client':
                                 if (cacheSignal) {
                                     cacheSignal.endRead();
                                     cacheSignal = null;
@@ -10725,6 +11573,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                                 break;
                             default:
                                 workUnitStore;
@@ -10754,10 +11603,12 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         break;
                     case 'prerender':
                     case 'prerender-client':
+                    case 'validation-client':
                     case 'prerender-runtime':
                     case 'prerender-ppr':
                     case 'prerender-legacy':
                     case 'unstable-cache':
+                    case 'generate-static-params':
                         break;
                     default:
                         workUnitStore;
@@ -10832,7 +11683,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         });
                     }
                     if (res.status === 200 && incrementalCache && cacheKey && (isCacheableRevalidate || serverComponentsHmrCache)) {
-                        const normalizedRevalidate = finalRevalidate >= _constants1.INFINITE_CACHE ? _constants1.CACHE_ONE_YEAR : finalRevalidate;
+                        const normalizedRevalidate = finalRevalidate >= _constants1.INFINITE_CACHE ? _constants1.CACHE_ONE_YEAR_SECONDS : finalRevalidate;
                         const incrementalCacheConfig = isCacheableRevalidate ? {
                             fetchCache: true,
                             fetchUrl,
@@ -10843,6 +11694,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         switch(workUnitStore == null ? void 0 : workUnitStore.type){
                             case 'prerender':
                             case 'prerender-client':
+                            case 'validation-client':
                             case 'prerender-runtime':
                                 return createCachedPrerenderResponse(res, cacheKey, incrementalCacheConfig, incrementalCache, normalizedRevalidate, handleUnlock);
                             case 'request':
@@ -10853,8 +11705,9 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                             case undefined:
-                                return createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheConfig, incrementalCache, serverComponentsHmrCache, normalizedRevalidate, input, handleUnlock);
+                                return createCachedDynamicResponse(workStore, res, cacheKey, incrementalCacheConfig, incrementalCache, serverComponentsHmrCache, normalizedRevalidate, input, handleUnlock, getRequestMeta('signal'));
                             default:
                                 workUnitStore;
                         }
@@ -10891,6 +11744,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                         switch(workUnitStore.type){
                             case 'prerender':
                             case 'prerender-client':
+                            case 'validation-client':
                             case 'prerender-runtime':
                                 // We sometimes use the cache to dedupe fetches that do not
                                 // specify a cache configuration. In these cases we want to
@@ -10907,6 +11761,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                                 break;
                             default:
                                 workUnitStore;
@@ -10980,6 +11835,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'prerender':
                             case 'prerender-client':
                             case 'prerender-runtime':
+                            case 'validation-client':
                                 if (cacheSignal) {
                                     cacheSignal.endRead();
                                     cacheSignal = null;
@@ -10993,6 +11849,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             case 'cache':
                             case 'private-cache':
                             case 'unstable-cache':
+                            case 'generate-static-params':
                                 break;
                             default:
                                 workUnitStore;
@@ -11010,6 +11867,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                 case 'prerender':
                                 case 'prerender-client':
                                 case 'prerender-runtime':
+                                case 'validation-client':
                                     return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
                                 case 'request':
                                     if (false) {}
@@ -11019,6 +11877,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                 case 'unstable-cache':
                                 case 'prerender-legacy':
                                 case 'prerender-ppr':
+                                case 'generate-static-params':
                                     break;
                                 default:
                                     workUnitStore;
@@ -11055,7 +11914,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 // available we construct manually cloned Response objects with the
                 // body as an ArrayBuffer. This will be resolvable in a microtask
                 // making it compatible with cacheComponents.
-                const pendingResponse = doOriginalFetch(true, cacheReasonOverride)// We're cloning the response using this utility because there
+                const pendingResponse = doOriginalFetch(true, cacheReasonOverride) // We're cloning the response using this utility because there
                 // exists a bug in the undici library around response cloning.
                 // See the following pull request for more details:
                 // https://github.com/vercel/next.js/pull/73274
@@ -11133,9 +11992,8 @@ function getTimeoutBoundary() {
         });
     }
     return currentTimeoutBoundary;
-}
+} //# sourceMappingURL=patch-fetch.js.map
 
-//# sourceMappingURL=patch-fetch.js.map
 
 /***/ }),
 
@@ -11267,6 +12125,15 @@ class RenderResult {
         }
     }
     /**
+   * Pipes the response through a transform stream. This converts the response
+   * to a single readable stream (chaining if needed) and pipes it through the
+   * provided transform.
+   *
+   * @param transform The transform stream to pipe through
+   */ pipeThrough(transform) {
+        this.response = this.readable.pipeThrough(transform);
+    }
+    /**
    * Unshifts a new stream to the response. This will convert the response to an
    * array of streams if it is not already one and will add the new stream to
    * the start of the array. When this response is piped, all of the streams
@@ -11599,7 +12466,7 @@ var IncrementalCacheKind = /*#__PURE__*/ function(IncrementalCacheKind) {
 /***/ }),
 
 /***/ 99887:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
@@ -11614,6 +12481,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    delayUntilRuntimeStage: function() {
+        return delayUntilRuntimeStage;
+    },
+    getRuntimeStage: function() {
+        return getRuntimeStage;
+    },
     isHangingPromiseRejectionError: function() {
         return isHangingPromiseRejectionError;
     },
@@ -11624,6 +12497,7 @@ _export(exports, {
         return makeHangingPromise;
     }
 });
+const _stagedrendering = __webpack_require__(17535);
 function isHangingPromiseRejectionError(err) {
     if (typeof err !== 'object' || err === null || !('digest' in err)) {
         return false;
@@ -11682,6 +12556,19 @@ function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
         }, 0);
     });
 }
+function getRuntimeStage(stagedRendering) {
+    if (stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyRuntime) {
+        return _stagedrendering.RenderStage.EarlyRuntime;
+    }
+    return _stagedrendering.RenderStage.Runtime;
+}
+function delayUntilRuntimeStage(prerenderStore, result) {
+    const { stagedRendering } = prerenderStore;
+    if (!stagedRendering) {
+        return result;
+    }
+    return stagedRendering.waitForStage(getRuntimeStage(stagedRendering)).then(()=>result);
+}
 
 //# sourceMappingURL=dynamic-rendering-utils.js.map