@preprio/prepr-nextjs 2.0.2 → 2.0.3

package/dist/server/index.mjs

@@ -0,0 +1,1569 @@
+import { require_cookies, require_reflect, require_work_async_storage_external, require_work_unit_async_storage_external, require_dynamic_rendering, require_static_generation_bailout, require_dynamic_rendering_utils, require_scheduler, require_utils, require_hooks_server_context, package_default } from '../chunk-32XGP2RS.mjs';
+export { createPreprMiddleware } from '../chunk-32XGP2RS.mjs';
+import { __commonJS, __require, __toESM, __async } from '../chunk-26CXDAG7.mjs';
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js
+var require_request_cookies = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+      },
+      RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+      },
+      appendMutableCookies: function() {
+        return appendMutableCookies;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return areCookiesMutableInCurrentPhase;
+      },
+      getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+      },
+      responseCookiesToRequestCookies: function() {
+        return responseCookiesToRequestCookies;
+      },
+      wrapWithMutableAccessCheck: function() {
+        return wrapWithMutableAccessCheck;
+      }
+    });
+    var _cookies = require_cookies();
+    var _reflect = require_reflect();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var ReadonlyRequestCookiesError = 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();
+      }
+    };
+    var RequestCookiesAdapter = class {
+      static seal(cookies) {
+        return new Proxy(cookies, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case "clear":
+              case "delete":
+              case "set":
+                return ReadonlyRequestCookiesError.callable;
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+      }
+    };
+    var SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for("next.mutated.cookies");
+    function getModifiedCookieValues(cookies) {
+      const modified = cookies[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;
+    }
+    var MutableRequestCookiesAdapter = class {
+      static wrap(cookies, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies.getAll()) {
+          responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = /* @__PURE__ */ new Set();
+        const updateResponseCookies = () => {
+          const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+          if (workStore) {
+            workStore.pathWasRevalidated = true;
+          }
+          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 wrapWithMutableAccessCheck(responseCookies) {
+      const wrappedCookies = new Proxy(responseCookies, {
+        get(target, prop, receiver) {
+          switch (prop) {
+            case "delete":
+              return function(...args) {
+                ensureCookiesAreStillMutable("cookies().delete");
+                target.delete(...args);
+                return wrappedCookies;
+              };
+            case "set":
+              return function(...args) {
+                ensureCookiesAreStillMutable("cookies().set");
+                target.set(...args);
+                return wrappedCookies;
+              };
+            default:
+              return _reflect.ReflectAdapter.get(target, prop, receiver);
+          }
+        }
+      });
+      return wrappedCookies;
+    }
+    function areCookiesMutableInCurrentPhase(requestStore) {
+      return requestStore.phase === "action";
+    }
+    function ensureCookiesAreStillMutable(callingExpression) {
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)(callingExpression);
+      if (!areCookiesMutableInCurrentPhase(requestStore)) {
+        throw new ReadonlyRequestCookiesError();
+      }
+    }
+    function responseCookiesToRequestCookies(responseCookies) {
+      const requestCookies = new _cookies.RequestCookies(new Headers());
+      for (const cookie of responseCookies.getAll()) {
+        requestCookies.set(cookie);
+      }
+      return requestCookies;
+    }
+  }
+});
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js
+var require_create_deduped_by_callsite_server_error_logger = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "createDedupedByCallsiteServerErrorLoggerDev", {
+      enumerable: true,
+      get: function() {
+        return createDedupedByCallsiteServerErrorLoggerDev;
+      }
+    });
+    var _react = /* @__PURE__ */ _interop_require_wildcard(__require("react"));
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function") return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interop_require_wildcard(obj, nodeInterop) {
+      if (obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+          default: obj
+        };
+      }
+      var cache2 = _getRequireWildcardCache(nodeInterop);
+      if (cache2 && cache2.has(obj)) {
+        return cache2.get(obj);
+      }
+      var newObj = {
+        __proto__: null
+      };
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache2) {
+        cache2.set(obj, newObj);
+      }
+      return newObj;
+    }
+    var errorRef = {
+      current: null
+    };
+    var cache = typeof _react.cache === "function" ? _react.cache : (fn) => fn;
+    var logErrorOrWarn = process.env.__NEXT_DYNAMIC_IO ? console.error : console.warn;
+    var flushCurrentErrorIfNew = cache(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+      (key) => {
+        try {
+          logErrorOrWarn(errorRef.current);
+        } finally {
+          errorRef.current = null;
+        }
+      }
+    );
+    function createDedupedByCallsiteServerErrorLoggerDev(getMessage) {
+      return function logDedupedError(...args) {
+        const message = getMessage(...args);
+        if (process.env.NODE_ENV !== "production") {
+          var _stack;
+          const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split("\n");
+          if (callStackFrames === void 0 || callStackFrames.length < 4) {
+            logErrorOrWarn(message);
+          } else {
+            const key = callStackFrames[4];
+            errorRef.current = message;
+            flushCurrentErrorIfNew(key);
+          }
+        } else {
+          logErrorOrWarn(message);
+        }
+      };
+    }
+  }
+});
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/request/cookies.js
+var require_cookies2 = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/request/cookies.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "cookies", {
+      enumerable: true,
+      get: function() {
+        return cookies;
+      }
+    });
+    var _requestcookies = require_request_cookies();
+    var _cookies = require_cookies();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _creatededupedbycallsiteservererrorlogger = require_create_deduped_by_callsite_server_error_logger();
+    var _scheduler = require_scheduler();
+    var _utils = require_utils();
+    function cookies() {
+      const callingExpression = "cookies";
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore) {
+        if (workUnitStore && workUnitStore.phase === "after" && !(0, _utils.isRequestAPICallableInsideAfter)()) {
+          throw Object.defineProperty(new Error(
+            // TODO(after): clarify that this only applies to pages?
+            `Route ${workStore.route} used "cookies" inside "after(...)". This is not supported. If you need this data inside an "after" callback, use "cookies" outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`
+          ), "__NEXT_ERROR_CODE", {
+            value: "E88",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workStore.forceStatic) {
+          const underlyingCookies2 = createEmptyCookies();
+          return makeUntrackedExoticCookies(underlyingCookies2);
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used "cookies" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "cookies" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+              value: "E398",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.type === "unstable-cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used "cookies" inside a function cached with "unstable_cache(...)". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "cookies" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+              value: "E157",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+        if (workStore.dynamicShouldError) {
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E549",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            return makeDynamicallyTrackedExoticCookies(workStore.route, workUnitStore);
+          } else if (workUnitStore.type === "prerender-ppr") {
+            (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
+          }
+        }
+        (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workStore, workUnitStore);
+      }
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)(callingExpression);
+      let underlyingCookies;
+      if ((0, _requestcookies.areCookiesMutableInCurrentPhase)(requestStore)) {
+        underlyingCookies = requestStore.userspaceMutableCookies;
+      } else {
+        underlyingCookies = requestStore.cookies;
+      }
+      if (process.env.NODE_ENV === "development" && !(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+        return makeUntrackedExoticCookiesWithDevWarnings(underlyingCookies, workStore == null ? void 0 : workStore.route);
+      } else {
+        return makeUntrackedExoticCookies(underlyingCookies);
+      }
+    }
+    function createEmptyCookies() {
+      return _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({})));
+    }
+    var CachedCookies = /* @__PURE__ */ new WeakMap();
+    function makeDynamicallyTrackedExoticCookies(route, prerenderStore) {
+      const cachedPromise = CachedCookies.get(prerenderStore);
+      if (cachedPromise) {
+        return cachedPromise;
+      }
+      const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, "`cookies()`");
+      CachedCookies.set(prerenderStore, promise);
+      Object.defineProperties(promise, {
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`cookies()[Symbol.iterator]()`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        size: {
+          get() {
+            const expression = "`cookies().size`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        get: {
+          value: function get() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().get()`";
+            } else {
+              expression = `\`cookies().get(${describeNameArg(arguments[0])})\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        getAll: {
+          value: function getAll() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().getAll()`";
+            } else {
+              expression = `\`cookies().getAll(${describeNameArg(arguments[0])})\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        has: {
+          value: function has() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().has()`";
+            } else {
+              expression = `\`cookies().has(${describeNameArg(arguments[0])})\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        set: {
+          value: function set() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().set()`";
+            } else {
+              const arg = arguments[0];
+              if (arg) {
+                expression = `\`cookies().set(${describeNameArg(arg)}, ...)\``;
+              } else {
+                expression = "`cookies().set(...)`";
+              }
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        delete: {
+          value: function() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().delete()`";
+            } else if (arguments.length === 1) {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])})\``;
+            } else {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])}, ...)\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        clear: {
+          value: function clear() {
+            const expression = "`cookies().clear()`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        toString: {
+          value: function toString() {
+            const expression = "`cookies().toString()`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticCookies(underlyingCookies) {
+      const cachedCookies = CachedCookies.get(underlyingCookies);
+      if (cachedCookies) {
+        return cachedCookies;
+      }
+      const promise = Promise.resolve(underlyingCookies);
+      CachedCookies.set(underlyingCookies, promise);
+      Object.defineProperties(promise, {
+        [Symbol.iterator]: {
+          value: underlyingCookies[Symbol.iterator] ? underlyingCookies[Symbol.iterator].bind(underlyingCookies) : (
+            // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+            // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+            // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+            // has extra properties not available on RequestCookie instances.
+            polyfilledResponseCookiesIterator.bind(underlyingCookies)
+          )
+        },
+        size: {
+          get() {
+            return underlyingCookies.size;
+          }
+        },
+        get: {
+          value: underlyingCookies.get.bind(underlyingCookies)
+        },
+        getAll: {
+          value: underlyingCookies.getAll.bind(underlyingCookies)
+        },
+        has: {
+          value: underlyingCookies.has.bind(underlyingCookies)
+        },
+        set: {
+          value: underlyingCookies.set.bind(underlyingCookies)
+        },
+        delete: {
+          value: underlyingCookies.delete.bind(underlyingCookies)
+        },
+        clear: {
+          value: (
+            // @ts-expect-error clear is defined in RequestCookies implementation but not in the type
+            typeof underlyingCookies.clear === "function" ? underlyingCookies.clear.bind(underlyingCookies) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              polyfilledResponseCookiesClear.bind(underlyingCookies, promise)
+            )
+          )
+        },
+        toString: {
+          value: underlyingCookies.toString.bind(underlyingCookies)
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticCookiesWithDevWarnings(underlyingCookies, route) {
+      const cachedCookies = CachedCookies.get(underlyingCookies);
+      if (cachedCookies) {
+        return cachedCookies;
+      }
+      const promise = new Promise((resolve) => (0, _scheduler.scheduleImmediate)(() => resolve(underlyingCookies)));
+      CachedCookies.set(underlyingCookies, promise);
+      Object.defineProperties(promise, {
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`...cookies()` or similar iteration";
+            syncIODev(route, expression);
+            return underlyingCookies[Symbol.iterator] ? underlyingCookies[Symbol.iterator].apply(underlyingCookies, arguments) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              polyfilledResponseCookiesIterator.call(underlyingCookies)
+            );
+          },
+          writable: false
+        },
+        size: {
+          get() {
+            const expression = "`cookies().size`";
+            syncIODev(route, expression);
+            return underlyingCookies.size;
+          }
+        },
+        get: {
+          value: function get() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().get()`";
+            } else {
+              expression = `\`cookies().get(${describeNameArg(arguments[0])})\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.get.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        getAll: {
+          value: function getAll() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().getAll()`";
+            } else {
+              expression = `\`cookies().getAll(${describeNameArg(arguments[0])})\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.getAll.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        has: {
+          value: function get() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().has()`";
+            } else {
+              expression = `\`cookies().has(${describeNameArg(arguments[0])})\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.has.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        set: {
+          value: function set() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().set()`";
+            } else {
+              const arg = arguments[0];
+              if (arg) {
+                expression = `\`cookies().set(${describeNameArg(arg)}, ...)\``;
+              } else {
+                expression = "`cookies().set(...)`";
+              }
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.set.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        delete: {
+          value: function() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().delete()`";
+            } else if (arguments.length === 1) {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])})\``;
+            } else {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])}, ...)\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.delete.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        clear: {
+          value: function clear() {
+            const expression = "`cookies().clear()`";
+            syncIODev(route, expression);
+            return typeof underlyingCookies.clear === "function" ? underlyingCookies.clear.apply(underlyingCookies, arguments) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              polyfilledResponseCookiesClear.call(underlyingCookies, promise)
+            );
+          },
+          writable: false
+        },
+        toString: {
+          value: function toString() {
+            const expression = "`cookies().toString()` or implicit casting";
+            syncIODev(route, expression);
+            return underlyingCookies.toString.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        }
+      });
+      return promise;
+    }
+    function describeNameArg(arg) {
+      return typeof arg === "object" && arg !== null && typeof arg.name === "string" ? `'${arg.name}'` : typeof arg === "string" ? `'${arg}'` : "...";
+    }
+    function syncIODev(route, expression) {
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore && workUnitStore.type === "request" && workUnitStore.prerenderPhase === true) {
+        const requestStore = workUnitStore;
+        (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
+      }
+      warnForSyncAccess(route, expression);
+    }
+    var warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createCookiesAccessError);
+    function createCookiesAccessError(route, expression) {
+      const prefix = route ? `Route "${route}" ` : "This route ";
+      return Object.defineProperty(new Error(`${prefix}used ${expression}. \`cookies()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E223",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function polyfilledResponseCookiesIterator() {
+      return this.getAll().map((c) => [
+        c.name,
+        c
+      ]).values();
+    }
+    function polyfilledResponseCookiesClear(returnable) {
+      for (const cookie of this.getAll()) {
+        this.delete(cookie.name);
+      }
+      return returnable;
+    }
+  }
+});
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/web/spec-extension/adapters/headers.js
+var require_headers = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/web/spec-extension/adapters/headers.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      HeadersAdapter: function() {
+        return HeadersAdapter;
+      },
+      ReadonlyHeadersError: function() {
+        return ReadonlyHeadersError;
+      }
+    });
+    var _reflect = require_reflect();
+    var ReadonlyHeadersError = 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();
+      }
+    };
+    var HeadersAdapter = 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 != null ? 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();
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/request/headers.js
+var require_headers2 = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/request/headers.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "headers", {
+      enumerable: true,
+      get: function() {
+        return headers2;
+      }
+    });
+    var _headers = require_headers();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _creatededupedbycallsiteservererrorlogger = require_create_deduped_by_callsite_server_error_logger();
+    var _scheduler = require_scheduler();
+    var _utils = require_utils();
+    function headers2() {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore) {
+        if (workUnitStore && workUnitStore.phase === "after" && !(0, _utils.isRequestAPICallableInsideAfter)()) {
+          throw Object.defineProperty(new Error(`Route ${workStore.route} used "headers" inside "after(...)". This is not supported. If you need this data inside an "after" callback, use "headers" outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+            value: "E367",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workStore.forceStatic) {
+          const underlyingHeaders = _headers.HeadersAdapter.seal(new Headers({}));
+          return makeUntrackedExoticHeaders(underlyingHeaders);
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used "headers" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "headers" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+              value: "E304",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.type === "unstable-cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used "headers" inside a function cached with "unstable_cache(...)". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "headers" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+              value: "E127",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+        if (workStore.dynamicShouldError) {
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`headers\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E525",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            return makeDynamicallyTrackedExoticHeaders(workStore.route, workUnitStore);
+          } else if (workUnitStore.type === "prerender-ppr") {
+            (0, _dynamicrendering.postponeWithTracking)(workStore.route, "headers", workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            (0, _dynamicrendering.throwToInterruptStaticGeneration)("headers", workStore, workUnitStore);
+          }
+        }
+        (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workStore, workUnitStore);
+      }
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)("headers");
+      if (process.env.NODE_ENV === "development" && !(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+        return makeUntrackedExoticHeadersWithDevWarnings(requestStore.headers, workStore == null ? void 0 : workStore.route);
+      } else {
+        return makeUntrackedExoticHeaders(requestStore.headers);
+      }
+    }
+    var CachedHeaders = /* @__PURE__ */ new WeakMap();
+    function makeDynamicallyTrackedExoticHeaders(route, prerenderStore) {
+      const cachedHeaders = CachedHeaders.get(prerenderStore);
+      if (cachedHeaders) {
+        return cachedHeaders;
+      }
+      const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, "`headers()`");
+      CachedHeaders.set(prerenderStore, promise);
+      Object.defineProperties(promise, {
+        append: {
+          value: function append() {
+            const expression = `\`headers().append(${describeNameArg(arguments[0])}, ...)\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        delete: {
+          value: function _delete() {
+            const expression = `\`headers().delete(${describeNameArg(arguments[0])})\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        get: {
+          value: function get() {
+            const expression = `\`headers().get(${describeNameArg(arguments[0])})\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        has: {
+          value: function has() {
+            const expression = `\`headers().has(${describeNameArg(arguments[0])})\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        set: {
+          value: function set() {
+            const expression = `\`headers().set(${describeNameArg(arguments[0])}, ...)\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        getSetCookie: {
+          value: function getSetCookie() {
+            const expression = "`headers().getSetCookie()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        forEach: {
+          value: function forEach() {
+            const expression = "`headers().forEach(...)`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        keys: {
+          value: function keys() {
+            const expression = "`headers().keys()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        values: {
+          value: function values() {
+            const expression = "`headers().values()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        entries: {
+          value: function entries() {
+            const expression = "`headers().entries()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`headers()[Symbol.iterator]()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticHeaders(underlyingHeaders) {
+      const cachedHeaders = CachedHeaders.get(underlyingHeaders);
+      if (cachedHeaders) {
+        return cachedHeaders;
+      }
+      const promise = Promise.resolve(underlyingHeaders);
+      CachedHeaders.set(underlyingHeaders, promise);
+      Object.defineProperties(promise, {
+        append: {
+          value: underlyingHeaders.append.bind(underlyingHeaders)
+        },
+        delete: {
+          value: underlyingHeaders.delete.bind(underlyingHeaders)
+        },
+        get: {
+          value: underlyingHeaders.get.bind(underlyingHeaders)
+        },
+        has: {
+          value: underlyingHeaders.has.bind(underlyingHeaders)
+        },
+        set: {
+          value: underlyingHeaders.set.bind(underlyingHeaders)
+        },
+        getSetCookie: {
+          value: underlyingHeaders.getSetCookie.bind(underlyingHeaders)
+        },
+        forEach: {
+          value: underlyingHeaders.forEach.bind(underlyingHeaders)
+        },
+        keys: {
+          value: underlyingHeaders.keys.bind(underlyingHeaders)
+        },
+        values: {
+          value: underlyingHeaders.values.bind(underlyingHeaders)
+        },
+        entries: {
+          value: underlyingHeaders.entries.bind(underlyingHeaders)
+        },
+        [Symbol.iterator]: {
+          value: underlyingHeaders[Symbol.iterator].bind(underlyingHeaders)
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticHeadersWithDevWarnings(underlyingHeaders, route) {
+      const cachedHeaders = CachedHeaders.get(underlyingHeaders);
+      if (cachedHeaders) {
+        return cachedHeaders;
+      }
+      const promise = new Promise((resolve) => (0, _scheduler.scheduleImmediate)(() => resolve(underlyingHeaders)));
+      CachedHeaders.set(underlyingHeaders, promise);
+      Object.defineProperties(promise, {
+        append: {
+          value: function append() {
+            const expression = `\`headers().append(${describeNameArg(arguments[0])}, ...)\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.append.apply(underlyingHeaders, arguments);
+          }
+        },
+        delete: {
+          value: function _delete() {
+            const expression = `\`headers().delete(${describeNameArg(arguments[0])})\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.delete.apply(underlyingHeaders, arguments);
+          }
+        },
+        get: {
+          value: function get() {
+            const expression = `\`headers().get(${describeNameArg(arguments[0])})\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.get.apply(underlyingHeaders, arguments);
+          }
+        },
+        has: {
+          value: function has() {
+            const expression = `\`headers().has(${describeNameArg(arguments[0])})\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.has.apply(underlyingHeaders, arguments);
+          }
+        },
+        set: {
+          value: function set() {
+            const expression = `\`headers().set(${describeNameArg(arguments[0])}, ...)\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.set.apply(underlyingHeaders, arguments);
+          }
+        },
+        getSetCookie: {
+          value: function getSetCookie() {
+            const expression = "`headers().getSetCookie()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.getSetCookie.apply(underlyingHeaders, arguments);
+          }
+        },
+        forEach: {
+          value: function forEach() {
+            const expression = "`headers().forEach(...)`";
+            syncIODev(route, expression);
+            return underlyingHeaders.forEach.apply(underlyingHeaders, arguments);
+          }
+        },
+        keys: {
+          value: function keys() {
+            const expression = "`headers().keys()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.keys.apply(underlyingHeaders, arguments);
+          }
+        },
+        values: {
+          value: function values() {
+            const expression = "`headers().values()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.values.apply(underlyingHeaders, arguments);
+          }
+        },
+        entries: {
+          value: function entries() {
+            const expression = "`headers().entries()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.entries.apply(underlyingHeaders, arguments);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`...headers()` or similar iteration";
+            syncIODev(route, expression);
+            return underlyingHeaders[Symbol.iterator].apply(underlyingHeaders, arguments);
+          }
+        }
+      });
+      return promise;
+    }
+    function describeNameArg(arg) {
+      return typeof arg === "string" ? `'${arg}'` : "...";
+    }
+    function syncIODev(route, expression) {
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore && workUnitStore.type === "request" && workUnitStore.prerenderPhase === true) {
+        const requestStore = workUnitStore;
+        (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
+      }
+      warnForSyncAccess(route, expression);
+    }
+    var warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createHeadersAccessError);
+    function createHeadersAccessError(route, expression) {
+      const prefix = route ? `Route "${route}" ` : "This route ";
+      return Object.defineProperty(new Error(`${prefix}used ${expression}. \`headers()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E277",
+        enumerable: false,
+        configurable: true
+      });
+    }
+  }
+});
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/request/draft-mode.js
+var require_draft_mode = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/dist/server/request/draft-mode.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "draftMode", {
+      enumerable: true,
+      get: function() {
+        return draftMode;
+      }
+    });
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _creatededupedbycallsiteservererrorlogger = require_create_deduped_by_callsite_server_error_logger();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _hooksservercontext = require_hooks_server_context();
+    function draftMode() {
+      const callingExpression = "draftMode";
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (!workStore || !workUnitStore) {
+        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+      }
+      switch (workUnitStore.type) {
+        case "request":
+          return createOrGetCachedExoticDraftMode(workUnitStore.draftMode, workStore);
+        case "cache":
+        case "unstable-cache":
+          const draftModeProvider = (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, workUnitStore);
+          if (draftModeProvider) {
+            return createOrGetCachedExoticDraftMode(draftModeProvider, workStore);
+          }
+        // Otherwise, we fall through to providing an empty draft mode.
+        // eslint-disable-next-line no-fallthrough
+        case "prerender":
+        case "prerender-ppr":
+        case "prerender-legacy":
+          if (process.env.NODE_ENV === "development" && !(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+            const route = workStore == null ? void 0 : workStore.route;
+            return createExoticDraftModeWithDevWarnings(null, route);
+          } else {
+            return createExoticDraftMode(null);
+          }
+        default:
+          const _exhaustiveCheck = workUnitStore;
+          return _exhaustiveCheck;
+      }
+    }
+    function createOrGetCachedExoticDraftMode(draftModeProvider, workStore) {
+      const cachedDraftMode = CachedDraftModes.get(draftMode);
+      if (cachedDraftMode) {
+        return cachedDraftMode;
+      }
+      let promise;
+      if (process.env.NODE_ENV === "development" && !(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+        const route = workStore == null ? void 0 : workStore.route;
+        promise = createExoticDraftModeWithDevWarnings(draftModeProvider, route);
+      } else {
+        promise = createExoticDraftMode(draftModeProvider);
+      }
+      CachedDraftModes.set(draftModeProvider, promise);
+      return promise;
+    }
+    var CachedDraftModes = /* @__PURE__ */ new WeakMap();
+    function createExoticDraftMode(underlyingProvider) {
+      const instance = new DraftMode(underlyingProvider);
+      const promise = Promise.resolve(instance);
+      Object.defineProperty(promise, "isEnabled", {
+        get() {
+          return instance.isEnabled;
+        },
+        set(newValue) {
+          Object.defineProperty(promise, "isEnabled", {
+            value: newValue,
+            writable: true,
+            enumerable: true
+          });
+        },
+        enumerable: true,
+        configurable: true
+      });
+      promise.enable = instance.enable.bind(instance);
+      promise.disable = instance.disable.bind(instance);
+      return promise;
+    }
+    function createExoticDraftModeWithDevWarnings(underlyingProvider, route) {
+      const instance = new DraftMode(underlyingProvider);
+      const promise = Promise.resolve(instance);
+      Object.defineProperty(promise, "isEnabled", {
+        get() {
+          const expression = "`draftMode().isEnabled`";
+          syncIODev(route, expression);
+          return instance.isEnabled;
+        },
+        set(newValue) {
+          Object.defineProperty(promise, "isEnabled", {
+            value: newValue,
+            writable: true,
+            enumerable: true
+          });
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(promise, "enable", {
+        value: function get() {
+          const expression = "`draftMode().enable()`";
+          syncIODev(route, expression);
+          return instance.enable.apply(instance, arguments);
+        }
+      });
+      Object.defineProperty(promise, "disable", {
+        value: function get() {
+          const expression = "`draftMode().disable()`";
+          syncIODev(route, expression);
+          return instance.disable.apply(instance, arguments);
+        }
+      });
+      return promise;
+    }
+    var DraftMode = class {
+      constructor(provider) {
+        this._provider = provider;
+      }
+      get isEnabled() {
+        if (this._provider !== null) {
+          return this._provider.isEnabled;
+        }
+        return false;
+      }
+      enable() {
+        trackDynamicDraftMode("draftMode().enable()");
+        if (this._provider !== null) {
+          this._provider.enable();
+        }
+      }
+      disable() {
+        trackDynamicDraftMode("draftMode().disable()");
+        if (this._provider !== null) {
+          this._provider.disable();
+        }
+      }
+    };
+    function syncIODev(route, expression) {
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore && workUnitStore.type === "request" && workUnitStore.prerenderPhase === true) {
+        const requestStore = workUnitStore;
+        (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
+      }
+      warnForSyncAccess(route, expression);
+    }
+    var warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createDraftModeAccessError);
+    function createDraftModeAccessError(route, expression) {
+      const prefix = route ? `Route "${route}" ` : "This route ";
+      return Object.defineProperty(new Error(`${prefix}used ${expression}. \`draftMode()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E377",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function trackDynamicDraftMode(expression) {
+      const store = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (store) {
+        if (workUnitStore) {
+          if (workUnitStore.type === "cache") {
+            throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" inside "use cache". The enabled status of draftMode can be read in caches but you must not enable or disable draftMode inside a cache. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+              value: "E246",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.type === "unstable-cache") {
+            throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" inside a function cached with "unstable_cache(...)". The enabled status of draftMode can be read in caches but you must not enable or disable draftMode inside a cache. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+              value: "E259",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.phase === "after") {
+            throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" inside \`after\`. The enabled status of draftMode can be read inside \`after\` but you cannot enable or disable draftMode. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+              value: "E348",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+        if (store.dynamicShouldError) {
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E553",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            const error = Object.defineProperty(new Error(`Route ${store.route} used ${expression} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`), "__NEXT_ERROR_CODE", {
+              value: "E126",
+              enumerable: false,
+              configurable: true
+            });
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(store.route, expression, error, workUnitStore);
+          } else if (workUnitStore.type === "prerender-ppr") {
+            (0, _dynamicrendering.postponeWithTracking)(store.route, expression, workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            workUnitStore.revalidate = 0;
+            const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+              value: "E558",
+              enumerable: false,
+              configurable: true
+            });
+            store.dynamicUsageDescription = expression;
+            store.dynamicUsageStack = err.stack;
+            throw err;
+          } else if (process.env.NODE_ENV === "development" && workUnitStore && workUnitStore.type === "request") {
+            workUnitStore.usedDynamic = true;
+          }
+        }
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/headers.js
+var require_headers3 = __commonJS({
+  "node_modules/.pnpm/next@15.3.1_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/next/headers.js"(exports, module) {
+    module.exports.cookies = require_cookies2().cookies;
+    module.exports.headers = require_headers2().headers;
+    module.exports.draftMode = require_draft_mode().draftMode;
+  }
+});
+
+// src/server/index.ts
+var import_headers = __toESM(require_headers3(), 1);
+var PreprError = class extends Error {
+  constructor(message, code, context, originalError) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.originalError = originalError;
+    this.name = "PreprError";
+  }
+};
+function getPreprHeader(name) {
+  return __async(this, null, function* () {
+    const headersList = yield (0, import_headers.headers)();
+    return headersList.get(name);
+  });
+}
+function getPreprUUID() {
+  return __async(this, null, function* () {
+    return getPreprHeader("prepr-customer-id");
+  });
+}
+function getActiveSegment() {
+  return __async(this, null, function* () {
+    return getPreprHeader("Prepr-Segments");
+  });
+}
+function getActiveVariant() {
+  return __async(this, null, function* () {
+    return getPreprHeader("Prepr-ABtesting");
+  });
+}
+function getPreprHeaders() {
+  return __async(this, null, function* () {
+    const preprHeaders = {};
+    const headersList = yield (0, import_headers.headers)();
+    headersList.forEach((value, key) => {
+      if (key.startsWith("prepr") || key.startsWith("Prepr")) {
+        preprHeaders[key] = value;
+      }
+    });
+    return preprHeaders;
+  });
+}
+function validatePreprToken(token) {
+  if (!token) {
+    return { valid: false, error: "Token is required" };
+  }
+  if (!token.startsWith("https://")) {
+    return { valid: false, error: "Token must be a valid HTTPS URL" };
+  }
+  return { valid: true };
+}
+function isPreviewMode() {
+  return process.env.PREPR_ENV === "preview";
+}
+function extractAccessToken(graphqlUrl) {
+  if (!graphqlUrl) return null;
+  try {
+    const url = new URL(graphqlUrl);
+    if (url.hostname !== "graphql.prepr.io") return null;
+    const pathParts = url.pathname.split("/");
+    const token = pathParts[pathParts.length - 1];
+    return token && token.length > 0 ? token : null;
+  } catch (e) {
+    return null;
+  }
+}
+function getPreprEnvironmentSegments(token) {
+  return __async(this, null, function* () {
+    const validation = validatePreprToken(token);
+    if (!validation.valid) {
+      throw new PreprError(
+        validation.error,
+        "INVALID_TOKEN",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    try {
+      const response = yield fetch(token, {
+        headers: {
+          "User-Agent": `Prepr-Preview-Bar/${getPackageVersion()}`,
+          "Content-Type": "application/json"
+        },
+        method: "POST",
+        body: JSON.stringify({
+          query: `{
+                _Segments {
+                    _id
+                    name
+                }
+            }`
+        })
+      });
+      if (!response.ok) {
+        throw new PreprError(
+          `HTTP ${response.status}: ${response.statusText}`,
+          "HTTP_ERROR",
+          "getPreprEnvironmentSegments"
+        );
+      }
+      const json = yield response.json();
+      if (!json || !json.data || !json.data._Segments) {
+        throw new PreprError(
+          "Invalid response format from Prepr API",
+          "INVALID_RESPONSE",
+          "getPreprEnvironmentSegments"
+        );
+      }
+      return json.data._Segments;
+    } catch (error) {
+      if (error instanceof PreprError) {
+        throw error;
+      }
+      throw new PreprError(
+        "Failed to fetch segments from Prepr API",
+        "FETCH_ERROR",
+        "getPreprEnvironmentSegments",
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  });
+}
+function getToolbarProps(token) {
+  return __async(this, null, function* () {
+    let data = [];
+    let activeSegment = null;
+    let activeVariant = null;
+    if (isPreviewMode()) {
+      try {
+        data = yield getPreprEnvironmentSegments(token);
+        activeSegment = yield getActiveSegment();
+        activeVariant = yield getActiveVariant();
+      } catch (error) {
+        console.error("Failed to fetch toolbar props:", error);
+        data = [];
+      }
+    }
+    return {
+      activeSegment,
+      activeVariant,
+      data
+    };
+  });
+}
+function getPackageVersion() {
+  return package_default.version;
+}
+
+export { PreprError, extractAccessToken, getActiveSegment, getActiveVariant, getPreprEnvironmentSegments, getPreprHeaders, getPreprUUID, getToolbarProps, isPreviewMode, validatePreprToken };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map