@iblai/web-utils 1.11.8 → 1.11.10

package/dist/index.esm.js

@@ -1099,6 +1099,13 @@ const MENTOR_AI_CONFIG = {
             description: "Allow users to report inappropriate content.",
             type: "boolean",
         },
+        {
+            slug: "enable_chat_history_export",
+            label: "Chat History Export",
+            defaultValue: true,
+            description: "Allow users to export their chat history. When off, the export option is hidden from users.",
+            type: "boolean",
+        },
         {
             slug: "help_center_url",
             label: "Help Center URL",
@@ -10387,7 +10394,7 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
      * Returns the mentor object if found, undefined otherwise
      */
     async function determineMentorToRedirectTo() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         setIsLoading(true);
         try {
             // Get the user's recent mentors
@@ -10422,9 +10429,9 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
             console.log("[determineMentorToRedirectTo] starredMentors ", starredMentors);
             if (starredMentors && starredMentors.length > 0) {
                 const starredMentor = starredMentors[0];
-                // @ts-expect-error - mentor is not part of the starred mentor object
-                if ((starredMentor === null || starredMentor === void 0 ? void 0 : starredMentor.unique_id) || (starredMentor === null || starredMentor === void 0 ? void 0 : starredMentor.mentor)) {
-                    return starredMentor;
+                const uniqueId = (_a = starredMentor === null || starredMentor === void 0 ? void 0 : starredMentor.unique_id) !== null && _a !== void 0 ? _a : starredMentor === null || starredMentor === void 0 ? void 0 : starredMentor.mentor;
+                if (uniqueId) {
+                    return { ...starredMentor, unique_id: uniqueId };
                 }
             }
             console.log("[determineMentorToRedirectTo] recentMentors ", recentMentors);
@@ -10441,12 +10448,12 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
                 orderBy: "recently_accessed_at",
             });
             console.log("[determineMentorToRedirectTo] recentMentorsResult ", recentMentorsResult);
-            recentMentors = ((_a = recentMentorsResult.data) === null || _a === void 0 ? void 0 : _a.results) || [];
+            recentMentors = ((_b = recentMentorsResult.data) === null || _b === void 0 ? void 0 : _b.results) || [];
             // Check if we found recent mentors for the tenant
             if (recentMentors.length > 0) {
                 console.log("found recent mentor", JSON.stringify({
-                    selectedMentorId: (_b = recentMentors[0]) === null || _b === void 0 ? void 0 : _b.unique_id,
-                    mentorName: (_c = recentMentors[0]) === null || _c === void 0 ? void 0 : _c.name,
+                    selectedMentorId: (_c = recentMentors[0]) === null || _c === void 0 ? void 0 : _c.unique_id,
+                    mentorName: (_d = recentMentors[0]) === null || _d === void 0 ? void 0 : _d.name,
                     tenantKey,
                 }));
                 return recentMentors[0];
@@ -10462,7 +10469,7 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
                 limit: QUERY_LIMIT,
                 orderBy: "recently_accessed_at",
             });
-            const featuredMentors = ((_d = featuredMentorsResult.data) === null || _d === void 0 ? void 0 : _d.results) || [];
+            const featuredMentors = ((_e = featuredMentorsResult.data) === null || _e === void 0 ? void 0 : _e.results) || [];
             console.log("featured mentors fetched", {
                 count: featuredMentors.length,
                 mentorIds: featuredMentors.map((m) => m === null || m === void 0 ? void 0 : m.unique_id),
@@ -10506,8 +10513,8 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
                 }
                 // If no default mentor, select the first featured mentor
                 console.log("found first featured mentor", {
-                    mentorId: (_e = featuredMentors[0]) === null || _e === void 0 ? void 0 : _e.unique_id,
-                    mentorName: (_f = featuredMentors[0]) === null || _f === void 0 ? void 0 : _f.name,
+                    mentorId: (_f = featuredMentors[0]) === null || _f === void 0 ? void 0 : _f.unique_id,
+                    mentorName: (_g = featuredMentors[0]) === null || _g === void 0 ? void 0 : _g.name,
                 });
                 return featuredMentors[0];
             }
@@ -10522,7 +10529,7 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
                 limit: QUERY_LIMIT,
                 orderBy: "recently_accessed_at",
             });
-            const nonFeaturedMentors = ((_g = nonFeaturedMentorsResult.data) === null || _g === void 0 ? void 0 : _g.results) || [];
+            const nonFeaturedMentors = ((_h = nonFeaturedMentorsResult.data) === null || _h === void 0 ? void 0 : _h.results) || [];
             console.log("non-featured mentors fetched", {
                 count: nonFeaturedMentors.length,
                 mentorIds: nonFeaturedMentors.map((m) => m === null || m === void 0 ? void 0 : m.unique_id),
@@ -10530,8 +10537,8 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
             // Check if we found non-featured mentors
             if (nonFeaturedMentors.length > 0) {
                 console.log("found first non-featured mentor", {
-                    mentorId: (_h = nonFeaturedMentors[0]) === null || _h === void 0 ? void 0 : _h.unique_id,
-                    mentorName: (_j = nonFeaturedMentors[0]) === null || _j === void 0 ? void 0 : _j.name,
+                    mentorId: (_j = nonFeaturedMentors[0]) === null || _j === void 0 ? void 0 : _j.unique_id,
+                    mentorName: (_k = nonFeaturedMentors[0]) === null || _k === void 0 ? void 0 : _k.name,
                 });
                 return nonFeaturedMentors[0];
             }
@@ -10552,7 +10559,7 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
                     // @ts-expect-error - userId is passed but not in generated API types
                     userId: username,
                 });
-                const seededMentorsDetails = (_k = seedMentorsResult.data) === null || _k === void 0 ? void 0 : _k.detail;
+                const seededMentorsDetails = (_l = seedMentorsResult.data) === null || _l === void 0 ? void 0 : _l.detail;
                 console.log("mentor seeding completed", {
                     success: !!seededMentorsDetails,
                     details: seededMentorsDetails,
@@ -10566,15 +10573,15 @@ function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redi
                         username,
                         limit: QUERY_LIMIT,
                     });
-                    const featuredMentorsAfterSeed = ((_l = featuredMentorsAfterSeedResult.data) === null || _l === void 0 ? void 0 : _l.results) || [];
+                    const featuredMentorsAfterSeed = ((_m = featuredMentorsAfterSeedResult.data) === null || _m === void 0 ? void 0 : _m.results) || [];
                     console.log("featured mentors after seeding", {
                         count: featuredMentorsAfterSeed.length,
                         mentorIds: featuredMentorsAfterSeed.map((m) => m === null || m === void 0 ? void 0 : m.unique_id),
                     });
                     if (featuredMentorsAfterSeed.length > 0) {
                         console.log("found seeded mentor", {
-                            mentorId: (_m = featuredMentorsAfterSeed[0]) === null || _m === void 0 ? void 0 : _m.unique_id,
-                            mentorName: (_o = featuredMentorsAfterSeed[0]) === null || _o === void 0 ? void 0 : _o.name,
+                            mentorId: (_o = featuredMentorsAfterSeed[0]) === null || _o === void 0 ? void 0 : _o.unique_id,
+                            mentorName: (_p = featuredMentorsAfterSeed[0]) === null || _p === void 0 ? void 0 : _p.name,
                         });
                         return featuredMentorsAfterSeed[0];
                     }
@@ -15825,6 +15832,9 @@ function requireDynamicRenderingUtils () {
 		    isHangingPromiseRejectionError: function() {
 		        return isHangingPromiseRejectionError;
 		    },
+		    makeDevtoolsIOAwarePromise: function() {
+		        return makeDevtoolsIOAwarePromise;
+		    },
 		    makeHangingPromise: function() {
 		        return makeHangingPromise;
 		    }
@@ -15837,17 +15847,17 @@ function requireDynamicRenderingUtils () {
 		}
 		const HANGING_PROMISE_REJECTION = 'HANGING_PROMISE_REJECTION';
 		class HangingPromiseRejectionError extends Error {
-		    constructor(expression){
-		        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context.`), this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
+		    constructor(route, expression){
+		        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${route}".`), this.route = route, this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
 		    }
 		}
 		const abortListenersBySignal = new WeakMap();
-		function makeHangingPromise(signal, expression) {
+		function makeHangingPromise(signal, route, expression) {
 		    if (signal.aborted) {
-		        return Promise.reject(new HangingPromiseRejectionError(expression));
+		        return Promise.reject(new HangingPromiseRejectionError(route, expression));
 		    } else {
 		        const hangingPromise = new Promise((_, reject)=>{
-		            const boundRejection = reject.bind(null, new HangingPromiseRejectionError(expression));
+		            const boundRejection = reject.bind(null, new HangingPromiseRejectionError(route, expression));
 		            let currentListeners = abortListenersBySignal.get(signal);
 		            if (currentListeners) {
 		                currentListeners.push(boundRejection);
@@ -15873,6 +15883,16 @@ function requireDynamicRenderingUtils () {
 		    }
 		}
 		function ignoreReject() {}
+		function makeDevtoolsIOAwarePromise(underlying) {
+		    // in React DevTools if we resolve in a setTimeout we will observe
+		    // the promise resolution as something that can suspend a boundary or root.
+		    return new Promise((resolve)=>{
+		        // Must use setTimeout to be considered IO React DevTools. setImmediate will not work.
+		        setTimeout(()=>{
+		            resolve(underlying);
+		        }, 0);
+		    });
+		}
 
 		
 	} (dynamicRenderingUtils));
@@ -16134,6 +16154,9 @@ function requireAppRouterHeaders () {
 		    FLIGHT_HEADERS: function() {
 		        return FLIGHT_HEADERS;
 		    },
+		    NEXT_ACTION_NOT_FOUND_HEADER: function() {
+		        return NEXT_ACTION_NOT_FOUND_HEADER;
+		    },
 		    NEXT_DID_POSTPONE_HEADER: function() {
 		        return NEXT_DID_POSTPONE_HEADER;
 		    },
@@ -16177,14 +16200,14 @@ function requireAppRouterHeaders () {
 		        return RSC_HEADER;
 		    }
 		});
-		const RSC_HEADER = 'RSC';
-		const ACTION_HEADER = 'Next-Action';
-		const NEXT_ROUTER_STATE_TREE_HEADER = 'Next-Router-State-Tree';
-		const NEXT_ROUTER_PREFETCH_HEADER = 'Next-Router-Prefetch';
-		const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'Next-Router-Segment-Prefetch';
-		const NEXT_HMR_REFRESH_HEADER = 'Next-HMR-Refresh';
+		const RSC_HEADER = 'rsc';
+		const ACTION_HEADER = 'next-action';
+		const NEXT_ROUTER_STATE_TREE_HEADER = 'next-router-state-tree';
+		const NEXT_ROUTER_PREFETCH_HEADER = 'next-router-prefetch';
+		const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'next-router-segment-prefetch';
+		const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh';
 		const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__';
-		const NEXT_URL = 'Next-Url';
+		const NEXT_URL = 'next-url';
 		const RSC_CONTENT_TYPE_HEADER = 'text/x-component';
 		const FLIGHT_HEADERS = [
 		    RSC_HEADER,
@@ -16199,6 +16222,7 @@ function requireAppRouterHeaders () {
 		const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path';
 		const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query';
 		const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender';
+		const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found';
 
 		if ((typeof exports$1.default === 'function' || (typeof exports$1.default === 'object' && exports$1.default !== null)) && typeof exports$1.default.__esModule === 'undefined') {
 		  Object.defineProperty(exports$1.default, '__esModule', { value: true });
@@ -16211,6 +16235,35 @@ function requireAppRouterHeaders () {
 	return appRouterHeaders.exports;
 }
 
+var invariantError = {};
+
+var hasRequiredInvariantError;
+
+function requireInvariantError () {
+	if (hasRequiredInvariantError) return invariantError;
+	hasRequiredInvariantError = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports$1, "InvariantError", {
+		    enumerable: true,
+		    get: function() {
+		        return InvariantError;
+		    }
+		});
+		class InvariantError extends Error {
+		    constructor(message, options){
+		        super("Invariant: " + (message.endsWith('.') ? message : message + '.') + " This is a bug in Next.js.", options);
+		        this.name = 'InvariantError';
+		    }
+		}
+
+		
+	} (invariantError));
+	return invariantError;
+}
+
 var hasRequiredWorkUnitAsyncStorage_external;
 
 function requireWorkUnitAsyncStorage_external () {
@@ -16227,12 +16280,12 @@ function requireWorkUnitAsyncStorage_external () {
 		    });
 		}
 		_export(exports$1, {
+		    getCacheSignal: function() {
+		        return getCacheSignal;
+		    },
 		    getDraftModeProviderForCacheScope: function() {
 		        return getDraftModeProviderForCacheScope;
 		    },
-		    getExpectedRequestStore: function() {
-		        return getExpectedRequestStore;
-		    },
 		    getHmrRefreshHash: function() {
 		        return getHmrRefreshHash;
 		    },
@@ -16242,49 +16295,28 @@ function requireWorkUnitAsyncStorage_external () {
 		    getRenderResumeDataCache: function() {
 		        return getRenderResumeDataCache;
 		    },
+		    getRuntimeStagePromise: function() {
+		        return getRuntimeStagePromise;
+		    },
+		    getServerComponentsHmrCache: function() {
+		        return getServerComponentsHmrCache;
+		    },
+		    isHmrRefresh: function() {
+		        return isHmrRefresh;
+		    },
 		    throwForMissingRequestStore: function() {
 		        return throwForMissingRequestStore;
 		    },
+		    throwInvariantForMissingStore: function() {
+		        return throwInvariantForMissingStore;
+		    },
 		    workUnitAsyncStorage: function() {
 		        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
 		    }
 		});
 		const _workunitasyncstorageinstance = requireWorkUnitAsyncStorageInstance();
 		const _approuterheaders = requireAppRouterHeaders();
-		function getExpectedRequestStore(callingExpression) {
-		    const workUnitStore = _workunitasyncstorageinstance.workUnitAsyncStorageInstance.getStore();
-		    if (!workUnitStore) {
-		        throwForMissingRequestStore(callingExpression);
-		    }
-		    switch(workUnitStore.type){
-		        case 'request':
-		            return workUnitStore;
-		        case 'prerender':
-		        case 'prerender-ppr':
-		        case 'prerender-legacy':
-		            // This should not happen because we should have checked it already.
-		            throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside a prerender. This is a bug in Next.js.`), "__NEXT_ERROR_CODE", {
-		                value: "E401",
-		                enumerable: false,
-		                configurable: true
-		            });
-		        case 'cache':
-		            throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside "use cache". Call it outside and pass an argument instead. Read more: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-		                value: "E37",
-		                enumerable: false,
-		                configurable: true
-		            });
-		        case 'unstable-cache':
-		            throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside unstable_cache. Call it outside and pass an argument instead. Read more: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-		                value: "E69",
-		                enumerable: false,
-		                configurable: true
-		            });
-		        default:
-		            const _exhaustiveCheck = workUnitStore;
-		            return _exhaustiveCheck;
-		    }
-		}
+		const _invarianterror = requireInvariantError();
 		function throwForMissingRequestStore(callingExpression) {
 		    throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
 		        value: "E251",
@@ -16292,43 +16324,143 @@ function requireWorkUnitAsyncStorage_external () {
 		        configurable: true
 		    });
 		}
+		function throwInvariantForMissingStore() {
+		    throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", {
+		        value: "E696",
+		        enumerable: false,
+		        configurable: true
+		    });
+		}
 		function getPrerenderResumeDataCache(workUnitStore) {
-		    if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-ppr') {
-		        return workUnitStore.prerenderResumeDataCache;
+		    switch(workUnitStore.type){
+		        case 'prerender':
+		        case 'prerender-runtime':
+		        case 'prerender-ppr':
+		            return workUnitStore.prerenderResumeDataCache;
+		        case 'prerender-client':
+		            // TODO eliminate fetch caching in client scope and stop exposing this data
+		            // cache during SSR.
+		            return workUnitStore.prerenderResumeDataCache;
+		        case 'prerender-legacy':
+		        case 'request':
+		        case 'cache':
+		        case 'private-cache':
+		        case 'unstable-cache':
+		            return null;
+		        default:
+		            return workUnitStore;
 		    }
-		    return null;
 		}
 		function getRenderResumeDataCache(workUnitStore) {
-		    if (workUnitStore.type !== 'prerender-legacy' && workUnitStore.type !== 'cache' && workUnitStore.type !== 'unstable-cache') {
-		        if (workUnitStore.type === 'request') {
+		    switch(workUnitStore.type){
+		        case 'request':
 		            return workUnitStore.renderResumeDataCache;
-		        }
-		        // We return the mutable resume data cache here as an immutable version of
-		        // the cache as it can also be used for reading.
-		        return workUnitStore.prerenderResumeDataCache;
+		        case 'prerender':
+		        case 'prerender-runtime':
+		        case 'prerender-client':
+		            if (workUnitStore.renderResumeDataCache) {
+		                // If we are in a prerender, we might have a render resume data cache
+		                // that is used to read from prefilled caches.
+		                return workUnitStore.renderResumeDataCache;
+		            }
+		        // fallthrough
+		        case 'prerender-ppr':
+		            // Otherwise we return the mutable resume data cache here as an immutable
+		            // version of the cache as it can also be used for reading.
+		            return workUnitStore.prerenderResumeDataCache;
+		        case 'cache':
+		        case 'private-cache':
+		        case 'unstable-cache':
+		        case 'prerender-legacy':
+		            return null;
+		        default:
+		            return workUnitStore;
 		    }
-		    return null;
 		}
 		function getHmrRefreshHash(workStore, workUnitStore) {
-		    var _workUnitStore_cookies_get;
-		    if (!workStore.dev) {
-		        return undefined;
+		    if (workStore.dev) {
+		        switch(workUnitStore.type){
+		            case 'cache':
+		            case 'private-cache':
+		            case 'prerender':
+		            case 'prerender-runtime':
+		                return workUnitStore.hmrRefreshHash;
+		            case 'request':
+		                var _workUnitStore_cookies_get;
+		                return (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value;
+		        }
 		    }
-		    return workUnitStore.type === 'cache' || workUnitStore.type === 'prerender' ? workUnitStore.hmrRefreshHash : workUnitStore.type === 'request' ? (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value : undefined;
+		    return undefined;
+		}
+		function isHmrRefresh(workStore, workUnitStore) {
+		    if (workStore.dev) {
+		        switch(workUnitStore.type){
+		            case 'cache':
+		            case 'private-cache':
+		            case 'request':
+		                return workUnitStore.isHmrRefresh ?? false;
+		        }
+		    }
+		    return false;
+		}
+		function getServerComponentsHmrCache(workStore, workUnitStore) {
+		    if (workStore.dev) {
+		        switch(workUnitStore.type){
+		            case 'cache':
+		            case 'private-cache':
+		            case 'request':
+		                return workUnitStore.serverComponentsHmrCache;
+		        }
+		    }
+		    return undefined;
 		}
 		function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
 		    if (workStore.isDraftMode) {
 		        switch(workUnitStore.type){
 		            case 'cache':
+		            case 'private-cache':
 		            case 'unstable-cache':
+		            case 'prerender-runtime':
 		            case 'request':
 		                return workUnitStore.draftMode;
-		            default:
-		                return undefined;
 		        }
 		    }
 		    return undefined;
 		}
+		function getCacheSignal(workUnitStore) {
+		    switch(workUnitStore.type){
+		        case 'prerender':
+		        case 'prerender-client':
+		        case 'prerender-runtime':
+		            return workUnitStore.cacheSignal;
+		        case 'prerender-ppr':
+		        case 'prerender-legacy':
+		        case 'request':
+		        case 'cache':
+		        case 'private-cache':
+		        case 'unstable-cache':
+		            return null;
+		        default:
+		            return workUnitStore;
+		    }
+		}
+		function getRuntimeStagePromise(workUnitStore) {
+		    switch(workUnitStore.type){
+		        case 'prerender-runtime':
+		        case 'private-cache':
+		            return workUnitStore.runtimeStagePromise;
+		        case 'prerender':
+		        case 'prerender-client':
+		        case 'prerender-ppr':
+		        case 'prerender-legacy':
+		        case 'request':
+		        case 'cache':
+		        case 'unstable-cache':
+		            return null;
+		        default:
+		            return workUnitStore;
+		    }
+		}
 
 		
 	} (workUnitAsyncStorage_external));
@@ -16384,13 +16516,13 @@ function requireWorkAsyncStorage_external () {
 	return workAsyncStorage_external;
 }
 
-var metadataConstants = {};
+var boundaryConstants = {};
 
-var hasRequiredMetadataConstants;
+var hasRequiredBoundaryConstants;
 
-function requireMetadataConstants () {
-	if (hasRequiredMetadataConstants) return metadataConstants;
-	hasRequiredMetadataConstants = 1;
+function requireBoundaryConstants () {
+	if (hasRequiredBoundaryConstants) return boundaryConstants;
+	hasRequiredBoundaryConstants = 1;
 	(function (exports$1) {
 		Object.defineProperty(exports$1, "__esModule", {
 		    value: true
@@ -16408,6 +16540,9 @@ function requireMetadataConstants () {
 		    OUTLET_BOUNDARY_NAME: function() {
 		        return OUTLET_BOUNDARY_NAME;
 		    },
+		    ROOT_LAYOUT_BOUNDARY_NAME: function() {
+		        return ROOT_LAYOUT_BOUNDARY_NAME;
+		    },
 		    VIEWPORT_BOUNDARY_NAME: function() {
 		        return VIEWPORT_BOUNDARY_NAME;
 		    }
@@ -16415,10 +16550,11 @@ function requireMetadataConstants () {
 		const METADATA_BOUNDARY_NAME = '__next_metadata_boundary__';
 		const VIEWPORT_BOUNDARY_NAME = '__next_viewport_boundary__';
 		const OUTLET_BOUNDARY_NAME = '__next_outlet_boundary__';
+		const ROOT_LAYOUT_BOUNDARY_NAME = '__next_root_layout_boundary__';
 
 		
-	} (metadataConstants));
-	return metadataConstants;
+	} (boundaryConstants));
+	return boundaryConstants;
 }
 
 var scheduler = {};
@@ -16531,6 +16667,9 @@ function requireDynamicRendering () {
 		    Postpone: function() {
 		        return Postpone;
 		    },
+		    PreludeState: function() {
+		        return PreludeState;
+		    },
 		    abortAndThrowOnSynchronousRequestDataAccess: function() {
 		        return abortAndThrowOnSynchronousRequestDataAccess;
 		    },
@@ -16555,8 +16694,11 @@ function requireDynamicRendering () {
 		    createHangingInputAbortSignal: function() {
 		        return createHangingInputAbortSignal;
 		    },
-		    createPostponedAbortSignal: function() {
-		        return createPostponedAbortSignal;
+		    createRenderInBrowserAbortSignal: function() {
+		        return createRenderInBrowserAbortSignal;
+		    },
+		    delayUntilRuntimeStage: function() {
+		        return delayUntilRuntimeStage;
 		    },
 		    formatDynamicAPIAccesses: function() {
 		        return formatDynamicAPIAccesses;
@@ -16570,6 +16712,9 @@ function requireDynamicRendering () {
 		    isPrerenderInterruptedError: function() {
 		        return isPrerenderInterruptedError;
 		    },
+		    logDisallowedDynamicError: function() {
+		        return logDisallowedDynamicError;
+		    },
 		    markCurrentScopeAsDynamic: function() {
 		        return markCurrentScopeAsDynamic;
 		    },
@@ -16588,9 +16733,6 @@ function requireDynamicRendering () {
 		    trackDynamicDataInDynamicRender: function() {
 		        return trackDynamicDataInDynamicRender;
 		    },
-		    trackFallbackParamAccessed: function() {
-		        return trackFallbackParamAccessed;
-		    },
 		    trackSynchronousPlatformIOAccessInDev: function() {
 		        return trackSynchronousPlatformIOAccessInDev;
 		    },
@@ -16599,6 +16741,9 @@ function requireDynamicRendering () {
 		    },
 		    useDynamicRouteParams: function() {
 		        return useDynamicRouteParams;
+		    },
+		    warnOnSyncDynamicError: function() {
+		        return warnOnSyncDynamicError;
 		    }
 		});
 		const _react = /*#__PURE__*/ _interop_require_default(React__default);
@@ -16607,8 +16752,10 @@ function requireDynamicRendering () {
 		const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
 		const _workasyncstorageexternal = requireWorkAsyncStorage_external();
 		const _dynamicrenderingutils = requireDynamicRenderingUtils();
-		const _metadataconstants = requireMetadataConstants();
+		const _boundaryconstants = requireBoundaryConstants();
 		const _scheduler = requireScheduler();
+		const _bailouttocsr = requireBailoutToCsr();
+		const _invarianterror = requireInvariantError();
 		function _interop_require_default(obj) {
 		    return obj && obj.__esModule ? obj : {
 		        default: obj
@@ -16619,16 +16766,15 @@ function requireDynamicRendering () {
 		    return {
 		        isDebugDynamicAccesses,
 		        dynamicAccesses: [],
-		        syncDynamicExpression: undefined,
 		        syncDynamicErrorWithStack: null
 		    };
 		}
 		function createDynamicValidationState() {
 		    return {
-		        hasSuspendedDynamic: false,
+		        hasSuspenseAboveBody: false,
 		        hasDynamicMetadata: false,
 		        hasDynamicViewport: false,
-		        hasSyncDynamicErrors: false,
+		        hasAllowedDynamic: false,
 		        dynamicErrors: []
 		    };
 		}
@@ -16638,11 +16784,17 @@ function requireDynamicRendering () {
 		}
 		function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
 		    if (workUnitStore) {
-		        if (workUnitStore.type === 'cache' || workUnitStore.type === 'unstable-cache') {
-		            // inside cache scopes marking a scope as dynamic has no effect because the outer cache scope
-		            // creates a cache boundary. This is subtly different from reading a dynamic data source which is
-		            // forbidden inside a cache scope.
-		            return;
+		        switch(workUnitStore.type){
+		            case 'cache':
+		            case 'unstable-cache':
+		                // Inside cache scopes, marking a scope as dynamic has no effect,
+		                // because the outer cache scope creates a cache boundary. This is
+		                // subtly different from reading a dynamic data source, which is
+		                // forbidden inside a cache scope.
+		                return;
+		            case 'private-cache':
+		                // A private cache scope is already dynamic by definition.
+		                return;
 		        }
 		    }
 		    // If we're forcing dynamic rendering or we're forcing static rendering, we
@@ -16657,29 +16809,29 @@ function requireDynamicRendering () {
 		        });
 		    }
 		    if (workUnitStore) {
-		        if (workUnitStore.type === 'prerender-ppr') {
-		            postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
-		        } else if (workUnitStore.type === 'prerender-legacy') {
-		            workUnitStore.revalidate = 0;
-		            // We aren't prerendering but we are generating a static page. We need to bail out of static generation
-		            const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
-		                value: "E550",
-		                enumerable: false,
-		                configurable: true
-		            });
-		            store.dynamicUsageDescription = expression;
-		            store.dynamicUsageStack = err.stack;
-		            throw err;
-		        } else if (process.env.NODE_ENV === 'development' && workUnitStore && workUnitStore.type === 'request') {
-		            workUnitStore.usedDynamic = true;
+		        switch(workUnitStore.type){
+		            case 'prerender-ppr':
+		                return postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
+		            case 'prerender-legacy':
+		                workUnitStore.revalidate = 0;
+		                // We aren't prerendering, but we are generating a static page. We need
+		                // to bail out of static generation.
+		                const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+		                    value: "E550",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		                store.dynamicUsageDescription = expression;
+		                store.dynamicUsageStack = err.stack;
+		                throw err;
+		            case 'request':
+		                if (process.env.NODE_ENV !== 'production') {
+		                    workUnitStore.usedDynamic = true;
+		                }
+		                break;
 		        }
 		    }
 		}
-		function trackFallbackParamAccessed(store, expression) {
-		    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-		    if (!prerenderStore || prerenderStore.type !== 'prerender-ppr') return;
-		    postponeWithTracking(store.route, expression, prerenderStore.dynamicTracking);
-		}
 		function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
 		    // We aren't prerendering but we are generating a static page. We need to bail out of static generation
 		    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
@@ -16692,25 +16844,31 @@ function requireDynamicRendering () {
 		    store.dynamicUsageStack = err.stack;
 		    throw err;
 		}
-		function trackDynamicDataInDynamicRender(_store, workUnitStore) {
-		    if (workUnitStore) {
-		        if (workUnitStore.type === 'cache' || workUnitStore.type === 'unstable-cache') {
-		            // inside cache scopes marking a scope as dynamic has no effect because the outer cache scope
-		            // creates a cache boundary. This is subtly different from reading a dynamic data source which is
+		function trackDynamicDataInDynamicRender(workUnitStore) {
+		    switch(workUnitStore.type){
+		        case 'cache':
+		        case 'unstable-cache':
+		            // Inside cache scopes, marking a scope as dynamic has no effect,
+		            // because the outer cache scope creates a cache boundary. This is
+		            // subtly different from reading a dynamic data source, which is
 		            // forbidden inside a cache scope.
 		            return;
-		        }
-		        if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-legacy') {
-		            workUnitStore.revalidate = 0;
-		        }
-		        if (process.env.NODE_ENV === 'development' && workUnitStore.type === 'request') {
-		            workUnitStore.usedDynamic = true;
-		        }
+		        case 'private-cache':
+		            // A private cache scope is already dynamic by definition.
+		            return;
+		        case 'prerender':
+		        case 'prerender-runtime':
+		        case 'prerender-legacy':
+		        case 'prerender-ppr':
+		        case 'prerender-client':
+		            break;
+		        case 'request':
+		            if (process.env.NODE_ENV !== 'production') {
+		                workUnitStore.usedDynamic = true;
+		            }
+		            break;
 		    }
 		}
-		// Despite it's name we don't actually abort unless we have a controller to call abort on
-		// There are times when we let a prerender run long to discover caches where we want the semantics
-		// of tracking dynamic access without terminating the prerender early
 		function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
 		    const reason = `Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`;
 		    const error = createPrerenderInterruptedError(reason);
@@ -16727,13 +16885,16 @@ function requireDynamicRendering () {
 		}
 		function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
 		    const dynamicTracking = prerenderStore.dynamicTracking;
+		    abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
+		    // It is important that we set this tracking value after aborting. Aborts are executed
+		    // synchronously except for the case where you abort during render itself. By setting this
+		    // value late we can use it to determine if any of the aborted tasks are the task that
+		    // called the sync IO expression in the first place.
 		    if (dynamicTracking) {
 		        if (dynamicTracking.syncDynamicErrorWithStack === null) {
-		            dynamicTracking.syncDynamicExpression = expression;
 		            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
 		        }
 		    }
-		    abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
 		}
 		function trackSynchronousPlatformIOAccessInDev(requestStore) {
 		    // We don't actually have a controller to abort but we do the semantic equivalent by
@@ -16748,22 +16909,27 @@ function requireDynamicRendering () {
 		        // since we need the throw semantics regardless of whether we abort it is easier to land
 		        // this way. See how this was handled with `abortOnSynchronousPlatformIOAccess` for a closer
 		        // to ideal implementation
+		        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
+		        // It is important that we set this tracking value after aborting. Aborts are executed
+		        // synchronously except for the case where you abort during render itself. By setting this
+		        // value late we can use it to determine if any of the aborted tasks are the task that
+		        // called the sync IO expression in the first place.
 		        const dynamicTracking = prerenderStore.dynamicTracking;
 		        if (dynamicTracking) {
 		            if (dynamicTracking.syncDynamicErrorWithStack === null) {
-		                dynamicTracking.syncDynamicExpression = expression;
 		                dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
-		                if (prerenderStore.validating === true) {
-		                    // We always log Request Access in dev at the point of calling the function
-		                    // So we mark the dynamic validation as not requiring it to be printed
-		                    dynamicTracking.syncDynamicLogged = true;
-		                }
 		            }
 		        }
-		        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
 		    }
 		    throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
 		}
+		function warnOnSyncDynamicError(dynamicTracking) {
+		    if (dynamicTracking.syncDynamicErrorWithStack) {
+		        // the server did something sync dynamic, likely
+		        // leading to an early termination of the prerender.
+		        console.error(dynamicTracking.syncDynamicErrorWithStack);
+		    }
+		}
 		const trackSynchronousRequestDataAccessInDev = trackSynchronousPlatformIOAccessInDev;
 		function Postpone({ reason, route }) {
 		    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
@@ -16856,35 +17022,57 @@ function requireDynamicRendering () {
 		        });
 		    }
 		}
-		function createPostponedAbortSignal(reason) {
-		    assertPostpone();
+		function createRenderInBrowserAbortSignal() {
 		    const controller = new AbortController();
-		    // We get our hands on a postpone instance by calling postpone and catching the throw
-		    try {
-		        _react.default.unstable_postpone(reason);
-		    } catch (x) {
-		        controller.abort(x);
-		    }
+		    controller.abort(Object.defineProperty(new _bailouttocsr.BailoutToCSRError('Render in Browser'), "__NEXT_ERROR_CODE", {
+		        value: "E721",
+		        enumerable: false,
+		        configurable: true
+		    }));
 		    return controller.signal;
 		}
 		function createHangingInputAbortSignal(workUnitStore) {
-		    const controller = new AbortController();
-		    if (workUnitStore.cacheSignal) {
-		        // If we have a cacheSignal it means we're in a prospective render. If the input
-		        // we're waiting on is coming from another cache, we do want to wait for it so that
-		        // we can resolve this cache entry too.
-		        workUnitStore.cacheSignal.inputReady().then(()=>{
-		            controller.abort();
-		        });
-		    } else {
-		        // Otherwise we're in the final render and we should already have all our caches
-		        // filled. We might still be waiting on some microtasks so we wait one tick before
-		        // giving up. When we give up, we still want to 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.
-		        (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
+		    switch(workUnitStore.type){
+		        case 'prerender':
+		        case 'prerender-runtime':
+		            const controller = new AbortController();
+		            if (workUnitStore.cacheSignal) {
+		                // If we have a cacheSignal it means we're in a prospective render. If
+		                // the input we're waiting on is coming from another cache, we do want
+		                // to wait for it so that we can resolve this cache entry too.
+		                workUnitStore.cacheSignal.inputReady().then(()=>{
+		                    controller.abort();
+		                });
+		            } else {
+		                // Otherwise we're in the final render and we should already have all
+		                // our caches filled.
+		                // If the prerender uses stages, we have wait until the runtime stage,
+		                // at which point all runtime inputs will be resolved.
+		                // (otherwise, a runtime prerender might consider `cookies()` hanging
+		                //  even though they'd resolve in the next task.)
+		                //
+		                // We might still be waiting on some microtasks so we
+		                // wait one tick before giving up. When we give up, we still want to
+		                // 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()));
+		                } else {
+		                    (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
+		                }
+		            }
+		            return controller.signal;
+		        case 'prerender-client':
+		        case 'prerender-ppr':
+		        case 'prerender-legacy':
+		        case 'request':
+		        case 'cache':
+		        case 'private-cache':
+		        case 'unstable-cache':
+		            return undefined;
 		    }
-		    return controller.signal;
 		}
 		function annotateDynamicAccess(expression, prerenderStore) {
 		    const dynamicTracking = prerenderStore.dynamicTracking;
@@ -16897,31 +17085,65 @@ function requireDynamicRendering () {
 		}
 		function useDynamicRouteParams(expression) {
 		    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-		    if (workStore && workStore.isStaticGeneration && workStore.fallbackRouteParams && workStore.fallbackRouteParams.size > 0) {
-		        // There are fallback route params, we should track these as dynamic
-		        // accesses.
-		        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-		        if (workUnitStore) {
-		            // We're prerendering with dynamicIO or PPR or both
-		            if (workUnitStore.type === 'prerender') {
-		                // We are in a prerender with dynamicIO semantics
-		                // We are going to hang here and never resolve. This will cause the currently
-		                // rendering component to effectively be a dynamic hole
-		                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, expression));
-		            } else if (workUnitStore.type === 'prerender-ppr') {
-		                // We're prerendering with PPR
-		                postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
-		            } else if (workUnitStore.type === 'prerender-legacy') {
-		                throwToInterruptStaticGeneration(expression, workStore, workUnitStore);
-		            }
+		    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+		    if (workStore && workUnitStore) {
+		        switch(workUnitStore.type){
+		            case 'prerender-client':
+		            case 'prerender':
+		                {
+		                    const fallbackParams = workUnitStore.fallbackRouteParams;
+		                    if (fallbackParams && fallbackParams.size > 0) {
+		                        // We are in a prerender with cacheComponents semantics. We are going to
+		                        // hang here and never resolve. This will cause the currently
+		                        // rendering component to effectively be a dynamic hole.
+		                        _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+		                    }
+		                    break;
+		                }
+		            case 'prerender-ppr':
+		                {
+		                    const fallbackParams = workUnitStore.fallbackRouteParams;
+		                    if (fallbackParams && fallbackParams.size > 0) {
+		                        return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
+		                    }
+		                    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",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		            case 'cache':
+		            case 'private-cache':
+		                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+		                    value: "E745",
+		                    enumerable: false,
+		                    configurable: true
+		                });
 		        }
 		    }
 		}
 		const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
-		const hasMetadataRegex = new RegExp(`\\n\\s+at ${_metadataconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
-		const hasViewportRegex = new RegExp(`\\n\\s+at ${_metadataconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
-		const hasOutletRegex = new RegExp(`\\n\\s+at ${_metadataconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
-		function trackAllowedDynamicAccess(route, componentStack, dynamicValidation, serverDynamic, clientDynamic) {
+		// Common implicit body tags that React will treat as body when placed directly in html
+		const bodyAndImplicitTags = 'body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6';
+		// Detects when RootLayoutBoundary (our framework marker component) appears
+		// after Suspense in the component stack, indicating the root layout is wrapped
+		// within a Suspense boundary. Ensures no body/html/implicit-body components are in between.
+		//
+		// Example matches:
+		//   at Suspense (<anonymous>)
+		//   at __next_root_layout_boundary__ (<anonymous>)
+		//
+		// Or with other components in between (but not body/html/implicit-body):
+		//   at Suspense (<anonymous>)
+		//   at SomeComponent (<anonymous>)
+		//   at __next_root_layout_boundary__ (<anonymous>)
+		const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${bodyAndImplicitTags}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`);
+		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]`);
+		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.
 		        return;
@@ -16931,92 +17153,112 @@ function requireDynamicRendering () {
 		    } else if (hasViewportRegex.test(componentStack)) {
 		        dynamicValidation.hasDynamicViewport = true;
 		        return;
+		    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+		        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
+		        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
+		        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
+		        dynamicValidation.hasAllowedDynamic = true;
+		        dynamicValidation.hasSuspenseAboveBody = true;
+		        return;
 		    } else if (hasSuspenseRegex.test(componentStack)) {
-		        dynamicValidation.hasSuspendedDynamic = true;
+		        // this error had a Suspense boundary above it so we don't need to report it as a source
+		        // of disallowed
+		        dynamicValidation.hasAllowedDynamic = true;
 		        return;
-		    } else if (serverDynamic.syncDynamicErrorWithStack || clientDynamic.syncDynamicErrorWithStack) {
-		        dynamicValidation.hasSyncDynamicErrors = true;
+		    } else if (clientDynamic.syncDynamicErrorWithStack) {
+		        // This task was the task that called the sync error.
+		        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
 		        return;
 		    } else {
-		        const message = `Route "${route}": A component accessed data, headers, params, searchParams, or a short-lived cache without a Suspense boundary nor a "use cache" above it. We don't have the exact line number added to error messages yet but you can see which component in the stack below. See more info: https://nextjs.org/docs/messages/next-prerender-missing-suspense`;
-		        const error = createErrorWithComponentStack(message, componentStack);
+		        const message = `Route "${workStore.route}": A component accessed data, headers, params, searchParams, or a short-lived cache without a Suspense boundary nor a "use cache" above it. See more info: https://nextjs.org/docs/messages/next-prerender-missing-suspense`;
+		        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
 		        dynamicValidation.dynamicErrors.push(error);
 		        return;
 		    }
 		}
-		function createErrorWithComponentStack(message, componentStack) {
+		/**
+		 * In dev mode, we prefer using the owner stack, otherwise the provided
+		 * component stack is used.
+		 */ function createErrorWithComponentOrOwnerStack(message, componentStack) {
+		    const ownerStack = process.env.NODE_ENV !== 'production' && _react.default.captureOwnerStack ? _react.default.captureOwnerStack() : null;
 		    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
 		        value: "E394",
 		        enumerable: false,
 		        configurable: true
 		    });
-		    error.stack = 'Error: ' + message + componentStack;
+		    error.stack = error.name + ': ' + message + (ownerStack ?? componentStack);
 		    return error;
 		}
-		function throwIfDisallowedDynamic(route, dynamicValidation, serverDynamic, clientDynamic) {
-		    let syncError;
-		    let syncExpression;
-		    let syncLogged;
-		    if (serverDynamic.syncDynamicErrorWithStack) {
-		        syncError = serverDynamic.syncDynamicErrorWithStack;
-		        syncExpression = serverDynamic.syncDynamicExpression;
-		        syncLogged = serverDynamic.syncDynamicLogged === true;
-		    } else if (clientDynamic.syncDynamicErrorWithStack) {
-		        syncError = clientDynamic.syncDynamicErrorWithStack;
-		        syncExpression = clientDynamic.syncDynamicExpression;
-		        syncLogged = clientDynamic.syncDynamicLogged === true;
-		    } else {
-		        syncError = null;
-		        syncExpression = undefined;
-		        syncLogged = false;
-		    }
-		    if (dynamicValidation.hasSyncDynamicErrors && syncError) {
-		        if (!syncLogged) {
-		            // In dev we already log errors about sync dynamic access. But during builds we need to ensure
-		            // the offending sync error is logged before we exit the build
-		            console.error(syncError);
+		var PreludeState = /*#__PURE__*/ function(PreludeState) {
+		    PreludeState[PreludeState["Full"] = 0] = "Full";
+		    PreludeState[PreludeState["Empty"] = 1] = "Empty";
+		    PreludeState[PreludeState["Errored"] = 2] = "Errored";
+		    return 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:
+  - 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.`);
 		        }
-		        // The actual error should have been logged when the sync access ocurred
-		        throw new _staticgenerationbailout.StaticGenBailoutError();
 		    }
-		    const dynamicErrors = dynamicValidation.dynamicErrors;
-		    if (dynamicErrors.length) {
-		        for(let i = 0; i < dynamicErrors.length; i++){
-		            console.error(dynamicErrors[i]);
+		}
+		function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
+		    if (prelude !== 0) {
+		        if (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
+		            return;
 		        }
-		        throw new _staticgenerationbailout.StaticGenBailoutError();
-		    }
-		    if (!dynamicValidation.hasSuspendedDynamic) {
-		        if (dynamicValidation.hasDynamicMetadata) {
-		            if (syncError) {
-		                console.error(syncError);
-		                throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" has a \`generateMetadata\` that could not finish rendering before ${syncExpression} was used. Follow the instructions in the error for this expression to resolve.`), "__NEXT_ERROR_CODE", {
-		                    value: "E608",
-		                    enumerable: false,
-		                    configurable: true
-		                });
-		            }
-		            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or external data (\`fetch(...)\`, etc...) but the rest of the route was static or only used cached data (\`"use cache"\`). If you expected this route to be prerenderable update your \`generateMetadata\` to not use Request data and only use cached external data. Otherwise, add \`await connection()\` somewhere within this route to indicate explicitly it should not be prerendered.`), "__NEXT_ERROR_CODE", {
-		                value: "E534",
-		                enumerable: false,
-		                configurable: true
-		            });
-		        } else if (dynamicValidation.hasDynamicViewport) {
-		            if (syncError) {
-		                console.error(syncError);
-		                throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" has a \`generateViewport\` that could not finish rendering before ${syncExpression} was used. Follow the instructions in the error for this expression to resolve.`), "__NEXT_ERROR_CODE", {
-		                    value: "E573",
-		                    enumerable: false,
-		                    configurable: true
-		                });
+		        if (serverDynamic.syncDynamicErrorWithStack) {
+		            // There is no shell and the server did something sync dynamic likely
+		            // leading to an early termination of the prerender before the shell
+		            // could be completed. We terminate the build/validating render.
+		            logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
+		            throw new _staticgenerationbailout.StaticGenBailoutError();
+		        }
+		        // We didn't have any sync bailouts but there may be user code which
+		        // blocked the root. We would have captured these during the prerender
+		        // and can log them here and then terminate the build/validating render
+		        const dynamicErrors = dynamicValidation.dynamicErrors;
+		        if (dynamicErrors.length > 0) {
+		            for(let i = 0; i < dynamicErrors.length; i++){
+		                logDisallowedDynamicError(workStore, dynamicErrors[i]);
 		            }
-		            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or external data (\`fetch(...)\`, etc...) but the rest of the route was static or only used cached data (\`"use cache"\`). If you expected this route to be prerenderable update your \`generateViewport\` to not use Request data and only use cached external data. Otherwise, add \`await connection()\` somewhere within this route to indicate explicitly it should not be prerendered.`), "__NEXT_ERROR_CODE", {
-		                value: "E590",
-		                enumerable: false,
-		                configurable: true
-		            });
+		            throw new _staticgenerationbailout.StaticGenBailoutError();
+		        }
+		        // If we got this far then the only other thing that could be blocking
+		        // the root is dynamic Viewport. If this is dynamic then
+		        // you need to opt into that by adding a Suspense boundary above the body
+		        // to indicate your are ok with fully dynamic rendering.
+		        if (dynamicValidation.hasDynamicViewport) {
+		            console.error(`Route "${workStore.route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) without explicitly allowing fully dynamic rendering. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`);
+		            throw new _staticgenerationbailout.StaticGenBailoutError();
+		        }
+		        if (prelude === 1) {
+		            // If we ever get this far then we messed up the tracking of invalid dynamic.
+		            // We still adhere to the constraint that you must produce a shell but invite the
+		            // user to report this as a bug in Next.js.
+		            console.error(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.`);
+		            throw new _staticgenerationbailout.StaticGenBailoutError();
 		        }
+		    } else {
+		        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
+		            console.error(`Route "${workStore.route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) when the rest of the route does not. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`);
+		            throw new _staticgenerationbailout.StaticGenBailoutError();
+		        }
+		    }
+		}
+		function delayUntilRuntimeStage(prerenderStore, result) {
+		    if (prerenderStore.runtimeStagePromise) {
+		        return prerenderStore.runtimeStagePromise.then(()=>result);
 		    }
+		    return result;
 		}
 
 		
@@ -17179,6 +17421,9 @@ function requireNavigation_reactServer () {
 		    unauthorized: function() {
 		        return _unauthorized.unauthorized;
 		    },
+		    unstable_isUnrecognizedActionError: function() {
+		        return unstable_isUnrecognizedActionError;
+		    },
 		    unstable_rethrow: function() {
 		        return _unstablerethrow.unstable_rethrow;
 		    }
@@ -17208,6 +17453,13 @@ function requireNavigation_reactServer () {
 		        throw new ReadonlyURLSearchParamsError();
 		    }
 		}
+		function unstable_isUnrecognizedActionError() {
+		    throw Object.defineProperty(new Error('`unstable_isUnrecognizedActionError` can only be used on the client.'), "__NEXT_ERROR_CODE", {
+		        value: "E776",
+		        enumerable: false,
+		        configurable: true
+		    });
+		}
 
 		if ((typeof exports$1.default === 'function' || (typeof exports$1.default === 'object' && exports$1.default !== null)) && typeof exports$1.default.__esModule === 'undefined') {
 		  Object.defineProperty(exports$1.default, '__esModule', { value: true });
@@ -17309,6 +17561,52 @@ function requireServerInsertedHtml_sharedRuntime () {
 	return serverInsertedHtml_sharedRuntime;
 }
 
+var unrecognizedActionError = {exports: {}};
+
+var hasRequiredUnrecognizedActionError;
+
+function requireUnrecognizedActionError () {
+	if (hasRequiredUnrecognizedActionError) return unrecognizedActionError.exports;
+	hasRequiredUnrecognizedActionError = 1;
+	(function (module, exports$1) {
+		Object.defineProperty(exports$1, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports$1, {
+		    UnrecognizedActionError: function() {
+		        return UnrecognizedActionError;
+		    },
+		    unstable_isUnrecognizedActionError: function() {
+		        return unstable_isUnrecognizedActionError;
+		    }
+		});
+		class UnrecognizedActionError extends Error {
+		    constructor(...args){
+		        super(...args);
+		        this.name = 'UnrecognizedActionError';
+		    }
+		}
+		function unstable_isUnrecognizedActionError(error) {
+		    return !!(error && typeof error === 'object' && error instanceof UnrecognizedActionError);
+		}
+
+		if ((typeof exports$1.default === 'function' || (typeof exports$1.default === 'object' && exports$1.default !== null)) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', { value: true });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		}
+
+		
+	} (unrecognizedActionError, unrecognizedActionError.exports));
+	return unrecognizedActionError.exports;
+}
+
 var bailoutToClientRendering = {exports: {}};
 
 var hasRequiredBailoutToClientRendering;
@@ -17328,14 +17626,25 @@ function requireBailoutToClientRendering () {
 		});
 		const _bailouttocsr = requireBailoutToCsr();
 		const _workasyncstorageexternal = requireWorkAsyncStorage_external();
+		const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
 		function bailoutToClientRendering(reason) {
 		    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
 		    if (workStore == null ? void 0 : workStore.forceStatic) return;
-		    if (workStore == null ? void 0 : workStore.isStaticGeneration) throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(reason), "__NEXT_ERROR_CODE", {
-		        value: "E394",
-		        enumerable: false,
-		        configurable: true
-		    });
+		    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+		    if (workUnitStore) {
+		        switch(workUnitStore.type){
+		            case 'prerender':
+		            case 'prerender-runtime':
+		            case 'prerender-client':
+		            case 'prerender-ppr':
+		            case 'prerender-legacy':
+		                throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(reason), "__NEXT_ERROR_CODE", {
+		                    value: "E394",
+		                    enumerable: false,
+		                    configurable: true
+		                });
+		        }
+		    }
 		}
 
 		if ((typeof exports$1.default === 'function' || (typeof exports$1.default === 'object' && exports$1.default !== null)) && typeof exports$1.default.__esModule === 'undefined') {
@@ -17389,6 +17698,9 @@ function requireNavigation$1 () {
 		    unauthorized: function() {
 		        return _navigationreactserver.unauthorized;
 		    },
+		    unstable_isUnrecognizedActionError: function() {
+		        return _unrecognizedactionerror.unstable_isUnrecognizedActionError;
+		    },
 		    unstable_rethrow: function() {
 		        return _navigationreactserver.unstable_rethrow;
 		    },
@@ -17421,6 +17733,7 @@ function requireNavigation$1 () {
 		const _segment = requireSegment();
 		const _navigationreactserver = requireNavigation_reactServer();
 		const _serverinsertedhtmlsharedruntime = requireServerInsertedHtml_sharedRuntime();
+		const _unrecognizedactionerror = requireUnrecognizedActionError();
 		const useDynamicRouteParams = typeof window === 'undefined' ? requireDynamicRendering().useDynamicRouteParams : undefined;
 		function useSearchParams() {
 		    const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);