failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/server/request/cache-stages.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    navigation: null,
+    prefetch: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    navigation: function() {
+        return navigation;
+    },
+    prefetch: function() {
+        return prefetch;
+    }
+});
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _utils = require("./utils");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _stagedrendering = require("../app-render/staged-rendering");
+function prefetch() {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!workStore || !workUnitStore) {
+        const callingExpression = 'prefetch';
+        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+    }
+    if (!process.env.__NEXT_CACHE_COMPONENTS) {
+        throw new Error(`Route ${workStore.route} used \`prefetch()\`, which requires Cache Components to be enabled. Learn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents`);
+    }
+    if (!(0, _utils.isRequestApiAllowedInCurrentPhase)(workUnitStore)) {
+        throw new Error(`Route ${workStore.route} used \`prefetch()\` inside \`after()\` while rendering. The \`prefetch()\` function is used to indicate the subsequent code must not run in the app shell, but \`after()\` executes after the request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`);
+    }
+    const stageVariants = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticUrlData.prefetchApi;
+    switch(workUnitStore.type){
+        case 'prerender':
+            {
+                // Content below `prefetch()` is excluded from the shell, but it's
+                // deliberately included in the static output (and thus in static
+                // prefetches), so we only delay it until the static prefetch stage.
+                // It resolves in `PrefetchStatic_prefetchApi`, one stage ahead of URL data,
+                // so validation can attribute a blocking hole to `prefetch()`.
+                const { stagedRendering } = workUnitStore;
+                if (!stagedRendering) {
+                    // Prospective prerender
+                    // `prefetch()` will resolve in the final prerender, so resolve it here as well.
+                    return Promise.resolve(undefined);
+                } else {
+                    // Final prerender
+                    return stagedRendering.delayUntilStage(stageVariants.static, 'prefetch', undefined);
+                }
+            }
+        case 'prerender-runtime':
+            {
+                // In a shell render, prefetch() doesn't resolve, because it doesn't reach
+                // `PrefetchRuntime`. It'll resolve in a runtime prefetch, and in a runtime
+                // prerender produced during a navigation.
+                // Note that this does not mark the subtree as dynamic -- content guarded by
+                // prefetch() is still considered cacheable.
+                const { stagedRendering } = workUnitStore;
+                const prefetchStage = stageVariants.runtime;
+                if (!stagedRendering) {
+                    // Prospective prerender
+                    // Make sure we don't unblock content that won't be reached in the final prerender.
+                    if (workUnitStore.finalStage < prefetchStage) {
+                        return (0, _dynamicrenderingutils.makePrefetchHangingPromise)(workUnitStore.renderSignal, workStore.route, '`prefetch()`');
+                    } else {
+                        return Promise.resolve(undefined);
+                    }
+                } else {
+                    // Final prerender
+                    return stagedRendering.delayUntilStage(prefetchStage, 'prefetch', undefined);
+                }
+            }
+        case 'request':
+            {
+                const { stagedRendering } = workUnitStore;
+                if (stagedRendering) {
+                    // We can either recover a static shell or a runtime shell, but not both.
+                    (0, _dynamicrenderingutils.trackIncompatibleShellContent)(workUnitStore, '`prefetch()`');
+                    const stage = stageVariants[workUnitStore.needsRuntimeShell ? 'runtime' // Match the timing of 'prerender-runtime'.
+                     : 'static' // Match the timing of 'prerender'.
+                    ];
+                    return stagedRendering.delayUntilStage(stage, 'prefetch', undefined);
+                }
+                return Promise.resolve(undefined);
+            }
+        case 'cache':
+            {
+                const error = new Error(`Route ${workStore.route} used \`prefetch()\` inside "use cache". This is not currently supported. Instead, move the "use cache" directive to a function that's called below \`await prefetch()\`, so that the cached content is deferred to the prefetch without caching the stage boundary itself. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`);
+                Error.captureStackTrace(error, prefetch);
+                (0, _dynamicrenderingutils.applyOwnerStack)(error);
+                workStore.invalidDynamicUsageError ??= error;
+                throw error;
+            }
+        case 'private-cache':
+            {
+                const error = new Error(`Route ${workStore.route} used \`prefetch()\` inside "use cache: private". This is not currently supported. Instead, move the "use cache" directive to a function that's called below \`await prefetch()\`, so that the cached content is deferred to the prefetch without caching the stage boundary itself. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`);
+                Error.captureStackTrace(error, prefetch);
+                (0, _dynamicrenderingutils.applyOwnerStack)(error);
+                workStore.invalidDynamicUsageError ??= error;
+                throw error;
+            }
+        case 'unstable-cache':
+            {
+                throw new Error(`Route ${workStore.route} used \`prefetch()\` inside a function cached with \`unstable_cache()\`. The \`prefetch()\` function is used to indicate the subsequent code must not run in the app shell, but \`unstable_cache()\` caches must be able to be produced before a prefetch, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`);
+            }
+        case 'build-time-generator':
+            {
+                throw new Error(`Route ${workStore.route} used \`prefetch()\` inside \`${workUnitStore.functionName}\`. This is not supported because \`${workUnitStore.functionName}\` runs at build time without a prefetch. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
+            }
+        case 'prerender-client':
+        case 'validation-client':
+            {
+                const exportName = '`prefetch`';
+                throw 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.`);
+            }
+        case 'prerender-legacy':
+            {
+                // NOTE: Should not be reachable, because we don't use this mode in cacheComponents,
+                // which we require at the top
+                throw new Error(`Route ${workStore.route} used \`prefetch()\`, which requires Cache Components to be enabled. Learn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents`);
+            }
+        default:
+            {
+                workUnitStore;
+                return Promise.resolve(undefined);
+            }
+    }
+}
+function navigation() {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!workStore || !workUnitStore) {
+        const callingExpression = 'navigation';
+        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+    }
+    if (!process.env.__NEXT_CACHE_COMPONENTS) {
+        throw new Error(`Route ${workStore.route} used \`navigation()\`, which requires Cache Components to be enabled. Learn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents`);
+    }
+    if (!(0, _utils.isRequestApiAllowedInCurrentPhase)(workUnitStore)) {
+        throw new Error(`Route ${workStore.route} used \`navigation()\` inside \`after()\` while rendering. The \`navigation()\` function is used to indicate the subsequent code must only run during an actual navigation, but \`after()\` executes after the request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`);
+    }
+    switch(workUnitStore.type){
+        case 'prerender':
+            {
+                // Static prerenders are computed once and shared across many
+                // clients, so there's no per-request prefetch cost to save by
+                // deferring the content — it's deliberately included in the static
+                // output (and thus in static prefetches).
+                // However, it's excluded from the shell, and has to be separated from
+                // prefetch(), so we have to delay it.
+                const { stagedRendering } = workUnitStore;
+                if (!stagedRendering) {
+                    // Prospective prerender
+                    // `navigation()` will resolve in the final prerender, so resolve it here as well.
+                    return Promise.resolve(undefined);
+                } else {
+                    // Final prerender
+                    return stagedRendering.delayUntilStage(_stagedrendering.RenderStage.NavigationStatic, 'navigation', undefined);
+                }
+            }
+        case 'prerender-runtime':
+            {
+                // In a shell or runtime prefetch, navigation() doesn't resolve,
+                // because they don't reach `NavigationRuntime`.
+                // It'll only resolve in a runtime prerender produced during a navigation.
+                // Note that this does not mark the subtree as dynamic -- content guarded by
+                // navigation() is still considered cacheable.
+                const { stagedRendering } = workUnitStore;
+                const navigationStage = _stagedrendering.RenderStage.NavigationRuntime;
+                if (!stagedRendering) {
+                    // Prospective prerender
+                    // Make sure we don't unblock content that won't be reached in the final prerender.
+                    if (workUnitStore.finalStage < navigationStage) {
+                        return (0, _dynamicrenderingutils.makeUntrackedHangingPromise)(workUnitStore.renderSignal, workStore.route, '`navigation()`');
+                    } else {
+                        return Promise.resolve(undefined);
+                    }
+                } else {
+                    // Final prerender
+                    return stagedRendering.delayUntilStage(navigationStage, 'navigation', undefined);
+                }
+            }
+        case 'request':
+            {
+                const { stagedRendering } = workUnitStore;
+                if (stagedRendering) {
+                    // We can either recover a static shell or a runtime shell, but not both.
+                    (0, _dynamicrenderingutils.trackIncompatibleShellContent)(workUnitStore, '`navigation()`');
+                    const stage = workUnitStore.needsRuntimeShell ? _stagedrendering.RenderStage.NavigationRuntime // Match the timing of 'prerender-runtime'.
+                     : _stagedrendering.RenderStage.NavigationStatic // Match the timing of 'prerender'.
+                    ;
+                    return stagedRendering.delayUntilStage(stage, 'navigation', undefined);
+                }
+                return Promise.resolve(undefined);
+            }
+        case 'cache':
+            {
+                const error = new Error(`Route ${workStore.route} used \`navigation()\` inside "use cache". This is not currently supported. Instead, move the "use cache" directive to a function that's called below \`await navigation()\`, so that the cached content is deferred to the navigation without caching the stage boundary itself. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`);
+                Error.captureStackTrace(error, navigation);
+                (0, _dynamicrenderingutils.applyOwnerStack)(error);
+                workStore.invalidDynamicUsageError ??= error;
+                throw error;
+            }
+        case 'private-cache':
+            {
+                const error = new Error(`Route ${workStore.route} used \`navigation()\` inside "use cache: private". This is not currently supported. Instead, move the "use cache" directive to a function that's called below \`await navigation()\`, so that the cached content is deferred to the navigation without caching the stage boundary itself. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`);
+                Error.captureStackTrace(error, navigation);
+                (0, _dynamicrenderingutils.applyOwnerStack)(error);
+                workStore.invalidDynamicUsageError ??= error;
+                throw error;
+            }
+        case 'unstable-cache':
+            {
+                throw new Error(`Route ${workStore.route} used \`navigation()\` inside a function cached with \`unstable_cache()\`. The \`navigation()\` function is used to indicate the subsequent code must only run during an actual navigation, but \`unstable_cache()\` caches must be able to be produced before a navigation, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`);
+            }
+        case 'build-time-generator':
+            {
+                throw new Error(`Route ${workStore.route} used \`navigation()\` inside \`${workUnitStore.functionName}\`. This is not supported because \`${workUnitStore.functionName}\` runs at build time without a navigation. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
+            }
+        case 'prerender-client':
+        case 'validation-client':
+            {
+                const exportName = '`navigation`';
+                throw 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.`);
+            }
+        case 'prerender-legacy':
+            {
+                // NOTE: Should not be reachable, because we don't use this mode in cacheComponents,
+                // which we require at the top
+                throw new Error(`Route ${workStore.route} used \`navigation()\`, which requires Cache Components to be enabled. Learn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents`);
+            }
+        default:
+            {
+                workUnitStore;
+                return Promise.resolve(undefined);
+            }
+    }
+}
+
+//# sourceMappingURL=cache-stages.js.map

package/.next/standalone/node_modules/next/dist/server/request/connection.js

@@ -16,17 +16,14 @@ const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _utils = require("./utils");
 const _stagedrendering = require("../app-render/staged-rendering");
 const _invarianterror = require("../../shared/lib/invariant-error");
+const _usecachemessages = require("../use-cache/use-cache-messages");
 function connection() {
     const callingExpression = 'connection';
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workStore) {
         if (workUnitStore && !(0, _utils.isRequestApiAllowedInCurrentPhase)(workUnitStore)) {
-            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside \`after()\` while rendering. 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/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
-                value: "E1377",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Route ${workStore.route} used \`connection()\` inside \`after()\` while rendering. 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/app/api-reference/functions/after`);
         }
         if (workStore.forceStatic) {
             // When using forceStatic, we override all other logic and always just
@@ -34,21 +31,13 @@ function connection() {
             return Promise.resolve(undefined);
         }
         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: "E847",
-                enumerable: false,
-                configurable: true
-            });
+            throw 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`);
         }
         if (workUnitStore) {
             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
-                        });
+                        const error = (0, _usecachemessages.createConnectionInPublicUseCacheError)(workStore.route);
                         Error.captureStackTrace(error, connection);
                         (0, _dynamicrenderingutils.applyOwnerStack)(error);
                         workStore.invalidDynamicUsageError ??= error;
@@ -59,28 +48,16 @@ function connection() {
                         // 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
-                        });
+                        const error = (0, _usecachemessages.createConnectionInPrivateUseCacheError)(workStore.route);
                         Error.captureStackTrace(error, connection);
                         (0, _dynamicrenderingutils.applyOwnerStack)(error);
                         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
-                    });
-                case 'generate-static-params':
-                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside \`generateStaticParams\`. This is not supported because \`generateStaticParams\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
-                        value: "E1125",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw (0, _usecachemessages.createConnectionInUnstableCacheError)(workStore.route);
+                case 'build-time-generator':
+                    throw new Error(`Route ${workStore.route} used \`connection()\` inside \`${workUnitStore.functionName}\`. This is not supported because \`${workUnitStore.functionName}\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
                 case 'prerender':
                 case 'prerender-client':
                 case 'prerender-runtime':
@@ -92,16 +69,8 @@ function connection() {
                         // TODO(NAR-789): make this consistent with the actual browser behavior when we change it.
                         // Until then, erroring is fine.
                         const exportName = '`connection`';
-                        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: "E1063",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw 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.`);
                     }
-                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

package/.next/standalone/node_modules/next/dist/server/request/cookies.js

@@ -18,17 +18,14 @@ const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
 const _utils = require("./utils");
 const _invarianterror = require("../../shared/lib/invariant-error");
+const _usecachemessages = require("../use-cache/use-cache-messages");
 function cookies() {
     const callingExpression = 'cookies';
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workStore) {
         if (workUnitStore && !(0, _utils.isRequestApiAllowedInCurrentPhase)(workUnitStore)) {
-            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` inside \`after()\` while rendering. This is not supported. If you need this data inside an \`after()\` callback, use \`cookies()\` outside of the callback. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
-                value: "E1381",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Route ${workStore.route} used \`cookies()\` inside \`after()\` while rendering. This is not supported. If you need this data inside an \`after()\` callback, use \`cookies()\` outside of the callback. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`);
         }
         if (workStore.forceStatic) {
             // When using forceStatic we override all other logic and always just return an empty
@@ -37,50 +34,26 @@ function cookies() {
             return makeUntrackedCookies(underlyingCookies);
         }
         if (workStore.dynamicShouldError) {
-            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-                value: "E849",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
         }
         if (workUnitStore) {
             switch(workUnitStore.type){
                 case 'cache':
-                    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`cookies()\` 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: "E831",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    const error = (0, _usecachemessages.createCookiesInUseCacheError)(workStore.route);
                     Error.captureStackTrace(error, cookies);
                     (0, _dynamicrenderingutils.applyOwnerStack)(error);
                     workStore.invalidDynamicUsageError ??= error;
                     throw error;
                 case 'unstable-cache':
-                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` inside a function cached with \`unstable_cache()\`. Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`cookies()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-                        value: "E846",
-                        enumerable: false,
-                        configurable: true
-                    });
-                case 'generate-static-params':
-                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` inside \`generateStaticParams\`. This is not supported because \`generateStaticParams\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
-                        value: "E1123",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw (0, _usecachemessages.createCookiesInUnstableCacheError)(workStore.route);
+                case 'build-time-generator':
+                    throw new Error(`Route ${workStore.route} used \`cookies()\` inside \`${workUnitStore.functionName}\`. This is not supported because \`${workUnitStore.functionName}\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
                 case 'prerender':
                     return makeHangingCookies(workStore, workUnitStore);
                 case 'prerender-client':
                 case 'validation-client':
                     const exportName = '`cookies`';
-                    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: "E1037",
-                        enumerable: false,
-                        configurable: true
-                    });
-                case 'prerender-ppr':
-                    // We need track dynamic access here eagerly to keep continuity with
-                    // how cookies has worked in PPR without cacheComponents.
-                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
+                    throw 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.`);
                 case 'prerender-legacy':
                     // We track dynamic access here so we don't need to wrap the cookies
                     // in individual property access tracking.
@@ -139,7 +112,7 @@ function makeHangingCookies(workStore, prerenderStore) {
     if (cachedPromise) {
         return cachedPromise;
     }
-    const promise = (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`cookies()`', prerenderStore);
+    const promise = (0, _dynamicrenderingutils.makeSessionDataHangingPromise)(prerenderStore.renderSignal, workStore.route, '`cookies()`', prerenderStore);
     CachedCookies.set(prerenderStore, promise);
     return promise;
 }
@@ -160,11 +133,7 @@ function makeUntrackedCookiesWithDevWarnings(requestStore, underlyingCookies, ro
         } else if (underlyingCookies === requestStore.cookies) {
             promise = requestStore.asyncApiPromises.cookies;
         } else {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Received an underlying cookies object that does not match either `cookies` or `mutableCookies`'), "__NEXT_ERROR_CODE", {
-                value: "E890",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Received an underlying cookies object that does not match either `cookies` or `mutableCookies`');
         }
         return instrumentCookiesPromiseWithDevWarnings(promise, route);
     }
@@ -229,11 +198,7 @@ function replaceableWarningDescriptorForSymbolIterator(target, route) {
 }
 function createCookiesAccessError(route, expression) {
     const prefix = route ? `Route "${route}" ` : 'This route ';
-    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`cookies()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
-        value: "E830",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`${prefix}used ${expression}. ` + `\`cookies()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
 }
 
 //# sourceMappingURL=cookies.js.map

package/.next/standalone/node_modules/next/dist/server/request/draft-mode.js

@@ -15,6 +15,7 @@ const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-
 const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
 const _hooksservercontext = require("../../client/components/hooks-server-context");
 const _invarianterror = require("../../shared/lib/invariant-error");
+const _usecachemessages = require("../use-cache/use-cache-messages");
 const _reflect = require("../web/spec-extension/adapters/reflect");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 function draftMode() {
@@ -50,7 +51,6 @@ function draftMode() {
         // Otherwise, we fall through to providing an empty draft mode.
         // eslint-disable-next-line no-fallthrough
         case 'prerender':
-        case 'prerender-ppr':
         case 'prerender-legacy':
             // Return empty draft mode
             return createOrGetCachedDraftMode(null, workStore);
@@ -58,18 +58,10 @@ function draftMode() {
         case 'validation-client':
             {
                 const exportName = '`draftMode`';
-                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: "E1046",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw 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.`);
             }
-        case 'generate-static-params':
-            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`${callingExpression}()\` inside \`generateStaticParams\`. This is not supported because \`generateStaticParams\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
-                value: "E1132",
-                enumerable: false,
-                configurable: true
-            });
+        case 'build-time-generator':
+            throw new Error(`Route ${workStore.route} used \`${callingExpression}()\` inside \`${workUnitStore.functionName}\`. This is not supported because \`${workUnitStore.functionName}\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
         default:
             return workUnitStore;
     }
@@ -142,11 +134,7 @@ class DraftMode {
 const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createDraftModeAccessError);
 function createDraftModeAccessError(route, expression) {
     const prefix = route ? `Route "${route}" ` : 'This route ';
-    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`draftMode()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
-        value: "E835",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`${prefix}used ${expression}. ` + `\`draftMode()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
 }
 function trackDynamicDraftMode(expression, constructorOpt) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
@@ -155,79 +143,45 @@ function trackDynamicDraftMode(expression, constructorOpt) {
         // We have a store we want to track dynamic data access to ensure we
         // don't statically generate routes that manipulate draft mode.
         if ((workUnitStore == null ? void 0 : workUnitStore.phase) === 'after') {
-            throw Object.defineProperty(new Error(`Route ${workStore.route} used "${expression}" inside \`after()\`. The enabled status of \`draftMode()\` can be read inside \`after()\` but you cannot enable or disable \`draftMode()\`. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
-                value: "E845",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Route ${workStore.route} used "${expression}" inside \`after()\`. The enabled status of \`draftMode()\` can be read inside \`after()\` but you cannot enable or disable \`draftMode()\`. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`);
         }
         if (workStore.dynamicShouldError) {
-            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.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: "E553",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.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`);
         }
         if (workUnitStore) {
             switch(workUnitStore.type){
                 case 'cache':
                 case 'private-cache':
                     {
-                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used "${expression}" inside "use cache". The enabled status of \`draftMode()\` can be read in caches but you must not enable or disable \`draftMode()\` inside a cache. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-                            value: "E829",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        const error = (0, _usecachemessages.createDraftModeMutationInUseCacheError)(workStore.route, expression);
                         Error.captureStackTrace(error, constructorOpt);
                         (0, _dynamicrenderingutils.applyOwnerStack)(error);
                         workStore.invalidDynamicUsageError ??= error;
                         throw error;
                     }
                 case 'unstable-cache':
-                    throw Object.defineProperty(new Error(`Route ${workStore.route} used "${expression}" inside a function cached with \`unstable_cache()\`. The enabled status of \`draftMode()\` can be read in caches but you must not enable or disable \`draftMode()\` inside a cache. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-                        value: "E844",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw (0, _usecachemessages.createDraftModeMutationInUnstableCacheError)(workStore.route, expression);
                 case 'prerender':
                 case 'prerender-runtime':
                     {
-                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used ${expression} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`), "__NEXT_ERROR_CODE", {
-                            value: "E126",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        const error = new Error(`Route ${workStore.route} used ${expression} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`);
                         return (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(workStore.route, expression, error, workUnitStore);
                     }
                 case 'prerender-client':
                 case 'validation-client':
                     const exportName = '`draftMode`';
-                    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: "E1046",
-                        enumerable: false,
-                        configurable: true
-                    });
-                case 'prerender-ppr':
-                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, workUnitStore.dynamicTracking);
+                    throw 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.`);
                 case 'prerender-legacy':
                     workUnitStore.revalidate = 0;
-                    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${workStore.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: "E558",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    const err = new _hooksservercontext.DynamicServerError(`Route ${workStore.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
                     workStore.dynamicUsageDescription = expression;
                     workStore.dynamicUsageStack = err.stack;
                     throw err;
                 case 'request':
                     (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
                     break;
-                case 'generate-static-params':
-                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`${expression}\` inside \`generateStaticParams\`. This is not supported because \`generateStaticParams\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
-                        value: "E1121",
-                        enumerable: false,
-                        configurable: true
-                    });
+                case 'build-time-generator':
+                    throw new Error(`Route ${workStore.route} used \`${expression}\` inside \`${workUnitStore.functionName}\`. This is not supported because \`${workUnitStore.functionName}\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
                 default:
                     workUnitStore;
             }