failproofai 1.0.11-beta.1 → 1.0.11-beta.2

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

@@ -67,6 +67,7 @@ const _trackmoduleloadingexternal = require("../../app-render/module-loading/tra
 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();
@@ -148,7 +149,12 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         this.resolvedPagePath = resolvedPagePath;
         this.nextConfigOutput = nextConfigOutput;
         this._getUserland = getUserland;
-        this._lazyUserland = new _lazymodule.LazyModule(userland, (module1)=>this._onUserlandLoaded(module1));
+        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') {
@@ -165,17 +171,9 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         this._dynamic = userland.dynamic;
         if (this.nextConfigOutput === 'export') {
             if (this._dynamic === 'force-dynamic') {
-                throw Object.defineProperty(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`), "__NEXT_ERROR_CODE", {
-                    value: "E278",
-                    enumerable: false,
-                    configurable: true
-                });
+                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 Object.defineProperty(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`), "__NEXT_ERROR_CODE", {
-                    value: "E301",
-                    enumerable: false,
-                    configurable: true
-                });
+                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';
             }
@@ -224,11 +222,76 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
             });
         return (0, _autoimplementmethods.autoImplementMethods)(userland)[method];
     }
-    async do(handler, actionStore, workStore, // @TODO refactor to not take this argument but instead construct the RequestStore
-    // inside this function. Right now we get passed a RequestStore even when
-    // we're going to do a prerender. We should probably just split do up into prexecute and execute
-    requestStore, implicitTags, request, context) {
-        const isStaticGeneration = workStore.isStaticGeneration;
+    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)({
@@ -238,299 +301,230 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         const handlerContext = {
             params: context.params ? (0, _params.createServerParamsForRoute)((0, _parsedurlquerytoparams.parsedUrlQueryToParams)(context.params)) : undefined
         };
-        const resolvePendingRevalidations = ()=>{
-            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);
-                    }
-                });
-            }
-        };
-        let prerenderStore = null;
+        let prerenderStore;
         let res;
         try {
-            if (isStaticGeneration) {
-                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();
-                    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,
-                        runtimeDataAccessed: null,
-                        shouldAttemptStaticPrefetch: null,
-                        isFallbackUpgradeable: false
-                    };
-                    let prospectiveResult;
-                    try {
-                        prospectiveResult = this.workUnitAsyncStorage.run(prospectiveRoutePrerenderStore, handler, request, handlerContext);
-                    } catch (err) {
+            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 || process.env.__NEXT_VERBOSE_LOGGING) {
+                        } 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`);
                     }
-                    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);
+                }
+                // 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;
                             }
-                        });
-                    }
-                    (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 Object.defineProperty(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`), "__NEXT_ERROR_CODE", {
-                                value: "E558",
-                                enumerable: false,
-                                configurable: true
-                            });
-                        } 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 Object.defineProperty(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`), "__NEXT_ERROR_CODE", {
-                                value: "E577",
-                                enumerable: false,
-                                configurable: true
+                            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);
                         }
-                    }
-                    // 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,
-                        runtimeDataAccessed: null,
-                        shouldAttemptStaticPrefetch: 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();
-                    }
+                    (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 {
-                    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);
+                    // 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 {
-                res = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, handler, request, handlerContext);
+                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) {
-            if ((0, _redirecterror.isRedirectError)(err)) {
-                const url = (0, _redirect.getURLFromRedirectError)(err);
-                if (!url) {
-                    throw Object.defineProperty(new Error('Invariant: Unexpected redirect url format'), "__NEXT_ERROR_CODE", {
-                        value: "E399",
-                        enumerable: false,
-                        configurable: true
-                    });
-                }
-                // 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 `do` call. During prerender there should be no mutableCookies because
-                (0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies);
-                resolvePendingRevalidations();
-                // Return the redirect response.
-                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
-                });
-            } else if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
-                const httpStatus = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
-                return new Response(null, {
-                    status: httpStatus
-                });
-            }
-            throw err;
-        }
-        // Validate that the response is a valid response object.
-        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 Object.defineProperty(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.`), "__NEXT_ERROR_CODE", {
-                value: "E985",
-                enumerable: false,
-                configurable: true
-            });
+            return this.handleHandlerError(err, actionStore, workStore, requestStore, context);
         }
-        context.renderOpts.fetchMetrics = workStore.fetchMetrics;
-        resolvePendingRevalidations();
-        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 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 res;
+        return this.finalizeResponse(res, request, workStore, requestStore, null, context);
     }
-    async handle(req, 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();
@@ -543,19 +537,11 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         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);
-        // Get the context for the static generation.
-        const staticGenerationContext = {
-            page: this.definition.page,
-            renderOpts: context.renderOpts,
-            buildId: context.sharedContext.buildId,
-            deploymentId: context.sharedContext.deploymentId,
-            previouslyRevalidatedTags: []
-        };
         // 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.
-        staticGenerationContext.renderOpts.fetchCache = userland.fetchCache;
+        context.renderOpts.fetchCache = userland.fetchCache;
         const actionStore = {
             isAppRoute: true,
             isAction: (0, _serveractionrequestmeta.getIsPossibleServerAction)(req)
@@ -563,76 +549,105 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         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);
-        const workStore = (0, _workstore.createWorkStore)(staticGenerationContext);
+        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, async ()=>{
-                    // Check to see if we should bail out of static generation based on
-                    // having non-static methods. Use live userland when available so
-                    // HMR changes to exported HTTP methods are reflected immediately.
-                    const hasNonStatic = liveUserland ? hasNonStaticMethods(liveUserland) : this._hasNonStaticMethods;
-                    if (hasNonStatic) {
-                        if (workStore.isStaticGeneration) {
-                            const err = Object.defineProperty(new _hooksservercontext.DynamicServerError('Route is configured with methods that cannot be statically generated.'), "__NEXT_ERROR_CODE", {
-                                value: "E582",
-                                enumerable: false,
-                                configurable: true
-                            });
-                            workStore.dynamicUsageDescription = err.message;
-                            workStore.dynamicUsageStack = err.stack;
-                            throw err;
-                        }
+        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;
                     }
-                    // We assume we can pass the original request through however we may end up
-                    // proxying it in certain circumstances based on execution type and configuration
                     let request = req;
-                    // Use the live dynamic value when available so HMR changes to
-                    // `export const dynamic` are reflected immediately.
-                    const dynamic = (liveUserland == null ? void 0 : liveUserland.dynamic) ?? this._dynamic;
-                    // Update the static generation store based on the dynamic property.
-                    switch(dynamic){
+                    switch(prepared.dynamic){
                         case 'force-dynamic':
                             {
-                                // Routes of generated paths should be dynamic
                                 workStore.forceDynamic = true;
-                                if (workStore.isStaticGeneration) {
-                                    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError('Route is configured with dynamic = error which cannot be statically generated.'), "__NEXT_ERROR_CODE", {
-                                        value: "E703",
-                                        enumerable: false,
-                                        configurable: true
-                                    });
-                                    workStore.dynamicUsageDescription = err.message;
-                                    workStore.dynamicUsageStack = err.stack;
-                                    throw err;
-                                }
-                                break;
+                                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':
-                            // The dynamic property is set to force-static, so we should
-                            // force the page to be static.
                             workStore.forceStatic = true;
-                            // We also Proxy the request to replace dynamic data on the request
-                            // with empty stubs to allow for safely executing as static
                             request = new Proxy(req, forceStaticRequestHandlers);
                             break;
                         case 'error':
-                            // The dynamic property is set to error, so we should throw an
-                            // error if the page is being statically generated.
                             workStore.dynamicShouldError = true;
-                            if (workStore.isStaticGeneration) request = new Proxy(req, requireStaticRequestHandlers);
+                            request = new Proxy(req, ensureStaticRequestHandlers);
                             break;
                         case undefined:
                         case 'auto':
-                            // We proxy `NextRequest` to track dynamic access, and
-                            // potentially bail out of static generation.
                             request = proxyNextRequest(req, workStore);
                             break;
                         default:
-                            dynamic;
+                            prepared.dynamic;
                     }
                     const tracer = (0, _tracer.getTracer)();
-                    // Update the root span attribute for the route.
                     const { pathname } = this.definition;
                     tracer.setRootSpanAttribute('next.route', pathname);
                     return tracer.trace(_constants.AppRouteRouteHandlersSpan.runHandler, {
@@ -640,32 +655,31 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
                         attributes: {
                             'next.route': pathname
                         }
-                    }, async ()=>this.do(handler, actionStore, workStore, requestStore, implicitTags, request, context));
+                    }, ()=>this.prerenderToResponse(handler, actionStore, workStore, requestStore, implicitTags, request, context));
                 })));
-        // If the handler did'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 Object.defineProperty(new Error('NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.'), "__NEXT_ERROR_CODE", {
-                value: "E374",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        if (response.headers.get('x-middleware-next') === '1') {
-            // TODO: move this error into the `NextResponse.next()` function.
-            throw Object.defineProperty(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'), "__NEXT_ERROR_CODE", {
-                value: "E385",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        return response;
+        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;
@@ -811,11 +825,11 @@ function proxyNextRequest(request, workStore) {
     };
     return new Proxy(request, nextRequestHandlers);
 }
-const requireStaticRequestHandlers = {
+const ensureStaticRequestHandlers = {
     get (target, prop, receiver) {
         switch(prop){
             case 'nextUrl':
-                return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, requireStaticNextUrlHandlers));
+                return target[nextURLSymbol] || (target[nextURLSymbol] = new Proxy(target.nextUrl, ensureStaticNextUrlHandlers));
             case 'headers':
             case 'cookies':
             case 'url':
@@ -825,11 +839,7 @@ const requireStaticRequestHandlers = {
             case 'text':
             case 'arrayBuffer':
             case 'formData':
-                throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.nextUrl.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`request.${prop}\`.`), "__NEXT_ERROR_CODE", {
-                    value: "E611",
-                    enumerable: false,
-                    configurable: true
-                });
+                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
@@ -838,13 +848,13 @@ const requireStaticRequestHandlers = {
                     // 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(), requireStaticRequestHandlers));
+                    target.clone(), ensureStaticRequestHandlers));
             default:
                 return _reflect.ReflectAdapter.get(target, prop, receiver);
         }
     }
 };
-const requireStaticNextUrlHandlers = {
+const ensureStaticNextUrlHandlers = {
     get (target, prop, receiver) {
         switch(prop){
             case 'search':
@@ -854,32 +864,20 @@ const requireStaticNextUrlHandlers = {
             case 'toJSON':
             case 'toString':
             case 'origin':
-                throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${target.pathname} with \`dynamic = "error"\` couldn't be rendered statically because it used \`nextUrl.${prop}\`.`), "__NEXT_ERROR_CODE", {
-                    value: "E575",
-                    enumerable: false,
-                    configurable: true
-                });
+                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(), requireStaticNextUrlHandlers));
+                return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), ensureStaticNextUrlHandlers));
             default:
                 return _reflect.ReflectAdapter.get(target, prop, receiver);
         }
     }
 };
 function createCacheComponentsError(route) {
-    return Object.defineProperty(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`), "__NEXT_ERROR_CODE", {
-        value: "E727",
-        enumerable: false,
-        configurable: true
-    });
+    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 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
-        });
+        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){
@@ -887,57 +885,26 @@ function trackDynamic(store, workUnitStore, expression) {
             case 'private-cache':
                 // TODO: Should we allow reading cookies and search params from the
                 // request for private caches in route handlers?
-                throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "${expression}" 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: "E178",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw (0, _usecachemessages.createRouteHandlerRequestInUseCacheError)(store.route, expression);
             case 'unstable-cache':
-                throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" 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 "${expression}" 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: "E133",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw (0, _usecachemessages.createRouteHandlerRequestInUnstableCacheError)(store.route, expression);
             case '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-request`), "__NEXT_ERROR_CODE", {
-                    value: "E261",
-                    enumerable: false,
-                    configurable: true
-                });
+                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 Object.defineProperty(new _invarianterror.InvariantError('A client prerender store should not be used for a route handler.'), "__NEXT_ERROR_CODE", {
-                    value: "E720",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('A client prerender store should not be used for a route handler.');
             case 'prerender-runtime':
-                throw Object.defineProperty(new _invarianterror.InvariantError('A runtime prerender store should not be used for a route handler.'), "__NEXT_ERROR_CODE", {
-                    value: "E767",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-ppr':
-                return (0, _dynamicrendering.postponeWithTracking)(store.route, expression, workUnitStore.dynamicTracking);
+                throw new _invarianterror.InvariantError('A runtime prerender store should not be used for a route handler.');
             case '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
-                });
+                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':
-                if (process.env.NODE_ENV !== 'production') {
-                    // TODO: This is currently not really needed for route handlers, as it
-                    // only controls the ISR status that's shown for pages.
-                    workUnitStore.usedDynamic = true;
-                }
                 break;
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;