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

package/.next/standalone/node_modules/next/dist/server/app-render/dynamic-rendering.js

@@ -24,7 +24,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     DynamicHoleKind: null,
-    Postpone: null,
     PreludeState: null,
     abortAndThrowOnSynchronousRequestDataAccess: null,
     abortOnSynchronousPlatformIOAccess: null,
@@ -35,27 +34,24 @@ Object.defineProperty(exports, "__esModule", {
     createDynamicValidationState: null,
     createHangingInputAbortSignal: null,
     createInstantValidationState: null,
-    createRenderInBrowserAbortSignal: null,
     formatDynamicAPIAccesses: null,
+    getDisallowedReasonsInStaticRoute: null,
     getFirstDynamicReason: null,
     getNavigationDisallowedDynamicReasons: null,
     getStaticShellDisallowedDynamicReasons: null,
-    isDynamicPostpone: null,
     isPrerenderInterruptedError: null,
     logDisallowedDynamicError: null,
     markCurrentScopeAsDynamic: null,
-    postponeWithTracking: null,
     throwIfDisallowedDynamic: null,
+    throwIfDisallowedDynamicInStaticRoute: null,
     throwIfSyncIOUsed: null,
     throwToInterruptStaticGeneration: null,
     trackAllowedDynamicAccess: null,
+    trackDynamicAccessInStaticRoute: null,
     trackDynamicDataInDynamicRender: null,
     trackDynamicHoleInNavigation: null,
-    trackDynamicHoleInRuntimeShell: null,
     trackDynamicHoleInStaticShell: null,
-    trackThrownErrorInNavigation: null,
-    useDynamicRouteParams: null,
-    useDynamicSearchParams: null
+    trackThrownErrorInNavigation: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -67,9 +63,6 @@ _export(exports, {
     DynamicHoleKind: function() {
         return DynamicHoleKind;
     },
-    Postpone: function() {
-        return Postpone;
-    },
     PreludeState: function() {
         return PreludeState;
     },
@@ -100,12 +93,12 @@ _export(exports, {
     createInstantValidationState: function() {
         return createInstantValidationState;
     },
-    createRenderInBrowserAbortSignal: function() {
-        return createRenderInBrowserAbortSignal;
-    },
     formatDynamicAPIAccesses: function() {
         return formatDynamicAPIAccesses;
     },
+    getDisallowedReasonsInStaticRoute: function() {
+        return getDisallowedReasonsInStaticRoute;
+    },
     getFirstDynamicReason: function() {
         return getFirstDynamicReason;
     },
@@ -115,9 +108,6 @@ _export(exports, {
     getStaticShellDisallowedDynamicReasons: function() {
         return getStaticShellDisallowedDynamicReasons;
     },
-    isDynamicPostpone: function() {
-        return isDynamicPostpone;
-    },
     isPrerenderInterruptedError: function() {
         return isPrerenderInterruptedError;
     },
@@ -127,12 +117,12 @@ _export(exports, {
     markCurrentScopeAsDynamic: function() {
         return markCurrentScopeAsDynamic;
     },
-    postponeWithTracking: function() {
-        return postponeWithTracking;
-    },
     throwIfDisallowedDynamic: function() {
         return throwIfDisallowedDynamic;
     },
+    throwIfDisallowedDynamicInStaticRoute: function() {
+        return throwIfDisallowedDynamicInStaticRoute;
+    },
     throwIfSyncIOUsed: function() {
         return throwIfSyncIOUsed;
     },
@@ -142,48 +132,40 @@ _export(exports, {
     trackAllowedDynamicAccess: function() {
         return trackAllowedDynamicAccess;
     },
+    trackDynamicAccessInStaticRoute: function() {
+        return trackDynamicAccessInStaticRoute;
+    },
     trackDynamicDataInDynamicRender: function() {
         return trackDynamicDataInDynamicRender;
     },
     trackDynamicHoleInNavigation: function() {
         return trackDynamicHoleInNavigation;
     },
-    trackDynamicHoleInRuntimeShell: function() {
-        return trackDynamicHoleInRuntimeShell;
-    },
     trackDynamicHoleInStaticShell: function() {
         return trackDynamicHoleInStaticShell;
     },
     trackThrownErrorInNavigation: function() {
         return trackThrownErrorInNavigation;
-    },
-    useDynamicRouteParams: function() {
-        return useDynamicRouteParams;
-    },
-    useDynamicSearchParams: function() {
-        return useDynamicSearchParams;
     }
 });
 const _react = /*#__PURE__*/ _interop_require_default(require("react"));
 const _hooksservercontext = require("../../client/components/hooks-server-context");
 const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
-const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _boundaryconstants = require("../../lib/framework/boundary-constants");
 const _scheduler = require("../../lib/scheduler");
-const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
 const _blockingroutemessages = require("./blocking-route-messages");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _boundaryconstants1 = require("./instant-validation/boundary-constants");
 const _boundarytracking = require("./instant-validation/boundary-tracking");
 const _instantmessages = require("../../shared/lib/instant-messages");
+const _reactbrowserbailout = require("../../shared/lib/lazy-dynamic/react-browser-bailout");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const hasPostpone = typeof _react.default.unstable_postpone === 'function';
 function createDynamicTrackingState(isDebugDynamicAccesses) {
     return {
         isDebugDynamicAccesses,
@@ -223,9 +205,8 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
                 // A private cache scope is already dynamic by definition.
                 return;
             case 'prerender-legacy':
-            case 'prerender-ppr':
             case 'request':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;
@@ -236,34 +217,22 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
     // or it's static and it should not throw or postpone here.
     if (store.forceDynamic || store.forceStatic) return;
     if (store.dynamicShouldError) {
-        throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.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 ${store.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 '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
-                });
+                const err = 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`);
                 store.dynamicUsageDescription = expression;
                 store.dynamicUsageStack = err.stack;
                 throw err;
             case 'request':
-                if (process.env.NODE_ENV !== 'production') {
-                    workUnitStore.usedDynamic = true;
-                }
+                markRequestStoreAsDynamic(workUnitStore);
                 break;
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;
@@ -272,11 +241,7 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
 }
 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", {
-        value: "E558",
-        enumerable: false,
-        configurable: true
-    });
+    const err = 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`);
     prerenderStore.revalidate = 0;
     store.dynamicUsageDescription = expression;
     store.dynamicUsageStack = err.stack;
@@ -297,20 +262,22 @@ function trackDynamicDataInDynamicRender(workUnitStore) {
         case 'prerender':
         case 'prerender-runtime':
         case 'prerender-legacy':
-        case 'prerender-ppr':
         case 'prerender-client':
         case 'validation-client':
-        case 'generate-static-params':
+        case 'build-time-generator':
             break;
         case 'request':
-            if (process.env.NODE_ENV !== 'production') {
-                workUnitStore.usedDynamic = true;
-            }
+            markRequestStoreAsDynamic(workUnitStore);
             break;
         default:
             workUnitStore;
     }
 }
+function markRequestStoreAsDynamic(requestStore) {
+    if (process.env.__NEXT_DEV_SERVER && requestStore.phase === 'render') {
+        requestStore.usedDynamic = true;
+    }
+}
 function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
     const reason = `Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`;
     const error = createPrerenderInterruptedError(reason);
@@ -339,14 +306,6 @@ function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, p
     abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
 }
 function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
-    // The synchronously accessed request data would have been available during
-    // a runtime prerender, which would have rendered past this point instead of
-    // aborting — so a runtime prefetch would produce more content than this
-    // render. Record that, same as when request data access creates a hanging
-    // promise (see makeRuntimeHangingPromise). Unlike
-    // `abortOnSynchronousPlatformIOAccess`, which aborts a runtime prerender
-    // all the same and therefore must not record anything.
-    (0, _dynamicrenderingutils.trackRuntimeDataAccessed)(prerenderStore);
     const prerenderSignal = prerenderStore.controller.signal;
     if (prerenderSignal.aborted === false) {
         // TODO it would be better to move this aborted check into the callsite so we can avoid making
@@ -366,49 +325,9 @@ function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWit
     }
     throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
 }
-function Postpone({ reason, route }) {
-    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    const dynamicTracking = prerenderStore && prerenderStore.type === 'prerender-ppr' ? prerenderStore.dynamicTracking : null;
-    postponeWithTracking(route, reason, dynamicTracking);
-}
-function postponeWithTracking(route, expression, dynamicTracking) {
-    assertPostpone();
-    if (dynamicTracking) {
-        dynamicTracking.dynamicAccesses.push({
-            // When we aren't debugging, we don't need to create another error for the
-            // stack trace.
-            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
-            expression
-        });
-    }
-    _react.default.unstable_postpone(createPostponeReason(route, expression));
-}
-function createPostponeReason(route, expression) {
-    return `Route ${route} needs to bail out of prerendering at this point because it used ${expression}. ` + `React throws this special object to indicate where. It should not be caught by ` + `your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`;
-}
-function isDynamicPostpone(err) {
-    if (typeof err === 'object' && err !== null && typeof err.message === 'string') {
-        return isDynamicPostponeReason(err.message);
-    }
-    return false;
-}
-function isDynamicPostponeReason(reason) {
-    return reason.includes('needs to bail out of prerendering at this point because it used') && reason.includes('Learn more: https://nextjs.org/docs/messages/ppr-caught-error');
-}
-if (isDynamicPostponeReason(createPostponeReason('%%%', '^^^')) === false) {
-    throw Object.defineProperty(new Error('Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-        value: "E296",
-        enumerable: false,
-        configurable: true
-    });
-}
 const NEXT_PRERENDER_INTERRUPTED = 'NEXT_PRERENDER_INTERRUPTED';
 function createPrerenderInterruptedError(message) {
-    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    const error = new Error(message);
     error.digest = NEXT_PRERENDER_INTERRUPTED;
     return error;
 }
@@ -448,24 +367,6 @@ function formatDynamicAPIAccesses(dynamicAccesses) {
         return `Dynamic API Usage Debug - ${expression}:\n${stack}`;
     });
 }
-function assertPostpone() {
-    if (!hasPostpone) {
-        throw Object.defineProperty(new Error(`Invariant: React.unstable_postpone is not defined. This suggests the wrong version of React was loaded. This is a bug in Next.js`), "__NEXT_ERROR_CODE", {
-            value: "E224",
-            enumerable: false,
-            configurable: true
-        });
-    }
-}
-function createRenderInBrowserAbortSignal() {
-    const controller = new AbortController();
-    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) {
     switch(workUnitStore.type){
         case 'prerender':
@@ -499,13 +400,12 @@ function createHangingInputAbortSignal(workUnitStore) {
             return controller.signal;
         case 'prerender-client':
         case 'validation-client':
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'request':
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
             return undefined;
         default:
             workUnitStore;
@@ -521,127 +421,6 @@ function annotateDynamicAccess(expression, prerenderStore) {
         });
     }
 }
-function useDynamicRouteParams(expression) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workStore && workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender-client':
-                {
-                    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.makeClientHookHangingPromise)(workUnitStore.renderSignal, new _dynamicrenderingutils.ClientHookDynamicError(workStore.route, expression)));
-                    }
-                    break;
-                }
-            case 'prerender':
-                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 'prerender-ppr':
-                {
-                    const fallbackParams = workUnitStore.fallbackRouteParams;
-                    if (fallbackParams && fallbackParams.size > 0) {
-                        return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
-                    }
-                    break;
-                }
-            case 'validation-client':
-                {
-                    break;
-                }
-            case 'prerender-runtime':
-                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called during a runtime prerender. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                    value: "E771",
-                    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
-                });
-            case 'generate-static-params':
-                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called in \`generateStaticParams\`. Next.js should be preventing ${expression} from being included in server component files statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                    value: "E1130",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-legacy':
-            case 'request':
-            case 'unstable-cache':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-}
-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 'validation-client':
-            // During instant validation we try to behave as close to client as possible,
-            // so this shouldn't hang during SSR.
-            return;
-        case 'prerender-client':
-            {
-                _react.default.use((0, _dynamicrenderingutils.makeClientHookHangingPromise)(workUnitStore.renderSignal, new _dynamicrenderingutils.ClientHookDynamicError(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 'generate-static-params':
-            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called in \`generateStaticParams\`. Next.js should be preventing ${expression} from being included in server component files statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                value: "E1130",
-                enumerable: false,
-                configurable: true
-            });
-        case 'request':
-            return;
-        default:
-            workUnitStore;
-    }
-}
 const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
 // 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';
@@ -710,7 +489,64 @@ const slotMarkerRegex = new RegExp(`\\n\\s+at ${_boundaryconstants1.INSTANT_SLOT
         dynamicValidation.hasSuspenseAboveBody = true;
     }
 }
+function trackDynamicAccessInStaticRoute(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic, isServerPartial, kind) {
+    const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
+    if (hasOutletRegex.test(componentStack)) {
+        trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
+        return;
+    }
+    if (hasMetadataRegex.test(componentStack)) {
+        dynamicValidation.dynamicErrors.push(addErrorContext(createMetadataErrorInStaticRoute(kind, workStore.route), componentStack, null));
+        return;
+    }
+    if (hasViewportRegex.test(componentStack)) {
+        dynamicValidation.dynamicErrors.push(addErrorContext(createViewportErrorInStaticRoute(kind, workStore.route), componentStack, null));
+        return;
+    }
+    let hasSuspense = false;
+    if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+        // this error had a Suspense boundary above it, and it's above the body as well.
+        dynamicValidation.hasSuspenseAboveBody = true;
+        hasSuspense = true;
+    } else if (hasSuspenseRegex.test(componentStack)) {
+        // this error had a Suspense boundary above it.
+        hasSuspense = true;
+    }
+    if (hasSuspense) {
+        if (!isServerPartial) {
+            // If we don't have holes caused by server data, then any holes must be caused
+            // by client-only code, which is allowed.
+            dynamicValidation.hasAllowedDynamic = true;
+            return;
+        }
+        // We have holes that may be caused by server data.
+        if (syncDynamicError || (0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
+            // We know this hole wasn't caused by server data, so it's allowed
+            // (because it's wrapped in a Suspense)
+            dynamicValidation.hasAllowedDynamic = true;
+            return;
+        }
+        // Any remaining hole may be caused by a server hole.
+        // These are not allowed even with Suspense.
+        // (NOTE: this may misreport valid client dynamic holes as server holes)
+        dynamicValidation.dynamicErrors.push(addErrorContext(createBodyErrorInStaticRoute(kind, workStore.route), componentStack, null));
+        return;
+    }
+    if (syncDynamicError) {
+        dynamicValidation.dynamicErrors.push(syncDynamicError);
+        return;
+    }
+    if ((0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
+        dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, null));
+        return;
+    }
+    const error = addErrorContext(isServerPartial ? // (NOTE: this may misreport client dynamic holes as server holes)
+    createBodyErrorInStaticRoute(kind, workStore.route) : // that server data is complete
+    createBodyError(kind, workStore.route), componentStack, null);
+    dynamicValidation.dynamicErrors.push(error);
+}
 function trackAllowedDynamicAccess(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic) {
+    const dynamicHoleKind = 6;
     const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
     if (hasOutletRegex.test(componentStack)) {
         trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
@@ -741,14 +577,17 @@ function trackAllowedDynamicAccess(dynamicReason, workStore, componentStack, dyn
         dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, null));
         return;
     }
-    const error = addErrorContext((0, _blockingroutemessages.createDynamicOrRuntimeBodyError)(workStore.route), componentStack, null);
+    const error = addErrorContext(createBodyError(dynamicHoleKind, workStore.route), componentStack, null);
     dynamicValidation.dynamicErrors.push(error);
     return;
 }
 var DynamicHoleKind = /*#__PURE__*/ function(DynamicHoleKind) {
-    /** We know that this hole is caused by link data. */ DynamicHoleKind[DynamicHoleKind["Link"] = 1] = "Link";
-    /** We know that this hole is caused by runtime data. */ DynamicHoleKind[DynamicHoleKind["Runtime"] = 2] = "Runtime";
-    /** We know that this hole is caused by dynamic data. */ DynamicHoleKind[DynamicHoleKind["Dynamic"] = 3] = "Dynamic";
+    /** We know that this hole is caused by runtime data. */ DynamicHoleKind[DynamicHoleKind["Runtime"] = 1] = "Runtime";
+    /** We know that this hole is caused by link data. */ DynamicHoleKind[DynamicHoleKind["Link"] = 2] = "Link";
+    /** We know that this hole is caused by navigation(). */ DynamicHoleKind[DynamicHoleKind["Navigation"] = 3] = "Navigation";
+    /** We know that this hole is caused by prefetch(). */ DynamicHoleKind[DynamicHoleKind["Prefetch"] = 4] = "Prefetch";
+    /** We know that this hole is caused by dynamic data. */ DynamicHoleKind[DynamicHoleKind["Dynamic"] = 5] = "Dynamic";
+    /** We know that this hole is caused by runtime or dynamic data, but don't know which. */ DynamicHoleKind[DynamicHoleKind["RuntimeOrDynamic"] = 6] = "RuntimeOrDynamic";
     return DynamicHoleKind;
 }({});
 function createInstantValidationState(slotStacks) {
@@ -775,12 +614,12 @@ function trackDynamicHoleInNavigation(dynamicReason, workStore, componentStack,
     // back to the default.
     const effectiveCreateInstantStack = resolveInstantStack(componentStack, dynamicValidation);
     if (hasMetadataRegex.test(componentStack)) {
-        const error = addErrorContext(kind === 1 ? (0, _blockingroutemessages.createLinkMetadataError)(workStore.route) : kind === 2 ? (0, _blockingroutemessages.createRuntimeMetadataError)(workStore.route) : (0, _blockingroutemessages.createDynamicMetadataError)(workStore.route), componentStack, effectiveCreateInstantStack);
+        const error = addErrorContext(createMetadataError(kind, workStore.route), componentStack, effectiveCreateInstantStack);
         dynamicValidation.dynamicMetadata = error;
         return;
     }
     if (hasViewportRegex.test(componentStack)) {
-        const error = addErrorContext(kind === 1 ? (0, _blockingroutemessages.createLinkViewportError)(workStore.route) : kind === 2 ? (0, _blockingroutemessages.createRuntimeViewportError)(workStore.route) : (0, _blockingroutemessages.createDynamicViewportError)(workStore.route), componentStack, effectiveCreateInstantStack);
+        const error = addErrorContext(createViewportError(kind, workStore.route), componentStack, effectiveCreateInstantStack);
         dynamicValidation.dynamicErrors.push(error);
         return;
     }
@@ -804,11 +643,7 @@ function trackDynamicHoleInNavigation(dynamicReason, workStore, componentStack,
             // the errors from the innermost (segments), i.e. omit layouts whose
             // slots managed to render (because clearly they didn't block validation)
             const message = `Route "${workStore.route}": Could not validate \`instant\` because a Client Component in a parent segment prevented the page from rendering.`;
-            const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                value: "E1331",
-                enumerable: false,
-                configurable: true
-            }), componentStack, effectiveCreateInstantStack);
+            const error = addErrorContext(new Error(message), componentStack, effectiveCreateInstantStack);
             dynamicValidation.validationPreventingErrors.push(error);
             return;
         }
@@ -854,11 +689,97 @@ function trackDynamicHoleInNavigation(dynamicReason, workStore, componentStack,
         dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, effectiveCreateInstantStack));
         return;
     }
-    const error = addErrorContext(kind === 1 ? (0, _blockingroutemessages.createLinkBodyErrorInNavigation)(workStore.route) : kind === 2 ? (0, _blockingroutemessages.createRuntimeBodyErrorInNavigation)(workStore.route) : (0, _blockingroutemessages.createDynamicBodyErrorInNavigation)(workStore.route), componentStack, effectiveCreateInstantStack);
+    const error = addErrorContext(createBodyErrorInNavigation(kind, workStore.route), componentStack, effectiveCreateInstantStack);
     dynamicValidation.dynamicErrors.push(error);
     return;
 }
-function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue, componentStack) {
+function createBodyError(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeBodyError)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicBodyError)(route);
+        case 6:
+            return (0, _blockingroutemessages.createDynamicOrRuntimeBodyError)(route);
+    }
+}
+function createBodyErrorInNavigation(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeBodyErrorInNavigation)(route);
+        case 2:
+            return (0, _blockingroutemessages.createLinkBodyErrorInNavigation)(route);
+        case 3:
+            return (0, _blockingroutemessages.createNavigationBodyErrorInNavigation)(route);
+        case 4:
+            return (0, _blockingroutemessages.createPrefetchBodyErrorInNavigation)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicBodyErrorInNavigation)(route);
+    }
+}
+function createMetadataError(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeMetadataError)(route);
+        case 2:
+            return (0, _blockingroutemessages.createLinkMetadataError)(route);
+        case 3:
+            return (0, _blockingroutemessages.createNavigationMetadataError)(route);
+        case 4:
+            return (0, _blockingroutemessages.createPrefetchMetadataError)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicMetadataError)(route);
+        case 6:
+            return (0, _blockingroutemessages.createDynamicOrRuntimeMetadataError)(route);
+    }
+}
+function createViewportError(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeViewportError)(route);
+        case 2:
+            return (0, _blockingroutemessages.createLinkViewportError)(route);
+        case 3:
+            return (0, _blockingroutemessages.createNavigationViewportError)(route);
+        case 4:
+            return (0, _blockingroutemessages.createPrefetchViewportError)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicViewportError)(route);
+        case 6:
+            return (0, _blockingroutemessages.createDynamicOrRuntimeViewportError)(route);
+    }
+}
+function createBodyErrorInStaticRoute(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeBodyErrorInStaticRoute)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicBodyErrorInStaticRoute)(route);
+        case 6:
+            return (0, _blockingroutemessages.createNonPrerenderableBodyErrorInStaticRoute)(route);
+    }
+}
+function createMetadataErrorInStaticRoute(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeMetadataErrorInStaticRoute)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicMetadataErrorInStaticRoute)(route);
+        case 6:
+            return (0, _blockingroutemessages.createNonPrerenderableMetadataErrorInStaticRoute)(route);
+    }
+}
+function createViewportErrorInStaticRoute(kind, route) {
+    switch(kind){
+        case 1:
+            return (0, _blockingroutemessages.createRuntimeViewportErrorInStaticRoute)(route);
+        case 5:
+            return (0, _blockingroutemessages.createDynamicViewportErrorInStaticRoute)(route);
+        case 6:
+            return (0, _blockingroutemessages.createNonPrerenderableViewportErrorInStaticRoute)(route);
+    }
+}
+function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue, componentStack, reactBrowserBailout) {
     const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
     if (!boundaryLocation) {
         // There's no validation boundary on the component stack.
@@ -867,12 +788,17 @@ function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue,
         // This helps for errors from node_modules which would otherwise
         // have no useful stack information due to ignore-listing,
         // e.g. next/dynamic with `ssr: false`.
-        const error = addErrorContext(Object.defineProperty(new Error('An error occurred while attempting to validate instant UI. This error may be preventing the validation from completing.', {
+        if (reactBrowserBailout) {
+            // React preserves Next's branded bailout reason as the error cause.
+            // Replace the internal wrapper before storing the user-facing diagnostic.
+            const browserBailoutReason = (0, _reactbrowserbailout.getReactBrowserBailoutReason)(thrownValue);
+            if (browserBailoutReason !== undefined) {
+                const browserBailoutError = thrownValue;
+                browserBailoutError.cause = browserBailoutReason;
+            }
+        }
+        const error = addErrorContext(new Error('An error occurred while attempting to validate instant UI. This error may be preventing the validation from completing.', {
             cause: thrownValue
-        }), "__NEXT_ERROR_CODE", {
-            value: "E1118",
-            enumerable: false,
-            configurable: true
         }), componentStack, null);
         dynamicValidation.thrownErrorsOutsideBoundary.push(error);
     } else {
@@ -892,29 +818,34 @@ function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue,
             // invalid - fallthrough
             }
         }
+        if (reactBrowserBailout) {
+            // React preserves Next's branded bailout reason as the error cause.
+            // Replace the internal wrapper before storing the user-facing diagnostic.
+            const browserBailoutReason = (0, _reactbrowserbailout.getReactBrowserBailoutReason)(thrownValue);
+            if (browserBailoutReason !== undefined) {
+                const browserBailoutError = thrownValue;
+                browserBailoutError.cause = browserBailoutReason;
+            }
+        }
         const message = `Route "${workStore.route}": Could not validate \`instant\` because an error prevented the target segment from rendering.`;
-        const error = addErrorContext(Object.defineProperty(new Error(message, {
+        const error = addErrorContext(new Error(message, {
             cause: thrownValue
-        }), "__NEXT_ERROR_CODE", {
-            value: "E1338",
-            enumerable: false,
-            configurable: true
         }), componentStack, null // TODO(instant-validation-build): conflicting use of cause
         );
         dynamicValidation.validationPreventingErrors.push(error);
     }
 }
-function trackDynamicHoleInRuntimeShell(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic) {
+function trackDynamicHoleInStaticShell(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic, kind) {
     const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
     if (hasOutletRegex.test(componentStack)) {
         trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
         return;
     } else if (hasMetadataRegex.test(componentStack)) {
-        const error = addErrorContext((0, _blockingroutemessages.createDynamicMetadataError)(workStore.route), componentStack, null);
+        const error = addErrorContext(createMetadataError(kind, workStore.route), componentStack, null);
         dynamicValidation.dynamicMetadata = error;
         return;
     } else if (hasViewportRegex.test(componentStack)) {
-        const error = addErrorContext((0, _blockingroutemessages.createDynamicViewportError)(workStore.route), componentStack, null);
+        const error = addErrorContext(createViewportError(kind, workStore.route), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -937,53 +868,13 @@ function trackDynamicHoleInRuntimeShell(dynamicReason, workStore, componentStack
         dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, null));
         return;
     }
-    const error = addErrorContext((0, _blockingroutemessages.createDynamicBodyError)(workStore.route), componentStack, null);
-    dynamicValidation.dynamicErrors.push(error);
-    return;
-}
-function trackDynamicHoleInStaticShell(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic) {
-    const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
-    if (hasOutletRegex.test(componentStack)) {
-        trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
-        return;
-    } else if (hasMetadataRegex.test(componentStack)) {
-        const error = addErrorContext((0, _blockingroutemessages.createRuntimeMetadataError)(workStore.route), componentStack, null);
-        dynamicValidation.dynamicMetadata = error;
-        return;
-    } else if (hasViewportRegex.test(componentStack)) {
-        const error = addErrorContext((0, _blockingroutemessages.createRuntimeViewportError)(workStore.route), componentStack, null);
-        dynamicValidation.dynamicErrors.push(error);
-        return;
-    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
-        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
-        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
-        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
-        dynamicValidation.hasAllowedDynamic = true;
-        dynamicValidation.hasSuspenseAboveBody = true;
-        return;
-    } else if (hasSuspenseRegex.test(componentStack)) {
-        // this error had a Suspense boundary above it so we don't need to report it as a source
-        // of disallowed
-        dynamicValidation.hasAllowedDynamic = true;
-        return;
-    } else if (syncDynamicError) {
-        dynamicValidation.dynamicErrors.push(syncDynamicError);
-        return;
-    }
-    if ((0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
-        dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, null));
-        return;
-    }
-    const error = addErrorContext((0, _blockingroutemessages.createRuntimeBodyError)(workStore.route), componentStack, null);
+    const error = addErrorContext(kind === 1 ? (0, _blockingroutemessages.createRuntimeBodyError)(workStore.route) : (0, _blockingroutemessages.createDynamicBodyError)(workStore.route), componentStack, null);
     dynamicValidation.dynamicErrors.push(error);
     return;
 }
 /**
  * In dev mode, we prefer using the owner stack, otherwise the provided
  * component stack is used.
- *
- * Accepts an already-created Error so the SWC error-code plugin can see the
- * `new Error(...)` call at each call site and auto-assign error codes.
  */ function addErrorContext(error, componentStack, createInstantStack) {
     const ownerStack = process.env.NODE_ENV !== 'production' && _react.default.captureOwnerStack ? _react.default.captureOwnerStack() : null;
     if (createInstantStack !== null) {
@@ -1011,6 +902,7 @@ function throwIfSyncIOUsed(workStore, serverDynamic) {
     }
 }
 function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic, allowEmptyStaticShell) {
+    const dynamicHoleKind = 6;
     throwIfSyncIOUsed(workStore, serverDynamic);
     // The dynamic metadata error is a mistake-detection signal. It fires when the
     // rest of the shell is otherwise fully static apart from metadata, suggesting
@@ -1018,7 +910,7 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
     // That condition is independent of whether the user or build phase accepted
     // an empty shell, so we surface it before any opt-in bypass.
     if (prelude === 0 && dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
-        console.error((0, _blockingroutemessages.createDynamicOrRuntimeMetadataError)(workStore.route).message);
+        console.error(createMetadataError(dynamicHoleKind, workStore.route).message);
         throw new _staticgenerationbailout.StaticGenBailoutError();
     }
     // Either flag expresses "this shell is allowed to be empty/blocking":
@@ -1046,7 +938,7 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
         // you need to opt into that by adding a Suspense boundary above the body
         // to indicate your are ok with fully dynamic rendering.
         if (dynamicValidation.hasDynamicViewport) {
-            console.error((0, _blockingroutemessages.createDynamicOrRuntimeViewportError)(workStore.route).message);
+            console.error(createViewportError(dynamicHoleKind, workStore.route).message);
             throw new _staticgenerationbailout.StaticGenBailoutError();
         }
         if (prelude === 1) {
@@ -1058,6 +950,53 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
         }
     }
 }
+function throwIfDisallowedDynamicInStaticRoute(workStore, prelude, dynamicValidation, serverDynamic, isFallbackShell, allowEmptyStaticShell, isServerPartial) {
+    const reasons = getDisallowedReasonsInStaticRoute(workStore, prelude, dynamicValidation, serverDynamic, isFallbackShell, allowEmptyStaticShell, isServerPartial);
+    if (reasons.length > 0) {
+        for (const reason of reasons){
+            logDisallowedDynamicError(workStore, reason);
+        }
+        throw new _staticgenerationbailout.StaticGenBailoutError();
+    }
+}
+function getDisallowedReasonsInStaticRoute(workStore, prelude, dynamicValidation, serverDynamic, isFallbackShell, allowEmptyStaticShell, isServerPartial) {
+    if (serverDynamic && serverDynamic.syncDynamicErrorWithStack) {
+        return [
+            serverDynamic.syncDynamicErrorWithStack
+        ];
+    }
+    // We do a fallback shell prerender, but it's not meant to be validated --
+    // we just need it to create the relevant prerender outputs.
+    if (isFallbackShell) {
+        return [];
+    }
+    // Suspense-above-body and `instant = false` bypass reporting
+    // that the shell is blocked. However, if we have non-prerenderable server
+    // data, we still have to error, regardless of those two.
+    if (!isServerPartial && (allowEmptyStaticShell || dynamicValidation.hasSuspenseAboveBody)) {
+        return [];
+    }
+    const { dynamicErrors } = dynamicValidation;
+    if (dynamicErrors.length > 0) {
+        return dynamicErrors;
+    }
+    // Dynamic data may have been passed into a client component without calling `use()`,
+    // in which case we wouldn't see it during the prerender, but still need to error.
+    // Fall back to a generic error message.
+    if (isServerPartial) {
+        return [
+            new Error(`Route "${workStore.route}": Next.js encountered data that is not available during a static prerender, but is unable to provide a location.`)
+        ];
+    }
+    if (prelude === 1 || prelude === 2) {
+        // We've somehow ended up with an empty prelude but no dynamic errors.
+        // We must've messed up the tracking somehow.
+        return [
+            new _invarianterror.InvariantError(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason.`)
+        ];
+    }
+    return [];
+}
 function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation, allowEmptyStaticShell) {
     // The dynamic metadata error is a mistake-detection signal. It fires when the
     // rest of the shell is otherwise fully static apart from metadata, suggesting
@@ -1091,11 +1030,7 @@ function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValid
             // We still adhere to the constraint that you must produce a shell but invite the
             // user to report this as a bug in Next.js.
             return [
-                Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
-                    value: "E936",
-                    enumerable: false,
-                    configurable: true
-                })
+                new _invarianterror.InvariantError(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason.`)
             ];
         }
     }
@@ -1131,11 +1066,7 @@ function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValida
             // If we ever get this far then we messed up the tracking of invalid
             // dynamic. (When boundaries are missing the deferred fallback below
             // will surface a more useful error.)
-            return Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" failed to render during instant validation and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
-                value: "E1055",
-                enumerable: false,
-                configurable: true
-            });
+            return new _invarianterror.InvariantError(`Route "${workStore.route}" failed to render during instant validation and Next.js was unable to determine a reason.`);
         }
     } else {
         const dynamicErrors = dynamicValidation.dynamicErrors;