boreal-ui 0.0.73 → 0.0.75

package/dist/next/{navigation-C2hD8Jlk.js → navigation-BCeRD3ib.js}

@@ -1,4 +1,4 @@
-import { r as require_interop_require_default, a as require_interop_require_wildcard, d as requireInvariantError, e as requireSegment } from "./link-CyxHztrS.js";
+import { r as require_interop_require_default, a as require_interop_require_wildcard, d as requireInvariantError, e as requireUtils, f as requireQuerystring, h as requireGetSegmentParam, i as requireSegment } from "./link-4NcriBFB.js";
 import React from "react";
 var navigation$1 = { exports: {} };
 var appRouterContext_sharedRuntime = {};
@@ -280,20 +280,12 @@ function requireRedirectError() {
       REDIRECT_ERROR_CODE: function() {
         return REDIRECT_ERROR_CODE;
       },
-      RedirectType: function() {
-        return RedirectType;
-      },
       isRedirectError: function() {
         return isRedirectError;
       }
     });
     const _redirectstatuscode = requireRedirectStatusCode();
     const REDIRECT_ERROR_CODE = "NEXT_REDIRECT";
-    var RedirectType = /* @__PURE__ */ (function(RedirectType2) {
-      RedirectType2["push"] = "push";
-      RedirectType2["replace"] = "replace";
-      return RedirectType2;
-    })({});
     function isRedirectError(error) {
       if (typeof error !== "object" || error === null || !("digest" in error) || typeof error.digest !== "string") {
         return false;
@@ -475,10 +467,10 @@ function requireRedirect() {
     }
     function redirect2(url, type) {
       var _a;
-      type ?? (type = ((_a = actionAsyncStorage == null ? void 0 : actionAsyncStorage.getStore()) == null ? void 0 : _a.isAction) ? _redirecterror.RedirectType.push : _redirecterror.RedirectType.replace);
+      type ?? (type = ((_a = actionAsyncStorage == null ? void 0 : actionAsyncStorage.getStore()) == null ? void 0 : _a.isAction) ? "push" : "replace");
       throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
     }
-    function permanentRedirect(url, type = _redirecterror.RedirectType.replace) {
+    function permanentRedirect(url, type = "replace") {
       throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.PermanentRedirect);
     }
     function getURLFromRedirectError(error) {
@@ -602,7 +594,7 @@ function requireNotFound() {
     const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};404`;
     function notFound2() {
       const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1041",
         enumerable: false,
         configurable: true
       });
@@ -643,7 +635,7 @@ function requireForbidden() {
         });
       }
       const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1019",
         enumerable: false,
         configurable: true
       });
@@ -684,7 +676,7 @@ function requireUnauthorized() {
         });
       }
       const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1002",
         enumerable: false,
         configurable: true
       });
@@ -702,6 +694,318 @@ function requireUnauthorized() {
 var unstableRethrow = { exports: {} };
 var unstableRethrow_server = { exports: {} };
 var dynamicRenderingUtils = {};
+var stagedRendering = {};
+var promiseWithResolvers = {};
+var hasRequiredPromiseWithResolvers;
+function requirePromiseWithResolvers() {
+  if (hasRequiredPromiseWithResolvers) return promiseWithResolvers;
+  hasRequiredPromiseWithResolvers = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "createPromiseWithResolvers", {
+      enumerable: true,
+      get: function() {
+        return createPromiseWithResolvers;
+      }
+    });
+    function createPromiseWithResolvers() {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return {
+        resolve,
+        reject,
+        promise
+      };
+    }
+  })(promiseWithResolvers);
+  return promiseWithResolvers;
+}
+var hasRequiredStagedRendering;
+function requireStagedRendering() {
+  if (hasRequiredStagedRendering) return stagedRendering;
+  hasRequiredStagedRendering = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      RenderStage: function() {
+        return RenderStage;
+      },
+      StagedRenderingController: function() {
+        return StagedRenderingController;
+      }
+    });
+    const _invarianterror = requireInvariantError();
+    const _promisewithresolvers = requirePromiseWithResolvers();
+    var RenderStage = /* @__PURE__ */ (function(RenderStage2) {
+      RenderStage2[RenderStage2["Before"] = 1] = "Before";
+      RenderStage2[RenderStage2["EarlyStatic"] = 2] = "EarlyStatic";
+      RenderStage2[RenderStage2["Static"] = 3] = "Static";
+      RenderStage2[RenderStage2["EarlyRuntime"] = 4] = "EarlyRuntime";
+      RenderStage2[RenderStage2["Runtime"] = 5] = "Runtime";
+      RenderStage2[RenderStage2["Dynamic"] = 6] = "Dynamic";
+      RenderStage2[RenderStage2["Abandoned"] = 7] = "Abandoned";
+      return RenderStage2;
+    })({});
+    class StagedRenderingController {
+      constructor(abortSignal, abandonController, shouldTrackSyncIO) {
+        this.abortSignal = abortSignal;
+        this.abandonController = abandonController;
+        this.shouldTrackSyncIO = shouldTrackSyncIO;
+        this.currentStage = 1;
+        this.syncInterruptReason = null;
+        this.staticStageEndTime = Infinity;
+        this.runtimeStageEndTime = Infinity;
+        this.staticStageListeners = [];
+        this.earlyRuntimeStageListeners = [];
+        this.runtimeStageListeners = [];
+        this.dynamicStageListeners = [];
+        this.staticStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.earlyRuntimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        if (abortSignal) {
+          abortSignal.addEventListener("abort", () => {
+            const { reason } = abortSignal;
+            this.staticStagePromise.promise.catch(ignoreReject);
+            this.staticStagePromise.reject(reason);
+            this.earlyRuntimeStagePromise.promise.catch(ignoreReject);
+            this.earlyRuntimeStagePromise.reject(reason);
+            this.runtimeStagePromise.promise.catch(ignoreReject);
+            this.runtimeStagePromise.reject(reason);
+            this.dynamicStagePromise.promise.catch(ignoreReject);
+            this.dynamicStagePromise.reject(reason);
+          }, {
+            once: true
+          });
+        }
+        if (abandonController) {
+          abandonController.signal.addEventListener("abort", () => {
+            this.abandonRender();
+          }, {
+            once: true
+          });
+        }
+      }
+      onStage(stage, callback) {
+        if (this.currentStage >= stage) {
+          callback();
+        } else if (stage === 3) {
+          this.staticStageListeners.push(callback);
+        } else if (stage === 4) {
+          this.earlyRuntimeStageListeners.push(callback);
+        } else if (stage === 5) {
+          this.runtimeStageListeners.push(callback);
+        } else if (stage === 6) {
+          this.dynamicStageListeners.push(callback);
+        } else {
+          throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+            value: "E881",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      }
+      shouldTrackSyncInterrupt() {
+        if (!this.shouldTrackSyncIO) {
+          return false;
+        }
+        switch (this.currentStage) {
+          case 1:
+            return false;
+          case 2:
+          case 3:
+            return true;
+          case 4:
+            return true;
+          case 5:
+            return false;
+          case 6:
+          case 7:
+            return false;
+          default:
+            return false;
+        }
+      }
+      syncInterruptCurrentStageWithReason(reason) {
+        if (this.currentStage === 1) {
+          return;
+        }
+        if (this.currentStage === 7) {
+          return;
+        }
+        if (this.abandonController) {
+          this.abandonController.abort();
+          return;
+        }
+        if (this.abortSignal) {
+          this.syncInterruptReason = reason;
+          this.currentStage = 7;
+          return;
+        }
+        switch (this.currentStage) {
+          case 2:
+          case 3:
+          case 4: {
+            this.syncInterruptReason = reason;
+            this.advanceStage(6);
+            return;
+          }
+          case 5: {
+            return;
+          }
+        }
+      }
+      getSyncInterruptReason() {
+        return this.syncInterruptReason;
+      }
+      getStaticStageEndTime() {
+        return this.staticStageEndTime;
+      }
+      getRuntimeStageEndTime() {
+        return this.runtimeStageEndTime;
+      }
+      abandonRender() {
+        const { currentStage } = this;
+        switch (currentStage) {
+          case 2: {
+            this.resolveStaticStage();
+          }
+          // intentional fallthrough
+          case 3: {
+            this.resolveEarlyRuntimeStage();
+          }
+          // intentional fallthrough
+          case 4: {
+            this.resolveRuntimeStage();
+          }
+          // intentional fallthrough
+          case 5: {
+            this.currentStage = 7;
+            return;
+          }
+        }
+      }
+      advanceStage(stage) {
+        if (stage <= this.currentStage) {
+          return;
+        }
+        let currentStage = this.currentStage;
+        this.currentStage = stage;
+        if (currentStage < 3 && stage >= 3) {
+          this.resolveStaticStage();
+        }
+        if (currentStage < 4 && stage >= 4) {
+          this.resolveEarlyRuntimeStage();
+        }
+        if (currentStage < 5 && stage >= 5) {
+          this.staticStageEndTime = performance.now() + performance.timeOrigin;
+          this.resolveRuntimeStage();
+        }
+        if (currentStage < 6 && stage >= 6) {
+          this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
+          this.resolveDynamicStage();
+          return;
+        }
+      }
+      /** Fire the `onStage` listeners for the static stage and unblock any promises waiting for it. */
+      resolveStaticStage() {
+        const staticListeners = this.staticStageListeners;
+        for (let i = 0; i < staticListeners.length; i++) {
+          staticListeners[i]();
+        }
+        staticListeners.length = 0;
+        this.staticStagePromise.resolve();
+      }
+      /** Fire the `onStage` listeners for the early runtime stage and unblock any promises waiting for it. */
+      resolveEarlyRuntimeStage() {
+        const earlyRuntimeListeners = this.earlyRuntimeStageListeners;
+        for (let i = 0; i < earlyRuntimeListeners.length; i++) {
+          earlyRuntimeListeners[i]();
+        }
+        earlyRuntimeListeners.length = 0;
+        this.earlyRuntimeStagePromise.resolve();
+      }
+      /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */
+      resolveRuntimeStage() {
+        const runtimeListeners = this.runtimeStageListeners;
+        for (let i = 0; i < runtimeListeners.length; i++) {
+          runtimeListeners[i]();
+        }
+        runtimeListeners.length = 0;
+        this.runtimeStagePromise.resolve();
+      }
+      /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */
+      resolveDynamicStage() {
+        const dynamicListeners = this.dynamicStageListeners;
+        for (let i = 0; i < dynamicListeners.length; i++) {
+          dynamicListeners[i]();
+        }
+        dynamicListeners.length = 0;
+        this.dynamicStagePromise.resolve();
+      }
+      getStagePromise(stage) {
+        switch (stage) {
+          case 3: {
+            return this.staticStagePromise.promise;
+          }
+          case 4: {
+            return this.earlyRuntimeStagePromise.promise;
+          }
+          case 5: {
+            return this.runtimeStagePromise.promise;
+          }
+          case 6: {
+            return this.dynamicStagePromise.promise;
+          }
+          default: {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+              value: "E881",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+      }
+      waitForStage(stage) {
+        return this.getStagePromise(stage);
+      }
+      delayUntilStage(stage, displayName, resolvedValue) {
+        const ioTriggerPromise = this.getStagePromise(stage);
+        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
+        if (this.abortSignal) {
+          promise.catch(ignoreReject);
+        }
+        return promise;
+      }
+    }
+    function ignoreReject() {
+    }
+    function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
+      const promise = new Promise((resolve, reject) => {
+        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
+      });
+      if (displayName !== void 0) {
+        promise.displayName = displayName;
+      }
+      return promise;
+    }
+  })(stagedRendering);
+  return stagedRendering;
+}
 var hasRequiredDynamicRenderingUtils;
 function requireDynamicRenderingUtils() {
   if (hasRequiredDynamicRenderingUtils) return dynamicRenderingUtils;
@@ -717,6 +1021,12 @@ function requireDynamicRenderingUtils() {
       });
     }
     _export(exports$1, {
+      delayUntilRuntimeStage: function() {
+        return delayUntilRuntimeStage;
+      },
+      getRuntimeStage: function() {
+        return getRuntimeStage;
+      },
       isHangingPromiseRejectionError: function() {
         return isHangingPromiseRejectionError;
       },
@@ -727,6 +1037,7 @@ function requireDynamicRenderingUtils() {
         return makeHangingPromise;
       }
     });
+    const _stagedrendering = requireStagedRendering();
     function isHangingPromiseRejectionError(err) {
       if (typeof err !== "object" || err === null || !("digest" in err)) {
         return false;
@@ -779,6 +1090,19 @@ function requireDynamicRenderingUtils() {
         }, 0);
       });
     }
+    function getRuntimeStage(stagedRendering2) {
+      if (stagedRendering2.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering2.currentStage === _stagedrendering.RenderStage.EarlyRuntime) {
+        return _stagedrendering.RenderStage.EarlyRuntime;
+      }
+      return _stagedrendering.RenderStage.Runtime;
+    }
+    function delayUntilRuntimeStage(prerenderStore, result) {
+      const { stagedRendering: stagedRendering2 } = prerenderStore;
+      if (!stagedRendering2) {
+        return result;
+      }
+      return stagedRendering2.waitForStage(getRuntimeStage(stagedRendering2)).then(() => result);
+    }
   })(dynamicRenderingUtils);
   return dynamicRenderingUtils;
 }
@@ -1018,6 +1342,12 @@ function requireAppRouterHeaders() {
       NEXT_HTML_REQUEST_ID_HEADER: function() {
         return NEXT_HTML_REQUEST_ID_HEADER;
       },
+      NEXT_INSTANT_PREFETCH_HEADER: function() {
+        return NEXT_INSTANT_PREFETCH_HEADER;
+      },
+      NEXT_INSTANT_TEST_COOKIE: function() {
+        return NEXT_INSTANT_TEST_COOKIE;
+      },
       NEXT_IS_PRERENDER_HEADER: function() {
         return NEXT_IS_PRERENDER_HEADER;
       },
@@ -1064,6 +1394,8 @@ function requireAppRouterHeaders() {
     const NEXT_HMR_REFRESH_HASH_COOKIE = "__next_hmr_refresh_hash__";
     const NEXT_URL = "next-url";
     const RSC_CONTENT_TYPE_HEADER = "text/x-component";
+    const NEXT_INSTANT_PREFETCH_HEADER = "next-instant-navigation-testing-prefetch";
+    const NEXT_INSTANT_TEST_COOKIE = "next-instant-navigation-testing";
     const FLIGHT_HEADERS = [
       RSC_HEADER,
       NEXT_ROUTER_STATE_TREE_HEADER,
@@ -1119,15 +1451,18 @@ function requireWorkUnitAsyncStorage_external() {
       getRenderResumeDataCache: function() {
         return getRenderResumeDataCache;
       },
-      getRuntimeStagePromise: function() {
-        return getRuntimeStagePromise;
-      },
       getServerComponentsHmrCache: function() {
         return getServerComponentsHmrCache;
       },
+      getStagedRenderingController: function() {
+        return getStagedRenderingController;
+      },
       isHmrRefresh: function() {
         return isHmrRefresh;
       },
+      isInEarlyRenderStage: function() {
+        return isInEarlyRenderStage;
+      },
       throwForMissingRequestStore: function() {
         return throwForMissingRequestStore;
       },
@@ -1141,6 +1476,14 @@ function requireWorkUnitAsyncStorage_external() {
     const _workunitasyncstorageinstance = requireWorkUnitAsyncStorageInstance();
     const _approuterheaders = requireAppRouterHeaders();
     const _invarianterror = requireInvariantError();
+    const _stagedrendering = requireStagedRendering();
+    function isInEarlyRenderStage(requestStore) {
+      const stagedRendering2 = requestStore.stagedRendering;
+      if (stagedRendering2) {
+        return stagedRendering2.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering2.currentStage === _stagedrendering.RenderStage.EarlyRuntime;
+      }
+      return false;
+    }
     function throwForMissingRequestStore(callingExpression) {
       throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
         value: "E251",
@@ -1162,6 +1505,7 @@ function requireWorkUnitAsyncStorage_external() {
         case "prerender-ppr":
           return workUnitStore.prerenderResumeDataCache;
         case "prerender-client":
+        case "validation-client":
           return workUnitStore.prerenderResumeDataCache;
         case "request": {
           if (workUnitStore.prerenderResumeDataCache) {
@@ -1172,6 +1516,7 @@ function requireWorkUnitAsyncStorage_external() {
         case "cache":
         case "private-cache":
         case "unstable-cache":
+        case "generate-static-params":
           return null;
         default:
           return workUnitStore;
@@ -1183,6 +1528,7 @@ function requireWorkUnitAsyncStorage_external() {
         case "prerender":
         case "prerender-runtime":
         case "prerender-client":
+        case "validation-client":
           if (workUnitStore.renderResumeDataCache) {
             return workUnitStore.renderResumeDataCache;
           }
@@ -1193,13 +1539,14 @@ function requireWorkUnitAsyncStorage_external() {
         case "private-cache":
         case "unstable-cache":
         case "prerender-legacy":
+        case "generate-static-params":
           return null;
         default:
           return workUnitStore;
       }
     }
-    function getHmrRefreshHash(workStore, workUnitStore) {
-      if (workStore.dev) {
+    function getHmrRefreshHash(workUnitStore) {
+      if (process.env.__NEXT_DEV_SERVER) {
         switch (workUnitStore.type) {
           case "cache":
           case "private-cache":
@@ -1213,8 +1560,8 @@ function requireWorkUnitAsyncStorage_external() {
       }
       return void 0;
     }
-    function isHmrRefresh(workStore, workUnitStore) {
-      if (workStore.dev) {
+    function isHmrRefresh(workUnitStore) {
+      if (process.env.__NEXT_DEV_SERVER) {
         switch (workUnitStore.type) {
           case "cache":
           case "private-cache":
@@ -1224,8 +1571,8 @@ function requireWorkUnitAsyncStorage_external() {
       }
       return false;
     }
-    function getServerComponentsHmrCache(workStore, workUnitStore) {
-      if (workStore.dev) {
+    function getServerComponentsHmrCache(workUnitStore) {
+      if (process.env.__NEXT_DEV_SERVER) {
         switch (workUnitStore.type) {
           case "cache":
           case "private-cache":
@@ -1248,39 +1595,43 @@ function requireWorkUnitAsyncStorage_external() {
       }
       return void 0;
     }
-    function getCacheSignal(workUnitStore) {
+    function getStagedRenderingController(workUnitStore) {
       switch (workUnitStore.type) {
+        case "request":
+        case "prerender-runtime":
+          return workUnitStore.stagedRendering ?? null;
         case "prerender":
         case "prerender-client":
-        case "prerender-runtime":
-          return workUnitStore.cacheSignal;
-        case "request": {
-          if (workUnitStore.cacheSignal) {
-            return workUnitStore.cacheSignal;
-          }
-        }
+        case "validation-client":
         case "prerender-ppr":
         case "prerender-legacy":
         case "cache":
         case "private-cache":
         case "unstable-cache":
+        case "generate-static-params":
           return null;
         default:
           return workUnitStore;
       }
     }
-    function getRuntimeStagePromise(workUnitStore) {
+    function getCacheSignal(workUnitStore) {
       switch (workUnitStore.type) {
-        case "prerender-runtime":
-        case "private-cache":
-          return workUnitStore.runtimeStagePromise;
         case "prerender":
         case "prerender-client":
+        case "validation-client":
+        case "prerender-runtime":
+          return workUnitStore.cacheSignal;
+        case "request": {
+          if (workUnitStore.cacheSignal) {
+            return workUnitStore.cacheSignal;
+          }
+        }
         case "prerender-ppr":
         case "prerender-legacy":
-        case "request":
         case "cache":
+        case "private-cache":
         case "unstable-cache":
+        case "generate-static-params":
           return null;
         default:
           return workUnitStore;
@@ -1328,11 +1679,11 @@ function requireWorkAsyncStorage_external() {
   })(workAsyncStorage_external);
   return workAsyncStorage_external;
 }
-var boundaryConstants = {};
-var hasRequiredBoundaryConstants;
-function requireBoundaryConstants() {
-  if (hasRequiredBoundaryConstants) return boundaryConstants;
-  hasRequiredBoundaryConstants = 1;
+var boundaryConstants$1 = {};
+var hasRequiredBoundaryConstants$1;
+function requireBoundaryConstants$1() {
+  if (hasRequiredBoundaryConstants$1) return boundaryConstants$1;
+  hasRequiredBoundaryConstants$1 = 1;
   (function(exports$1) {
     Object.defineProperty(exports$1, "__esModule", {
       value: true
@@ -1361,8 +1712,8 @@ function requireBoundaryConstants() {
     const VIEWPORT_BOUNDARY_NAME = "__next_viewport_boundary__";
     const OUTLET_BOUNDARY_NAME = "__next_outlet_boundary__";
     const ROOT_LAYOUT_BOUNDARY_NAME = "__next_root_layout_boundary__";
-  })(boundaryConstants);
-  return boundaryConstants;
+  })(boundaryConstants$1);
+  return boundaryConstants$1;
 }
 var scheduler = {};
 var hasRequiredScheduler;
@@ -1422,6 +1773,25 @@ function requireScheduler() {
   })(scheduler);
   return scheduler;
 }
+var boundaryConstants = {};
+var hasRequiredBoundaryConstants;
+function requireBoundaryConstants() {
+  if (hasRequiredBoundaryConstants) return boundaryConstants;
+  hasRequiredBoundaryConstants = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "INSTANT_VALIDATION_BOUNDARY_NAME", {
+      enumerable: true,
+      get: function() {
+        return INSTANT_VALIDATION_BOUNDARY_NAME;
+      }
+    });
+    const INSTANT_VALIDATION_BOUNDARY_NAME = "__next_instant_validation_boundary__";
+  })(boundaryConstants);
+  return boundaryConstants;
+}
 var hasRequiredDynamicRendering;
 function requireDynamicRendering() {
   if (hasRequiredDynamicRendering) return dynamicRendering;
@@ -1437,6 +1807,9 @@ function requireDynamicRendering() {
       });
     }
     _export(exports$1, {
+      DynamicHoleKind: function() {
+        return DynamicHoleKind;
+      },
       Postpone: function() {
         return Postpone;
       },
@@ -1467,18 +1840,21 @@ function requireDynamicRendering() {
       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;
       },
@@ -1509,12 +1885,18 @@ function requireDynamicRendering() {
       trackDynamicDataInDynamicRender: function() {
         return trackDynamicDataInDynamicRender;
       },
+      trackDynamicHoleInNavigation: function() {
+        return trackDynamicHoleInNavigation;
+      },
       trackDynamicHoleInRuntimeShell: function() {
         return trackDynamicHoleInRuntimeShell;
       },
       trackDynamicHoleInStaticShell: function() {
         return trackDynamicHoleInStaticShell;
       },
+      trackThrownErrorInNavigation: function() {
+        return trackThrownErrorInNavigation;
+      },
       useDynamicRouteParams: function() {
         return useDynamicRouteParams;
       },
@@ -1528,10 +1910,11 @@ function requireDynamicRendering() {
     const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
     const _workasyncstorageexternal = requireWorkAsyncStorage_external();
     const _dynamicrenderingutils = requireDynamicRenderingUtils();
-    const _boundaryconstants = requireBoundaryConstants();
+    const _boundaryconstants = requireBoundaryConstants$1();
     const _scheduler = requireScheduler();
     const _bailouttocsr = requireBailoutToCsr();
     const _invarianterror = requireInvariantError();
+    const _boundaryconstants1 = requireBoundaryConstants();
     function _interop_require_default(obj) {
       return obj && obj.__esModule ? obj : {
         default: obj
@@ -1622,6 +2005,8 @@ function requireDynamicRendering() {
         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") {
@@ -1768,21 +2153,26 @@ ${stack}`;
               controller.abort();
             });
           } else {
-            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: stagedRendering2 } = workUnitStore;
+              stagedRendering2.waitForStage((0, _dynamicrenderingutils.getRuntimeStage)(stagedRendering2)).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 void 0;
       }
     }
@@ -1815,6 +2205,9 @@ ${stack}`;
             }
             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",
@@ -1828,6 +2221,12 @@ ${stack}`;
               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
+            });
         }
       }
     }
@@ -1841,6 +2240,8 @@ ${stack}`;
         (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
       }
       switch (workUnitStore.type) {
+        case "validation-client":
+          return;
         case "prerender-client": {
           _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
           break;
@@ -1871,6 +2272,12 @@ ${stack}`;
             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;
       }
@@ -1881,6 +2288,7 @@ ${stack}`;
     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)) {
         return;
@@ -1902,23 +2310,156 @@ ${stack}`;
         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(DynamicHoleKind2) {
+      DynamicHoleKind2[DynamicHoleKind2["Runtime"] = 1] = "Runtime";
+      DynamicHoleKind2[DynamicHoleKind2["Dynamic"] = 2] = "Dynamic";
+      return DynamicHoleKind2;
+    })({});
+    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)) {
+        return;
+      }
+      if (hasMetadataRegex.test(componentStack)) {
+        const usageDescription2 = 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 message2 = `Route "${workStore.route}": ${usageDescription2} 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 error2 = addErrorContext(Object.defineProperty(new Error(message2), "__NEXT_ERROR_CODE", {
+          value: "E1076",
+          enumerable: false,
+          configurable: true
+        }), componentStack, dynamicValidation.createInstantStack);
+        dynamicValidation.dynamicMetadata = error2;
+        return;
+      }
+      if (hasViewportRegex.test(componentStack)) {
+        const usageDescription2 = kind === 1 ? `Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`.` : `Uncached data or \`connection()\` was accessed inside \`generateViewport\`.`;
+        const message2 = `Route "${workStore.route}": ${usageDescription2} 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 error2 = addErrorContext(Object.defineProperty(new Error(message2), "__NEXT_ERROR_CODE", {
+          value: "E1086",
+          enumerable: false,
+          configurable: true
+        }), componentStack, dynamicValidation.createInstantStack);
+        dynamicValidation.dynamicErrors.push(error2);
+        return;
+      }
+      const boundaryLocation = hasInstantValidationBoundaryRegex.exec(componentStack);
+      if (!boundaryLocation) {
+        if (boundaryState.expectedIds.size === boundaryState.renderedIds.size) {
+          dynamicValidation.hasAllowedClientDynamicAboveBoundary = true;
+          dynamicValidation.hasAllowedDynamic = true;
+          return;
+        } else {
+          const message2 = `Route "${workStore.route}": Could not validate \`unstable_instant\` because a Client Component in a parent segment prevented the page from rendering.`;
+          const error2 = addErrorContext(Object.defineProperty(new Error(message2), "__NEXT_ERROR_CODE", {
+            value: "E1082",
+            enumerable: false,
+            configurable: true
+          }), componentStack, dynamicValidation.createInstantStack);
+          dynamicValidation.validationPreventingErrors.push(error2);
+          return;
+        }
+      } else {
+        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
+        if (suspenseLocation) {
+          if (suspenseLocation.index < boundaryLocation.index) {
+            dynamicValidation.hasAllowedDynamic = true;
+            return;
+          }
+        }
+      }
+      if (clientDynamic.syncDynamicErrorWithStack) {
+        const syncError = clientDynamic.syncDynamicErrorWithStack;
+        if (dynamicValidation.createInstantStack !== null && syncError.cause === void 0) {
+          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) {
+        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 {
+        const suspenseLocation = hasSuspenseRegex.exec(componentStack);
+        if (suspenseLocation) {
+          if (suspenseLocation.index < boundaryLocation.index) {
+            return;
+          }
+        }
+        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)) {
         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);
-        dynamicValidation.dynamicMetadata = error;
+        const message2 = `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 error2 = addErrorContext(Object.defineProperty(new Error(message2), "__NEXT_ERROR_CODE", {
+          value: "E1080",
+          enumerable: false,
+          configurable: true
+        }), componentStack, null);
+        dynamicValidation.dynamicMetadata = error2;
         return;
       } else if (hasViewportRegex.test(componentStack)) {
-        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);
-        dynamicValidation.dynamicErrors.push(error);
+        const message2 = `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 error2 = addErrorContext(Object.defineProperty(new Error(message2), "__NEXT_ERROR_CODE", {
+          value: "E1077",
+          enumerable: false,
+          configurable: true
+        }), componentStack, null);
+        dynamicValidation.dynamicErrors.push(error2);
         return;
       } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
         dynamicValidation.hasAllowedDynamic = true;
@@ -1930,24 +2471,35 @@ ${stack}`;
       } else if (clientDynamic.syncDynamicErrorWithStack) {
         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)) {
         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)) {
@@ -1962,19 +2514,21 @@ ${stack}`;
         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;
       }
     }
-    function createErrorWithComponentOrOwnerStack(message, componentStack) {
+    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
-      });
-      error.stack = error.name + ": " + message + (ownerStack || componentStack);
+      if (createInstantStack !== null) {
+        error.cause = createInstantStack();
+      }
+      error.stack = error.name + ": " + error.message + (ownerStack || componentStack);
       return error;
     }
     var PreludeState = /* @__PURE__ */ (function(PreludeState2) {
@@ -1985,14 +2539,12 @@ ${stack}`;
     })({});
     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) {
@@ -2026,8 +2578,8 @@ ${stack}`;
         }
       }
     }
-    function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation) {
-      if (dynamicValidation.hasSuspenseAboveBody) {
+    function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation, configAllowsBlocking) {
+      if (configAllowsBlocking || dynamicValidation.hasSuspenseAboveBody) {
         return [];
       }
       if (prelude !== 0) {
@@ -2053,11 +2605,76 @@ ${stack}`;
       }
       return [];
     }
-    function delayUntilRuntimeStage(prerenderStore, result) {
-      if (prerenderStore.runtimeStagePromise) {
-        return prerenderStore.runtimeStagePromise.then(() => result);
+    function getNavigationDisallowedDynamicReasons(workStore, prelude, dynamicValidation, validationSampleTracking, boundaryState) {
+      if (validationSampleTracking) {
+        const { missingSampleErrors } = validationSampleTracking;
+        if (missingSampleErrors.length > 0) {
+          return missingSampleErrors;
+        }
       }
-      return result;
+      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 (prelude !== 0) {
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+          return dynamicErrors;
+        }
+        if (prelude === 1) {
+          if (dynamicValidation.hasAllowedClientDynamicAboveBoundary) {
+            return [];
+          }
+          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
+          ];
+        }
+      }
+      return [];
     }
   })(dynamicRendering);
   return dynamicRendering;
@@ -2173,7 +2790,7 @@ function requireNavigation_reactServer() {
         return _readonlyurlsearchparams.ReadonlyURLSearchParams;
       },
       RedirectType: function() {
-        return _redirecterror.RedirectType;
+        return RedirectType;
       },
       forbidden: function() {
         return _forbidden.forbidden;
@@ -2199,7 +2816,6 @@ function requireNavigation_reactServer() {
     });
     const _readonlyurlsearchparams = requireReadonlyUrlSearchParams();
     const _redirect = requireRedirect();
-    const _redirecterror = requireRedirectError();
     const _notfound = requireNotFound();
     const _forbidden = requireForbidden();
     const _unauthorized = requireUnauthorized();
@@ -2211,6 +2827,10 @@ function requireNavigation_reactServer() {
         configurable: true
       });
     }
+    const RedirectType = {
+      push: "push",
+      replace: "replace"
+    };
     if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
       Object.defineProperty(exports$1.default, "__esModule", { value: true });
       Object.assign(exports$1.default, exports$1);
@@ -2219,6 +2839,1410 @@ function requireNavigation_reactServer() {
   })(navigation_reactServer, navigation_reactServer.exports);
   return navigation_reactServer.exports;
 }
+var instantSamplesClient = {};
+var instantSamples = {};
+var cookies$1 = {};
+var cookies;
+var hasRequiredCookies$1;
+function requireCookies$1() {
+  if (hasRequiredCookies$1) return cookies;
+  hasRequiredCookies$1 = 1;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    RequestCookies: () => RequestCookies,
+    ResponseCookies: () => ResponseCookies,
+    parseCookie: () => parseCookie,
+    parseSetCookie: () => parseSetCookie,
+    stringifyCookie: () => stringifyCookie
+  });
+  cookies = __toCommonJS(src_exports);
+  function stringifyCookie(c) {
+    var _a;
+    const attrs = [
+      "path" in c && c.path && `Path=${c.path}`,
+      "expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
+      "maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
+      "domain" in c && c.domain && `Domain=${c.domain}`,
+      "secure" in c && c.secure && "Secure",
+      "httpOnly" in c && c.httpOnly && "HttpOnly",
+      "sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`,
+      "partitioned" in c && c.partitioned && "Partitioned",
+      "priority" in c && c.priority && `Priority=${c.priority}`
+    ].filter(Boolean);
+    const stringified = `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}`;
+    return attrs.length === 0 ? stringified : `${stringified}; ${attrs.join("; ")}`;
+  }
+  function parseCookie(cookie) {
+    const map = /* @__PURE__ */ new Map();
+    for (const pair of cookie.split(/; */)) {
+      if (!pair)
+        continue;
+      const splitAt = pair.indexOf("=");
+      if (splitAt === -1) {
+        map.set(pair, "true");
+        continue;
+      }
+      const [key, value] = [pair.slice(0, splitAt), pair.slice(splitAt + 1)];
+      try {
+        map.set(key, decodeURIComponent(value != null ? value : "true"));
+      } catch {
+      }
+    }
+    return map;
+  }
+  function parseSetCookie(setCookie) {
+    if (!setCookie) {
+      return void 0;
+    }
+    const [[name, value], ...attributes] = parseCookie(setCookie);
+    const {
+      domain,
+      expires,
+      httponly,
+      maxage,
+      path,
+      samesite,
+      secure,
+      partitioned,
+      priority
+    } = Object.fromEntries(
+      attributes.map(([key, value2]) => [
+        key.toLowerCase().replace(/-/g, ""),
+        value2
+      ])
+    );
+    const cookie = {
+      name,
+      value: decodeURIComponent(value),
+      domain,
+      ...expires && { expires: new Date(expires) },
+      ...httponly && { httpOnly: true },
+      ...typeof maxage === "string" && { maxAge: Number(maxage) },
+      path,
+      ...samesite && { sameSite: parseSameSite(samesite) },
+      ...secure && { secure: true },
+      ...priority && { priority: parsePriority(priority) },
+      ...partitioned && { partitioned: true }
+    };
+    return compact(cookie);
+  }
+  function compact(t) {
+    const newT = {};
+    for (const key in t) {
+      if (t[key]) {
+        newT[key] = t[key];
+      }
+    }
+    return newT;
+  }
+  var SAME_SITE = ["strict", "lax", "none"];
+  function parseSameSite(string) {
+    string = string.toLowerCase();
+    return SAME_SITE.includes(string) ? string : void 0;
+  }
+  var PRIORITY = ["low", "medium", "high"];
+  function parsePriority(string) {
+    string = string.toLowerCase();
+    return PRIORITY.includes(string) ? string : void 0;
+  }
+  function splitCookiesString(cookiesString) {
+    if (!cookiesString)
+      return [];
+    var cookiesStrings = [];
+    var pos = 0;
+    var start;
+    var ch;
+    var lastComma;
+    var nextStart;
+    var cookiesSeparatorFound;
+    function skipWhitespace() {
+      while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+        pos += 1;
+      }
+      return pos < cookiesString.length;
+    }
+    function notSpecialChar() {
+      ch = cookiesString.charAt(pos);
+      return ch !== "=" && ch !== ";" && ch !== ",";
+    }
+    while (pos < cookiesString.length) {
+      start = pos;
+      cookiesSeparatorFound = false;
+      while (skipWhitespace()) {
+        ch = cookiesString.charAt(pos);
+        if (ch === ",") {
+          lastComma = pos;
+          pos += 1;
+          skipWhitespace();
+          nextStart = pos;
+          while (pos < cookiesString.length && notSpecialChar()) {
+            pos += 1;
+          }
+          if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+            cookiesSeparatorFound = true;
+            pos = nextStart;
+            cookiesStrings.push(cookiesString.substring(start, lastComma));
+            start = pos;
+          } else {
+            pos = lastComma + 1;
+          }
+        } else {
+          pos += 1;
+        }
+      }
+      if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+        cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+      }
+    }
+    return cookiesStrings;
+  }
+  var RequestCookies = class {
+    constructor(requestHeaders) {
+      this._parsed = /* @__PURE__ */ new Map();
+      this._headers = requestHeaders;
+      const header = requestHeaders.get("cookie");
+      if (header) {
+        const parsed = parseCookie(header);
+        for (const [name, value] of parsed) {
+          this._parsed.set(name, { name, value });
+        }
+      }
+    }
+    [Symbol.iterator]() {
+      return this._parsed[Symbol.iterator]();
+    }
+    /**
+     * The amount of cookies received from the client
+     */
+    get size() {
+      return this._parsed.size;
+    }
+    get(...args) {
+      const name = typeof args[0] === "string" ? args[0] : args[0].name;
+      return this._parsed.get(name);
+    }
+    getAll(...args) {
+      var _a;
+      const all = Array.from(this._parsed);
+      if (!args.length) {
+        return all.map(([_, value]) => value);
+      }
+      const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+      return all.filter(([n]) => n === name).map(([_, value]) => value);
+    }
+    has(name) {
+      return this._parsed.has(name);
+    }
+    set(...args) {
+      const [name, value] = args.length === 1 ? [args[0].name, args[0].value] : args;
+      const map = this._parsed;
+      map.set(name, { name, value });
+      this._headers.set(
+        "cookie",
+        Array.from(map).map(([_, value2]) => stringifyCookie(value2)).join("; ")
+      );
+      return this;
+    }
+    /**
+     * Delete the cookies matching the passed name or names in the request.
+     */
+    delete(names) {
+      const map = this._parsed;
+      const result = !Array.isArray(names) ? map.delete(names) : names.map((name) => map.delete(name));
+      this._headers.set(
+        "cookie",
+        Array.from(map).map(([_, value]) => stringifyCookie(value)).join("; ")
+      );
+      return result;
+    }
+    /**
+     * Delete all the cookies in the cookies in the request.
+     */
+    clear() {
+      this.delete(Array.from(this._parsed.keys()));
+      return this;
+    }
+    /**
+     * Format the cookies in the request as a string for logging
+     */
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+      return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+    }
+    toString() {
+      return [...this._parsed.values()].map((v) => `${v.name}=${encodeURIComponent(v.value)}`).join("; ");
+    }
+  };
+  var ResponseCookies = class {
+    constructor(responseHeaders) {
+      this._parsed = /* @__PURE__ */ new Map();
+      var _a, _b, _c;
+      this._headers = responseHeaders;
+      const setCookie = (_c = (_b = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders)) != null ? _b : responseHeaders.get("set-cookie")) != null ? _c : [];
+      const cookieStrings = Array.isArray(setCookie) ? setCookie : splitCookiesString(setCookie);
+      for (const cookieString of cookieStrings) {
+        const parsed = parseSetCookie(cookieString);
+        if (parsed)
+          this._parsed.set(parsed.name, parsed);
+      }
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+     */
+    get(...args) {
+      const key = typeof args[0] === "string" ? args[0] : args[0].name;
+      return this._parsed.get(key);
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+     */
+    getAll(...args) {
+      var _a;
+      const all = Array.from(this._parsed.values());
+      if (!args.length) {
+        return all;
+      }
+      const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+      return all.filter((c) => c.name === key);
+    }
+    has(name) {
+      return this._parsed.has(name);
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+     */
+    set(...args) {
+      const [name, value, cookie] = args.length === 1 ? [args[0].name, args[0].value, args[0]] : args;
+      const map = this._parsed;
+      map.set(name, normalizeCookie({ name, value, ...cookie }));
+      replace(map, this._headers);
+      return this;
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+     */
+    delete(...args) {
+      const [name, options] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0]];
+      return this.set({ ...options, name, value: "", expires: /* @__PURE__ */ new Date(0) });
+    }
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+      return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+    }
+    toString() {
+      return [...this._parsed.values()].map(stringifyCookie).join("; ");
+    }
+  };
+  function replace(bag, headers2) {
+    headers2.delete("set-cookie");
+    for (const [, value] of bag) {
+      const serialized = stringifyCookie(value);
+      headers2.append("set-cookie", serialized);
+    }
+  }
+  function normalizeCookie(cookie = { name: "", value: "" }) {
+    if (typeof cookie.expires === "number") {
+      cookie.expires = new Date(cookie.expires);
+    }
+    if (cookie.maxAge) {
+      cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+    }
+    if (cookie.path === null || cookie.path === void 0) {
+      cookie.path = "/";
+    }
+    return cookie;
+  }
+  return cookies;
+}
+var hasRequiredCookies;
+function requireCookies() {
+  if (hasRequiredCookies) return cookies$1;
+  hasRequiredCookies = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      RequestCookies: function() {
+        return _cookies.RequestCookies;
+      },
+      ResponseCookies: function() {
+        return _cookies.ResponseCookies;
+      },
+      stringifyCookie: function() {
+        return _cookies.stringifyCookie;
+      }
+    });
+    const _cookies = requireCookies$1();
+  })(cookies$1);
+  return cookies$1;
+}
+var requestCookies = {};
+var reflect = {};
+var hasRequiredReflect;
+function requireReflect() {
+  if (hasRequiredReflect) return reflect;
+  hasRequiredReflect = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "ReflectAdapter", {
+      enumerable: true,
+      get: function() {
+        return ReflectAdapter;
+      }
+    });
+    class ReflectAdapter {
+      static get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      static set(target, prop, value, receiver) {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      static has(target, prop) {
+        return Reflect.has(target, prop);
+      }
+      static deleteProperty(target, prop) {
+        return Reflect.deleteProperty(target, prop);
+      }
+    }
+  })(reflect);
+  return reflect;
+}
+var actionRevalidationKind = {};
+var hasRequiredActionRevalidationKind;
+function requireActionRevalidationKind() {
+  if (hasRequiredActionRevalidationKind) return actionRevalidationKind;
+  hasRequiredActionRevalidationKind = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      ActionDidNotRevalidate: function() {
+        return ActionDidNotRevalidate;
+      },
+      ActionDidRevalidateDynamicOnly: function() {
+        return ActionDidRevalidateDynamicOnly;
+      },
+      ActionDidRevalidateStaticAndDynamic: function() {
+        return ActionDidRevalidateStaticAndDynamic;
+      }
+    });
+    const ActionDidNotRevalidate = 0;
+    const ActionDidRevalidateStaticAndDynamic = 1;
+    const ActionDidRevalidateDynamicOnly = 2;
+  })(actionRevalidationKind);
+  return actionRevalidationKind;
+}
+var hasRequiredRequestCookies;
+function requireRequestCookies() {
+  if (hasRequiredRequestCookies) return requestCookies;
+  hasRequiredRequestCookies = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+      },
+      RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+      },
+      appendMutableCookies: function() {
+        return appendMutableCookies;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return areCookiesMutableInCurrentPhase;
+      },
+      createCookiesWithMutableAccessCheck: function() {
+        return createCookiesWithMutableAccessCheck;
+      },
+      getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+      },
+      responseCookiesToRequestCookies: function() {
+        return responseCookiesToRequestCookies;
+      }
+    });
+    const _cookies = requireCookies();
+    const _reflect = requireReflect();
+    const _workasyncstorageexternal = requireWorkAsyncStorage_external();
+    const _actionrevalidationkind = requireActionRevalidationKind();
+    class ReadonlyRequestCookiesError extends Error {
+      constructor() {
+        super("Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options");
+      }
+      static callable() {
+        throw new ReadonlyRequestCookiesError();
+      }
+    }
+    class RequestCookiesAdapter {
+      static seal(cookies2) {
+        return new Proxy(cookies2, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case "clear":
+              case "delete":
+              case "set":
+                return ReadonlyRequestCookiesError.callable;
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+      }
+    }
+    const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for("next.mutated.cookies");
+    function getModifiedCookieValues(cookies2) {
+      const modified = cookies2[SYMBOL_MODIFY_COOKIE_VALUES];
+      if (!modified || !Array.isArray(modified) || modified.length === 0) {
+        return [];
+      }
+      return modified;
+    }
+    function appendMutableCookies(headers2, mutableCookies) {
+      const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
+      if (modifiedCookieValues.length === 0) {
+        return false;
+      }
+      const resCookies = new _cookies.ResponseCookies(headers2);
+      const returnedCookies = resCookies.getAll();
+      for (const cookie of modifiedCookieValues) {
+        resCookies.set(cookie);
+      }
+      for (const cookie of returnedCookies) {
+        resCookies.set(cookie);
+      }
+      return true;
+    }
+    class MutableRequestCookiesAdapter {
+      static wrap(cookies2, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies2.getAll()) {
+          responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = /* @__PURE__ */ new Set();
+        const updateResponseCookies = () => {
+          const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+          if (workStore) {
+            workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
+          }
+          const allCookies = responseCookies.getAll();
+          modifiedValues = allCookies.filter((c) => modifiedCookies.has(c.name));
+          if (onUpdateCookies) {
+            const serializedCookies = [];
+            for (const cookie of modifiedValues) {
+              const tempCookies = new _cookies.ResponseCookies(new Headers());
+              tempCookies.set(cookie);
+              serializedCookies.push(tempCookies.toString());
+            }
+            onUpdateCookies(serializedCookies);
+          }
+        };
+        const wrappedCookies = new Proxy(responseCookies, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              // A special symbol to get the modified cookie values
+              case SYMBOL_MODIFY_COOKIE_VALUES:
+                return modifiedValues;
+              // TODO: Throw error if trying to set a cookie after the response
+              // headers have been set.
+              case "delete":
+                return function(...args) {
+                  modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                  try {
+                    target.delete(...args);
+                    return wrappedCookies;
+                  } finally {
+                    updateResponseCookies();
+                  }
+                };
+              case "set":
+                return function(...args) {
+                  modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                  try {
+                    target.set(...args);
+                    return wrappedCookies;
+                  } finally {
+                    updateResponseCookies();
+                  }
+                };
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+        return wrappedCookies;
+      }
+    }
+    function createCookiesWithMutableAccessCheck(requestStore) {
+      const wrappedCookies = new Proxy(requestStore.mutableCookies, {
+        get(target, prop, receiver) {
+          switch (prop) {
+            case "delete":
+              return function(...args) {
+                ensureCookiesAreStillMutable(requestStore);
+                target.delete(...args);
+                return wrappedCookies;
+              };
+            case "set":
+              return function(...args) {
+                ensureCookiesAreStillMutable(requestStore);
+                target.set(...args);
+                return wrappedCookies;
+              };
+            default:
+              return _reflect.ReflectAdapter.get(target, prop, receiver);
+          }
+        }
+      });
+      return wrappedCookies;
+    }
+    function areCookiesMutableInCurrentPhase(requestStore) {
+      return requestStore.phase === "action";
+    }
+    function ensureCookiesAreStillMutable(requestStore, _callingExpression) {
+      if (!areCookiesMutableInCurrentPhase(requestStore)) {
+        throw new ReadonlyRequestCookiesError();
+      }
+    }
+    function responseCookiesToRequestCookies(responseCookies) {
+      const requestCookies2 = new _cookies.RequestCookies(new Headers());
+      for (const cookie of responseCookies.getAll()) {
+        requestCookies2.set(cookie);
+      }
+      return requestCookies2;
+    }
+  })(requestCookies);
+  return requestCookies;
+}
+var headers = {};
+var hasRequiredHeaders;
+function requireHeaders() {
+  if (hasRequiredHeaders) return headers;
+  hasRequiredHeaders = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      HeadersAdapter: function() {
+        return HeadersAdapter;
+      },
+      ReadonlyHeadersError: function() {
+        return ReadonlyHeadersError;
+      }
+    });
+    const _reflect = requireReflect();
+    class ReadonlyHeadersError extends Error {
+      constructor() {
+        super("Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers");
+      }
+      static callable() {
+        throw new ReadonlyHeadersError();
+      }
+    }
+    class HeadersAdapter extends Headers {
+      constructor(headers2) {
+        super();
+        this.headers = new Proxy(headers2, {
+          get(target, prop, receiver) {
+            if (typeof prop === "symbol") {
+              return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            if (typeof original === "undefined") return;
+            return _reflect.ReflectAdapter.get(target, original, receiver);
+          },
+          set(target, prop, value, receiver) {
+            if (typeof prop === "symbol") {
+              return _reflect.ReflectAdapter.set(target, prop, value, receiver);
+            }
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            return _reflect.ReflectAdapter.set(target, original ?? prop, value, receiver);
+          },
+          has(target, prop) {
+            if (typeof prop === "symbol") return _reflect.ReflectAdapter.has(target, prop);
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            if (typeof original === "undefined") return false;
+            return _reflect.ReflectAdapter.has(target, original);
+          },
+          deleteProperty(target, prop) {
+            if (typeof prop === "symbol") return _reflect.ReflectAdapter.deleteProperty(target, prop);
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            if (typeof original === "undefined") return true;
+            return _reflect.ReflectAdapter.deleteProperty(target, original);
+          }
+        });
+      }
+      /**
+      * Seals a Headers instance to prevent modification by throwing an error when
+      * any mutating method is called.
+      */
+      static seal(headers2) {
+        return new Proxy(headers2, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case "append":
+              case "delete":
+              case "set":
+                return ReadonlyHeadersError.callable;
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+      }
+      /**
+      * Merges a header value into a string. This stores multiple values as an
+      * array, so we need to merge them into a string.
+      *
+      * @param value a header value
+      * @returns a merged header value (a string)
+      */
+      merge(value) {
+        if (Array.isArray(value)) return value.join(", ");
+        return value;
+      }
+      /**
+      * Creates a Headers instance from a plain object or a Headers instance.
+      *
+      * @param headers a plain object or a Headers instance
+      * @returns a headers instance
+      */
+      static from(headers2) {
+        if (headers2 instanceof Headers) return headers2;
+        return new HeadersAdapter(headers2);
+      }
+      append(name, value) {
+        const existing = this.headers[name];
+        if (typeof existing === "string") {
+          this.headers[name] = [
+            existing,
+            value
+          ];
+        } else if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          this.headers[name] = value;
+        }
+      }
+      delete(name) {
+        delete this.headers[name];
+      }
+      get(name) {
+        const value = this.headers[name];
+        if (typeof value !== "undefined") return this.merge(value);
+        return null;
+      }
+      has(name) {
+        return typeof this.headers[name] !== "undefined";
+      }
+      set(name, value) {
+        this.headers[name] = value;
+      }
+      forEach(callbackfn, thisArg) {
+        for (const [name, value] of this.entries()) {
+          callbackfn.call(thisArg, value, name, this);
+        }
+      }
+      *entries() {
+        for (const key of Object.keys(this.headers)) {
+          const name = key.toLowerCase();
+          const value = this.get(name);
+          yield [
+            name,
+            value
+          ];
+        }
+      }
+      *keys() {
+        for (const key of Object.keys(this.headers)) {
+          const name = key.toLowerCase();
+          yield name;
+        }
+      }
+      *values() {
+        for (const key of Object.keys(this.headers)) {
+          const value = this.get(key);
+          yield value;
+        }
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    }
+  })(headers);
+  return headers;
+}
+var parseRelativeUrl = {};
+var hasRequiredParseRelativeUrl;
+function requireParseRelativeUrl() {
+  if (hasRequiredParseRelativeUrl) return parseRelativeUrl;
+  hasRequiredParseRelativeUrl = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "parseRelativeUrl", {
+      enumerable: true,
+      get: function() {
+        return parseRelativeUrl2;
+      }
+    });
+    const _utils = requireUtils();
+    const _querystring = requireQuerystring();
+    function parseRelativeUrl2(url, base, parseQuery = true) {
+      const globalBase = new URL(typeof window === "undefined" ? "http://n" : (0, _utils.getLocationOrigin)());
+      const resolvedBase = base ? new URL(base, globalBase) : url.startsWith(".") ? new URL(typeof window === "undefined" ? "http://n" : window.location.href) : globalBase;
+      const { pathname, searchParams, search, hash, href, origin } = url.startsWith("/") ? (
+        // See https://nodejs.org/api/http.html#messageurl
+        // Not using `origin` to support other protocols
+        new URL(`${resolvedBase.protocol}//${resolvedBase.host}${url}`)
+      ) : new URL(url, resolvedBase);
+      if (origin !== globalBase.origin) {
+        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
+          value: "E159",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return {
+        auth: null,
+        host: null,
+        hostname: null,
+        pathname,
+        port: null,
+        protocol: null,
+        query: parseQuery ? (0, _querystring.searchParamsToUrlQuery)(searchParams) : void 0,
+        search,
+        hash,
+        href: href.slice(origin.length),
+        // We don't know for relative URLs at this point since we set a custom, internal
+        // base that isn't surfaced to users.
+        slashes: null
+      };
+    }
+  })(parseRelativeUrl);
+  return parseRelativeUrl;
+}
+var instantValidationError = {};
+var hasRequiredInstantValidationError;
+function requireInstantValidationError() {
+  if (hasRequiredInstantValidationError) return instantValidationError;
+  hasRequiredInstantValidationError = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      InstantValidationError: function() {
+        return InstantValidationError;
+      },
+      isInstantValidationError: function() {
+        return isInstantValidationError;
+      }
+    });
+    const INSTANT_VALIDATION_ERROR_DIGEST = "INSTANT_VALIDATION_ERROR";
+    function isInstantValidationError(err) {
+      return !!(err && typeof err === "object" && err instanceof Error && err.digest === INSTANT_VALIDATION_ERROR_DIGEST);
+    }
+    class InstantValidationError extends Error {
+      constructor(...args) {
+        super(...args), this.digest = INSTANT_VALIDATION_ERROR_DIGEST;
+      }
+    }
+  })(instantValidationError);
+  return instantValidationError;
+}
+var reflectUtils = {};
+var hasRequiredReflectUtils;
+function requireReflectUtils() {
+  if (hasRequiredReflectUtils) return reflectUtils;
+  hasRequiredReflectUtils = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      describeHasCheckingStringProperty: function() {
+        return describeHasCheckingStringProperty;
+      },
+      describeStringPropertyAccess: function() {
+        return describeStringPropertyAccess;
+      },
+      wellKnownProperties: function() {
+        return wellKnownProperties;
+      }
+    });
+    const isDefinitelyAValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+    function describeStringPropertyAccess(target, prop) {
+      if (isDefinitelyAValidIdentifier.test(prop)) {
+        return `\`${target}.${prop}\``;
+      }
+      return `\`${target}[${JSON.stringify(prop)}]\``;
+    }
+    function describeHasCheckingStringProperty(target, prop) {
+      const stringifiedProp = JSON.stringify(prop);
+      return `\`Reflect.has(${target}, ${stringifiedProp})\`, \`${stringifiedProp} in ${target}\`, or similar`;
+    }
+    const wellKnownProperties = /* @__PURE__ */ new Set([
+      "hasOwnProperty",
+      "isPrototypeOf",
+      "propertyIsEnumerable",
+      "toString",
+      "valueOf",
+      "toLocaleString",
+      // Promise prototype
+      "then",
+      "catch",
+      "finally",
+      // React Promise extension
+      "status",
+      // 'value',
+      // 'error',
+      // React introspection
+      "displayName",
+      "_debugInfo",
+      // Common tested properties
+      "toJSON",
+      "$$typeof",
+      "__esModule",
+      // Tested by flight when checking for iterables
+      "@@iterator"
+    ]);
+  })(reflectUtils);
+  return reflectUtils;
+}
+var hasRequiredInstantSamples;
+function requireInstantSamples() {
+  if (hasRequiredInstantSamples) return instantSamples;
+  hasRequiredInstantSamples = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      assertRootParamInSamples: function() {
+        return assertRootParamInSamples;
+      },
+      createCookiesFromSample: function() {
+        return createCookiesFromSample;
+      },
+      createDraftModeForValidation: function() {
+        return createDraftModeForValidation;
+      },
+      createExhaustiveParamsProxy: function() {
+        return createExhaustiveParamsProxy;
+      },
+      createExhaustiveSearchParamsProxy: function() {
+        return createExhaustiveSearchParamsProxy;
+      },
+      createExhaustiveURLSearchParamsProxy: function() {
+        return createExhaustiveURLSearchParamsProxy;
+      },
+      createHeadersFromSample: function() {
+        return createHeadersFromSample;
+      },
+      createRelativeURLFromSamples: function() {
+        return createRelativeURLFromSamples;
+      },
+      createValidationSampleTracking: function() {
+        return createValidationSampleTracking;
+      },
+      trackMissingSampleError: function() {
+        return trackMissingSampleError;
+      },
+      trackMissingSampleErrorAndThrow: function() {
+        return trackMissingSampleErrorAndThrow;
+      }
+    });
+    const _cookies = requireCookies();
+    const _requestcookies = requireRequestCookies();
+    const _headers = requireHeaders();
+    const _getsegmentparam = requireGetSegmentParam();
+    const _parserelativeurl = requireParseRelativeUrl();
+    const _invarianterror = requireInvariantError();
+    const _instantvalidationerror = requireInstantValidationError();
+    const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
+    const _reflectutils = requireReflectUtils();
+    function createValidationSampleTracking() {
+      return {
+        missingSampleErrors: []
+      };
+    }
+    function getExpectedSampleTracking() {
+      let validationSampleTracking = null;
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore) {
+        switch (workUnitStore.type) {
+          case "request":
+          case "validation-client":
+            validationSampleTracking = workUnitStore.validationSampleTracking ?? null;
+            break;
+        }
+      }
+      if (!validationSampleTracking) {
+        throw Object.defineProperty(new _invarianterror.InvariantError("Expected to have a workUnitStore that provides validationSampleTracking"), "__NEXT_ERROR_CODE", {
+          value: "E1110",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return validationSampleTracking;
+    }
+    function trackMissingSampleError(error) {
+      const validationSampleTracking = getExpectedSampleTracking();
+      validationSampleTracking.missingSampleErrors.push(error);
+    }
+    function trackMissingSampleErrorAndThrow(error) {
+      trackMissingSampleError(error);
+      throw error;
+    }
+    function createCookiesFromSample(sampleCookies, route) {
+      const declaredNames = /* @__PURE__ */ new Set();
+      const cookies2 = new _cookies.RequestCookies(new Headers());
+      if (sampleCookies) {
+        for (const cookie of sampleCookies) {
+          declaredNames.add(cookie.name);
+          if (cookie.value !== null) {
+            cookies2.set(cookie.name, cookie.value);
+          }
+        }
+      }
+      const sealed = _requestcookies.RequestCookiesAdapter.seal(cookies2);
+      return new Proxy(sealed, {
+        get(target, prop, receiver) {
+          if (prop === "has") {
+            const originalMethod = Reflect.get(target, prop, receiver);
+            const wrappedMethod = function(name) {
+              if (!declaredNames.has(name)) {
+                trackMissingSampleErrorAndThrow(createMissingCookieSampleError(route, name));
+              }
+              return originalMethod.call(target, name);
+            };
+            return wrappedMethod;
+          }
+          if (prop === "get") {
+            const originalMethod = Reflect.get(target, prop, receiver);
+            const wrappedMethod = function(nameOrCookie) {
+              let name;
+              if (typeof nameOrCookie === "string") {
+                name = nameOrCookie;
+              } else if (nameOrCookie && typeof nameOrCookie === "object" && typeof nameOrCookie.name === "string") {
+                name = nameOrCookie.name;
+              } else {
+                return originalMethod.call(target, nameOrCookie);
+              }
+              if (!declaredNames.has(name)) {
+                trackMissingSampleErrorAndThrow(createMissingCookieSampleError(route, name));
+              }
+              return originalMethod.call(target, name);
+            };
+            return wrappedMethod;
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    }
+    function createMissingCookieSampleError(route, name) {
+      return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed cookie "${name}" which is not defined in the \`samples\` of \`unstable_instant\`. Add it to the sample's \`cookies\` array, or \`{ name: "${name}", value: null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
+        value: "E1115",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function createHeadersFromSample(rawSampleHeaders, sampleCookies, route) {
+      const sampleHeaders = rawSampleHeaders ? [
+        ...rawSampleHeaders
+      ] : [];
+      if (sampleHeaders.find(([name]) => name.toLowerCase() === "cookie")) {
+        throw Object.defineProperty(new _instantvalidationerror.InstantValidationError('Invalid sample: Defining cookies via a "cookie" header is not supported. Use `cookies: [{ name: ..., value: ... }]` instead.'), "__NEXT_ERROR_CODE", {
+          value: "E1111",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      if (sampleCookies) {
+        const cookieHeaderValue = sampleCookies.toString();
+        sampleHeaders.push([
+          "cookie",
+          // if the `cookies` samples were empty, or they were all `null`, then we have no cookies,
+          // and the header isn't present, but should remains readable, so we set it to null.
+          cookieHeaderValue !== "" ? cookieHeaderValue : null
+        ]);
+      }
+      const declaredNames = /* @__PURE__ */ new Set();
+      const headersInit = {};
+      for (const [name, value] of sampleHeaders) {
+        declaredNames.add(name.toLowerCase());
+        if (value !== null) {
+          headersInit[name.toLowerCase()] = value;
+        }
+      }
+      const sealed = _headers.HeadersAdapter.seal(_headers.HeadersAdapter.from(headersInit));
+      return new Proxy(sealed, {
+        get(target, prop, receiver) {
+          if (prop === "get" || prop === "has") {
+            const originalMethod = Reflect.get(target, prop, receiver);
+            const patchedMethod = function(rawName) {
+              const name = rawName.toLowerCase();
+              if (!declaredNames.has(name)) {
+                trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed header "${name}" which is not defined in the \`samples\` of \`unstable_instant\`. Add it to the sample's \`headers\` array, or \`["${name}", null]\` if it should be absent.`), "__NEXT_ERROR_CODE", {
+                  value: "E1116",
+                  enumerable: false,
+                  configurable: true
+                }));
+              }
+              return originalMethod.call(target, name);
+            };
+            return patchedMethod;
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    }
+    function createDraftModeForValidation() {
+      return {
+        get isEnabled() {
+          return false;
+        },
+        enable() {
+          throw Object.defineProperty(new Error("Draft mode cannot be enabled during build-time instant validation."), "__NEXT_ERROR_CODE", {
+            value: "E1092",
+            enumerable: false,
+            configurable: true
+          });
+        },
+        disable() {
+          throw Object.defineProperty(new Error("Draft mode cannot be disabled during build-time instant validation."), "__NEXT_ERROR_CODE", {
+            value: "E1094",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      };
+    }
+    function createExhaustiveParamsProxy(underlyingParams, declaredParamNames, route) {
+      return new Proxy(underlyingParams, {
+        get(target, prop, receiver) {
+          if (typeof prop === "string" && !_reflectutils.wellKnownProperties.has(prop) && // Only error when accessing a param that is part of the route but wasn't provided.
+          // accessing properties that aren't expected to be a valid param value is fine.
+          prop in underlyingParams && !declaredParamNames.has(prop)) {
+            trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed param "${prop}" which is not defined in the \`samples\` of \`unstable_instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
+              value: "E1095",
+              enumerable: false,
+              configurable: true
+            }));
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    }
+    function createExhaustiveSearchParamsProxy(searchParams, declaredSearchParamNames, route) {
+      return new Proxy(searchParams, {
+        get(target, prop, receiver) {
+          if (typeof prop === "string" && !_reflectutils.wellKnownProperties.has(prop) && !declaredSearchParamNames.has(prop)) {
+            trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, prop));
+          }
+          return Reflect.get(target, prop, receiver);
+        },
+        has(target, prop) {
+          if (typeof prop === "string" && !_reflectutils.wellKnownProperties.has(prop) && !declaredSearchParamNames.has(prop)) {
+            trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, prop));
+          }
+          return Reflect.has(target, prop);
+        }
+      });
+    }
+    function createExhaustiveURLSearchParamsProxy(searchParams, declaredSearchParamNames, route) {
+      return new Proxy(searchParams, {
+        get(target, prop, receiver) {
+          if (prop === "get" || prop === "getAll" || prop === "has") {
+            const originalMathod = Reflect.get(target, prop, receiver);
+            return (name) => {
+              if (typeof name === "string" && !declaredSearchParamNames.has(name)) {
+                trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, name));
+              }
+              return originalMathod.call(target, name);
+            };
+          }
+          const value = Reflect.get(target, prop, receiver);
+          if (typeof value === "function" && !Object.hasOwn(target, prop)) {
+            return value.bind(target);
+          }
+          return value;
+        }
+      });
+    }
+    function createMissingSearchParamSampleError(route, name) {
+      return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed searchParam "${name}" which is not defined in the \`samples\` of \`unstable_instant\`. Add it to the sample's \`searchParams\` object, or \`{ "${name}": null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
+        value: "E1098",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function createRelativeURLFromSamples(route, sampleParams, sampleSearchParams) {
+      const pathname = createPathnameFromRouteAndSampleParams(route, sampleParams ?? {});
+      let search = "";
+      if (sampleSearchParams) {
+        const qs = createURLSearchParamsFromSample(sampleSearchParams).toString();
+        if (qs) {
+          search = "?" + qs;
+        }
+      }
+      return (0, _parserelativeurl.parseRelativeUrl)(pathname + search, void 0, true);
+    }
+    function createURLSearchParamsFromSample(sampleSearchParams) {
+      const result = new URLSearchParams();
+      if (sampleSearchParams) {
+        for (const [key, value] of Object.entries(sampleSearchParams)) {
+          if (value === null || value === void 0) continue;
+          if (Array.isArray(value)) {
+            for (const v of value) {
+              result.append(key, v);
+            }
+          } else {
+            result.set(key, value);
+          }
+        }
+      }
+      return result;
+    }
+    function createPathnameFromRouteAndSampleParams(route, params) {
+      let interpolatedSegments = [];
+      const rawSegments = route.split("/");
+      for (const rawSegment of rawSegments) {
+        const param = (0, _getsegmentparam.getSegmentParam)(rawSegment);
+        if (param) {
+          switch (param.paramType) {
+            case "catchall":
+            case "optional-catchall": {
+              let paramValue = params[param.paramName];
+              if (paramValue === void 0) {
+                paramValue = [
+                  rawSegment
+                ];
+              } else if (!Array.isArray(paramValue)) {
+                throw Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be an array of strings, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
+                  value: "E1104",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+              interpolatedSegments.push(...paramValue.map((v) => encodeURIComponent(v)));
+              break;
+            }
+            case "dynamic": {
+              let paramValue = params[param.paramName];
+              if (paramValue === void 0) {
+                paramValue = rawSegment;
+              } else if (typeof paramValue !== "string") {
+                throw Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be a string, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
+                  value: "E1108",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+              interpolatedSegments.push(encodeURIComponent(paramValue));
+              break;
+            }
+            case "catchall-intercepted-(..)(..)":
+            case "catchall-intercepted-(.)":
+            case "catchall-intercepted-(..)":
+            case "catchall-intercepted-(...)":
+            case "dynamic-intercepted-(..)(..)":
+            case "dynamic-intercepted-(.)":
+            case "dynamic-intercepted-(..)":
+            case "dynamic-intercepted-(...)": {
+              throw Object.defineProperty(new _invarianterror.InvariantError("Not implemented: Validation of interception routes"), "__NEXT_ERROR_CODE", {
+                value: "E1106",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            default: {
+              param.paramType;
+            }
+          }
+        } else {
+          interpolatedSegments.push(rawSegment);
+        }
+      }
+      return interpolatedSegments.join("/");
+    }
+    function assertRootParamInSamples(workStore, sampleParams, paramName) {
+      if (sampleParams && paramName in sampleParams) ;
+      else {
+        const route = workStore.route;
+        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed root param "${paramName}" which is not defined in the \`samples\` of \`unstable_instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
+          value: "E1114",
+          enumerable: false,
+          configurable: true
+        }));
+      }
+    }
+  })(instantSamples);
+  return instantSamples;
+}
+var hasRequiredInstantSamplesClient;
+function requireInstantSamplesClient() {
+  if (hasRequiredInstantSamplesClient) return instantSamplesClient;
+  hasRequiredInstantSamplesClient = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      expectCompleteParamsInClientValidation: function() {
+        return expectCompleteParamsInClientValidation;
+      },
+      instrumentParamsForClientValidation: function() {
+        return instrumentParamsForClientValidation;
+      },
+      instrumentSearchParamsForClientValidation: function() {
+        return instrumentSearchParamsForClientValidation;
+      }
+    });
+    const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
+    const _workasyncstorageexternal = requireWorkAsyncStorage_external();
+    const _instantsamples = requireInstantSamples();
+    const _instantvalidationerror = requireInstantValidationError();
+    function instrumentParamsForClientValidation(underlyingParams) {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore && workUnitStore) {
+        switch (workUnitStore.type) {
+          case "validation-client": {
+            if (workUnitStore.validationSamples) {
+              const declaredKeys = new Set(Object.keys(workUnitStore.validationSamples.params ?? {}));
+              return (0, _instantsamples.createExhaustiveParamsProxy)(underlyingParams, declaredKeys, workStore.route);
+            }
+            break;
+          }
+        }
+      }
+      return underlyingParams;
+    }
+    function expectCompleteParamsInClientValidation(expression) {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore && workUnitStore) {
+        switch (workUnitStore.type) {
+          case "validation-client": {
+            if (workUnitStore.validationSamples) {
+              const fallbackParams = workUnitStore.fallbackRouteParams;
+              if (fallbackParams && fallbackParams.size > 0) {
+                const missingParams = Array.from(fallbackParams.keys());
+                (0, _instantsamples.trackMissingSampleErrorAndThrow)(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${workStore.route}" called ${expression} but param${missingParams.length > 1 ? "s" : ""} ${missingParams.map((p) => `"${p}"`).join(", ")} ${missingParams.length > 1 ? "are" : "is"} not defined in the \`samples\` of \`unstable_instant\`. ${expression} requires all route params to be provided.`), "__NEXT_ERROR_CODE", {
+                  value: "E1109",
+                  enumerable: false,
+                  configurable: true
+                }));
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+    function instrumentSearchParamsForClientValidation(underlyingSearchParams) {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore && workUnitStore) {
+        switch (workUnitStore.type) {
+          case "validation-client": {
+            if (workUnitStore.validationSamples) {
+              const declaredKeys = new Set(Object.keys(workUnitStore.validationSamples.searchParams ?? {}));
+              return (0, _instantsamples.createExhaustiveURLSearchParamsProxy)(underlyingSearchParams, declaredKeys, workStore.route);
+            }
+            break;
+          }
+        }
+      }
+      return underlyingSearchParams;
+    }
+  })(instantSamplesClient);
+  return instantSamplesClient;
+}
 var hasRequiredNavigation$1;
 function requireNavigation$1() {
   if (hasRequiredNavigation$1) return navigation$1.exports;
@@ -2298,6 +4322,7 @@ function requireNavigation$1() {
     const _navigationreactserver = requireNavigation_reactServer();
     const useDynamicRouteParams = typeof window === "undefined" ? requireDynamicRendering().useDynamicRouteParams : void 0;
     const useDynamicSearchParams = typeof window === "undefined" ? requireDynamicRendering().useDynamicSearchParams : void 0;
+    const { instrumentParamsForClientValidation, instrumentSearchParamsForClientValidation, expectCompleteParamsInClientValidation } = typeof window === "undefined" && process.env.__NEXT_CACHE_COMPONENTS ? requireInstantSamplesClient() : {};
     function useSearchParams() {
       useDynamicSearchParams == null ? void 0 : useDynamicSearchParams("useSearchParams()");
       const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
@@ -2309,6 +4334,9 @@ function requireNavigation$1() {
       }, [
         searchParams
       ]);
+      if (typeof window === "undefined" && process.env.__NEXT_CACHE_COMPONENTS && readonlySearchParams) {
+        return instrumentSearchParamsForClientValidation(readonlySearchParams);
+      }
       if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
         if (navigationPromises) {
@@ -2320,6 +4348,10 @@ function requireNavigation$1() {
     function usePathname() {
       useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("usePathname()");
       const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+      if (typeof window === "undefined" && process.env.__NEXT_CACHE_COMPONENTS && pathname) {
+        expectCompleteParamsInClientValidation("usePathname()");
+        return pathname;
+      }
       if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
         if (navigationPromises) {
@@ -2342,6 +4374,9 @@ function requireNavigation$1() {
     function useParams() {
       useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("useParams()");
       const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
+      if (typeof window === "undefined" && process.env.__NEXT_CACHE_COMPONENTS && params) {
+        return instrumentParamsForClientValidation(params);
+      }
       if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
         if (navigationPromises) {
@@ -2355,6 +4390,9 @@ function requireNavigation$1() {
       useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("useSelectedLayoutSegments()");
       const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
       if (!context) return null;
+      if (typeof window === "undefined" && process.env.__NEXT_CACHE_COMPONENTS && context) {
+        expectCompleteParamsInClientValidation("useSelectedLayoutSegments()");
+      }
       if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
         if (navigationPromises) {
@@ -2371,6 +4409,9 @@ function requireNavigation$1() {
       useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("useSelectedLayoutSegment()");
       const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
       const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
+      if (typeof window === "undefined" && process.env.__NEXT_CACHE_COMPONENTS) {
+        expectCompleteParamsInClientValidation("useSelectedLayoutSegment()");
+      }
       if (process.env.NODE_ENV !== "production" && navigationPromises && "use" in _react.default) {
         const promise = (_a = navigationPromises.selectedLayoutSegmentPromises) == null ? void 0 : _a.get(parallelRouteKey);
         if (promise) {
@@ -2399,4 +4440,4 @@ var navigationExports = requireNavigation();
 export {
   navigationExports as n
 };
-//# sourceMappingURL=navigation-C2hD8Jlk.js.map
+//# sourceMappingURL=navigation-BCeRD3ib.js.map