@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.3

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

@@ -23,6 +23,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    DynamicHoleKind: null,
     Postpone: null,
     PreludeState: null,
     abortAndThrowOnSynchronousRequestDataAccess: null,
@@ -33,10 +34,11 @@ Object.defineProperty(exports, "__esModule", {
     createDynamicTrackingState: null,
     createDynamicValidationState: null,
     createHangingInputAbortSignal: null,
+    createInstantValidationState: null,
     createRenderInBrowserAbortSignal: null,
-    delayUntilRuntimeStage: null,
     formatDynamicAPIAccesses: null,
     getFirstDynamicReason: null,
+    getNavigationDisallowedDynamicReasons: null,
     getStaticShellDisallowedDynamicReasons: null,
     isDynamicPostpone: null,
     isPrerenderInterruptedError: null,
@@ -47,8 +49,10 @@ Object.defineProperty(exports, "__esModule", {
     throwToInterruptStaticGeneration: null,
     trackAllowedDynamicAccess: null,
     trackDynamicDataInDynamicRender: null,
+    trackDynamicHoleInNavigation: null,
     trackDynamicHoleInRuntimeShell: null,
     trackDynamicHoleInStaticShell: null,
+    trackThrownErrorInNavigation: null,
     useDynamicRouteParams: null,
     useDynamicSearchParams: null
 });
@@ -59,6 +63,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    DynamicHoleKind: function() {
+        return DynamicHoleKind;
+    },
     Postpone: function() {
         return Postpone;
     },
@@ -89,18 +96,21 @@ _export(exports, {
     createHangingInputAbortSignal: function() {
         return createHangingInputAbortSignal;
     },
+    createInstantValidationState: function() {
+        return createInstantValidationState;
+    },
     createRenderInBrowserAbortSignal: function() {
         return createRenderInBrowserAbortSignal;
     },
-    delayUntilRuntimeStage: function() {
-        return delayUntilRuntimeStage;
-    },
     formatDynamicAPIAccesses: function() {
         return formatDynamicAPIAccesses;
     },
     getFirstDynamicReason: function() {
         return getFirstDynamicReason;
     },
+    getNavigationDisallowedDynamicReasons: function() {
+        return getNavigationDisallowedDynamicReasons;
+    },
     getStaticShellDisallowedDynamicReasons: function() {
         return getStaticShellDisallowedDynamicReasons;
     },
@@ -131,12 +141,18 @@ _export(exports, {
     trackDynamicDataInDynamicRender: function() {
         return trackDynamicDataInDynamicRender;
     },
+    trackDynamicHoleInNavigation: function() {
+        return trackDynamicHoleInNavigation;
+    },
     trackDynamicHoleInRuntimeShell: function() {
         return trackDynamicHoleInRuntimeShell;
     },
     trackDynamicHoleInStaticShell: function() {
         return trackDynamicHoleInStaticShell;
     },
+    trackThrownErrorInNavigation: function() {
+        return trackThrownErrorInNavigation;
+    },
     useDynamicRouteParams: function() {
         return useDynamicRouteParams;
     },
@@ -154,6 +170,7 @@ const _boundaryconstants = require("../../lib/framework/boundary-constants");
 const _scheduler = require("../../lib/scheduler");
 const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
 const _invarianterror = require("../../shared/lib/invariant-error");
+const _boundaryconstants1 = require("./instant-validation/boundary-constants");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -197,6 +214,7 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
             case 'prerender-legacy':
             case 'prerender-ppr':
             case 'request':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;
@@ -234,6 +252,8 @@ function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
                     workUnitStore.usedDynamic = true;
                 }
                 break;
+            case 'generate-static-params':
+                break;
             default:
                 workUnitStore;
         }
@@ -268,6 +288,8 @@ function trackDynamicDataInDynamicRender(workUnitStore) {
         case 'prerender-legacy':
         case 'prerender-ppr':
         case 'prerender-client':
+        case 'validation-client':
+        case 'generate-static-params':
             break;
         case 'request':
             if (process.env.NODE_ENV !== 'production') {
@@ -452,21 +474,24 @@ function createHangingInputAbortSignal(workUnitStore) {
                 // render the content of this cache as deeply as we can so that we can
                 // suspend as deeply as possible in the tree or not at all if we don't
                 // end up waiting for the input.
-                const runtimeStagePromise = (0, _workunitasyncstorageexternal.getRuntimeStagePromise)(workUnitStore);
-                if (runtimeStagePromise) {
-                    runtimeStagePromise.then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
+                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()));
                 } else {
                     (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
                 }
             }
             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':
             return undefined;
         default:
             workUnitStore;
@@ -506,6 +531,10 @@ function useDynamicRouteParams(expression) {
                     }
                     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",
@@ -519,6 +548,12 @@ function useDynamicRouteParams(expression) {
                     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':
@@ -539,6 +574,10 @@ function useDynamicSearchParams(expression) {
         (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.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
@@ -571,6 +610,12 @@ function useDynamicSearchParams(expression) {
                 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:
@@ -596,6 +641,7 @@ const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\
 const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
 const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
 const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+const hasInstantValidationBoundaryRegex = new RegExp(`\\n\\s+at ${_boundaryconstants1.INSTANT_VALIDATION_BOUNDARY_NAME}[\\n\\s]`);
 function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
     if (hasOutletRegex.test(componentStack)) {
         // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
@@ -624,10 +670,183 @@ function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation,
         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 = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1079",
+            enumerable: false,
+            configurable: true
+        }), 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";
+    return DynamicHoleKind;
+}({});
+function createInstantValidationState(createInstantStack) {
+    return {
+        hasDynamicMetadata: false,
+        hasAllowedClientDynamicAboveBoundary: false,
+        dynamicMetadata: null,
+        hasDynamicViewport: false,
+        hasAllowedDynamic: false,
+        dynamicErrors: [],
+        validationPreventingErrors: [],
+        thrownErrorsOutsideBoundary: [],
+        createInstantStack
+    };
+}
+function trackDynamicHoleInNavigation(workStore, componentStack, dynamicValidation, clientDynamic, kind, boundaryState) {
+    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;
+    }
+    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);
+        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);
         dynamicValidation.dynamicErrors.push(error);
         return;
     }
+    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
+    if (!boundaryLocation) {
+        // We don't see the validation boundary in the component stack,
+        // so this hole must be coming from a shared parent.
+        // Shared parents are fully resolved and don't have RSC holes,
+        // but they can still suspend in a client component during SSR.
+        // 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) {
+            dynamicValidation.hasAllowedClientDynamicAboveBoundary = true;
+            dynamicValidation.hasAllowedDynamic = true // Holes outside the boundary contribute to allowing dynamic metadata
+            ;
+            return;
+        } else {
+            // TODO(instant-validation) TODO(NAR-787)
+            // 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 error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+                value: "E1082",
+                enumerable: false,
+                configurable: true
+            }), componentStack, dynamicValidation.createInstantStack);
+            dynamicValidation.validationPreventingErrors.push(error);
+            return;
+        }
+    } else {
+        // The hole originates inside the validation boundary.
+        //
+        // Check if we have a Suspense above the hole, but below the validation boundary.
+        // If we do, then this dynamic usage wouldn't block a navigation to this subtree.
+        // Conversely, if the nearest suspense is above the validation boundary, then this subtree would block.
+        //
+        // Note that in the component stack, children come before parents.
+        //
+        // Valid:
+        //   ...
+        //   at Suspense
+        //   ...
+        //   at __next_prefetch_validation_boundary__
+        //
+        // Invalid:
+        //   ...
+        //   at __next_prefetch_validation_boundary__
+        //   ...
+        //   at Suspense
+        //
+        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
+        if (suspenseLocation) {
+            if (suspenseLocation.index < boundaryLocation.index) {
+                dynamicValidation.hasAllowedDynamic = true;
+                return;
+            } else {
+            // invalid - fallthrough
+            }
+        }
+    }
+    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();
+        }
+        dynamicValidation.dynamicErrors.push(syncError);
+        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);
+    dynamicValidation.dynamicErrors.push(error);
+    return;
+}
+function trackThrownErrorInNavigation(workStore, dynamicValidation, thrownValue, componentStack) {
+    const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
+    if (!boundaryLocation) {
+        // There's no validation boundary on the component stack.
+        // This error may have blocked a boundary from rendering.
+        // Wrap the error to provide component context.
+        // 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.', {
+            cause: thrownValue
+        }), "__NEXT_ERROR_CODE", {
+            value: "E1118",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
+        dynamicValidation.thrownErrorsOutsideBoundary.push(error);
+    } else {
+        // There's validation boundary on the component stack,
+        // so we know this error didn't block a validation boundary from rendering.
+        // However, this error might be hiding be hiding dynamic content that would
+        // cause validation to fail.
+        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
+        if (suspenseLocation) {
+            if (suspenseLocation.index < boundaryLocation.index) {
+                // There's a Suspense below the validation boundary but above this error's location.
+                // This subtree can't fail instant validation because any potential
+                // dynamic holes would be guarded by the Suspense anyway,
+                // so we can allow this.
+                return;
+            } else {
+            // invalid - fallthrough
+            }
+        }
+        const message = `Route "${workStore.route}": Could not validate \`unstable_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",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null // TODO(instant-validation-build): conflicting use of cause
+        );
+        dynamicValidation.validationPreventingErrors.push(error);
+    }
 }
 function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
     if (hasOutletRegex.test(componentStack)) {
@@ -635,12 +854,23 @@ function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValida
         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 = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1080",
+            enumerable: false,
+            configurable: true
+        }), 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 = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1077",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -659,12 +889,15 @@ function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValida
         // This task was the task that called the sync error.
         dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
         return;
-    } else {
-        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 = createErrorWithComponentOrOwnerStack(message, componentStack);
-        dynamicValidation.dynamicErrors.push(error);
-        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);
+    dynamicValidation.dynamicErrors.push(error);
+    return;
 }
 function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidation, clientDynamic) {
     if (hasOutletRegex.test(componentStack)) {
@@ -672,12 +905,20 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
         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 = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1085",
+            enumerable: false,
+            configurable: true
+        }), 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 = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1081",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
@@ -698,7 +939,11 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
         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 = createErrorWithComponentOrOwnerStack(message, componentStack);
+        const error = addErrorContext(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E1083",
+            enumerable: false,
+            configurable: true
+        }), componentStack, null);
         dynamicValidation.dynamicErrors.push(error);
         return;
     }
@@ -706,16 +951,17 @@ function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidat
 /**
  * In dev mode, we prefer using the owner stack, otherwise the provided
  * component stack is used.
- */ function createErrorWithComponentOrOwnerStack(message, componentStack) {
+ *
+ * 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;
-    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E394",
-        enumerable: false,
-        configurable: true
-    });
+    if (createInstantStack !== null) {
+        error.cause = createInstantStack();
+    }
     // TODO go back to owner stack here if available. This is temporarily using componentStack to get the right
     //
-    error.stack = error.name + ': ' + message + (ownerStack || componentStack);
+    error.stack = error.name + ': ' + error.message + (ownerStack || componentStack);
     return error;
 }
 var PreludeState = /*#__PURE__*/ function(PreludeState) {
@@ -726,14 +972,12 @@ var PreludeState = /*#__PURE__*/ function(PreludeState) {
 }({});
 function logDisallowedDynamicError(workStore, error) {
     console.error(error);
-    if (!workStore.dev) {
-        if (workStore.hasReadableErrorStacks) {
-            console.error(`To get a more detailed stack trace and pinpoint the issue, start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.`);
-        } else {
-            console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
+    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.`);
     }
 }
 function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
@@ -780,8 +1024,8 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
         }
     }
 }
-function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation) {
-    if (dynamicValidation.hasSuspenseAboveBody) {
+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
@@ -818,11 +1062,83 @@ function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValid
     // We had a non-empty prelude and there are no dynamic holes
     return [];
 }
-function delayUntilRuntimeStage(prerenderStore, result) {
-    if (prerenderStore.runtimeStagePromise) {
-        return prerenderStore.runtimeStagePromise.then(()=>result);
+function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState) {
+    // If we have errors related to missing samples, those should take precedence over everything else.
+    if (validationSampleTracking) {
+        const { missingSampleErrors } = validationSampleTracking;
+        if (missingSampleErrors.length > 0) {
+            return missingSampleErrors;
+        }
+    }
+    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
+            ];
+        }
     }
-    return result;
+    // NOTE: We don't care about Suspense above body here,
+    // we're only concerned with the validation boundary
+    if (prelude !== 0) {
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        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
+                })
+            ];
+        }
+    } else {
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+            return dynamicErrors;
+        }
+        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicMetadata) {
+            return [
+                dynamicValidation.dynamicMetadata
+            ];
+        }
+    }
+    // We had a non-empty prelude and there are no dynamic holes
+    return [];
 }
 
 //# sourceMappingURL=dynamic-rendering.js.map