@codelionapps/unharness 0.0.0-stage → 0.1.1

package/dashboard/.next/standalone/node_modules/next/dist/server/route-modules/app-route/module.js

@@ -0,0 +1,915 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AppRouteRouteModule: null,
+    WrappedNextRouterError: null,
+    default: null,
+    hasNonStaticMethods: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AppRouteRouteModule: function() {
+        return AppRouteRouteModule;
+    },
+    WrappedNextRouterError: function() {
+        return WrappedNextRouterError;
+    },
+    default: function() {
+        return _default;
+    },
+    hasNonStaticMethods: function() {
+        return hasNonStaticMethods;
+    }
+});
+const _routemodule = require("../route-module");
+const _requeststore = require("../../async-storage/request-store");
+const _workstore = require("../../async-storage/work-store");
+const _http = require("../../web/http");
+const _implicittags = require("../../lib/implicit-tags");
+const _patchfetch = require("../../lib/patch-fetch");
+const _tracer = require("../../lib/trace/tracer");
+const _constants = require("../../lib/trace/constants");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../build/output/log"));
+const _autoimplementmethods = require("./helpers/auto-implement-methods");
+const _requestcookies = require("../../web/spec-extension/adapters/request-cookies");
+const _headers = require("../../web/spec-extension/adapters/headers");
+const _parsedurlquerytoparams = require("./helpers/parsed-url-query-to-params");
+const _prospectiverenderutils = require("../../app-render/prospective-render-utils");
+const _hooksservercontext = /*#__PURE__*/ _interop_require_wildcard(require("../../../client/components/hooks-server-context"));
+const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
+const _actionasyncstorageexternal = require("../../app-render/action-async-storage.external");
+const _sharedmodules = /*#__PURE__*/ _interop_require_wildcard(require("./shared-modules"));
+const _serveractionrequestmeta = require("../../lib/server-action-request-meta");
+const _cookies = require("next/dist/compiled/@edge-runtime/cookies");
+const _cleanurl = require("./helpers/clean-url");
+const _staticgenerationbailout = require("../../../client/components/static-generation-bailout");
+const _isstaticgenenabled = require("./helpers/is-static-gen-enabled");
+const _dynamicrendering = require("../../app-render/dynamic-rendering");
+const _reflect = require("../../web/spec-extension/adapters/reflect");
+const _cachesignal = require("../../app-render/cache-signal");
+const _scheduler = require("../../../lib/scheduler");
+const _params = require("../../request/params");
+const _redirect = require("../../../client/components/redirect");
+const _redirecterror = require("../../../client/components/redirect-error");
+const _httpaccessfallback = require("../../../client/components/http-access-fallback/http-access-fallback");
+const _redirectstatuscode = require("../../../client/components/redirect-status-code");
+const _constants1 = require("../../../lib/constants");
+const _revalidationutils = require("../../revalidation-utils");
+const _trackmoduleloadingexternal = require("../../app-render/module-loading/track-module-loading.external");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _lazymodule = require("../../lib/lazy-module");
+const _resumedatacache = require("../../resume-data-cache/resume-data-cache");
+const _usecachemessages = require("../../use-cache/use-cache-messages");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.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 (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class WrappedNextRouterError {
+    constructor(error, headers){
+        this.error = error;
+        this.headers = headers;
+    }
+}
+class AppRouteRouteModule extends _routemodule.RouteModule {
+    static #_ = this.sharedModules = _sharedmodules;
+    get userland() {
+        return this._lazyUserland.assertLoaded();
+    }
+    /**
+   * Ensures the userland module is fully loaded before it's accessed via
+   * `userland`. Required for route files that use top-level await, where
+   * require() returns a promise instead of the module directly. Must be called
+   * before accessing `userland` in contexts where the module may not yet be
+   * resolved (e.g. the export/static-generation worker).
+   */ async ensureUserland() {
+        await this._lazyUserland.waitUntilLoaded();
+    }
+    constructor({ userland, getUserland, definition, distDir, relativeProjectDir, resolvedPagePath, nextConfigOutput }){
+        super({
+            userland: undefined,
+            definition,
+            distDir,
+            relativeProjectDir
+        }), /**
+   * A reference to the request async storage.
+   */ this.workUnitAsyncStorage = _workunitasyncstorageexternal.workUnitAsyncStorage, /**
+   * A reference to the static generation async storage.
+   */ this.workAsyncStorage = _workasyncstorageexternal.workAsyncStorage, /**
+   * An interface to call server hooks which interact with the underlying
+   * storage.
+   */ this.serverHooks = _hooksservercontext, /**
+   * A reference to the mutation related async storage, such as mutations of
+   * cookies.
+   */ this.actionAsyncStorage = _actionasyncstorageexternal.actionAsyncStorage;
+        this.resolvedPagePath = resolvedPagePath;
+        this.nextConfigOutput = nextConfigOutput;
+        this._getUserland = getUserland;
+        this._lazyUserland = new _lazymodule.LazyModule(()=>(0, _tracer.getTracer)().trace(_constants.AppRouteRouteModuleSpan.loadUserland, {
+                spanName: 'load app route module',
+                attributes: {
+                    'next.route': this.definition.pathname
+                }
+            }, userland), (module1)=>this._onUserlandLoaded(module1));
+        // output:export routes load eagerly, so that errors surface at module
+        // load time (as a Redbox in dev) rather than at request time.
+        if (nextConfigOutput === 'export') {
+            this._lazyUserland.loadIfNeeded();
+        }
+    }
+    _onUserlandLoaded(userland) {
+        // Automatically implement some methods if they aren't implemented by the
+        // userland module.
+        this._methods = (0, _autoimplementmethods.autoImplementMethods)(userland);
+        // Get the non-static methods for this route.
+        this._hasNonStaticMethods = hasNonStaticMethods(userland);
+        // Get the dynamic property from the userland module.
+        this._dynamic = userland.dynamic;
+        if (this.nextConfigOutput === 'export') {
+            if (this._dynamic === 'force-dynamic') {
+                throw new Error(`export const dynamic = "force-dynamic" on page "${this.definition.pathname}" cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`);
+            } else if (!(0, _isstaticgenenabled.isStaticGenEnabled)(userland) && userland['GET']) {
+                throw new Error(`export const dynamic = "force-static"/export const revalidate not configured on route "${this.definition.pathname}" with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`);
+            } else {
+                this._dynamic = 'error';
+            }
+        }
+        // We only warn in development after here, so return if we're not in
+        // development.
+        if (process.env.NODE_ENV === 'development') {
+            // Print error in development if the exported handlers are in lowercase, only
+            // uppercase handlers are supported.
+            const lowercased = _http.HTTP_METHODS.map((method)=>method.toLowerCase());
+            for (const method of lowercased){
+                if (method in userland) {
+                    _log.error(`Detected lowercase method '${method}' in '${this.resolvedPagePath}'. Export the uppercase '${method.toUpperCase()}' method name to fix this error.`);
+                }
+            }
+            // Print error if the module exports a default handler, they must use named
+            // exports for each HTTP method.
+            if ('default' in userland) {
+                _log.error(`Detected default export in '${this.resolvedPagePath}'. Export a named export for each HTTP method instead.`);
+            }
+            // If there is no methods exported by this module, then return a not found
+            // response.
+            if (!_http.HTTP_METHODS.some((method)=>method in userland)) {
+                _log.error(`No HTTP methods exported in '${this.resolvedPagePath}'. Export a named export for each HTTP method.`);
+            }
+        }
+    }
+    /**
+   * Returns the handler function for the given HTTP method.
+   * Must be called after ensureUserland() has resolved so that _methods is
+   * populated.
+   */ resolveHandler(method) {
+        // Prevent RCE: only allow recognized HTTP methods.
+        if (!(0, _http.isHTTPMethod)(method)) return ()=>new Response(null, {
+                status: 400
+            });
+        return this._methods[method];
+    }
+    /**
+   * Returns the handler for the given method using a live userland snapshot.
+   * Used in Turbopack dev mode to pick up server HMR updates. The userland
+   * is fetched synchronously via require() so no async overhead is added.
+   */ resolveHandlerFromUserland(method, userland) {
+        if (!(0, _http.isHTTPMethod)(method)) return ()=>new Response(null, {
+                status: 400
+            });
+        return (0, _autoimplementmethods.autoImplementMethods)(userland)[method];
+    }
+    resolvePendingRevalidations(workStore, requestStore, context) {
+        const maybeRevalidatesPromise = (0, _revalidationutils.executeRevalidates)(workStore);
+        if (maybeRevalidatesPromise !== false) {
+            context.renderOpts.pendingWaitUntil = maybeRevalidatesPromise.finally(()=>{
+                if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+                    console.log('pending revalidates promise finished for:', requestStore.url.pathname + requestStore.url.search);
+                }
+            });
+        }
+    }
+    handleHandlerError(err, actionStore, workStore, requestStore, context) {
+        if ((0, _redirecterror.isRedirectError)(err)) {
+            const url = (0, _redirect.getURLFromRedirectError)(err);
+            if (!url) {
+                throw new Error('Invariant: Unexpected redirect url format');
+            }
+            // We need to capture any headers that should be sent on the response.
+            const headers = new Headers({
+                Location: url
+            });
+            // Let's append any cookies that were added by the cookie API.
+            // TODO leaving the gate here b/c it indicates that we might not actually
+            // want to do this on every handler invocation. During prerender there
+            // should be no mutableCookies because then they'd be dynamic.
+            (0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies);
+            this.resolvePendingRevalidations(workStore, requestStore, context);
+            return new Response(null, {
+                // If we're in an action, we want to use a 303 redirect as we don't
+                // want the POST request to follow the redirect, as it could result in
+                // erroneous re-submissions.
+                status: actionStore.isAction ? _redirectstatuscode.RedirectStatusCode.SeeOther : (0, _redirect.getRedirectStatusCodeFromError)(err),
+                headers
+            });
+        }
+        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+            const httpStatus = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+            return new Response(null, {
+                status: httpStatus
+            });
+        }
+        throw err;
+    }
+    finalizeResponse(res, request, workStore, requestStore, prerenderStore, context) {
+        if (!(res instanceof Response)) {
+            var _res_constructor;
+            const invalidType = res === null ? 'null' : res === undefined ? 'undefined' : typeof res === 'object' ? ((_res_constructor = res.constructor) == null ? void 0 : _res_constructor.name) || 'object' : typeof res;
+            throw new Error(`No response is returned from route handler '${this.resolvedPagePath}'. ` + `Expected a Response object but received '${invalidType}' (method: ${request.method}, url: ${requestStore.url.pathname}). ` + `Ensure you return a \`Response\` or a \`NextResponse\` in all branches of your handler.`);
+        }
+        context.renderOpts.fetchMetrics = workStore.fetchMetrics;
+        this.resolvePendingRevalidations(workStore, requestStore, context);
+        if (prerenderStore) {
+            var _prerenderStore_tags;
+            context.renderOpts.collectedTags = (_prerenderStore_tags = prerenderStore.tags) == null ? void 0 : _prerenderStore_tags.join(',');
+            context.renderOpts.collectedRevalidate = prerenderStore.revalidate;
+            context.renderOpts.collectedExpire = prerenderStore.expire;
+            context.renderOpts.collectedStale = prerenderStore.stale;
+        }
+        // It's possible cookies were set in the handler, so we need to merge the
+        // modified cookies and the returned response here.
+        const headers = new Headers(res.headers);
+        if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
+            return new Response(res.body, {
+                status: res.status,
+                statusText: res.statusText,
+                headers
+            });
+        }
+        return res;
+    }
+    async prerenderToResponse(handler, actionStore, workStore, requestStore, implicitTags, request, context) {
+        const cacheComponentsEnabled = !!context.renderOpts.cacheComponents;
+        // Patch the global fetch.
+        (0, _patchfetch.patchFetch)({
+            workAsyncStorage: this.workAsyncStorage,
+            workUnitAsyncStorage: this.workUnitAsyncStorage
+        });
+        const handlerContext = {
+            params: context.params ? (0, _params.createServerParamsForRoute)((0, _parsedurlquerytoparams.parsedUrlQueryToParams)(context.params)) : undefined
+        };
+        let prerenderStore;
+        let res;
+        try {
+            const userlandRevalidate = this.userland.revalidate;
+            const defaultRevalidate = // If the static generation store does not have a revalidate value
+            // set, then we should set it the revalidate value from the userland
+            // module or default to false.
+            userlandRevalidate === false || userlandRevalidate === undefined ? _constants1.INFINITE_CACHE : userlandRevalidate;
+            if (cacheComponentsEnabled) {
+                /**
+         * When we are attempting to statically prerender the GET handler of a route.ts module
+         * and cacheComponents is on we follow a similar pattern to rendering.
+         *
+         * We first run the handler letting caches fill. If something synchronously dynamic occurs
+         * during this prospective render then we can infer it will happen on every render and we
+         * just bail out of prerendering.
+         *
+         * Next we run the handler again and we check if we get a result back in a microtask.
+         * Next.js expects the return value to be a Response or a Thenable that resolves to a Response.
+         * Unfortunately Response's do not allow for accessing the response body synchronously or in
+         * a microtask so we need to allow one more task to unwrap the response body. This is a slightly
+         * different semantic than what we have when we render and it means that certain tasks can still
+         * execute before a prerender completes such as a carefully timed setImmediate.
+         *
+         * Functionally though IO should still take longer than the time it takes to unwrap the response body
+         * so our heuristic of excluding any IO should be preserved.
+         */ const prospectiveController = new AbortController();
+                let prospectiveRenderIsDynamic = false;
+                const cacheSignal = new _cachesignal.CacheSignal(null);
+                let dynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(undefined);
+                // TODO: Route handlers are never resumed, so it's counter-intuitive
+                // to use an RDC here. However, we need the data cache to store cached
+                // results in memory during the prospective prerender, so that they
+                // can be retrieved during the final prerender within microtasks. This
+                // is crucial when doing revalidations of a deployed route handler,
+                // where the default cache handler does not do any in-memory caching.
+                const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+                const prospectiveRoutePrerenderStore = prerenderStore = {
+                    type: 'prerender',
+                    phase: 'action',
+                    // This replicates prior behavior where rootParams is empty in routes
+                    // TODO we need to make this have the proper rootParams for this route
+                    rootParams: {},
+                    fallbackRouteParams: null,
+                    implicitTags,
+                    renderSignal: prospectiveController.signal,
+                    controller: prospectiveController,
+                    stagedRendering: null,
+                    cacheSignal,
+                    // During prospective render we don't use a controller
+                    // because we need to let all caches fill.
+                    dynamicTracking,
+                    revalidate: defaultRevalidate,
+                    expire: _constants1.INFINITE_CACHE,
+                    stale: _constants1.INFINITE_CACHE,
+                    tags: [
+                        ...implicitTags.tags
+                    ],
+                    resumeDataCache: prerenderResumeDataCache,
+                    hmrRefreshHash: undefined,
+                    varyParamsAccumulator: null,
+                    ensureStaticLevel: null,
+                    prerenderDataTracking: null,
+                    isFallbackUpgradeable: false
+                };
+                let prospectiveResult;
+                try {
+                    prospectiveResult = this.workUnitAsyncStorage.run(prospectiveRoutePrerenderStore, handler, request, handlerContext);
+                } catch (err) {
+                    if (prospectiveController.signal.aborted) {
+                        // the route handler called an API which is always dynamic
+                        // there is no need to try again
+                        prospectiveRenderIsDynamic = true;
+                    } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
+                    }
+                }
+                if (typeof prospectiveResult === 'object' && prospectiveResult !== null && typeof prospectiveResult.then === 'function') {
+                    // The handler returned a Thenable. We'll listen for rejections to determine
+                    // if the route is erroring for dynamic reasons.
+                    ;
+                    prospectiveResult.then(()=>{}, (err)=>{
+                        if (prospectiveController.signal.aborted) {
+                            // the route handler called an API which is always dynamic
+                            // there is no need to try again
+                            prospectiveRenderIsDynamic = true;
+                        } else if (process.env.NEXT_DEBUG_BUILD) {
+                            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
+                        }
+                    });
+                }
+                (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+                await cacheSignal.cacheReady();
+                if (prospectiveRenderIsDynamic) {
+                    // the route handler called an API which is always dynamic
+                    // there is no need to try again
+                    const dynamicReason = (0, _dynamicrendering.getFirstDynamicReason)(dynamicTracking);
+                    if (dynamicReason) {
+                        throw new _hooksservercontext.DynamicServerError(`Route ${workStore.route} couldn't be rendered statically because it used \`${dynamicReason}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+                    } else {
+                        console.error('Expected Next.js to keep track of reason for opting out of static rendering but one was not found. This is a bug in Next.js');
+                        throw new _hooksservercontext.DynamicServerError(`Route ${workStore.route} couldn't be rendered statically because it used a dynamic API. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+                    }
+                }
+                // TODO start passing this controller to the route handler. We should expose
+                // it so the handler to abort inflight requests and other operations if we abort
+                // the prerender.
+                const finalController = new AbortController();
+                dynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(undefined);
+                const finalRoutePrerenderStore = prerenderStore = {
+                    type: 'prerender',
+                    phase: 'action',
+                    rootParams: {},
+                    fallbackRouteParams: null,
+                    implicitTags,
+                    renderSignal: finalController.signal,
+                    controller: finalController,
+                    stagedRendering: null,
+                    cacheSignal: null,
+                    dynamicTracking,
+                    revalidate: defaultRevalidate,
+                    expire: _constants1.INFINITE_CACHE,
+                    stale: _constants1.INFINITE_CACHE,
+                    tags: [
+                        ...implicitTags.tags
+                    ],
+                    resumeDataCache: prerenderResumeDataCache,
+                    hmrRefreshHash: undefined,
+                    varyParamsAccumulator: null,
+                    ensureStaticLevel: null,
+                    prerenderDataTracking: null,
+                    isFallbackUpgradeable: false
+                };
+                let responseHandled = false;
+                res = await new Promise((resolve, reject)=>{
+                    (0, _scheduler.scheduleImmediate)(async ()=>{
+                        try {
+                            const result = await this.workUnitAsyncStorage.run(finalRoutePrerenderStore, handler, request, handlerContext);
+                            if (responseHandled) {
+                                // we already rejected in the followup task
+                                return;
+                            } else if (!(result instanceof Response)) {
+                                // This is going to error but we let that happen below
+                                resolve(result);
+                                return;
+                            }
+                            responseHandled = true;
+                            let bodyHandled = false;
+                            result.arrayBuffer().then((body)=>{
+                                if (!bodyHandled) {
+                                    bodyHandled = true;
+                                    resolve(new Response(body, {
+                                        headers: result.headers,
+                                        status: result.status,
+                                        statusText: result.statusText
+                                    }));
+                                }
+                            }, reject);
+                            (0, _scheduler.scheduleImmediate)(()=>{
+                                if (!bodyHandled) {
+                                    bodyHandled = true;
+                                    finalController.abort();
+                                    reject(createCacheComponentsError(workStore.route));
+                                }
+                            });
+                        } catch (err) {
+                            reject(err);
+                        }
+                    });
+                    (0, _scheduler.scheduleImmediate)(()=>{
+                        if (!responseHandled) {
+                            responseHandled = true;
+                            finalController.abort();
+                            reject(createCacheComponentsError(workStore.route));
+                        }
+                    });
+                });
+                if (finalController.signal.aborted) {
+                    // We aborted from within the execution
+                    throw createCacheComponentsError(workStore.route);
+                } else {
+                    // We didn't abort during the execution. We can abort now as a matter of semantics
+                    // though at the moment nothing actually consumes this signal so it won't halt any
+                    // inflight work.
+                    finalController.abort();
+                }
+            } else {
+                prerenderStore = {
+                    type: 'prerender-legacy',
+                    phase: 'action',
+                    rootParams: {},
+                    implicitTags,
+                    revalidate: defaultRevalidate,
+                    expire: _constants1.INFINITE_CACHE,
+                    stale: _constants1.INFINITE_CACHE,
+                    tags: [
+                        ...implicitTags.tags
+                    ]
+                };
+                res = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderStore, handler, request, handlerContext);
+            }
+        } catch (err) {
+            return this.handleHandlerError(err, actionStore, workStore, requestStore, context);
+        }
+        return this.finalizeResponse(res, request, workStore, requestStore, prerenderStore, context);
+    }
+    async renderToResponse(handler, actionStore, workStore, requestStore, request, context) {
+        // Patch the global fetch.
+        (0, _patchfetch.patchFetch)({
+            workAsyncStorage: this.workAsyncStorage,
+            workUnitAsyncStorage: this.workUnitAsyncStorage
+        });
+        const handlerContext = {
+            params: context.params ? (0, _params.createServerParamsForRoute)((0, _parsedurlquerytoparams.parsedUrlQueryToParams)(context.params)) : undefined
+        };
+        let res;
+        try {
+            res = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, handler, request, handlerContext);
+        } catch (err) {
+            return this.handleHandlerError(err, actionStore, workStore, requestStore, context);
+        }
+        return this.finalizeResponse(res, request, workStore, requestStore, null, context);
+    }
+    async prepareExecution(req, context) {
+        // Ensure userland is fully loaded (handles async modules with top-level
+        // await, where require() returns a Promise instead of the module).
+        await this.ensureUserland();
+        // In Turbopack dev mode, fetch the live userland module on every request
+        // via the synchronous require() getter so server HMR updates are reflected
+        // immediately. This is cheap — it is just a devModuleCache lookup.
+        // For routes with top-level await, require() may still return a Promise
+        // (async module); in that case fall back to the already-resolved
+        // userland module resolved by ensureUserland() above.
+        const rawLiveUserland = this._getUserland == null ? void 0 : this._getUserland.call(this);
+        const liveUserland = rawLiveUserland instanceof Promise ? undefined : rawLiveUserland;
+        const handler = liveUserland ? this.resolveHandlerFromUserland(req.method, liveUserland) : this.resolveHandler(req.method);
+        // Use the live userland (if available) for per-request values so HMR
+        // changes to fetchCache, dynamic, etc. are also picked up.
+        const userland = liveUserland ?? this.userland;
+        // Add the fetchCache option to the renderOpts.
+        context.renderOpts.fetchCache = userland.fetchCache;
+        const actionStore = {
+            isAppRoute: true,
+            isAction: (0, _serveractionrequestmeta.getIsPossibleServerAction)(req)
+        };
+        const implicitTags = await (0, _implicittags.getImplicitTags)(this.definition.page, req.nextUrl.pathname, // App Routes don't support unknown route params.
+        null);
+        const requestStore = (0, _requeststore.createRequestStoreForAPI)(req, req.nextUrl, implicitTags, undefined, context.previewProps, context.renderOpts.hmrRefreshHash);
+        return {
+            handler,
+            dynamic: (liveUserland == null ? void 0 : liveUserland.dynamic) ?? this._dynamic,
+            hasNonStaticMethods: liveUserland ? hasNonStaticMethods(liveUserland) : this._hasNonStaticMethods,
+            actionStore,
+            implicitTags,
+            requestStore
+        };
+    }
+    validateExecutionResponse(response) {
+        // If the handler didn't return a valid response, then return the internal
+        // error response.
+        if (!(response instanceof Response)) {
+            // TODO: validate the correct handling behavior, maybe log something?
+            return new Response(null, {
+                status: 500
+            });
+        }
+        if (response.headers.has('x-middleware-rewrite')) {
+            throw new Error('NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.');
+        }
+        if (response.headers.get('x-middleware-next') === '1') {
+            // TODO: move this error into the `NextResponse.next()` function.
+            throw new Error('NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler');
+        }
+        return response;
+    }
+    async executeRequest(req, context, prepared, workStore) {
+        const { actionStore, handler, requestStore } = prepared;
+        const response = await this.actionAsyncStorage.run(actionStore, ()=>this.workUnitAsyncStorage.run(requestStore, ()=>this.workAsyncStorage.run(workStore, ()=>{
+                    let request = req;
+                    switch(prepared.dynamic){
+                        case 'force-dynamic':
+                            workStore.forceDynamic = true;
+                            break;
+                        case 'force-static':
+                            workStore.forceStatic = true;
+                            request = new Proxy(req, forceStaticRequestHandlers);
+                            break;
+                        case 'error':
+                            workStore.dynamicShouldError = true;
+                            break;
+                        case undefined:
+                        case 'auto':
+                            request = proxyNextRequest(req, workStore);
+                            break;
+                        default:
+                            prepared.dynamic;
+                    }
+                    const tracer = (0, _tracer.getTracer)();
+                    const { pathname } = this.definition;
+                    tracer.setRootSpanAttribute('next.route', pathname);
+                    return tracer.trace(_constants.AppRouteRouteHandlersSpan.runHandler, {
+                        spanName: `executing api route (app) ${pathname}`,
+                        attributes: {
+                            'next.route': pathname
+                        }
+                    }, ()=>this.renderToResponse(handler, actionStore, workStore, requestStore, request, context));
+                })));
+        return this.validateExecutionResponse(response);
+    }
+    async executePrerender(req, context, prepared, workStore) {
+        const { actionStore, handler, implicitTags, requestStore } = prepared;
+        // Run the handler with the request AsyncLocalStorage to inject the helper
+        // support. We set this to `unknown` because the type is not known until
+        // runtime when we do a instanceof check below.
+        const response = await this.actionAsyncStorage.run(actionStore, ()=>this.workUnitAsyncStorage.run(requestStore, ()=>this.workAsyncStorage.run(workStore, ()=>{
+                    if (prepared.hasNonStaticMethods) {
+                        const err = new _hooksservercontext.DynamicServerError('Route is configured with methods that cannot be statically generated.');
+                        workStore.dynamicUsageDescription = err.message;
+                        workStore.dynamicUsageStack = err.stack;
+                        throw err;
+                    }
+                    let request = req;
+                    switch(prepared.dynamic){
+                        case 'force-dynamic':
+                            {
+                                workStore.forceDynamic = true;
+                                const err = new _hooksservercontext.DynamicServerError('Route is configured with dynamic = error which cannot be statically generated.');
+                                workStore.dynamicUsageDescription = err.message;
+                                workStore.dynamicUsageStack = err.stack;
+                                throw err;
+                            }
+                        case 'force-static':
+                            workStore.forceStatic = true;
+                            request = new Proxy(req, forceStaticRequestHandlers);
+                            break;
+                        case 'error':
+                            workStore.dynamicShouldError = true;
+                            request = new Proxy(req, ensureStaticRequestHandlers);
+                            break;
+                        case undefined:
+                        case 'auto':
+                            request = proxyNextRequest(req, workStore);
+                            break;
+                        default:
+                            prepared.dynamic;
+                    }
+                    const tracer = (0, _tracer.getTracer)();
+                    const { pathname } = this.definition;
+                    tracer.setRootSpanAttribute('next.route', pathname);
+                    return tracer.trace(_constants.AppRouteRouteHandlersSpan.runHandler, {
+                        spanName: `executing api route (app) ${pathname}`,
+                        attributes: {
+                            'next.route': pathname
+                        }
+                    }, ()=>this.prerenderToResponse(handler, actionStore, workStore, requestStore, implicitTags, request, context));
+                })));
+        return this.validateExecutionResponse(response);
+    }
+    async handle(req, context) {
+        const prepared = await this.prepareExecution(req, context);
+        const workStore = (0, _workstore.createWorkStore)({
+            page: this.definition.page,
+            renderOpts: context.renderOpts,
+            buildId: context.sharedContext.buildId,
+            deploymentId: context.sharedContext.deploymentId,
+            previouslyRevalidatedTags: []
+        });
+        return this.executeRequest(req, context, prepared, workStore);
+    }
+    async prerender(req, context) {
+        const prepared = await this.prepareExecution(req, context);
+        const workStore = (0, _workstore.createPrerenderWorkStore)({
+            page: this.definition.page,
+            renderOpts: context.renderOpts,
+            buildId: context.sharedContext.buildId,
+            deploymentId: context.sharedContext.deploymentId,
+            previouslyRevalidatedTags: []
+        });
+        return this.executePrerender(req, context, prepared, workStore);
+    }
+}
+const _default = AppRouteRouteModule;
+function hasNonStaticMethods(handlers) {
+    if (// Order these by how common they are to be used
+    handlers.POST || handlers.PUT || handlers.DELETE || handlers.PATCH || handlers.OPTIONS) {
+        return true;
+    }
+    return false;
+}
+// These symbols will be used to stash cached values on Proxied requests without requiring
+// additional closures or storage such as WeakMaps.
+const nextURLSymbol = Symbol('nextUrl');
+const requestCloneSymbol = Symbol('clone');
+const urlCloneSymbol = Symbol('clone');
+const searchParamsSymbol = Symbol('searchParams');
+const hrefSymbol = Symbol('href');
+const toStringSymbol = Symbol('toString');
+const headersSymbol = Symbol('headers');
+const cookiesSymbol = Symbol('cookies');
+/**
+ * The general technique with these proxy handlers is to prioritize keeping them static
+ * by stashing computed values on the Proxy itself. This is safe because the Proxy is
+ * inaccessible to the consumer since all operations are forwarded
+ */ const forceStaticRequestHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            case 'headers':
+                return target[headersSymbol] || (target[headersSymbol] = _headers.HeadersAdapter.seal(new Headers({})));
+            case 'cookies':
+                return target[cookiesSymbol] || (target[cookiesSymbol] = _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({}))));
+            case 'nextUrl':
+                return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, forceStaticNextUrlHandlers));
+            case 'url':
+                // we don't need to separately cache this we can just read the nextUrl
+                // and return the href since we know it will have been stripped of any
+                // dynamic parts. We access via the receiver to trigger the get trap
+                return receiver.nextUrl.href;
+            case 'geo':
+            case 'ip':
+                return undefined;
+            case 'clone':
+                return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
+                    // clone. The reason we might expect this to work in this context is the Proxy will
+                    // respond with static-amenable values anyway somewhat restoring the interface.
+                    // @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
+                    // sophisticated to adequately represent themselves in all contexts. A better approach is
+                    // to probably embed the static generation logic into the class itself removing the need
+                    // for any kind of proxying
+                    target.clone(), forceStaticRequestHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+const forceStaticNextUrlHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            // URL properties
+            case 'search':
+                return '';
+            case 'searchParams':
+                return target[searchParamsSymbol] || (target[searchParamsSymbol] = new URLSearchParams());
+            case 'href':
+                return target[hrefSymbol] || (target[hrefSymbol] = (0, _cleanurl.cleanURL)(target.href).href);
+            case 'toJSON':
+            case 'toString':
+                return target[toStringSymbol] || (target[toStringSymbol] = ()=>receiver.href);
+            // NextUrl properties
+            case 'url':
+                // Currently nextURL does not expose url but our Docs indicate that it is an available property
+                // I am forcing this to undefined here to avoid accidentally exposing a dynamic value later if
+                // the underlying nextURL ends up adding this property
+                return undefined;
+            case 'clone':
+                return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), forceStaticNextUrlHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+function proxyNextRequest(request, workStore) {
+    const nextUrlHandlers = {
+        get (target, prop, receiver) {
+            switch(prop){
+                case 'search':
+                case 'searchParams':
+                case 'url':
+                case 'href':
+                case 'toJSON':
+                case 'toString':
+                case 'origin':
+                    {
+                        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+                        trackDynamic(workStore, workUnitStore, `nextUrl.${prop}`);
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                    }
+                case 'clone':
+                    return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), nextUrlHandlers));
+                default:
+                    return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+        }
+    };
+    const nextRequestHandlers = {
+        get (target, prop) {
+            switch(prop){
+                case 'nextUrl':
+                    return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, nextUrlHandlers));
+                case 'headers':
+                case 'cookies':
+                case 'url':
+                case 'body':
+                case 'blob':
+                case 'json':
+                case 'text':
+                case 'arrayBuffer':
+                case 'formData':
+                    {
+                        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+                        trackDynamic(workStore, workUnitStore, `request.${prop}`);
+                        // The receiver arg is intentionally the same as the target to fix an issue with
+                        // edge runtime, where attempting to access internal slots with the wrong `this` context
+                        // results in an error.
+                        return _reflect.ReflectAdapter.get(target, prop, target);
+                    }
+                case 'clone':
+                    return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
+                        // clone. The reason we might expect this to work in this context is the Proxy will
+                        // respond with static-amenable values anyway somewhat restoring the interface.
+                        // @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
+                        // sophisticated to adequately represent themselves in all contexts. A better approach is
+                        // to probably embed the static generation logic into the class itself removing the need
+                        // for any kind of proxying
+                        target.clone(), nextRequestHandlers));
+                default:
+                    // The receiver arg is intentionally the same as the target to fix an issue with
+                    // edge runtime, where attempting to access internal slots with the wrong `this` context
+                    // results in an error.
+                    return _reflect.ReflectAdapter.get(target, prop, target);
+            }
+        }
+    };
+    return new Proxy(request, nextRequestHandlers);
+}
+const ensureStaticRequestHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            case 'nextUrl':
+                return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, ensureStaticNextUrlHandlers));
+            case 'headers':
+            case 'cookies':
+            case 'url':
+            case 'body':
+            case 'blob':
+            case 'json':
+            case 'text':
+            case 'arrayBuffer':
+            case 'formData':
+                throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.nextUrl.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`request.${prop}\`.`);
+            case 'clone':
+                return target[requestCloneSymbol] || (target[requestCloneSymbol] = ()=>new Proxy(// This is vaguely unsafe but it's required since NextRequest does not implement
+                    // clone. The reason we might expect this to work in this context is the Proxy will
+                    // respond with static-amenable values anyway somewhat restoring the interface.
+                    // @TODO we need to rethink NextRequest and NextURL because they are not sufficientlly
+                    // sophisticated to adequately represent themselves in all contexts. A better approach is
+                    // to probably embed the static generation logic into the class itself removing the need
+                    // for any kind of proxying
+                    target.clone(), ensureStaticRequestHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+const ensureStaticNextUrlHandlers = {
+    get (target, prop, receiver) {
+        switch(prop){
+            case 'search':
+            case 'searchParams':
+            case 'url':
+            case 'href':
+            case 'toJSON':
+            case 'toString':
+            case 'origin':
+                throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`nextUrl.${prop}\`.`);
+            case 'clone':
+                return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), ensureStaticNextUrlHandlers));
+            default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+function createCacheComponentsError(route) {
+    return new _hooksservercontext.DynamicServerError(`Route ${route} couldn't be rendered statically because it used IO that was not cached. See more info here: https://nextjs.org/docs/messages/cache-components`);
+}
+function trackDynamic(store, workUnitStore, expression) {
+    if (store.dynamicShouldError) {
+        throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
+    }
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+                // TODO: Should we allow reading cookies and search params from the
+                // request for private caches in route handlers?
+                throw (0, _usecachemessages.createRouteHandlerRequestInUseCacheError)(store.route, expression);
+            case 'unstable-cache':
+                throw (0, _usecachemessages.createRouteHandlerRequestInUnstableCacheError)(store.route, expression);
+            case 'prerender':
+                const error = new Error(`Route ${store.route} used ${expression} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-request`);
+                return (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(store.route, expression, error, workUnitStore);
+            case 'prerender-client':
+            case 'validation-client':
+                throw new _invarianterror.InvariantError('A client prerender store should not be used for a route handler.');
+            case 'prerender-runtime':
+                throw new _invarianterror.InvariantError('A runtime prerender store should not be used for a route handler.');
+            case 'prerender-legacy':
+                workUnitStore.revalidate = 0;
+                const err = new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+                store.dynamicUsageDescription = expression;
+                store.dynamicUsageStack = err.stack;
+                throw err;
+            case 'request':
+                break;
+            case 'build-time-generator':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+}
+
+//# sourceMappingURL=module.js.map