@evoscientist/webui 0.2.4 → 0.2.6

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

@@ -46,6 +46,7 @@ Object.defineProperty(exports, "__esModule", {
     markCurrentScopeAsDynamic: null,
     postponeWithTracking: null,
     throwIfDisallowedDynamic: null,
+    throwIfSyncIOUsed: null,
     throwToInterruptStaticGeneration: null,
     trackAllowedDynamicAccess: null,
     trackDynamicDataInDynamicRender: null,
@@ -132,6 +133,9 @@ _export(exports, {
     throwIfDisallowedDynamic: function() {
         return throwIfDisallowedDynamic;
     },
+    throwIfSyncIOUsed: function() {
+        return throwIfSyncIOUsed;
+    },
     throwToInterruptStaticGeneration: function() {
         return throwToInterruptStaticGeneration;
     },
@@ -169,8 +173,11 @@ 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");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -181,7 +188,8 @@ function createDynamicTrackingState(isDebugDynamicAccesses) {
     return {
         isDebugDynamicAccesses,
         dynamicAccesses: [],
-        syncDynamicErrorWithStack: null
+        syncDynamicErrorWithStack: null,
+        syncDynamicErrorWithStackPostMicrotask: false
     };
 }
 function createDynamicValidationState() {
@@ -194,6 +202,9 @@ function createDynamicValidationState() {
         dynamicErrors: []
     };
 }
+function getPendingClientSyncDynamicError(clientDynamic) {
+    return clientDynamic.syncDynamicErrorWithStackPostMicrotask ? null : clientDynamic.syncDynamicErrorWithStack;
+}
 function getFirstDynamicReason(trackingState) {
     var _trackingState_dynamicAccesses_;
     return (_trackingState_dynamicAccesses_ = trackingState.dynamicAccesses[0]) == null ? void 0 : _trackingState_dynamicAccesses_.expression;
@@ -316,18 +327,26 @@ function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore)
 }
 function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
     const dynamicTracking = prerenderStore.dynamicTracking;
-    abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
-    // It is important that we set this tracking value after aborting. Aborts are executed
-    // synchronously except for the case where you abort during render itself. By setting this
-    // value late we can use it to determine if any of the aborted tasks are the task that
-    // called the sync IO expression in the first place.
-    if (dynamicTracking) {
-        if (dynamicTracking.syncDynamicErrorWithStack === null) {
-            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
-        }
+    if (dynamicTracking && dynamicTracking.syncDynamicErrorWithStack === null) {
+        dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
+        // React completes the task that is currently rendering before scheduled
+        // abort cleanup. Client tracking can attribute the sync IO only during
+        // that current task; server tracking keeps the error regardless.
+        queueMicrotask(()=>{
+            dynamicTracking.syncDynamicErrorWithStackPostMicrotask = true;
+        });
     }
+    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
@@ -336,10 +355,8 @@ function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWit
         // this way. See how this was handled with `abortOnSynchronousPlatformIOAccess` for a closer
         // to ideal implementation
         abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
-        // It is important that we set this tracking value after aborting. Aborts are executed
-        // synchronously except for the case where you abort during render itself. By setting this
-        // value late we can use it to determine if any of the aborted tasks are the task that
-        // called the sync IO expression in the first place.
+        // Preserve the exact server-side dynamic access for final validation after
+        // interrupting this render.
         const dynamicTracking = prerenderStore.dynamicTracking;
         if (dynamicTracking) {
             if (dynamicTracking.syncDynamicErrorWithStack === null) {
@@ -464,20 +481,17 @@ function createHangingInputAbortSignal(workUnitStore) {
             } else {
                 // Otherwise we're in the final render and we should already have all
                 // our caches filled.
-                // If the prerender uses stages, we have wait until the runtime stage,
-                // at which point all runtime inputs will be resolved.
-                // (otherwise, a runtime prerender might consider `cookies()` hanging
-                //  even though they'd resolve in the next task.)
+                // If the prerender uses stages, we have wait until the final stage.
+                // if an input didn't resolve at that point, then we can assume it never will.
                 //
                 // We might still be waiting on some microtasks so we
                 // wait one tick before giving up. When we give up, we still want to
                 // render the content of this cache as deeply as we can so that we can
                 // suspend as deeply as possible in the tree or not at all if we don't
                 // end up waiting for the input.
-                if (// eslint-disable-next-line no-restricted-syntax -- We are discriminating between two different refined types and don't need an addition exhaustive switch here
-                workUnitStore.type === 'prerender-runtime' && workUnitStore.stagedRendering) {
-                    const { stagedRendering } = workUnitStore;
-                    stagedRendering.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering)).then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
+                const stagedRendering = (0, _workunitasyncstorageexternal.getStagedRenderingController)(workUnitStore);
+                if (stagedRendering && stagedRendering.finalStage !== null) {
+                    stagedRendering.waitForStage(stagedRendering.finalStage).then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()), noop);
                 } else {
                     (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
                 }
@@ -497,6 +511,7 @@ function createHangingInputAbortSignal(workUnitStore) {
             workUnitStore;
     }
 }
+function noop() {}
 function annotateDynamicAccess(expression, prerenderStore) {
     const dynamicTracking = prerenderStore.dynamicTracking;
     if (dynamicTracking) {
@@ -512,17 +527,22 @@ function useDynamicRouteParams(expression) {
     if (workStore && workUnitStore) {
         switch(workUnitStore.type){
             case 'prerender-client':
-            case 'prerender':
                 {
                     const fallbackParams = workUnitStore.fallbackRouteParams;
                     if (fallbackParams && fallbackParams.size > 0) {
                         // We are in a prerender with cacheComponents semantics. We are going to
                         // hang here and never resolve. This will cause the currently
                         // rendering component to effectively be a dynamic hole.
-                        _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+                        _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;
@@ -580,7 +600,7 @@ function useDynamicSearchParams(expression) {
             return;
         case 'prerender-client':
             {
-                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+                _react.default.use((0, _dynamicrenderingutils.makeClientHookHangingPromise)(workUnitStore.renderSignal, new _dynamicrenderingutils.ClientHookDynamicError(workStore.route, expression)));
                 break;
             }
         case 'prerender-legacy':
@@ -642,9 +662,58 @@ const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOU
 const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
 const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
 const hasInstantValidationBoundaryRegex = new RegExp(`\\n\\s+at ${_boundaryconstants1.INSTANT_VALIDATION_BOUNDARY_NAME}[\\n\\s]`);
-function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
+const slotMarkerRegex = new RegExp(`\\n\\s+at ${_boundaryconstants1.INSTANT_SLOT_MARKER_PREFIX}(\\d+)${_boundaryconstants1.INSTANT_SLOT_MARKER_SUFFIX}[\\n\\s]`);
+/** Look up the config factory for the slot this error belongs to.
+ * Checks the component stack for a slot marker (__next_instant_slot_N__)
+ * and returns the config at that index. Falls back to index 0 (root
+ * config) when no slot marker is found or the slot has no config. */ function resolveInstantStack(componentStack, dynamicValidation) {
+    const { slotStacks } = dynamicValidation;
+    if (slotStacks.length > 1) {
+        const match = slotMarkerRegex.exec(componentStack);
+        if (match) {
+            // Slot markers are 0-indexed in the component name but
+            // slotStacks is 1-indexed (index 0 is the root config).
+            const slotIndex = parseInt(match[1], 10) + 1;
+            const slotStack = slotStacks[slotIndex];
+            if (slotStack != null) {
+                return slotStack;
+            }
+        }
+    }
+    // Fall back to root config (index 0)
+    return slotStacks[0] ?? null;
+}
+/**
+ * Inspects the component stack of an outlet boundary to discover whether the
+ * user placed a Suspense boundary above the document body, and records the
+ * opt-in on `dynamicValidation.hasSuspenseAboveBody` if so.
+ *
+ * The outlet itself isn't a meaningful source of dynamic — it only resolves
+ * when metadata/viewport are dynamic, which we track via their own boundaries.
+ * However, the outlet renders alongside the page content, so its stack passes
+ * through the user's layout chain (typically reaching into `<body>` via the
+ * root layout). That makes the outlet stack our best opportunity to spot a
+ * Suspense boundary above the body, even when no real body content is dynamic.
+ * Without this, a route whose only dynamic source is `generateViewport()` would
+ * miss the Suspense-above-body opt-in, because the viewport's stack lives in
+ * the head and never sees the user's root layout.
+ *
+ * We deliberately only set `hasSuspenseAboveBody`, not `hasAllowedDynamic`. The
+ * latter tracks whether the body has dynamic content that's been wrapped in
+ * Suspense (i.e., the page is partially dynamic). The outlet rendering tells us
+ * about the structural opt-in for an empty shell, not about the body being
+ * partially dynamic. The distinction matters because dynamic metadata is only
+ * acceptable when the page is partially dynamic (via real body holes), and we
+ * don't want this outlet-based detection to mask that case.
+ */ function trackOutletSuspenseAboveBody(componentStack, dynamicValidation) {
+    if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+        dynamicValidation.hasSuspenseAboveBody = true;
+    }
+}
+function trackAllowedDynamicAccess(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic) {
+    const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
     if (hasOutletRegex.test(componentStack)) {
-        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
+        trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
         return;
     } else if (hasMetadataRegex.test(componentStack)) {
         dynamicValidation.hasDynamicMetadata = true;
@@ -664,27 +733,25 @@ function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation,
         // of disallowed
         dynamicValidation.hasAllowedDynamic = true;
         return;
-    } else if (clientDynamic.syncDynamicErrorWithStack) {
-        // This task was the task that called the sync error.
-        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
+    } else if (syncDynamicError) {
+        dynamicValidation.dynamicErrors.push(syncDynamicError);
         return;
-    } else {
-        const message = `Route "${workStore.route}": Uncached data was accessed outside of ` + '<Suspense>. This delays the entire page from rendering, resulting in a ' + 'slow user experience. Learn more: ' + 'https://nextjs.org/docs/messages/blocking-route';
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1079",
-            enumerable: false,
-            configurable: true
-        }), componentStack, null);
-        dynamicValidation.dynamicErrors.push(error);
+    }
+    if ((0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
+        dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, null));
         return;
     }
+    const error = addErrorContext((0, _blockingroutemessages.createDynamicOrRuntimeBodyError)(workStore.route), componentStack, null);
+    dynamicValidation.dynamicErrors.push(error);
+    return;
 }
 var DynamicHoleKind = /*#__PURE__*/ function(DynamicHoleKind) {
-    /** We know that this hole is caused by runtime data. */ DynamicHoleKind[DynamicHoleKind["Runtime"] = 1] = "Runtime";
-    /** We know that this hole is caused by dynamic data. */ DynamicHoleKind[DynamicHoleKind["Dynamic"] = 2] = "Dynamic";
+    /** 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";
     return DynamicHoleKind;
 }({});
-function createInstantValidationState(createInstantStack) {
+function createInstantValidationState(slotStacks) {
     return {
         hasDynamicMetadata: false,
         hasAllowedClientDynamicAboveBoundary: false,
@@ -694,33 +761,26 @@ function createInstantValidationState(createInstantStack) {
         dynamicErrors: [],
         validationPreventingErrors: [],
         thrownErrorsOutsideBoundary: [],
-        createInstantStack
+        slotStacks
     };
 }
-function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidation, clientDynamic, kind, boundaryState) {
+function trackDynamicHoleInNavigation(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic, kind, boundaryState) {
+    const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
     if (hasOutletRegex.test(componentStack)) {
         // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
         return;
     }
+    // Resolve the config stack for this specific error. If the error
+    // is inside a slot marker, use that slot's config. Otherwise fall
+    // back to the default.
+    const effectiveCreateInstantStack = resolveInstantStack(componentStack, dynamicValidation);
     if (hasMetadataRegex.test(componentStack)) {
-        const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments.` : `Uncached data or \`connection()\` was accessed inside \`generateMetadata\`.`;
-        const message = `Route "${workStore.route}": ${usageDescription} Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1076",
-            enumerable: false,
-            configurable: true
-        }), componentStack, dynamicValidation.createInstantStack);
+        const error = addErrorContext(kind === 1 ? (0, _blockingroutemessages.createLinkMetadataError)(workStore.route) : kind === 2 ? (0, _blockingroutemessages.createRuntimeMetadataError)(workStore.route) : (0, _blockingroutemessages.createDynamicMetadataError)(workStore.route), componentStack, effectiveCreateInstantStack);
         dynamicValidation.dynamicMetadata = error;
         return;
     }
     if (hasViewportRegex.test(componentStack)) {
-        const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`.` : `Uncached data or \`connection()\` was accessed inside \`generateViewport\`.`;
-        const message = `Route "${workStore.route}": ${usageDescription} This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1086",
-            enumerable: false,
-            configurable: true
-        }), componentStack, dynamicValidation.createInstantStack);
+        const error = addErrorContext(kind === 1 ? (0, _blockingroutemessages.createLinkViewportError)(workStore.route) : kind === 2 ? (0, _blockingroutemessages.createRuntimeViewportError)(workStore.route) : (0, _blockingroutemessages.createDynamicViewportError)(workStore.route), componentStack, effectiveCreateInstantStack);
         dynamicValidation.dynamicErrors.push(error);
         return;
     }
@@ -733,7 +793,7 @@ function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidati
         // If we managed to render all the validation boundaries, that means
         // that the client holes aren't blocking validation and we can disregard them.
         // Note that we don't even care whether they have suspense or not.
-        if (boundaryState.expectedIds.size === boundaryState.renderedIds.size) {
+        if ((0, _boundarytracking.allRequiredBoundariesRendered)(boundaryState)) {
             dynamicValidation.hasAllowedClientDynamicAboveBoundary = true;
             dynamicValidation.hasAllowedDynamic = true // Holes outside the boundary contribute to allowing dynamic metadata
             ;
@@ -743,12 +803,12 @@ function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidati
             // If shared parents blocked us from validating, we should only log
             // the errors from the innermost (segments), i.e. omit layouts whose
             // slots managed to render (because clearly they didn't block validation)
-            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because a Client Component in a parent segment prevented the page from rendering.`;
+            const 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: "E1082",
+                value: "E1331",
                 enumerable: false,
                 configurable: true
-            }), componentStack, dynamicValidation.createInstantStack);
+            }), componentStack, effectiveCreateInstantStack);
             dynamicValidation.validationPreventingErrors.push(error);
             return;
         }
@@ -783,22 +843,18 @@ function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidati
             }
         }
     }
-    if (clientDynamic.syncDynamicErrorWithStack) {
-        // This task was the task that called the sync error.
-        const syncError = clientDynamic.syncDynamicErrorWithStack;
-        if (dynamicValidation.createInstantStack !== null && syncError.cause === undefined) {
-            syncError.cause = dynamicValidation.createInstantStack();
+    if (syncDynamicError) {
+        if (effectiveCreateInstantStack !== null && syncDynamicError.cause === undefined) {
+            syncDynamicError.cause = effectiveCreateInstantStack();
         }
-        dynamicValidation.dynamicErrors.push(syncError);
+        dynamicValidation.dynamicErrors.push(syncDynamicError);
         return;
     }
-    const usageDescription = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`.` : `Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`.`;
-    const message = `Route "${workStore.route}": ${usageDescription} This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
-    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E1078",
-        enumerable: false,
-        configurable: true
-    }), componentStack, dynamicValidation.createInstantStack);
+    if ((0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
+        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);
     dynamicValidation.dynamicErrors.push(error);
     return;
 }
@@ -836,11 +892,11 @@ function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue,
             // invalid - fallthrough
             }
         }
-        const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because an error prevented the target segment from rendering.`;
+        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, {
             cause: thrownValue
         }), "__NEXT_ERROR_CODE", {
-            value: "E1112",
+            value: "E1338",
             enumerable: false,
             configurable: true
         }), componentStack, null // TODO(instant-validation-build): conflicting use of cause
@@ -848,29 +904,17 @@ function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue,
         dynamicValidation.validationPreventingErrors.push(error);
     }
 }
-function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+function trackDynamicHoleInRuntimeShell(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic) {
+    const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
     if (hasOutletRegex.test(componentStack)) {
-        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
+        trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
         return;
     } else if (hasMetadataRegex.test(componentStack)) {
-        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1080",
-            enumerable: false,
-            configurable: true
-        }), componentStack, null);
+        const error = addErrorContext((0, _blockingroutemessages.createDynamicMetadataError)(workStore.route), componentStack, null);
         dynamicValidation.dynamicMetadata = error;
         return;
     } else if (hasViewportRegex.test(componentStack)) {
-        // TODO(instant-validation): If the page only has holes caused by runtime data,
-        // we won't find out if there's a suspense-above-body and error for dynamic viewport
-        // even if there is in fact a suspense-above-body
-        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1077",
-            enumerable: false,
-            configurable: true
-        }), componentStack, null);
+        const error = addErrorContext((0, _blockingroutemessages.createDynamicViewportError)(workStore.route), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -885,40 +929,29 @@ function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValida
         // of disallowed
         dynamicValidation.hasAllowedDynamic = true;
         return;
-    } else if (clientDynamic.syncDynamicErrorWithStack) {
-        // This task was the task that called the sync error.
-        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
+    } else if (syncDynamicError) {
+        dynamicValidation.dynamicErrors.push(syncDynamicError);
         return;
     }
-    const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
-    const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E1084",
-        enumerable: false,
-        configurable: true
-    }), componentStack, null);
+    if ((0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
+        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(workStore, componentStack, dynamicValidation, clientDynamic) {
+function trackDynamicHoleInStaticShell(dynamicReason, workStore, componentStack, dynamicValidation, clientDynamic) {
+    const syncDynamicError = getPendingClientSyncDynamicError(clientDynamic);
     if (hasOutletRegex.test(componentStack)) {
-        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
+        trackOutletSuspenseAboveBody(componentStack, dynamicValidation);
         return;
     } else if (hasMetadataRegex.test(componentStack)) {
-        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1085",
-            enumerable: false,
-            configurable: true
-        }), componentStack, null);
+        const error = addErrorContext((0, _blockingroutemessages.createRuntimeMetadataError)(workStore.route), componentStack, null);
         dynamicValidation.dynamicMetadata = error;
         return;
     } else if (hasViewportRegex.test(componentStack)) {
-        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1081",
-            enumerable: false,
-            configurable: true
-        }), componentStack, null);
+        const error = addErrorContext((0, _blockingroutemessages.createRuntimeViewportError)(workStore.route), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -933,20 +966,17 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
         // of disallowed
         dynamicValidation.hasAllowedDynamic = true;
         return;
-    } else if (clientDynamic.syncDynamicErrorWithStack) {
-        // This task was the task that called the sync error.
-        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
+    } else if (syncDynamicError) {
+        dynamicValidation.dynamicErrors.push(syncDynamicError);
         return;
-    } else {
-        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
-        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1083",
-            enumerable: false,
-            configurable: true
-        }), componentStack, null);
-        dynamicValidation.dynamicErrors.push(error);
+    }
+    if ((0, _dynamicrenderingutils.isClientHookDynamicError)(dynamicReason)) {
+        dynamicValidation.dynamicErrors.push(addErrorContext(dynamicReason, componentStack, null));
         return;
     }
+    const error = addErrorContext((0, _blockingroutemessages.createRuntimeBodyError)(workStore.route), componentStack, null);
+    dynamicValidation.dynamicErrors.push(error);
+    return;
 }
 /**
  * In dev mode, we prefer using the owner stack, otherwise the provided
@@ -972,26 +1002,35 @@ var PreludeState = /*#__PURE__*/ function(PreludeState) {
 }({});
 function logDisallowedDynamicError(workStore, error) {
     console.error(error);
-    if (process.env.NODE_ENV !== 'development') {
-        console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
-  - Start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.
-  - Rerun the production build with \`next build --debug-prerender\` to generate better stack traces.`);
-    } else if (!process.env.__NEXT_DEV_SERVER) {
-        console.error(`To debug the issue, start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.`);
-    }
+    (0, _blockingroutemessages.logBuildDebugHint)(workStore.route);
 }
-function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
+function throwIfSyncIOUsed(workStore, serverDynamic) {
     if (serverDynamic.syncDynamicErrorWithStack) {
         logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
         throw new _staticgenerationbailout.StaticGenBailoutError();
     }
+}
+function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic, allowEmptyStaticShell) {
+    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
+    // the dynamic data access in `generateMetadata` was probably unintentional.
+    // 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);
+        throw new _staticgenerationbailout.StaticGenBailoutError();
+    }
+    // Either flag expresses "this shell is allowed to be empty/blocking":
+    //   - `allowEmptyStaticShell` covers `instant = false` (user opt-in)
+    //     and the build-phase fallback-shell case.
+    //   - `hasSuspenseAboveBody` is the structural opt-in inside the user's root
+    //     layout.
+    // Treat them as synonyms for the purpose of bypassing shell-failure errors.
+    if (allowEmptyStaticShell || dynamicValidation.hasSuspenseAboveBody) {
+        return;
+    }
     if (prelude !== 0) {
-        if (dynamicValidation.hasSuspenseAboveBody) {
-            // This route has opted into allowing fully dynamic rendering
-            // by including a Suspense boundary above the body. In this case
-            // a lack of a shell is not considered disallowed so we simply return
-            return;
-        }
         // We didn't have any sync bailouts but there may be user code which
         // blocked the root. We would have captured these during the prerender
         // and can log them here and then terminate the build/validating render
@@ -1007,7 +1046,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(`Route "${workStore.route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) without explicitly allowing fully dynamic rendering. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`);
+            console.error((0, _blockingroutemessages.createDynamicOrRuntimeViewportError)(workStore.route).message);
             throw new _staticgenerationbailout.StaticGenBailoutError();
         }
         if (prelude === 1) {
@@ -1017,18 +1056,26 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
             console.error(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.`);
             throw new _staticgenerationbailout.StaticGenBailoutError();
         }
-    } else {
-        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
-            console.error(`Route "${workStore.route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) when the rest of the route does not. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`);
-            throw new _staticgenerationbailout.StaticGenBailoutError();
-        }
     }
 }
-function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation, configAllowsBlocking) {
-    if (configAllowsBlocking || dynamicValidation.hasSuspenseAboveBody) {
-        // This route has opted into allowing fully dynamic rendering
-        // by including a Suspense boundary above the body. In this case
-        // a lack of a shell is not considered disallowed so we simply return
+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
+    // the dynamic data access in `generateMetadata` was probably unintentional.
+    // 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.dynamicErrors.length === 0 && dynamicValidation.dynamicMetadata) {
+        return [
+            dynamicValidation.dynamicMetadata
+        ];
+    }
+    // Either flag expresses "this shell is allowed to be empty/blocking":
+    //   - `allowEmptyStaticShell` covers `instant = false` (user opt-in)
+    //     and the build-phase fallback-shell case.
+    //   - `hasSuspenseAboveBody` is the structural opt-in inside the user's root
+    //     layout.
+    // Treat them as synonyms for the purpose of bypassing shell-failure errors.
+    if (allowEmptyStaticShell || dynamicValidation.hasSuspenseAboveBody) {
         return [];
     }
     if (prelude !== 0) {
@@ -1051,18 +1098,11 @@ function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValid
                 })
             ];
         }
-    } else {
-        // We have a prelude but we might still have dynamic metadata without any other dynamic access
-        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicErrors.length === 0 && dynamicValidation.dynamicMetadata) {
-            return [
-                dynamicValidation.dynamicMetadata
-            ];
-        }
     }
     // We had a non-empty prelude and there are no dynamic holes
     return [];
 }
-function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState) {
+function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState, devRenderDidError) {
     // If we have errors related to missing samples, those should take precedence over everything else.
     if (validationSampleTracking) {
         const { missingSampleErrors } = validationSampleTracking;
@@ -1072,37 +1112,13 @@ function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValida
     }
     const { validationPreventingErrors } = dynamicValidation;
     if (validationPreventingErrors.length > 0) {
-        return validationPreventingErrors;
-    }
-    if (boundaryState.renderedIds.size < boundaryState.expectedIds.size) {
-        const { thrownErrorsOutsideBoundary, createInstantStack } = dynamicValidation;
-        if (thrownErrorsOutsideBoundary.length === 0) {
-            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering for an unknown reason.`;
-            const error = createInstantStack !== null ? createInstantStack() : new Error();
-            error.name = 'Error';
-            error.message = message;
-            return [
-                error
-            ];
-        } else if (thrownErrorsOutsideBoundary.length === 1) {
-            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering, likely due to the following error.`;
-            const error = createInstantStack !== null ? createInstantStack() : new Error();
-            error.name = 'Error';
-            error.message = message;
-            return [
-                error,
-                thrownErrorsOutsideBoundary[0]
-            ];
-        } else {
-            const message = `Route "${workStore.route}": Could not validate \`unstable_instant\` because the target segment was prevented from rendering, likely due to one of the following errors.`;
-            const error = createInstantStack !== null ? createInstantStack() : new Error();
-            error.name = 'Error';
-            error.message = message;
-            return [
-                error,
-                ...thrownErrorsOutsideBoundary
-            ];
+        if (process.env.__NEXT_DEV_SERVER && devRenderDidError) {
+            // The dev render already surfaced server errors to the user.
+            // The same errors likely caused validation to be inconclusive,
+            // so reporting them again as validation failures would be noisy.
+            return [];
         }
+        return validationPreventingErrors;
     }
     // NOTE: We don't care about Suspense above body here,
     // we're only concerned with the validation boundary
@@ -1111,20 +1127,15 @@ function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValida
         if (dynamicErrors.length > 0) {
             return dynamicErrors;
         }
-        if (prelude === 1) {
-            // If a client component suspended prevented us from rendering a shell
-            // but didn't block validation, we don't require a prelude.
-            if (dynamicValidation.hasAllowedClientDynamicAboveBoundary) {
-                return [];
-            }
-            // If we ever get this far then we messed up the tracking of invalid dynamic.
-            return [
-                Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" failed to render during instant validation and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
-                    value: "E1055",
-                    enumerable: false,
-                    configurable: true
-                })
-            ];
+        if (prelude === 1 && !dynamicValidation.hasAllowedClientDynamicAboveBoundary && (0, _boundarytracking.allRequiredBoundariesRendered)(boundaryState)) {
+            // 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
+            });
         }
     } else {
         const dynamicErrors = dynamicValidation.dynamicErrors;
@@ -1137,6 +1148,52 @@ function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValida
             ];
         }
     }
+    // Missing boundaries on their own aren't a strong signal — a parent
+    // layout may legitimately omit a slot. Defer this so the caller can
+    // try shallower validation depths first; if every depth comes up
+    // empty we still want to surface this so the user is made aware that
+    // validation didn't complete. When we add a markers API, the
+    // marker-based variant of this check can become strict again.
+    if (!(0, _boundarytracking.allRequiredBoundariesRendered)(boundaryState)) {
+        const { thrownErrorsOutsideBoundary } = dynamicValidation;
+        const rootInstantStack = dynamicValidation.slotStacks[0];
+        if (thrownErrorsOutsideBoundary.length === 0) {
+            const missingFiles = [];
+            for (const [id, filePaths] of boundaryState.requiredIds){
+                if (!boundaryState.renderedIds.has(id)) {
+                    for (const filePath of filePaths){
+                        let normalized = filePath.replace(/^\[project\][\\/]?/, '').replace(process.cwd() + '/', '').replace(process.cwd() + '\\', '');
+                        missingFiles.push(normalized);
+                    }
+                }
+            }
+            missingFiles.sort();
+            return (0, _instantmessages.createUnrenderedSegmentError)(workStore.route, missingFiles);
+        } else if (process.env.__NEXT_DEV_SERVER && devRenderDidError) {
+            // Errors outside the boundary likely blocked it from rendering,
+            // but they're already being reported to the user via the dev
+            // render. Suppress the validation failure to avoid noise.
+            return [];
+        } else if (thrownErrorsOutsideBoundary.length === 1) {
+            const message = `Route "${workStore.route}": Could not validate \`instant\` because the target segment was prevented from rendering, likely due to the following error.`;
+            const error = rootInstantStack !== null ? rootInstantStack() : new Error();
+            error.name = 'Error';
+            error.message = message;
+            return new AggregateError([
+                error,
+                thrownErrorsOutsideBoundary[0]
+            ]);
+        } else {
+            const message = `Route "${workStore.route}": Could not validate \`instant\` because the target segment was prevented from rendering, likely due to one of the following errors.`;
+            const error = rootInstantStack !== null ? rootInstantStack() : new Error();
+            error.name = 'Error';
+            error.message = message;
+            return new AggregateError([
+                error,
+                ...thrownErrorsOutsideBoundary
+            ]);
+        }
+    }
     // We had a non-empty prelude and there are no dynamic holes
     return [];
 }