@dodopayments/nextjs 0.3.1 → 0.3.2

package/dist/index.js

@@ -24,10 +24,9 @@ var detectDomainLocale = {};
 	        detectedLocale = detectedLocale.toLowerCase();
 	    }
 	    for (const item of domainItems){
-	        var _item_domain, _item_locales;
 	        // remove port if present
-	        const domainHostname = (_item_domain = item.domain) == null ? void 0 : _item_domain.split(':', 1)[0].toLowerCase();
-	        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? void 0 : _item_locales.some((locale)=>locale.toLowerCase() === detectedLocale))) {
+	        const domainHostname = item.domain?.split(':', 1)[0].toLowerCase();
+	        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || item.locales?.some((locale)=>locale.toLowerCase() === detectedLocale)) {
 	            return item;
 	        }
 	    }
@@ -122,7 +121,7 @@ var parsePath = {};
 	        return path;
 	    }
 	    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
-	    return "" + prefix + pathname + query + hash;
+	    return `${prefix}${pathname}${query}${hash}`;
 	}
 
 	
@@ -146,7 +145,7 @@ var addPathSuffix = {};
 	        return path;
 	    }
 	    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
-	    return "" + pathname + suffix + query + hash;
+	    return `${pathname}${suffix}${query}${hash}`;
 	}
 
 	
@@ -199,10 +198,10 @@ var pathHasPrefix = {};
 	    // don't need to prefix the path.
 	    if (!ignorePrefix) {
 	        if ((0, _pathhasprefix.pathHasPrefix)(lower, '/api')) return path;
-	        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase())) return path;
+	        if ((0, _pathhasprefix.pathHasPrefix)(lower, `/${locale.toLowerCase()}`)) return path;
 	    }
 	    // Add the locale prefix to the path.
-	    return (0, _addpathprefix.addPathPrefix)(path, "/" + locale);
+	    return (0, _addpathprefix.addPathPrefix)(path, `/${locale}`);
 	}
 
 	
@@ -228,7 +227,7 @@ var pathHasPrefix = {};
 	        pathname = (0, _removetrailingslash.removeTrailingSlash)(pathname);
 	    }
 	    if (info.buildId) {
-	        pathname = (0, _addpathsuffix.addPathSuffix)((0, _addpathprefix.addPathPrefix)(pathname, "/_next/data/" + info.buildId), info.pathname === '/' ? 'index.json' : '.json');
+	        pathname = (0, _addpathsuffix.addPathSuffix)((0, _addpathprefix.addPathPrefix)(pathname, `/_next/data/${info.buildId}`), info.pathname === '/' ? 'index.json' : '.json');
 	    }
 	    pathname = (0, _addpathprefix.addPathPrefix)(pathname, info.basePath);
 	    return !info.buildId && info.trailingSlash ? !pathname.endsWith('/') ? (0, _addpathsuffix.addPathSuffix)(pathname, '/') : pathname : (0, _removetrailingslash.removeTrailingSlash)(pathname);
@@ -253,7 +252,7 @@ var getHostname = {};
 	    // Get the hostname from the headers if it exists, otherwise use the parsed
 	    // hostname.
 	    let hostname;
-	    if ((headers == null ? void 0 : headers.host) && !Array.isArray(headers.host)) {
+	    if (headers?.host && !Array.isArray(headers.host)) {
 	        hostname = headers.host.toString().split(':', 1)[0];
 	    } else if (parsed.hostname) {
 	        hostname = parsed.hostname;
@@ -361,7 +360,7 @@ var removePathPrefix = {};
 	    }
 	    // If the path without the prefix doesn't start with a `/` we need to add it
 	    // back to the path to make sure it's a valid path.
-	    return "/" + withoutPrefix;
+	    return `/${withoutPrefix}`;
 	}
 
 	
@@ -381,8 +380,7 @@ var removePathPrefix = {};
 	const _removepathprefix = removePathPrefix;
 	const _pathhasprefix = pathHasPrefix;
 	function getNextPathnameInfo(pathname, options) {
-	    var _options_nextConfig;
-	    const { basePath, i18n, trailingSlash } = (_options_nextConfig = options.nextConfig) != null ? _options_nextConfig : {};
+	    const { basePath, i18n, trailingSlash } = options.nextConfig ?? {};
 	    const info = {
 	        pathname,
 	        trailingSlash: pathname !== '/' ? pathname.endsWith('/') : trailingSlash
@@ -396,7 +394,7 @@ var removePathPrefix = {};
 	        const paths = info.pathname.replace(/^\/_next\/data\//, '').replace(/\.json$/, '').split('/');
 	        const buildId = paths[0];
 	        info.buildId = buildId;
-	        pathnameNoDataPrefix = paths[1] !== 'index' ? "/" + paths.slice(1).join('/') : '/';
+	        pathnameNoDataPrefix = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/';
 	        // update pathname with normalized if enabled although
 	        // we use normalized to populate locale info still
 	        if (options.parseData === true) {
@@ -408,8 +406,7 @@ var removePathPrefix = {};
 	    if (i18n) {
 	        let result = options.i18nProvider ? options.i18nProvider.analyze(info.pathname) : (0, _normalizelocalepath.normalizeLocalePath)(info.pathname, i18n.locales);
 	        info.locale = result.detectedLocale;
-	        var _result_pathname;
-	        info.pathname = (_result_pathname = result.pathname) != null ? _result_pathname : info.pathname;
+	        info.pathname = result.pathname ?? info.pathname;
 	        if (!result.detectedLocale && info.buildId) {
 	            result = options.i18nProvider ? options.i18nProvider.analyze(pathnameNoDataPrefix) : (0, _normalizelocalepath.normalizeLocalePath)(pathnameNoDataPrefix, i18n.locales);
 	            if (result.detectedLocale) {
@@ -659,12 +656,18 @@ var constants = {};
 	    GSSP_NO_RETURNED_VALUE: function() {
 	        return GSSP_NO_RETURNED_VALUE;
 	    },
+	    HTML_CONTENT_TYPE_HEADER: function() {
+	        return HTML_CONTENT_TYPE_HEADER;
+	    },
 	    INFINITE_CACHE: function() {
 	        return INFINITE_CACHE;
 	    },
 	    INSTRUMENTATION_HOOK_FILENAME: function() {
 	        return INSTRUMENTATION_HOOK_FILENAME;
 	    },
+	    JSON_CONTENT_TYPE_HEADER: function() {
+	        return JSON_CONTENT_TYPE_HEADER;
+	    },
 	    MATCHED_PATH_HEADER: function() {
 	        return MATCHED_PATH_HEADER;
 	    },
@@ -725,6 +728,12 @@ var constants = {};
 	    PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER: function() {
 	        return PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER;
 	    },
+	    PROXY_FILENAME: function() {
+	        return PROXY_FILENAME;
+	    },
+	    PROXY_LOCATION_REGEXP: function() {
+	        return PROXY_LOCATION_REGEXP;
+	    },
 	    PUBLIC_DIR_MIDDLEWARE_CONFLICT: function() {
 	        return PUBLIC_DIR_MIDDLEWARE_CONFLICT;
 	    },
@@ -785,6 +794,9 @@ var constants = {};
 	    STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR: function() {
 	        return STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR;
 	    },
+	    TEXT_PLAIN_CONTENT_TYPE_HEADER: function() {
+	        return TEXT_PLAIN_CONTENT_TYPE_HEADER;
+	    },
 	    UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
 	        return UNSTABLE_REVALIDATE_RENAME_ERROR;
 	    },
@@ -793,8 +805,14 @@ var constants = {};
 	    },
 	    WEBPACK_RESOURCE_QUERIES: function() {
 	        return WEBPACK_RESOURCE_QUERIES;
+	    },
+	    WEB_SOCKET_MAX_RECONNECTIONS: function() {
+	        return WEB_SOCKET_MAX_RECONNECTIONS;
 	    }
 	});
+	const TEXT_PLAIN_CONTENT_TYPE_HEADER = 'text/plain';
+	const HTML_CONTENT_TYPE_HEADER = 'text/html; charset=utf-8';
+	const JSON_CONTENT_TYPE_HEADER = 'application/json; charset=utf-8';
 	const NEXT_QUERY_PARAM_PREFIX = 'nxtP';
 	const NEXT_INTERCEPTION_MARKER_PREFIX = 'nxtI';
 	const MATCHED_PATH_HEADER = 'x-matched-path';
@@ -820,6 +838,8 @@ var constants = {};
 	const INFINITE_CACHE = 0xfffffffe;
 	const MIDDLEWARE_FILENAME = 'middleware';
 	const MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
+	const PROXY_FILENAME = 'proxy';
+	const PROXY_LOCATION_REGEXP = `(?:src/)?${PROXY_FILENAME}`;
 	const INSTRUMENTATION_HOOK_FILENAME = 'instrumentation';
 	const PAGES_DIR_ALIAS = 'private-next-pages';
 	const DOT_NEXT_ALIAS = 'private-dot-next';
@@ -856,6 +876,7 @@ var constants = {};
 	    experimentalEdge: 'experimental-edge',
 	    nodejs: 'nodejs'
 	};
+	const WEB_SOCKET_MAX_RECONNECTIONS = 12;
 	/**
 	 * The names of the webpack layers. These layers are the primitives for the
 	 * webpack chunks.
@@ -1941,7 +1962,8 @@ var asyncLocalStorage = {};
 	    }
 	    return new FakeAsyncLocalStorage();
 	}
-	function bindSnapshot(fn) {
+	function bindSnapshot(// WARNING: Don't pass a named function to this argument! See: https://github.com/facebook/react/pull/34911
+	fn) {
 	    if (maybeGlobalAsyncLocalStorage) {
 	        return maybeGlobalAsyncLocalStorage.bind(fn);
 	    }
@@ -2093,9 +2115,15 @@ var appRouterHeaders = {exports: {}};
 	    NEXT_HMR_REFRESH_HEADER: function() {
 	        return NEXT_HMR_REFRESH_HEADER;
 	    },
+	    NEXT_HTML_REQUEST_ID_HEADER: function() {
+	        return NEXT_HTML_REQUEST_ID_HEADER;
+	    },
 	    NEXT_IS_PRERENDER_HEADER: function() {
 	        return NEXT_IS_PRERENDER_HEADER;
 	    },
+	    NEXT_REQUEST_ID_HEADER: function() {
+	        return NEXT_REQUEST_ID_HEADER;
+	    },
 	    NEXT_REWRITTEN_PATH_HEADER: function() {
 	        return NEXT_REWRITTEN_PATH_HEADER;
 	    },
@@ -2127,14 +2155,14 @@ var appRouterHeaders = {exports: {}};
 	        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,
@@ -2150,6 +2178,8 @@ var appRouterHeaders = {exports: {}};
 	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';
+	const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id';
+	const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id';
 
 	if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
 	  Object.defineProperty(exports.default, '__esModule', { value: true });
@@ -2162,6 +2192,28 @@ var appRouterHeaders = {exports: {}};
 
 var appRouterHeadersExports = appRouterHeaders.exports;
 
+var invariantError = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	Object.defineProperty(exports, "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));
+
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", {
 	    value: true
@@ -2173,12 +2225,12 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	    });
 	}
 	_export(exports, {
+	    getCacheSignal: function() {
+	        return getCacheSignal;
+	    },
 	    getDraftModeProviderForCacheScope: function() {
 	        return getDraftModeProviderForCacheScope;
 	    },
-	    getExpectedRequestStore: function() {
-	        return getExpectedRequestStore;
-	    },
 	    getHmrRefreshHash: function() {
 	        return getHmrRefreshHash;
 	    },
@@ -2188,50 +2240,28 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	    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 = workUnitAsyncStorageInstance;
 	const _approuterheaders = appRouterHeadersExports;
-	function getExpectedRequestStore(callingExpression) {
-	    const workUnitStore = _workunitasyncstorageinstance.workUnitAsyncStorageInstance.getStore();
-	    if (!workUnitStore) {
-	        throwForMissingRequestStore(callingExpression);
-	    }
-	    switch(workUnitStore.type){
-	        case 'request':
-	            return workUnitStore;
-	        case 'prerender':
-	        case 'prerender-client':
-	        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 = invariantError;
 	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",
@@ -2239,18 +2269,45 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	        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' || // TODO eliminate fetch caching in client scope and stop exposing this data cache during SSR
-	    workUnitStore.type === 'prerender-client' || 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 'request':
+	            {
+	                // In dev, we might fill caches even during a dynamic request.
+	                if (workUnitStore.prerenderResumeDataCache) {
+	                    return workUnitStore.prerenderResumeDataCache;
+	                }
+	            // fallthrough
+	            }
+	        case 'prerender-legacy':
+	        case 'cache':
+	        case 'private-cache':
+	        case 'unstable-cache':
+	            return null;
+	        default:
+	            return workUnitStore;
 	    }
-	    return null;
 	}
 	function getRenderResumeDataCache(workUnitStore) {
 	    switch(workUnitStore.type){
 	        case 'request':
-	            return workUnitStore.renderResumeDataCache;
 	        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
@@ -2261,31 +2318,107 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	        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;
-	        default:
+	            return workUnitStore.prerenderResumeDataCache ?? null;
+	        case 'cache':
+	        case 'private-cache':
+	        case 'unstable-cache':
+	        case 'prerender-legacy':
 	            return null;
+	        default:
+	            return workUnitStore;
 	    }
 	}
 	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 'request':
+	            {
+	                // In dev, we might fill caches even during a dynamic request.
+	                if (workUnitStore.cacheSignal) {
+	                    return workUnitStore.cacheSignal;
+	                }
+	            // fallthrough
+	            }
+	        case 'prerender-ppr':
+	        case 'prerender-legacy':
+	        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));
@@ -4172,7 +4305,7 @@ var hooksServerContext = {exports: {}};
 	const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
 	class DynamicServerError extends Error {
 	    constructor(description){
-	        super("Dynamic server usage: " + description), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+	        super(`Dynamic server usage: ${description}`), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
 	    }
 	}
 	function isDynamicServerError(err) {
@@ -4253,6 +4386,9 @@ var dynamicRenderingUtils = {};
 	    isHangingPromiseRejectionError: function() {
 	        return isHangingPromiseRejectionError;
 	    },
+	    makeDevtoolsIOAwarePromise: function() {
+	        return makeDevtoolsIOAwarePromise;
+	    },
 	    makeHangingPromise: function() {
 	        return makeHangingPromise;
 	    }
@@ -4265,17 +4401,17 @@ var dynamicRenderingUtils = {};
 	}
 	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);
@@ -4301,11 +4437,25 @@ var dynamicRenderingUtils = {};
 	    }
 	}
 	function ignoreReject() {}
+	function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
+	    if (requestStore.stagedRendering) {
+	        // We resolve each stage in a timeout, so React DevTools will pick this up as IO.
+	        return requestStore.stagedRendering.delayUntilStage(stage, undefined, 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));
 
-var metadataConstants = {};
+var boundaryConstants = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", {
@@ -4324,6 +4474,9 @@ var metadataConstants = {};
 	    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;
 	    }
@@ -4331,9 +4484,10 @@ var metadataConstants = {};
 	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));
+} (boundaryConstants));
 
 var scheduler = {};
 
@@ -4397,6 +4551,198 @@ var scheduler = {};
 	
 } (scheduler));
 
+var bailoutToCsr = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	function _export(target, all) {
+	    for(var name in all)Object.defineProperty(target, name, {
+	        enumerable: true,
+	        get: all[name]
+	    });
+	}
+	_export(exports, {
+	    BailoutToCSRError: function() {
+	        return BailoutToCSRError;
+	    },
+	    isBailoutToCSRError: function() {
+	        return isBailoutToCSRError;
+	    }
+	});
+	const BAILOUT_TO_CSR = 'BAILOUT_TO_CLIENT_SIDE_RENDERING';
+	class BailoutToCSRError extends Error {
+	    constructor(reason){
+	        super(`Bail out to client-side rendering: ${reason}`), this.reason = reason, this.digest = BAILOUT_TO_CSR;
+	    }
+	}
+	function isBailoutToCSRError(err) {
+	    if (typeof err !== 'object' || err === null || !('digest' in err)) {
+	        return false;
+	    }
+	    return err.digest === BAILOUT_TO_CSR;
+	}
+
+	
+} (bailoutToCsr));
+
+var stagedRendering = {};
+
+var promiseWithResolvers = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	Object.defineProperty(exports, "createPromiseWithResolvers", {
+	    enumerable: true,
+	    get: function() {
+	        return createPromiseWithResolvers;
+	    }
+	});
+	function createPromiseWithResolvers() {
+	    // Shim of Stage 4 Promise.withResolvers proposal
+	    let resolve;
+	    let reject;
+	    const promise = new Promise((res, rej)=>{
+	        resolve = res;
+	        reject = rej;
+	    });
+	    return {
+	        resolve: resolve,
+	        reject: reject,
+	        promise
+	    };
+	}
+
+	
+} (promiseWithResolvers));
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	function _export(target, all) {
+	    for(var name in all)Object.defineProperty(target, name, {
+	        enumerable: true,
+	        get: all[name]
+	    });
+	}
+	_export(exports, {
+	    RenderStage: function() {
+	        return RenderStage;
+	    },
+	    StagedRenderingController: function() {
+	        return StagedRenderingController;
+	    }
+	});
+	const _invarianterror = invariantError;
+	const _promisewithresolvers = promiseWithResolvers;
+	var RenderStage = /*#__PURE__*/ function(RenderStage) {
+	    RenderStage[RenderStage["Static"] = 1] = "Static";
+	    RenderStage[RenderStage["Runtime"] = 2] = "Runtime";
+	    RenderStage[RenderStage["Dynamic"] = 3] = "Dynamic";
+	    return RenderStage;
+	}({});
+	class StagedRenderingController {
+	    constructor(abortSignal = null){
+	        this.abortSignal = abortSignal;
+	        this.currentStage = 1;
+	        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+	        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+	        if (abortSignal) {
+	            abortSignal.addEventListener('abort', ()=>{
+	                const { reason } = abortSignal;
+	                if (this.currentStage < 2) {
+	                    this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
+	                    ;
+	                    this.runtimeStagePromise.reject(reason);
+	                }
+	                if (this.currentStage < 3) {
+	                    this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
+	                    ;
+	                    this.dynamicStagePromise.reject(reason);
+	                }
+	            }, {
+	                once: true
+	            });
+	        }
+	    }
+	    advanceStage(stage) {
+	        // If we're already at the target stage or beyond, do nothing.
+	        // (this can happen e.g. if sync IO advanced us to the dynamic stage)
+	        if (this.currentStage >= stage) {
+	            return;
+	        }
+	        this.currentStage = stage;
+	        // Note that we might be going directly from Static to Dynamic,
+	        // so we need to resolve the runtime stage as well.
+	        if (stage >= 2) {
+	            this.runtimeStagePromise.resolve();
+	        }
+	        if (stage >= 3) {
+	            this.dynamicStagePromise.resolve();
+	        }
+	    }
+	    getStagePromise(stage) {
+	        switch(stage){
+	            case 2:
+	                {
+	                    return this.runtimeStagePromise.promise;
+	                }
+	            case 3:
+	                {
+	                    return this.dynamicStagePromise.promise;
+	                }
+	            default:
+	                {
+	                    throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+	                        value: "E881",
+	                        enumerable: false,
+	                        configurable: true
+	                    });
+	                }
+	        }
+	    }
+	    waitForStage(stage) {
+	        return this.getStagePromise(stage);
+	    }
+	    delayUntilStage(stage, displayName, resolvedValue) {
+	        const ioTriggerPromise = this.getStagePromise(stage);
+	        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
+	        // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
+	        // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
+	        // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
+	        if (this.abortSignal) {
+	            promise.catch(ignoreReject);
+	        }
+	        return promise;
+	    }
+	}
+	function ignoreReject() {}
+	// TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
+	// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`
+	// is confusing, we should clean it up.
+	function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
+	    // If we create a `new Promise` and give it a displayName
+	    // (with no userspace code above us in the stack)
+	    // React Devtools will use it as the IO cause when determining "suspended by".
+	    // In particular, it should shadow any inner IO that resolved/rejected the promise
+	    // (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage)
+	    const promise = new Promise((resolve, reject)=>{
+	        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
+	    });
+	    if (displayName !== undefined) {
+	        // @ts-expect-error
+	        promise.displayName = displayName;
+	    }
+	    return promise;
+	}
+
+	
+} (stagedRendering));
+
 /**
  * The functions provided by this module are used to communicate certain properties
  * about the currently running code so that Next.js can make decisions on how to handle
@@ -4460,8 +4806,11 @@ var scheduler = {};
 	    createHangingInputAbortSignal: function() {
 	        return createHangingInputAbortSignal;
 	    },
-	    createPostponedAbortSignal: function() {
-	        return createPostponedAbortSignal;
+	    createRenderInBrowserAbortSignal: function() {
+	        return createRenderInBrowserAbortSignal;
+	    },
+	    delayUntilRuntimeStage: function() {
+	        return delayUntilRuntimeStage;
 	    },
 	    formatDynamicAPIAccesses: function() {
 	        return formatDynamicAPIAccesses;
@@ -4475,6 +4824,9 @@ var scheduler = {};
 	    isPrerenderInterruptedError: function() {
 	        return isPrerenderInterruptedError;
 	    },
+	    logDisallowedDynamicError: function() {
+	        return logDisallowedDynamicError;
+	    },
 	    markCurrentScopeAsDynamic: function() {
 	        return markCurrentScopeAsDynamic;
 	    },
@@ -4493,17 +4845,14 @@ var scheduler = {};
 	    trackDynamicDataInDynamicRender: function() {
 	        return trackDynamicDataInDynamicRender;
 	    },
-	    trackFallbackParamAccessed: function() {
-	        return trackFallbackParamAccessed;
-	    },
 	    trackSynchronousPlatformIOAccessInDev: function() {
 	        return trackSynchronousPlatformIOAccessInDev;
 	    },
-	    trackSynchronousRequestDataAccessInDev: function() {
-	        return trackSynchronousRequestDataAccessInDev;
-	    },
 	    useDynamicRouteParams: function() {
 	        return useDynamicRouteParams;
+	    },
+	    useDynamicSearchParams: function() {
+	        return useDynamicSearchParams;
 	    }
 	});
 	const _react = /*#__PURE__*/ _interop_require_default(reactExports);
@@ -4512,8 +4861,11 @@ var scheduler = {};
 	const _workunitasyncstorageexternal = workUnitAsyncStorage_external;
 	const _workasyncstorageexternal = workAsyncStorage_external;
 	const _dynamicrenderingutils = dynamicRenderingUtils;
-	const _metadataconstants = metadataConstants;
+	const _boundaryconstants = boundaryConstants;
 	const _scheduler = scheduler;
+	const _bailouttocsr = bailoutToCsr;
+	const _invarianterror = invariantError;
+	const _stagedrendering = stagedRendering;
 	function _interop_require_default(obj) {
 	    return obj && obj.__esModule ? obj : {
 	        default: obj
@@ -4542,11 +4894,17 @@ var scheduler = {};
 	}
 	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
@@ -4561,29 +4919,29 @@ var scheduler = {};
 	        });
 	    }
 	    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", {
@@ -4596,21 +4954,29 @@ var scheduler = {};
 	    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;
-	        }
-	        // TODO: it makes no sense to have these work unit store types during a dev render.
-	        if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-client' || 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;
 	    }
 	}
 	function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
@@ -4642,8 +5008,12 @@ var scheduler = {};
 	}
 	function trackSynchronousPlatformIOAccessInDev(requestStore) {
 	    // We don't actually have a controller to abort but we do the semantic equivalent by
-	    // advancing the request store out of prerender mode
-	    requestStore.prerenderPhase = false;
+	    // advancing the request store out of the prerender stage
+	    if (requestStore.stagedRendering) {
+	        // TODO: error for sync IO in the runtime stage
+	        // (which is not currently covered by the validation render in `spawnDynamicValidationInDev`)
+	        requestStore.stagedRendering.advanceStage(_stagedrendering.RenderStage.Dynamic);
+	    }
 	}
 	function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
 	    const prerenderSignal = prerenderStore.controller.signal;
@@ -4667,7 +5037,6 @@ var scheduler = {};
 	    }
 	    throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
 	}
-	const trackSynchronousRequestDataAccessInDev = trackSynchronousPlatformIOAccessInDev;
 	function Postpone({ reason, route }) {
 	    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
 	    const dynamicTracking = prerenderStore && prerenderStore.type === 'prerender-ppr' ? prerenderStore.dynamicTracking : null;
@@ -4759,35 +5128,57 @@ var scheduler = {};
 	        });
 	    }
 	}
-	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;
@@ -4800,31 +5191,111 @@ var scheduler = {};
 	}
 	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-client') {
-	                // 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
+	                });
 	        }
 	    }
 	}
+	function useDynamicSearchParams(expression) {
+	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+	    if (!workStore) {
+	        // We assume pages router context and just return
+	        return;
+	    }
+	    if (!workUnitStore) {
+	        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
+	    }
+	    switch(workUnitStore.type){
+	        case 'prerender-client':
+	            {
+	                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+	                break;
+	            }
+	        case 'prerender-legacy':
+	        case 'prerender-ppr':
+	            {
+	                if (workStore.forceStatic) {
+	                    return;
+	                }
+	                throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(expression), "__NEXT_ERROR_CODE", {
+	                    value: "E394",
+	                    enumerable: false,
+	                    configurable: true
+	                });
+	            }
+	        case 'prerender':
+	        case 'prerender-runtime':
+	            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called from a Server Component. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+	                value: "E795",
+	                enumerable: false,
+	                configurable: true
+	            });
+	        case 'cache':
+	        case 'unstable-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
+	            });
+	        case 'request':
+	            return;
+	    }
+	}
 	const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
-	const hasSuspenseAfterBodyOrHtmlRegex = /\n\s+at (?:body|html) \(<anonymous>\)[\s\S]*?\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]`);
+	// 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.
@@ -4835,9 +5306,10 @@ var scheduler = {};
 	    } else if (hasViewportRegex.test(componentStack)) {
 	        dynamicValidation.hasDynamicViewport = true;
 	        return;
-	    } else if (hasSuspenseAfterBodyOrHtmlRegex.test(componentStack)) {
-	        // This prerender has a Suspense boundary above the body which
-	        // effectively opts the page into allowing 100% dynamic rendering
+	    } 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;
@@ -4851,7 +5323,7 @@ var scheduler = {};
 	        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
 	        return;
 	    } else {
-	        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 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);
 	        dynamicValidation.dynamicErrors.push(error);
 	        return;
@@ -4889,8 +5361,8 @@ var scheduler = {};
 	    }
 	}
 	function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
-	    if (workStore.invalidDynamicUsageError) {
-	        logDisallowedDynamicError(workStore, workStore.invalidDynamicUsageError);
+	    if (serverDynamic.syncDynamicErrorWithStack) {
+	        logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
 	        throw new _staticgenerationbailout.StaticGenBailoutError();
 	    }
 	    if (prelude !== 0) {
@@ -4900,13 +5372,6 @@ var scheduler = {};
 	            // a lack of a shell is not considered disallowed so we simply return
 	            return;
 	        }
-	        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
@@ -4939,6 +5404,12 @@ var scheduler = {};
 	        }
 	    }
 	}
+	function delayUntilRuntimeStage(prerenderStore, result) {
+	    if (prerenderStore.runtimeStagePromise) {
+	        return prerenderStore.runtimeStagePromise.then(()=>result);
+	    }
+	    return result;
+	}
 
 	
 } (dynamicRendering));
@@ -4997,22 +5468,12 @@ var afterTaskAsyncStorageInstance = {};
 	    throwForSearchParamsAccessInUseCache: function() {
 	        return throwForSearchParamsAccessInUseCache;
 	    },
-	    throwWithStaticGenerationBailoutError: function() {
-	        return throwWithStaticGenerationBailoutError;
-	    },
 	    throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
 	        return throwWithStaticGenerationBailoutErrorWithDynamicError;
 	    }
 	});
 	const _staticgenerationbailout = staticGenerationBailoutExports;
 	const _aftertaskasyncstorageexternal = afterTaskAsyncStorage_external;
-	function throwWithStaticGenerationBailoutError(route, expression) {
-	    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-	        value: "E576",
-	        enumerable: false,
-	        configurable: true
-	    });
-	}
 	function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
 	    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
 	        value: "E543",
@@ -5021,8 +5482,8 @@ var afterTaskAsyncStorageInstance = {};
 	    });
 	}
 	function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
-	    const error = Object.defineProperty(new Error(`Route ${workStore.route} used "searchParams" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "searchParams" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-	        value: "E634",
+	    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+	        value: "E842",
 	        enumerable: false,
 	        configurable: true
 	    });
@@ -5054,294 +5515,100 @@ var afterTaskAsyncStorageInstance = {};
 	const _staticgenerationbailout = staticGenerationBailoutExports;
 	const _dynamicrenderingutils = dynamicRenderingUtils;
 	const _utils = utils;
+	const _stagedrendering = stagedRendering;
 	function connection() {
+	    const callingExpression = 'connection';
 	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
 	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
 	    if (workStore) {
 	        if (workUnitStore && workUnitStore.phase === 'after' && !(0, _utils.isRequestAPICallableInsideAfter)()) {
-	            throw Object.defineProperty(new Error(`Route ${workStore.route} used "connection" inside "after(...)". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but "after(...)" executes after the request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
-	                value: "E186",
+	            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside \`after()\`. The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but \`after()\` executes after the request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+	                value: "E827",
 	                enumerable: false,
 	                configurable: true
 	            });
 	        }
 	        if (workStore.forceStatic) {
-	            // When using forceStatic we override all other logic and always just return an empty
-	            // headers object without tracking
+	            // When using forceStatic, we override all other logic and always just
+	            // return a resolving promise without tracking.
 	            return Promise.resolve(undefined);
 	        }
-	        if (workUnitStore) {
-	            if (workUnitStore.type === 'cache') {
-	                throw Object.defineProperty(new Error(`Route ${workStore.route} used "connection" inside "use cache". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but caches must be able to be produced before a Request so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-	                    value: "E111",
-	                    enumerable: false,
-	                    configurable: true
-	                });
-	            } else if (workUnitStore.type === 'unstable-cache') {
-	                throw Object.defineProperty(new Error(`Route ${workStore.route} used "connection" inside a function cached with "unstable_cache(...)". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but caches must be able to be produced before a Request so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-	                    value: "E1",
-	                    enumerable: false,
-	                    configurable: true
-	                });
-	            }
-	        }
 	        if (workStore.dynamicShouldError) {
-	            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`connection\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-	                value: "E562",
+	            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`connection()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+	                value: "E847",
 	                enumerable: false,
 	                configurable: true
 	            });
 	        }
 	        if (workUnitStore) {
-	            if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-client') {
-	                // dynamicIO Prerender
-	                // We return a promise that never resolves to allow the prender to stall at this point
-	                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, '`connection()`');
-	            } else if (workUnitStore.type === 'prerender-ppr') {
-	                // PPR Prerender (no dynamicIO)
-	                // We use React's postpone API to interrupt rendering here to create a dynamic hole
-	                (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'connection', workUnitStore.dynamicTracking);
-	            } else if (workUnitStore.type === 'prerender-legacy') {
-	                // Legacy Prerender
-	                // We throw an error here to interrupt prerendering to mark the route as dynamic
-	                (0, _dynamicrendering.throwToInterruptStaticGeneration)('connection', workStore, workUnitStore);
-	            }
-	        }
-	        // We fall through to the dynamic context below but we still track dynamic access
-	        // because in dev we can still error for things like using headers inside a cache context
-	        (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workStore, workUnitStore);
-	    }
-	    return Promise.resolve(undefined);
-	}
-
-	
-} (connection));
-
-var rootParams = {};
-
-var invariantError = {};
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", {
-	    value: true
-	});
-	Object.defineProperty(exports, "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));
-
-var reflectUtils = {};
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", {
-	    value: true
-	});
-	function _export(target, all) {
-	    for(var name in all)Object.defineProperty(target, name, {
-	        enumerable: true,
-	        get: all[name]
-	    });
-	}
-	_export(exports, {
-	    describeHasCheckingStringProperty: function() {
-	        return describeHasCheckingStringProperty;
-	    },
-	    describeStringPropertyAccess: function() {
-	        return describeStringPropertyAccess;
-	    },
-	    wellKnownProperties: function() {
-	        return wellKnownProperties;
-	    }
-	});
-	const isDefinitelyAValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-	function describeStringPropertyAccess(target, prop) {
-	    if (isDefinitelyAValidIdentifier.test(prop)) {
-	        return "`" + target + "." + prop + "`";
-	    }
-	    return "`" + target + "[" + JSON.stringify(prop) + "]`";
-	}
-	function describeHasCheckingStringProperty(target, prop) {
-	    const stringifiedProp = JSON.stringify(prop);
-	    return "`Reflect.has(" + target + ", " + stringifiedProp + ")`, `" + stringifiedProp + " in " + target + "`, or similar";
-	}
-	const wellKnownProperties = new Set([
-	    'hasOwnProperty',
-	    'isPrototypeOf',
-	    'propertyIsEnumerable',
-	    'toString',
-	    'valueOf',
-	    'toLocaleString',
-	    // Promise prototype
-	    // fallthrough
-	    'then',
-	    'catch',
-	    'finally',
-	    // React Promise extension
-	    // fallthrough
-	    'status',
-	    // React introspection
-	    'displayName',
-	    '_debugInfo',
-	    // Common tested properties
-	    // fallthrough
-	    'toJSON',
-	    '$$typeof',
-	    '__esModule'
-	]);
-
-	
-} (reflectUtils));
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", {
-	    value: true
-	});
-	Object.defineProperty(exports, "unstable_rootParams", {
-	    enumerable: true,
-	    get: function() {
-	        return unstable_rootParams;
-	    }
-	});
-	const _invarianterror = invariantError;
-	const _dynamicrendering = dynamicRendering;
-	const _workasyncstorageexternal = workAsyncStorage_external;
-	const _workunitasyncstorageexternal = workUnitAsyncStorage_external;
-	const _dynamicrenderingutils = dynamicRenderingUtils;
-	const _reflectutils = reflectUtils;
-	const CachedParams = new WeakMap();
-	async function unstable_rootParams() {
-	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-	    if (!workStore) {
-	        throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in unstable_rootParams'), "__NEXT_ERROR_CODE", {
-	            value: "E615",
-	            enumerable: false,
-	            configurable: true
-	        });
-	    }
-	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-	    if (!workUnitStore) {
-	        throw Object.defineProperty(new Error(`Route ${workStore.route} used \`unstable_rootParams()\` in Pages Router. This API is only available within App Router.`), "__NEXT_ERROR_CODE", {
-	            value: "E641",
-	            enumerable: false,
-	            configurable: true
-	        });
-	    }
-	    switch(workUnitStore.type){
-	        case 'unstable-cache':
-	        case 'cache':
-	            {
-	                throw Object.defineProperty(new Error(`Route ${workStore.route} used \`unstable_rootParams()\` inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
-	                    value: "E642",
-	                    enumerable: false,
-	                    configurable: true
-	                });
-	            }
-	        case 'prerender':
-	        case 'prerender-client':
-	        case 'prerender-ppr':
-	        case 'prerender-legacy':
-	            return createPrerenderRootParams(workUnitStore.rootParams, workStore, workUnitStore);
-	        default:
-	            return Promise.resolve(workUnitStore.rootParams);
-	    }
-	}
-	function createPrerenderRootParams(underlyingParams, workStore, prerenderStore) {
-	    const fallbackParams = workStore.fallbackRouteParams;
-	    if (fallbackParams) {
-	        let hasSomeFallbackParams = false;
-	        for(const key in underlyingParams){
-	            if (fallbackParams.has(key)) {
-	                hasSomeFallbackParams = true;
-	                break;
-	            }
-	        }
-	        if (hasSomeFallbackParams) {
-	            // params need to be treated as dynamic because we have at least one fallback param
-	            switch(prerenderStore.type){
-	                case 'prerender':
-	                    // We are in a dynamicIO prerender
-	                    const cachedParams = CachedParams.get(underlyingParams);
-	                    if (cachedParams) {
-	                        return cachedParams;
+	            switch(workUnitStore.type){
+	                case 'cache':
+	                    {
+	                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside "use cache". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual request, but caches must be able to be produced before a request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+	                            value: "E841",
+	                            enumerable: false,
+	                            configurable: true
+	                        });
+	                        Error.captureStackTrace(error, connection);
+	                        workStore.invalidDynamicUsageError ??= error;
+	                        throw error;
 	                    }
-	                    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, '`unstable_rootParams`');
-	                    CachedParams.set(underlyingParams, promise);
-	                    return promise;
-	                case 'prerender-client':
-	                    const exportName = '`unstable_rootParams`';
-	                    throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a client component. Next.js should be preventing ${exportName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-	                        value: "E693",
+	                case 'private-cache':
+	                    {
+	                        // It might not be intuitive to throw for private caches as well, but
+	                        // we don't consider runtime prefetches as "actual requests" (in the
+	                        // navigation sense), despite allowing them to read cookies.
+	                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside "use cache: private". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual navigation request, but caches must be able to be produced before a navigation request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+	                            value: "E837",
+	                            enumerable: false,
+	                            configurable: true
+	                        });
+	                        Error.captureStackTrace(error, connection);
+	                        workStore.invalidDynamicUsageError ??= error;
+	                        throw error;
+	                    }
+	                case 'unstable-cache':
+	                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside a function cached with \`unstable_cache()\`. The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but caches must be able to be produced before a Request so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+	                        value: "E840",
 	                        enumerable: false,
 	                        configurable: true
 	                    });
-	                default:
-	                    // remaining cases are prerender-ppr and prerender-legacy
-	                    // We aren't in a dynamicIO prerender but we do have fallback params at this
-	                    // level so we need to make an erroring params object which will postpone
-	                    // if you access the fallback params
-	                    return makeErroringRootParams(underlyingParams, fallbackParams, workStore, prerenderStore);
-	            }
-	        }
-	    }
-	    // We don't have any fallback params so we have an entirely static safe params object
-	    return Promise.resolve(underlyingParams);
-	}
-	function makeErroringRootParams(underlyingParams, fallbackParams, workStore, prerenderStore) {
-	    const cachedParams = CachedParams.get(underlyingParams);
-	    if (cachedParams) {
-	        return cachedParams;
-	    }
-	    const augmentedUnderlying = {
-	        ...underlyingParams
-	    };
-	    // We don't use makeResolvedReactPromise here because params
-	    // supports copying with spread and we don't want to unnecessarily
-	    // instrument the promise with spreadable properties of ReactPromise.
-	    const promise = Promise.resolve(augmentedUnderlying);
-	    CachedParams.set(underlyingParams, promise);
-	    Object.keys(underlyingParams).forEach((prop)=>{
-	        if (_reflectutils.wellKnownProperties.has(prop)) ; else {
-	            if (fallbackParams.has(prop)) {
-	                Object.defineProperty(augmentedUnderlying, prop, {
-	                    get () {
-	                        const expression = (0, _reflectutils.describeStringPropertyAccess)('unstable_rootParams', prop);
-	                        // In most dynamic APIs we also throw if `dynamic = "error"` however
-	                        // for params is only dynamic when we're generating a fallback shell
-	                        // and even when `dynamic = "error"` we still support generating dynamic
-	                        // fallback shells
-	                        // TODO remove this comment when dynamicIO is the default since there
-	                        // will be no `dynamic = "error"`
-	                        if (prerenderStore.type === 'prerender-ppr') {
-	                            // PPR Prerender (no dynamicIO)
-	                            (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
-	                        } else {
-	                            // Legacy Prerender
-	                            (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
+	                case 'prerender':
+	                case 'prerender-client':
+	                case 'prerender-runtime':
+	                    // We return a promise that never resolves to allow the prerender to
+	                    // stall at this point.
+	                    return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`connection()`');
+	                case 'prerender-ppr':
+	                    // We use React's postpone API to interrupt rendering here to create a
+	                    // dynamic hole
+	                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'connection', workUnitStore.dynamicTracking);
+	                case 'prerender-legacy':
+	                    // We throw an error here to interrupt prerendering to mark the route
+	                    // as dynamic
+	                    return (0, _dynamicrendering.throwToInterruptStaticGeneration)('connection', workStore, workUnitStore);
+	                case 'request':
+	                    (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
+	                    if (process.env.NODE_ENV === 'development') {
+	                        // Semantically we only need the dev tracking when running in `next dev`
+	                        // but since you would never use next dev with production NODE_ENV we use this
+	                        // as a proxy so we can statically exclude this code from production builds.
+	                        if (workUnitStore.asyncApiPromises) {
+	                            return workUnitStore.asyncApiPromises.connection;
 	                        }
-	                    },
-	                    enumerable: true
-	                });
-	            } else {
-	                promise[prop] = underlyingParams[prop];
+	                        return (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, _stagedrendering.RenderStage.Dynamic);
+	                    } else {
+	                        return Promise.resolve(undefined);
+	                    }
 	            }
 	        }
-	    });
-	    return promise;
+	    }
+	    // If we end up here, there was no work store or work unit store present.
+	    (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
 	}
 
 	
-} (rootParams));
+} (connection));
 
 (function (module, exports) {
 	const serverExports = {
@@ -5359,8 +5626,6 @@ var reflectUtils = {};
 	    .URLPattern,
 	  after: after$1.after,
 	  connection: connection.connection,
-	  unstable_rootParams: rootParams
-	    .unstable_rootParams,
 	};
 
 	// https://nodejs.org/api/esm.html#commonjs-namespaces
@@ -5375,8 +5640,7 @@ var reflectUtils = {};
 	exports.userAgent = serverExports.userAgent;
 	exports.URLPattern = serverExports.URLPattern;
 	exports.after = serverExports.after;
-	exports.connection = serverExports.connection;
-	exports.unstable_rootParams = serverExports.unstable_rootParams; 
+	exports.connection = serverExports.connection; 
 } (server, server.exports));
 
 var serverExports = server.exports;
@@ -12544,6 +12808,13 @@ var checkoutSessionCustomizationSchema = objectType({
 }).optional();
 var checkoutSessionFeatureFlagsSchema = objectType({
   allow_currency_selection: booleanType().optional(),
+  allow_customer_editing_city: booleanType().optional(),
+  allow_customer_editing_country: booleanType().optional(),
+  allow_customer_editing_email: booleanType().optional(),
+  allow_customer_editing_name: booleanType().optional(),
+  allow_customer_editing_state: booleanType().optional(),
+  allow_customer_editing_street: booleanType().optional(),
+  allow_customer_editing_zipcode: booleanType().optional(),
   allow_discount_code: booleanType().optional(),
   allow_phone_number_collection: booleanType().optional(),
   allow_tax_id: booleanType().optional(),
@@ -12644,7 +12915,11 @@ var buildCheckoutUrl = async ({
     if (!sessionPayload) {
       throw new Error("sessionPayload is required when type is 'session'");
     }
-    const session = await createCheckoutSession(sessionPayload, {
+    const finalPayload = {
+      ...sessionPayload,
+      return_url: sessionPayload.return_url ?? returnUrl
+    };
+    const session = await createCheckoutSession(finalPayload, {
       bearerToken,
       environment
     });
@@ -13275,6 +13550,12 @@ var SubscriptionExpiredPayloadSchema = objectType({
   timestamp: stringType().transform((d) => new Date(d)),
   data: SubscriptionSchema
 });
+var SubscriptionUpdatedPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("subscription.updated"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
+});
 var LicenseKeyCreatedPayloadSchema = objectType({
   business_id: stringType(),
   type: literalType("license_key.created"),
@@ -13303,6 +13584,7 @@ var WebhookPayloadSchema = discriminatedUnionType("type", [
   SubscriptionCancelledPayloadSchema,
   SubscriptionFailedPayloadSchema,
   SubscriptionExpiredPayloadSchema,
+  SubscriptionUpdatedPayloadSchema,
   LicenseKeyCreatedPayloadSchema
 ]);
 
@@ -13377,6 +13659,9 @@ async function handleWebhookPayload(payload, config, context) {
   if (payload.type === "subscription.expired") {
     await callHandler(config.onSubscriptionExpired, payload);
   }
+  if (payload.type === "subscription.updated") {
+    await callHandler(config.onSubscriptionUpdated, payload);
+  }
   if (payload.type === "license_key.created") {
     await callHandler(config.onLicenseKeyCreated, payload);
   }