Update (part 22)

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/auto-implement-methods.js

@@ -0,0 +1,71 @@
+import { HTTP_METHODS } from '../../../web/http';
+const AUTOMATIC_ROUTE_METHODS = [
+    'HEAD',
+    'OPTIONS'
+];
+function handleMethodNotAllowedResponse() {
+    return new Response(null, {
+        status: 405
+    });
+}
+export function autoImplementMethods(handlers) {
+    // Loop through all the HTTP methods to create the initial methods object.
+    // Each of the methods will be set to the 405 response handler.
+    const methods = HTTP_METHODS.reduce((acc, method)=>({
+            ...acc,
+            // If the userland module implements the method, then use it. Otherwise,
+            // use the 405 response handler.
+            [method]: handlers[method] ?? handleMethodNotAllowedResponse
+        }), {});
+    // Get all the methods that could be automatically implemented that were not
+    // implemented by the userland module.
+    const implemented = new Set(HTTP_METHODS.filter((method)=>handlers[method]));
+    const missing = AUTOMATIC_ROUTE_METHODS.filter((method)=>!implemented.has(method));
+    // Loop over the missing methods to automatically implement them if we can.
+    for (const method of missing){
+        // If the userland module doesn't implement the HEAD method, then
+        // we'll automatically implement it by calling the GET method (if it
+        // exists).
+        if (method === 'HEAD') {
+            if (handlers.GET) {
+                // Implement the HEAD method by calling the GET method.
+                methods.HEAD = handlers.GET;
+                // Mark it as implemented.
+                implemented.add('HEAD');
+            }
+            continue;
+        }
+        // If OPTIONS is not provided then implement it.
+        if (method === 'OPTIONS') {
+            // TODO: check if HEAD is implemented, if so, use it to add more headers
+            // Get all the methods that were implemented by the userland module.
+            const allow = [
+                'OPTIONS',
+                ...implemented
+            ];
+            // If the list of methods doesn't include HEAD, but it includes GET, then
+            // add HEAD as it's automatically implemented.
+            if (!implemented.has('HEAD') && implemented.has('GET')) {
+                allow.push('HEAD');
+            }
+            // Sort and join the list with commas to create the `Allow` header. See:
+            // https://httpwg.org/specs/rfc9110.html#field.allow
+            const headers = {
+                Allow: allow.sort().join(', ')
+            };
+            // Implement the OPTIONS method by returning a 204 response with the
+            // `Allow` header.
+            methods.OPTIONS = ()=>new Response(null, {
+                    status: 204,
+                    headers
+                });
+            // Mark this method as implemented.
+            implemented.add('OPTIONS');
+            continue;
+        }
+        throw new Error(`Invariant: should handle all automatic implementable methods, got method: ${method}`);
+    }
+    return methods;
+}
+
+//# sourceMappingURL=auto-implement-methods.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/auto-implement-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/app-route/helpers/auto-implement-methods.ts"],"sourcesContent":["import type { AppRouteHandlerFn, AppRouteHandlers } from '../module'\n\nimport { HTTP_METHODS, type HTTP_METHOD } from '../../../web/http'\n\nconst AUTOMATIC_ROUTE_METHODS = ['HEAD', 'OPTIONS'] as const\n\nfunction handleMethodNotAllowedResponse(): Response {\n  return new Response(null, { status: 405 })\n}\n\nexport function autoImplementMethods(\n  handlers: AppRouteHandlers\n): Record<HTTP_METHOD, AppRouteHandlerFn> {\n  // Loop through all the HTTP methods to create the initial methods object.\n  // Each of the methods will be set to the 405 response handler.\n  const methods: Record<HTTP_METHOD, AppRouteHandlerFn> = HTTP_METHODS.reduce(\n    (acc, method) => ({\n      ...acc,\n      // If the userland module implements the method, then use it. Otherwise,\n      // use the 405 response handler.\n      [method]: handlers[method] ?? handleMethodNotAllowedResponse,\n    }),\n    {} as Record<HTTP_METHOD, AppRouteHandlerFn>\n  )\n\n  // Get all the methods that could be automatically implemented that were not\n  // implemented by the userland module.\n  const implemented = new Set(HTTP_METHODS.filter((method) => handlers[method]))\n  const missing = AUTOMATIC_ROUTE_METHODS.filter(\n    (method) => !implemented.has(method)\n  )\n\n  // Loop over the missing methods to automatically implement them if we can.\n  for (const method of missing) {\n    // If the userland module doesn't implement the HEAD method, then\n    // we'll automatically implement it by calling the GET method (if it\n    // exists).\n    if (method === 'HEAD') {\n      if (handlers.GET) {\n        // Implement the HEAD method by calling the GET method.\n        methods.HEAD = handlers.GET\n\n        // Mark it as implemented.\n        implemented.add('HEAD')\n      }\n      continue\n    }\n\n    // If OPTIONS is not provided then implement it.\n    if (method === 'OPTIONS') {\n      // TODO: check if HEAD is implemented, if so, use it to add more headers\n\n      // Get all the methods that were implemented by the userland module.\n      const allow: HTTP_METHOD[] = ['OPTIONS', ...implemented]\n\n      // If the list of methods doesn't include HEAD, but it includes GET, then\n      // add HEAD as it's automatically implemented.\n      if (!implemented.has('HEAD') && implemented.has('GET')) {\n        allow.push('HEAD')\n      }\n\n      // Sort and join the list with commas to create the `Allow` header. See:\n      // https://httpwg.org/specs/rfc9110.html#field.allow\n      const headers = { Allow: allow.sort().join(', ') }\n\n      // Implement the OPTIONS method by returning a 204 response with the\n      // `Allow` header.\n      methods.OPTIONS = () => new Response(null, { status: 204, headers })\n\n      // Mark this method as implemented.\n      implemented.add('OPTIONS')\n\n      continue\n    }\n\n    throw new Error(\n      `Invariant: should handle all automatic implementable methods, got method: ${method}`\n    )\n  }\n\n  return methods\n}\n"],"names":["HTTP_METHODS","AUTOMATIC_ROUTE_METHODS","handleMethodNotAllowedResponse","Response","status","autoImplementMethods","handlers","methods","reduce","acc","method","implemented","Set","filter","missing","has","GET","HEAD","add","allow","push","headers","Allow","sort","join","OPTIONS","Error"],"mappings":"AAEA,SAASA,YAAY,QAA0B,oBAAmB;AAElE,MAAMC,0BAA0B;IAAC;IAAQ;CAAU;AAEnD,SAASC;IACP,OAAO,IAAIC,SAAS,MAAM;QAAEC,QAAQ;IAAI;AAC1C;AAEA,OAAO,SAASC,qBACdC,QAA0B;IAE1B,0EAA0E;IAC1E,+DAA+D;IAC/D,MAAMC,UAAkDP,aAAaQ,MAAM,CACzE,CAACC,KAAKC,SAAY,CAAA;YAChB,GAAGD,GAAG;YACN,wEAAwE;YACxE,gCAAgC;YAChC,CAACC,OAAO,EAAEJ,QAAQ,CAACI,OAAO,IAAIR;QAChC,CAAA,GACA,CAAC;IAGH,4EAA4E;IAC5E,sCAAsC;IACtC,MAAMS,cAAc,IAAIC,IAAIZ,aAAaa,MAAM,CAAC,CAACH,SAAWJ,QAAQ,CAACI,OAAO;IAC5E,MAAMI,UAAUb,wBAAwBY,MAAM,CAC5C,CAACH,SAAW,CAACC,YAAYI,GAAG,CAACL;IAG/B,2EAA2E;IAC3E,KAAK,MAAMA,UAAUI,QAAS;QAC5B,iEAAiE;QACjE,oEAAoE;QACpE,WAAW;QACX,IAAIJ,WAAW,QAAQ;YACrB,IAAIJ,SAASU,GAAG,EAAE;gBAChB,uDAAuD;gBACvDT,QAAQU,IAAI,GAAGX,SAASU,GAAG;gBAE3B,0BAA0B;gBAC1BL,YAAYO,GAAG,CAAC;YAClB;YACA;QACF;QAEA,gDAAgD;QAChD,IAAIR,WAAW,WAAW;YACxB,wEAAwE;YAExE,oEAAoE;YACpE,MAAMS,QAAuB;gBAAC;mBAAcR;aAAY;YAExD,yEAAyE;YACzE,8CAA8C;YAC9C,IAAI,CAACA,YAAYI,GAAG,CAAC,WAAWJ,YAAYI,GAAG,CAAC,QAAQ;gBACtDI,MAAMC,IAAI,CAAC;YACb;YAEA,wEAAwE;YACxE,oDAAoD;YACpD,MAAMC,UAAU;gBAAEC,OAAOH,MAAMI,IAAI,GAAGC,IAAI,CAAC;YAAM;YAEjD,oEAAoE;YACpE,kBAAkB;YAClBjB,QAAQkB,OAAO,GAAG,IAAM,IAAItB,SAAS,MAAM;oBAAEC,QAAQ;oBAAKiB;gBAAQ;YAElE,mCAAmC;YACnCV,YAAYO,GAAG,CAAC;YAEhB;QACF;QAEA,MAAM,IAAIQ,MACR,CAAC,0EAA0E,EAAEhB,QAAQ;IAEzF;IAEA,OAAOH;AACT","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/clean-url.js

@@ -0,0 +1,14 @@
+/**
+ * Cleans a URL by stripping the protocol, host, and search params.
+ *
+ * @param urlString the url to clean
+ * @returns the cleaned url
+ */ export function cleanURL(url) {
+    const u = new URL(url);
+    u.host = 'localhost:3000';
+    u.search = '';
+    u.protocol = 'http';
+    return u;
+}
+
+//# sourceMappingURL=clean-url.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/clean-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/app-route/helpers/clean-url.ts"],"sourcesContent":["/**\n * Cleans a URL by stripping the protocol, host, and search params.\n *\n * @param urlString the url to clean\n * @returns the cleaned url\n */\n\nexport function cleanURL(url: string | URL): URL {\n  const u = new URL(url)\n  u.host = 'localhost:3000'\n  u.search = ''\n  u.protocol = 'http'\n  return u\n}\n"],"names":["cleanURL","url","u","URL","host","search","protocol"],"mappings":"AAAA;;;;;CAKC,GAED,OAAO,SAASA,SAASC,GAAiB;IACxC,MAAMC,IAAI,IAAIC,IAAIF;IAClBC,EAAEE,IAAI,GAAG;IACTF,EAAEG,MAAM,GAAG;IACXH,EAAEI,QAAQ,GAAG;IACb,OAAOJ;AACT","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/get-pathname-from-absolute-path.js

@@ -0,0 +1,19 @@
+/**
+ * Get pathname from absolute path.
+ *
+ * @param absolutePath the absolute path
+ * @returns the pathname
+ */ export function getPathnameFromAbsolutePath(absolutePath) {
+    // Remove prefix including app dir
+    let appDir = '/app/';
+    if (!absolutePath.includes(appDir)) {
+        appDir = '\\app\\';
+    }
+    const [, ...parts] = absolutePath.split(appDir);
+    const relativePath = appDir[0] + parts.join(appDir);
+    // remove extension
+    const pathname = relativePath.split('.').slice(0, -1).join('.');
+    return pathname;
+}
+
+//# sourceMappingURL=get-pathname-from-absolute-path.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/get-pathname-from-absolute-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/app-route/helpers/get-pathname-from-absolute-path.ts"],"sourcesContent":["/**\n * Get pathname from absolute path.\n *\n * @param absolutePath the absolute path\n * @returns the pathname\n */\nexport function getPathnameFromAbsolutePath(absolutePath: string) {\n  // Remove prefix including app dir\n  let appDir = '/app/'\n  if (!absolutePath.includes(appDir)) {\n    appDir = '\\\\app\\\\'\n  }\n  const [, ...parts] = absolutePath.split(appDir)\n  const relativePath = appDir[0] + parts.join(appDir)\n\n  // remove extension\n  const pathname = relativePath.split('.').slice(0, -1).join('.')\n  return pathname\n}\n"],"names":["getPathnameFromAbsolutePath","absolutePath","appDir","includes","parts","split","relativePath","join","pathname","slice"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,SAASA,4BAA4BC,YAAoB;IAC9D,kCAAkC;IAClC,IAAIC,SAAS;IACb,IAAI,CAACD,aAAaE,QAAQ,CAACD,SAAS;QAClCA,SAAS;IACX;IACA,MAAM,GAAG,GAAGE,MAAM,GAAGH,aAAaI,KAAK,CAACH;IACxC,MAAMI,eAAeJ,MAAM,CAAC,EAAE,GAAGE,MAAMG,IAAI,CAACL;IAE5C,mBAAmB;IACnB,MAAMM,WAAWF,aAAaD,KAAK,CAAC,KAAKI,KAAK,CAAC,GAAG,CAAC,GAAGF,IAAI,CAAC;IAC3D,OAAOC;AACT","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/is-static-gen-enabled.js

@@ -0,0 +1,12 @@
+// route handlers are only statically optimized if they define
+// one of these top-level configs manually
+//   - dynamic = 'force-static'
+//   - dynamic = 'error'
+//   - revalidate > 0
+//   - revalidate = false
+//   - generateStaticParams
+export function isStaticGenEnabled(mod) {
+    return mod.dynamic === 'force-static' || mod.dynamic === 'error' || mod.revalidate === false || mod.revalidate !== undefined && mod.revalidate > 0 || typeof mod.generateStaticParams == 'function';
+}
+
+//# sourceMappingURL=is-static-gen-enabled.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/is-static-gen-enabled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/app-route/helpers/is-static-gen-enabled.ts"],"sourcesContent":["import type { AppRouteModule } from '../module.compiled'\n\n// route handlers are only statically optimized if they define\n// one of these top-level configs manually\n//   - dynamic = 'force-static'\n//   - dynamic = 'error'\n//   - revalidate > 0\n//   - revalidate = false\n//   - generateStaticParams\nexport function isStaticGenEnabled(\n  mod: AppRouteModule['routeModule']['userland']\n) {\n  return (\n    mod.dynamic === 'force-static' ||\n    mod.dynamic === 'error' ||\n    mod.revalidate === false ||\n    (mod.revalidate !== undefined && mod.revalidate > 0) ||\n    typeof mod.generateStaticParams == 'function'\n  )\n}\n"],"names":["isStaticGenEnabled","mod","dynamic","revalidate","undefined","generateStaticParams"],"mappings":"AAEA,8DAA8D;AAC9D,0CAA0C;AAC1C,+BAA+B;AAC/B,wBAAwB;AACxB,qBAAqB;AACrB,yBAAyB;AACzB,2BAA2B;AAC3B,OAAO,SAASA,mBACdC,GAA8C;IAE9C,OACEA,IAAIC,OAAO,KAAK,kBAChBD,IAAIC,OAAO,KAAK,WAChBD,IAAIE,UAAU,KAAK,SAClBF,IAAIE,UAAU,KAAKC,aAAaH,IAAIE,UAAU,GAAG,KAClD,OAAOF,IAAII,oBAAoB,IAAI;AAEvC","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/parsed-url-query-to-params.js

@@ -0,0 +1,15 @@
+/**
+ * Converts the query into params.
+ *
+ * @param query the query to convert to params
+ * @returns the params
+ */ export function parsedUrlQueryToParams(query) {
+    const params = {};
+    for (const [key, value] of Object.entries(query)){
+        if (typeof value === 'undefined') continue;
+        params[key] = value;
+    }
+    return params;
+}
+
+//# sourceMappingURL=parsed-url-query-to-params.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/helpers/parsed-url-query-to-params.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/app-route/helpers/parsed-url-query-to-params.ts"],"sourcesContent":["import type { ParsedUrlQuery } from 'querystring'\n\n/**\n * Converts the query into params.\n *\n * @param query the query to convert to params\n * @returns the params\n */\nexport function parsedUrlQueryToParams(\n  query: ParsedUrlQuery\n): Record<string, string | string[]> {\n  const params: Record<string, string | string[]> = {}\n\n  for (const [key, value] of Object.entries(query)) {\n    if (typeof value === 'undefined') continue\n    params[key] = value\n  }\n\n  return params\n}\n"],"names":["parsedUrlQueryToParams","query","params","key","value","Object","entries"],"mappings":"AAEA;;;;;CAKC,GACD,OAAO,SAASA,uBACdC,KAAqB;IAErB,MAAMC,SAA4C,CAAC;IAEnD,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACL,OAAQ;QAChD,IAAI,OAAOG,UAAU,aAAa;QAClCF,MAAM,CAACC,IAAI,GAAGC;IAChB;IAEA,OAAOF;AACT","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/module.compiled.d.ts

@@ -0,0 +1 @@
+export * from './module'

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/module.compiled.js

@@ -0,0 +1,35 @@
+if (process.env.NEXT_RUNTIME === 'edge') {
+    module.exports = require('next/dist/server/route-modules/app-route/module.js');
+} else {
+    if (process.env.__NEXT_EXPERIMENTAL_REACT) {
+        if (process.env.NODE_ENV === 'development') {
+            if (process.env.TURBOPACK) {
+                module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.dev.js');
+            } else {
+                module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.dev.js');
+            }
+        } else {
+            if (process.env.TURBOPACK) {
+                module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.prod.js');
+            } else {
+                module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.prod.js');
+            }
+        }
+    } else {
+        if (process.env.NODE_ENV === 'development') {
+            if (process.env.TURBOPACK) {
+                module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.dev.js');
+            } else {
+                module.exports = require('next/dist/compiled/next-server/app-route.runtime.dev.js');
+            }
+        } else {
+            if (process.env.TURBOPACK) {
+                module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.prod.js');
+            } else {
+                module.exports = require('next/dist/compiled/next-server/app-route.runtime.prod.js');
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=module.compiled.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/module.compiled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/app-route/module.compiled.js"],"sourcesContent":["if (process.env.NEXT_RUNTIME === 'edge') {\n  module.exports = require('next/dist/server/route-modules/app-route/module.js')\n} else {\n  if (process.env.__NEXT_EXPERIMENTAL_REACT) {\n    if (process.env.NODE_ENV === 'development') {\n      if (process.env.TURBOPACK) {\n        module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.dev.js')\n      } else {\n        module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.dev.js')\n      }\n    } else {\n      if (process.env.TURBOPACK) {\n        module.exports = require('next/dist/compiled/next-server/app-route-turbo-experimental.runtime.prod.js')\n      } else {\n        module.exports = require('next/dist/compiled/next-server/app-route-experimental.runtime.prod.js')\n      }\n    }\n  } else {\n    if (process.env.NODE_ENV === 'development') {\n      if (process.env.TURBOPACK) {\n        module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.dev.js')\n      } else {\n        module.exports = require('next/dist/compiled/next-server/app-route.runtime.dev.js')\n      }\n    } else {\n      if (process.env.TURBOPACK) {\n        module.exports = require('next/dist/compiled/next-server/app-route-turbo.runtime.prod.js')\n      } else {\n        module.exports = require('next/dist/compiled/next-server/app-route.runtime.prod.js')\n      }\n    }\n  }\n}\n"],"names":["process","env","NEXT_RUNTIME","module","exports","require","__NEXT_EXPERIMENTAL_REACT","NODE_ENV","TURBOPACK"],"mappings":"AAAA,IAAIA,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;IACvCC,OAAOC,OAAO,GAAGC,QAAQ;AAC3B,OAAO;IACL,IAAIL,QAAQC,GAAG,CAACK,yBAAyB,EAAE;QACzC,IAAIN,QAAQC,GAAG,CAACM,QAAQ,KAAK,eAAe;YAC1C,IAAIP,QAAQC,GAAG,CAACO,SAAS,EAAE;gBACzBL,OAAOC,OAAO,GAAGC,QAAQ;YAC3B,OAAO;gBACLF,OAAOC,OAAO,GAAGC,QAAQ;YAC3B;QACF,OAAO;YACL,IAAIL,QAAQC,GAAG,CAACO,SAAS,EAAE;gBACzBL,OAAOC,OAAO,GAAGC,QAAQ;YAC3B,OAAO;gBACLF,OAAOC,OAAO,GAAGC,QAAQ;YAC3B;QACF;IACF,OAAO;QACL,IAAIL,QAAQC,GAAG,CAACM,QAAQ,KAAK,eAAe;YAC1C,IAAIP,QAAQC,GAAG,CAACO,SAAS,EAAE;gBACzBL,OAAOC,OAAO,GAAGC,QAAQ;YAC3B,OAAO;gBACLF,OAAOC,OAAO,GAAGC,QAAQ;YAC3B;QACF,OAAO;YACL,IAAIL,QAAQC,GAAG,CAACO,SAAS,EAAE;gBACzBL,OAAOC,OAAO,GAAGC,QAAQ;YAC3B,OAAO;gBACLF,OAAOC,OAAO,GAAGC,QAAQ;YAC3B;QACF;IACF;AACF","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/module.js

@@ -0,0 +1,854 @@
+import { RouteModule } from '../route-module';
+import { createRequestStoreForAPI } from '../../async-storage/request-store';
+import { createPrerenderWorkStore, createWorkStore } from '../../async-storage/work-store';
+import { HTTP_METHODS, isHTTPMethod } from '../../web/http';
+import { getImplicitTags } from '../../lib/implicit-tags';
+import { patchFetch } from '../../lib/patch-fetch';
+import { getTracer } from '../../lib/trace/tracer';
+import { AppRouteRouteHandlersSpan, AppRouteRouteModuleSpan } from '../../lib/trace/constants';
+import * as Log from '../../../build/output/log';
+import { autoImplementMethods } from './helpers/auto-implement-methods';
+import { appendMutableCookies } from '../../web/spec-extension/adapters/request-cookies';
+import { HeadersAdapter } from '../../web/spec-extension/adapters/headers';
+import { RequestCookiesAdapter } from '../../web/spec-extension/adapters/request-cookies';
+import { parsedUrlQueryToParams } from './helpers/parsed-url-query-to-params';
+import { Phase, printDebugThrownValueForProspectiveRender } from '../../app-render/prospective-render-utils';
+import * as serverHooks from '../../../client/components/hooks-server-context';
+import { DynamicServerError } from '../../../client/components/hooks-server-context';
+import { workAsyncStorage } from '../../app-render/work-async-storage.external';
+import { workUnitAsyncStorage } from '../../app-render/work-unit-async-storage.external';
+import { actionAsyncStorage } from '../../app-render/action-async-storage.external';
+import * as sharedModules from './shared-modules';
+import { getIsPossibleServerAction } from '../../lib/server-action-request-meta';
+import { RequestCookies } from 'next/dist/compiled/@edge-runtime/cookies';
+import { cleanURL } from './helpers/clean-url';
+import { StaticGenBailoutError } from '../../../client/components/static-generation-bailout';
+import { isStaticGenEnabled } from './helpers/is-static-gen-enabled';
+import { abortAndThrowOnSynchronousRequestDataAccess, createDynamicTrackingState, getFirstDynamicReason } from '../../app-render/dynamic-rendering';
+import { ReflectAdapter } from '../../web/spec-extension/adapters/reflect';
+import { CacheSignal } from '../../app-render/cache-signal';
+import { scheduleImmediate } from '../../../lib/scheduler';
+import { createServerParamsForRoute } from '../../request/params';
+import { getRedirectStatusCodeFromError, getURLFromRedirectError } from '../../../client/components/redirect';
+import { isRedirectError } from '../../../client/components/redirect-error';
+import { getAccessFallbackHTTPStatus, isHTTPAccessFallbackError } from '../../../client/components/http-access-fallback/http-access-fallback';
+import { RedirectStatusCode } from '../../../client/components/redirect-status-code';
+import { INFINITE_CACHE } from '../../../lib/constants';
+import { executeRevalidates } from '../../revalidation-utils';
+import { trackPendingModules } from '../../app-render/module-loading/track-module-loading.external';
+import { InvariantError } from '../../../shared/lib/invariant-error';
+import { LazyModule } from '../../lib/lazy-module';
+import { createPrerenderResumeDataCache } from '../../resume-data-cache/resume-data-cache';
+import { createRouteHandlerRequestInUseCacheError, createRouteHandlerRequestInUnstableCacheError } from '../../use-cache/use-cache-messages';
+export class WrappedNextRouterError {
+    constructor(error, headers){
+        this.error = error;
+        this.headers = headers;
+    }
+}
+/**
+ * AppRouteRouteHandler is the handler for app routes.
+ */ export class AppRouteRouteModule extends 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 = workUnitAsyncStorage, /**
+   * A reference to the static generation async storage.
+   */ this.workAsyncStorage = workAsyncStorage, /**
+   * An interface to call server hooks which interact with the underlying
+   * storage.
+   */ this.serverHooks = serverHooks, /**
+   * A reference to the mutation related async storage, such as mutations of
+   * cookies.
+   */ this.actionAsyncStorage = actionAsyncStorage;
+        this.resolvedPagePath = resolvedPagePath;
+        this.nextConfigOutput = nextConfigOutput;
+        this._getUserland = getUserland;
+        this._lazyUserland = new LazyModule(()=>getTracer().trace(AppRouteRouteModuleSpan.loadUserland, {
+                spanName: 'load app route module',
+                attributes: {
+                    'next.route': this.definition.pathname
+                }
+            }, userland), (module)=>this._onUserlandLoaded(module));
+        // 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 = 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 (!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_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_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 (!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 (!isHTTPMethod(method)) return ()=>new Response(null, {
+                status: 400
+            });
+        return autoImplementMethods(userland)[method];
+    }
+    resolvePendingRevalidations(workStore, requestStore, context) {
+        const maybeRevalidatesPromise = 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 (isRedirectError(err)) {
+            const url = 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.
+            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.SeeOther : getRedirectStatusCodeFromError(err),
+                headers
+            });
+        }
+        if (isHTTPAccessFallbackError(err)) {
+            const httpStatus = 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 (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.
+        patchFetch({
+            workAsyncStorage: this.workAsyncStorage,
+            workUnitAsyncStorage: this.workUnitAsyncStorage
+        });
+        const handlerContext = {
+            params: context.params ? createServerParamsForRoute(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 ? 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(null);
+                let dynamicTracking = 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 = 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: INFINITE_CACHE,
+                    stale: 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) {
+                        printDebugThrownValueForProspectiveRender(err, workStore.route, 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) {
+                            printDebugThrownValueForProspectiveRender(err, workStore.route, Phase.ProspectiveRender);
+                        }
+                    });
+                }
+                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 = getFirstDynamicReason(dynamicTracking);
+                    if (dynamicReason) {
+                        throw new 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 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 = 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: INFINITE_CACHE,
+                    stale: 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)=>{
+                    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);
+                            scheduleImmediate(()=>{
+                                if (!bodyHandled) {
+                                    bodyHandled = true;
+                                    finalController.abort();
+                                    reject(createCacheComponentsError(workStore.route));
+                                }
+                            });
+                        } catch (err) {
+                            reject(err);
+                        }
+                    });
+                    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: INFINITE_CACHE,
+                    stale: INFINITE_CACHE,
+                    tags: [
+                        ...implicitTags.tags
+                    ]
+                };
+                res = await 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.
+        patchFetch({
+            workAsyncStorage: this.workAsyncStorage,
+            workUnitAsyncStorage: this.workUnitAsyncStorage
+        });
+        const handlerContext = {
+            params: context.params ? createServerParamsForRoute(parsedUrlQueryToParams(context.params)) : undefined
+        };
+        let res;
+        try {
+            res = await 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: getIsPossibleServerAction(req)
+        };
+        const implicitTags = await getImplicitTags(this.definition.page, req.nextUrl.pathname, // App Routes don't support unknown route params.
+        null);
+        const 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 = getTracer();
+                    const { pathname } = this.definition;
+                    tracer.setRootSpanAttribute('next.route', pathname);
+                    return tracer.trace(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 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 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 = getTracer();
+                    const { pathname } = this.definition;
+                    tracer.setRootSpanAttribute('next.route', pathname);
+                    return tracer.trace(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 = 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 = createPrerenderWorkStore({
+            page: this.definition.page,
+            renderOpts: context.renderOpts,
+            buildId: context.sharedContext.buildId,
+            deploymentId: context.sharedContext.deploymentId,
+            previouslyRevalidatedTags: []
+        });
+        return this.executePrerender(req, context, prepared, workStore);
+    }
+}
+export default AppRouteRouteModule;
+/**
+ * Gets all the method names for handlers that are not considered static.
+ *
+ * @param handlers the handlers from the userland module
+ * @returns the method names that are not considered static or false if all
+ *          methods are static
+ */ export 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] = HeadersAdapter.seal(new Headers({})));
+            case 'cookies':
+                return target[cookiesSymbol] || (target[cookiesSymbol] = RequestCookiesAdapter.seal(new 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 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] = 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 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 = workUnitAsyncStorage.getStore();
+                        trackDynamic(workStore, workUnitStore, `nextUrl.${prop}`);
+                        return ReflectAdapter.get(target, prop, receiver);
+                    }
+                case 'clone':
+                    return target[urlCloneSymbol] || (target[urlCloneSymbol] = ()=>new Proxy(target.clone(), nextUrlHandlers));
+                default:
+                    return 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 = 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 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 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 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 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 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 ReflectAdapter.get(target, prop, receiver);
+        }
+    }
+};
+function createCacheComponentsError(route) {
+    return new 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 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 createRouteHandlerRequestInUseCacheError(store.route, expression);
+            case 'unstable-cache':
+                throw 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 abortAndThrowOnSynchronousRequestDataAccess(store.route, expression, error, workUnitStore);
+            case 'prerender-client':
+            case 'validation-client':
+                throw new InvariantError('A client prerender store should not be used for a route handler.');
+            case 'prerender-runtime':
+                throw new InvariantError('A runtime prerender store should not be used for a route handler.');
+            case 'prerender-legacy':
+                workUnitStore.revalidate = 0;
+                const err = new 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

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/module.js.map

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

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/shared-modules.js

@@ -0,0 +1,5 @@
+// the name of the export has to be the camelCase version of the file name (without the extension)
+// TODO: remove this. We need it because using notFound from next/navigation imports this file :(
+export * as appRouterContext from '../../../shared/lib/app-router-context.shared-runtime';
+
+//# sourceMappingURL=shared-modules.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/app-route/shared-modules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/app-route/shared-modules.ts"],"sourcesContent":["// the name of the export has to be the camelCase version of the file name (without the extension)\n// TODO: remove this. We need it because using notFound from next/navigation imports this file :(\nexport * as appRouterContext from '../../../shared/lib/app-router-context.shared-runtime'\n"],"names":["appRouterContext"],"mappings":"AAAA,kGAAkG;AAClG,iGAAiG;AACjG,OAAO,KAAKA,gBAAgB,MAAM,wDAAuD","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/checks.js

@@ -0,0 +1,15 @@
+import { RouteKind } from '../route-kind';
+export function isAppRouteRouteModule(routeModule) {
+    return routeModule.definition.kind === RouteKind.APP_ROUTE;
+}
+export function isAppPageRouteModule(routeModule) {
+    return routeModule.definition.kind === RouteKind.APP_PAGE;
+}
+export function isPagesRouteModule(routeModule) {
+    return routeModule.definition.kind === RouteKind.PAGES;
+}
+export function isPagesAPIRouteModule(routeModule) {
+    return routeModule.definition.kind === RouteKind.PAGES_API;
+}
+
+//# sourceMappingURL=checks.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/checks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/route-modules/checks.ts"],"sourcesContent":["import type { AppRouteRouteModule } from './app-route/module'\nimport type { AppPageRouteModule } from './app-page/module'\nimport type { PagesRouteModule } from './pages/module'\nimport type { PagesAPIRouteModule } from './pages-api/module'\n\nimport type { RouteModule } from './route-module'\n\nimport { RouteKind } from '../route-kind'\n\nexport function isAppRouteRouteModule(\n  routeModule: RouteModule\n): routeModule is AppRouteRouteModule {\n  return routeModule.definition.kind === RouteKind.APP_ROUTE\n}\n\nexport function isAppPageRouteModule(\n  routeModule: RouteModule\n): routeModule is AppPageRouteModule {\n  return routeModule.definition.kind === RouteKind.APP_PAGE\n}\n\nexport function isPagesRouteModule(\n  routeModule: RouteModule\n): routeModule is PagesRouteModule {\n  return routeModule.definition.kind === RouteKind.PAGES\n}\n\nexport function isPagesAPIRouteModule(\n  routeModule: RouteModule\n): routeModule is PagesAPIRouteModule {\n  return routeModule.definition.kind === RouteKind.PAGES_API\n}\n"],"names":["RouteKind","isAppRouteRouteModule","routeModule","definition","kind","APP_ROUTE","isAppPageRouteModule","APP_PAGE","isPagesRouteModule","PAGES","isPagesAPIRouteModule","PAGES_API"],"mappings":"AAOA,SAASA,SAAS,QAAQ,gBAAe;AAEzC,OAAO,SAASC,sBACdC,WAAwB;IAExB,OAAOA,YAAYC,UAAU,CAACC,IAAI,KAAKJ,UAAUK,SAAS;AAC5D;AAEA,OAAO,SAASC,qBACdJ,WAAwB;IAExB,OAAOA,YAAYC,UAAU,CAACC,IAAI,KAAKJ,UAAUO,QAAQ;AAC3D;AAEA,OAAO,SAASC,mBACdN,WAAwB;IAExB,OAAOA,YAAYC,UAAU,CAACC,IAAI,KAAKJ,UAAUS,KAAK;AACxD;AAEA,OAAO,SAASC,sBACdR,WAAwB;IAExB,OAAOA,YAAYC,UAAU,CAACC,IAAI,KAAKJ,UAAUW,SAAS;AAC5D","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages-api/module.compiled.d.ts

@@ -0,0 +1 @@
+export * from './module'

e-commerce/node_modules/next/dist/esm/server/route-modules/pages-api/module.compiled.js

@@ -0,0 +1,19 @@
+if (process.env.NEXT_RUNTIME === 'edge') {
+    module.exports = require('next/dist/server/route-modules/pages-api/module.js');
+} else {
+    if (process.env.NODE_ENV === 'development') {
+        if (process.env.TURBOPACK) {
+            module.exports = require('next/dist/compiled/next-server/pages-api-turbo.runtime.dev.js');
+        } else {
+            module.exports = require('next/dist/compiled/next-server/pages-api.runtime.dev.js');
+        }
+    } else {
+        if (process.env.TURBOPACK) {
+            module.exports = require('next/dist/compiled/next-server/pages-api-turbo.runtime.prod.js');
+        } else {
+            module.exports = require('next/dist/compiled/next-server/pages-api.runtime.prod.js');
+        }
+    }
+}
+
+//# sourceMappingURL=module.compiled.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages-api/module.compiled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages-api/module.compiled.js"],"sourcesContent":["if (process.env.NEXT_RUNTIME === 'edge') {\n  module.exports = require('next/dist/server/route-modules/pages-api/module.js')\n} else {\n  if (process.env.NODE_ENV === 'development') {\n    if (process.env.TURBOPACK) {\n      module.exports = require('next/dist/compiled/next-server/pages-api-turbo.runtime.dev.js')\n    } else {\n      module.exports = require('next/dist/compiled/next-server/pages-api.runtime.dev.js')\n    }\n  } else {\n    if (process.env.TURBOPACK) {\n      module.exports = require('next/dist/compiled/next-server/pages-api-turbo.runtime.prod.js')\n    } else {\n      module.exports = require('next/dist/compiled/next-server/pages-api.runtime.prod.js')\n    }\n  }\n}\n"],"names":["process","env","NEXT_RUNTIME","module","exports","require","NODE_ENV","TURBOPACK"],"mappings":"AAAA,IAAIA,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;IACvCC,OAAOC,OAAO,GAAGC,QAAQ;AAC3B,OAAO;IACL,IAAIL,QAAQC,GAAG,CAACK,QAAQ,KAAK,eAAe;QAC1C,IAAIN,QAAQC,GAAG,CAACM,SAAS,EAAE;YACzBJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF,OAAO;QACL,IAAIL,QAAQC,GAAG,CAACM,SAAS,EAAE;YACzBJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF;AACF","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages-api/module.js

@@ -0,0 +1,32 @@
+import { wrapApiHandler } from '../../api-utils';
+import { RouteModule } from '../route-module';
+import { apiResolver } from '../../api-utils/node/api-resolver';
+export class PagesAPIRouteModule extends RouteModule {
+    constructor(options){
+        super(options);
+        if (typeof options.userland.default !== 'function') {
+            throw new Error(`Page ${options.definition.page} does not export a default function.`);
+        }
+        this.apiResolverWrapped = wrapApiHandler(options.definition.page, apiResolver);
+    }
+    /**
+   *
+   * @param req the incoming server request
+   * @param res the outgoing server response
+   * @param context the context for the render
+   */ async render(req, res, context) {
+        const { apiResolverWrapped } = this;
+        await apiResolverWrapped(req, res, context.query, this.userland, {
+            ...context.previewProps,
+            trustHostHeader: context.trustHostHeader,
+            allowedRevalidateHeaderKeys: context.allowedRevalidateHeaderKeys,
+            hostname: context.hostname,
+            multiZoneDraftMode: context.multiZoneDraftMode,
+            dev: context.dev,
+            internalRevalidate: context.internalRevalidate
+        }, context.propagateError, context.dev, context.page, context.onError);
+    }
+}
+export default PagesAPIRouteModule;
+
+//# sourceMappingURL=module.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages-api/module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages-api/module.ts"],"sourcesContent":["import type { IncomingMessage, ServerResponse } from 'http'\nimport type { PagesAPIRouteDefinition } from '../../route-definitions/pages-api-route-definition'\nimport type { PageConfig } from '../../../types'\nimport type { ParsedUrlQuery } from 'querystring'\nimport { wrapApiHandler, type __ApiPreviewProps } from '../../api-utils'\nimport type { RouteModuleOptions } from '../route-module'\n\nimport { RouteModule, type RouteModuleHandleContext } from '../route-module'\nimport { apiResolver } from '../../api-utils/node/api-resolver'\nimport type { RevalidateFn } from '../../lib/router-utils/router-server-context'\n\ntype PagesAPIHandleFn = (\n  req: IncomingMessage,\n  res: ServerResponse\n) => Promise<void>\n\n/**\n * The PagesAPIModule is the type of the module exported by the bundled Pages\n * API module.\n */\nexport type PagesAPIModule = typeof import('../../../build/templates/pages-api')\n\ntype PagesAPIUserlandModule = {\n  /**\n   * The exported handler method.\n   */\n  readonly default: PagesAPIHandleFn\n\n  /**\n   * The exported page config.\n   */\n  readonly config?: PageConfig\n}\n\ntype PagesAPIRouteHandlerContext = RouteModuleHandleContext & {\n  /**\n   * The incoming server request in non-edge runtime.\n   */\n  req?: IncomingMessage\n\n  /**\n   * The outgoing server response in non-edge runtime.\n   */\n  res?: ServerResponse\n\n  /**\n   * The hostname for the request.\n   */\n  hostname?: string\n\n  /**\n   * Keys allowed in the revalidate call.\n   */\n  allowedRevalidateHeaderKeys?: string[]\n\n  /**\n   * Whether to trust the host header.\n   */\n  trustHostHeader?: boolean\n\n  /**\n   * The query for the request.\n   */\n  query: ParsedUrlQuery\n\n  /**\n   * The preview props used by the `preview` API.\n   */\n  previewProps: __ApiPreviewProps\n\n  /**\n   * True if the server is in development mode.\n   */\n  dev: boolean\n\n  /**\n   * Whether errors should be left uncaught to handle\n   * higher up\n   */\n  propagateError: boolean\n\n  /**\n   * The page that's being rendered.\n   */\n  page: string\n\n  /**\n   * The error handler for the request.\n   */\n  onError?: Parameters<typeof apiResolver>[8]\n\n  /**\n   * whether multi-zone flag is enabled for draft mode\n   */\n  multiZoneDraftMode?: boolean\n\n  /**\n   * Internal revalidate function to avoid revalidating\n   * over the network\n   */\n  internalRevalidate?: RevalidateFn\n}\n\nexport type PagesAPIRouteModuleOptions = RouteModuleOptions<\n  PagesAPIRouteDefinition,\n  PagesAPIUserlandModule\n>\n\nexport class PagesAPIRouteModule extends RouteModule<\n  PagesAPIRouteDefinition,\n  PagesAPIUserlandModule\n> {\n  private apiResolverWrapped: typeof apiResolver\n\n  constructor(options: PagesAPIRouteModuleOptions) {\n    super(options)\n\n    if (typeof options.userland.default !== 'function') {\n      throw new Error(\n        `Page ${options.definition.page} does not export a default function.`\n      )\n    }\n\n    this.apiResolverWrapped = wrapApiHandler(\n      options.definition.page,\n      apiResolver\n    )\n  }\n\n  /**\n   *\n   * @param req the incoming server request\n   * @param res the outgoing server response\n   * @param context the context for the render\n   */\n  public async render(\n    req: IncomingMessage,\n    res: ServerResponse,\n    context: PagesAPIRouteHandlerContext\n  ): Promise<void> {\n    const { apiResolverWrapped } = this\n    await apiResolverWrapped(\n      req,\n      res,\n      context.query,\n      this.userland,\n      {\n        ...context.previewProps,\n        trustHostHeader: context.trustHostHeader,\n        allowedRevalidateHeaderKeys: context.allowedRevalidateHeaderKeys,\n        hostname: context.hostname,\n        multiZoneDraftMode: context.multiZoneDraftMode,\n        dev: context.dev,\n        internalRevalidate: context.internalRevalidate,\n      },\n      context.propagateError,\n      context.dev,\n      context.page,\n      context.onError\n    )\n  }\n}\n\nexport default PagesAPIRouteModule\n"],"names":["wrapApiHandler","RouteModule","apiResolver","PagesAPIRouteModule","constructor","options","userland","default","Error","definition","page","apiResolverWrapped","render","req","res","context","query","previewProps","trustHostHeader","allowedRevalidateHeaderKeys","hostname","multiZoneDraftMode","dev","internalRevalidate","propagateError","onError"],"mappings":"AAIA,SAASA,cAAc,QAAgC,kBAAiB;AAGxE,SAASC,WAAW,QAAuC,kBAAiB;AAC5E,SAASC,WAAW,QAAQ,oCAAmC;AAoG/D,OAAO,MAAMC,4BAA4BF;IAMvCG,YAAYC,OAAmC,CAAE;QAC/C,KAAK,CAACA;QAEN,IAAI,OAAOA,QAAQC,QAAQ,CAACC,OAAO,KAAK,YAAY;YAClD,MAAM,IAAIC,MACR,CAAC,KAAK,EAAEH,QAAQI,UAAU,CAACC,IAAI,CAAC,oCAAoC,CAAC;QAEzE;QAEA,IAAI,CAACC,kBAAkB,GAAGX,eACxBK,QAAQI,UAAU,CAACC,IAAI,EACvBR;IAEJ;IAEA;;;;;GAKC,GACD,MAAaU,OACXC,GAAoB,EACpBC,GAAmB,EACnBC,OAAoC,EACrB;QACf,MAAM,EAAEJ,kBAAkB,EAAE,GAAG,IAAI;QACnC,MAAMA,mBACJE,KACAC,KACAC,QAAQC,KAAK,EACb,IAAI,CAACV,QAAQ,EACb;YACE,GAAGS,QAAQE,YAAY;YACvBC,iBAAiBH,QAAQG,eAAe;YACxCC,6BAA6BJ,QAAQI,2BAA2B;YAChEC,UAAUL,QAAQK,QAAQ;YAC1BC,oBAAoBN,QAAQM,kBAAkB;YAC9CC,KAAKP,QAAQO,GAAG;YAChBC,oBAAoBR,QAAQQ,kBAAkB;QAChD,GACAR,QAAQS,cAAc,EACtBT,QAAQO,GAAG,EACXP,QAAQL,IAAI,EACZK,QAAQU,OAAO;IAEnB;AACF;AAEA,eAAetB,oBAAmB","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/builtin/_error.js

@@ -0,0 +1,32 @@
+import App from '../../../../pages/_app';
+import Document from '../../../../pages/_document';
+import { RouteKind } from '../../../route-kind';
+import * as moduleError from '../../../../pages/_error';
+import PagesRouteModule from '../module';
+import { getHandler } from '../pages-handler';
+export const routeModule = new PagesRouteModule({
+    // TODO: add descriptor for internal error page
+    definition: {
+        kind: RouteKind.PAGES,
+        page: '/_error',
+        pathname: '/_error',
+        filename: '',
+        bundlePath: ''
+    },
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
+    components: {
+        App,
+        Document
+    },
+    userland: moduleError
+});
+export const handler = getHandler({
+    srcPage: '/_error',
+    routeModule,
+    userland: moduleError,
+    config: {},
+    isFallbackError: true
+});
+
+//# sourceMappingURL=_error.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/builtin/_error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/builtin/_error.tsx"],"sourcesContent":["import App from '../../../../pages/_app'\nimport Document from '../../../../pages/_document'\nimport { RouteKind } from '../../../route-kind'\n\nimport * as moduleError from '../../../../pages/_error'\n\nimport PagesRouteModule from '../module'\nimport { getHandler } from '../pages-handler'\n\nexport const routeModule = new PagesRouteModule({\n  // TODO: add descriptor for internal error page\n  definition: {\n    kind: RouteKind.PAGES,\n    page: '/_error',\n    pathname: '/_error',\n    filename: '',\n    bundlePath: '',\n  },\n  distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',\n  relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',\n  components: {\n    App,\n    Document,\n  },\n  userland: moduleError,\n})\n\nexport const handler = getHandler({\n  srcPage: '/_error',\n  routeModule,\n  userland: moduleError,\n  config: {},\n  isFallbackError: true,\n})\n"],"names":["App","Document","RouteKind","moduleError","PagesRouteModule","getHandler","routeModule","definition","kind","PAGES","page","pathname","filename","bundlePath","distDir","process","env","__NEXT_RELATIVE_DIST_DIR","relativeProjectDir","__NEXT_RELATIVE_PROJECT_DIR","components","userland","handler","srcPage","config","isFallbackError"],"mappings":"AAAA,OAAOA,SAAS,yBAAwB;AACxC,OAAOC,cAAc,8BAA6B;AAClD,SAASC,SAAS,QAAQ,sBAAqB;AAE/C,YAAYC,iBAAiB,2BAA0B;AAEvD,OAAOC,sBAAsB,YAAW;AACxC,SAASC,UAAU,QAAQ,mBAAkB;AAE7C,OAAO,MAAMC,cAAc,IAAIF,iBAAiB;IAC9C,+CAA+C;IAC/CG,YAAY;QACVC,MAAMN,UAAUO,KAAK;QACrBC,MAAM;QACNC,UAAU;QACVC,UAAU;QACVC,YAAY;IACd;IACAC,SAASC,QAAQC,GAAG,CAACC,wBAAwB,IAAI;IACjDC,oBAAoBH,QAAQC,GAAG,CAACG,2BAA2B,IAAI;IAC/DC,YAAY;QACVpB;QACAC;IACF;IACAoB,UAAUlB;AACZ,GAAE;AAEF,OAAO,MAAMmB,UAAUjB,WAAW;IAChCkB,SAAS;IACTjB;IACAe,UAAUlB;IACVqB,QAAQ,CAAC;IACTC,iBAAiB;AACnB,GAAE","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.compiled.d.ts

@@ -0,0 +1 @@
+export * from './module'

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.compiled.js

@@ -0,0 +1,19 @@
+if (process.env.NEXT_RUNTIME === 'edge') {
+    module.exports = require('next/dist/server/route-modules/pages/module.js');
+} else {
+    if (process.env.NODE_ENV === 'development') {
+        if (process.env.TURBOPACK) {
+            module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.dev.js');
+        } else {
+            module.exports = require('next/dist/compiled/next-server/pages.runtime.dev.js');
+        }
+    } else {
+        if (process.env.TURBOPACK) {
+            module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.prod.js');
+        } else {
+            module.exports = require('next/dist/compiled/next-server/pages.runtime.prod.js');
+        }
+    }
+}
+
+//# sourceMappingURL=module.compiled.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.compiled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages/module.compiled.js"],"sourcesContent":["if (process.env.NEXT_RUNTIME === 'edge') {\n  module.exports = require('next/dist/server/route-modules/pages/module.js')\n} else {\n  if (process.env.NODE_ENV === 'development') {\n    if (process.env.TURBOPACK) {\n      module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.dev.js')\n    } else {\n      module.exports = require('next/dist/compiled/next-server/pages.runtime.dev.js')\n    }\n  } else {\n    if (process.env.TURBOPACK) {\n      module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.prod.js')\n    } else {\n      module.exports = require('next/dist/compiled/next-server/pages.runtime.prod.js')\n    }\n  }\n}\n"],"names":["process","env","NEXT_RUNTIME","module","exports","require","NODE_ENV","TURBOPACK"],"mappings":"AAAA,IAAIA,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;IACvCC,OAAOC,OAAO,GAAGC,QAAQ;AAC3B,OAAO;IACL,IAAIL,QAAQC,GAAG,CAACK,QAAQ,KAAK,eAAe;QAC1C,IAAIN,QAAQC,GAAG,CAACM,SAAS,EAAE;YACzBJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF,OAAO;QACL,IAAIL,QAAQC,GAAG,CAACM,SAAS,EAAE;YACzBJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF;AACF","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.js

@@ -0,0 +1,23 @@
+import { RouteModule } from '../route-module';
+import { renderToHTMLImpl, renderToHTML } from '../../render';
+import * as vendoredContexts from './vendored/contexts/entrypoints';
+export class PagesRouteModule extends RouteModule {
+    constructor(options){
+        super(options);
+        this.components = options.components;
+    }
+    render(req, res, context) {
+        return renderToHTMLImpl(req, res, context.page, context.query, context.renderOpts, {
+            App: this.components.App,
+            Document: this.components.Document
+        }, context.sharedContext, context.renderContext);
+    }
+}
+const vendored = {
+    contexts: vendoredContexts
+};
+// needed for the static build
+export { renderToHTML, vendored };
+export default PagesRouteModule;
+
+//# sourceMappingURL=module.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages/module.ts"],"sourcesContent":["import type { IncomingMessage, ServerResponse } from 'http'\nimport type {\n  GetServerSideProps,\n  GetStaticPaths,\n  GetStaticProps,\n  NextComponentType,\n  PageConfig,\n} from '../../../types'\nimport type { PagesRouteDefinition } from '../../route-definitions/pages-route-definition'\nimport type { NextParsedUrlQuery } from '../../request-meta'\nimport type {\n  PagesRenderContext,\n  PagesSharedContext,\n  RenderOpts,\n} from '../../render'\nimport type RenderResult from '../../render-result'\nimport type { AppType, DocumentType } from '../../../shared/lib/utils'\n\nimport {\n  RouteModule,\n  type RouteModuleHandleContext,\n  type RouteModuleOptions,\n} from '../route-module'\nimport { renderToHTMLImpl, renderToHTML } from '../../render'\nimport * as vendoredContexts from './vendored/contexts/entrypoints'\n\n/**\n * The PagesModule is the type of the module exported by the bundled pages\n * module.\n */\nexport type PagesModule = typeof import('../../../build/templates/pages')\n\n/**\n * The userland module for a page. This is the module that is exported from the\n * page file that contains the page component, page config, and any page data\n * fetching functions.\n */\nexport type PagesUserlandModule = {\n  /**\n   * The exported page component.\n   */\n  readonly default: NextComponentType\n\n  /**\n   * The exported page config.\n   */\n  readonly config?: PageConfig\n\n  /**\n   * The exported `getStaticProps` function.\n   */\n  readonly getStaticProps?: GetStaticProps\n\n  /**\n   * The exported `getStaticPaths` function.\n   */\n  readonly getStaticPaths?: GetStaticPaths\n\n  /**\n   * The exported `getServerSideProps` function.\n   */\n  readonly getServerSideProps?: GetServerSideProps\n}\n\n/**\n * The components that are used to render a page. These aren't tied to the\n * specific page being rendered, but rather are the components that are used to\n * render all pages.\n */\ntype PagesComponents = {\n  /**\n   * The `App` component. This could be exported by a user's custom `_app` page\n   * file, or it could be the default `App` component.\n   */\n  readonly App: AppType\n\n  /**\n   * The `Document` component. This could be exported by a user's custom\n   * `_document` page file, or it could be the default `Document` component.\n   */\n  readonly Document: DocumentType\n}\n\nexport interface PagesRouteModuleOptions\n  extends RouteModuleOptions<PagesRouteDefinition, PagesUserlandModule> {\n  readonly components: PagesComponents\n}\n\n/**\n * AppRouteRouteHandlerContext is the context that is passed to the route\n * handler for app routes.\n */\nexport interface PagesRouteHandlerContext extends RouteModuleHandleContext {\n  /**\n   * The page for the given route.\n   */\n  page: string\n\n  /**\n   * The parsed URL query for the given request.\n   */\n  query: NextParsedUrlQuery\n\n  /**\n   * The shared context used for all page renders.\n   */\n  sharedContext: PagesSharedContext\n\n  /**\n   * The context for the given request.\n   */\n  renderContext: PagesRenderContext\n\n  /**\n   * The arguments for the given request.\n  /**\n   * The RenderOpts for the given request which include the specific modules to\n   * use for rendering.\n   */\n  // TODO: (wyattjoh) break this out into smaller parts, it currently includes the userland components\n  renderOpts: Omit<RenderOpts, 'Document' | 'App'>\n}\n\nexport class PagesRouteModule extends RouteModule<\n  PagesRouteDefinition,\n  PagesUserlandModule\n> {\n  private readonly components: PagesComponents\n\n  constructor(options: PagesRouteModuleOptions) {\n    super(options)\n\n    this.components = options.components\n  }\n\n  public render(\n    req: IncomingMessage,\n    res: ServerResponse,\n    context: PagesRouteHandlerContext\n  ): Promise<RenderResult> {\n    return renderToHTMLImpl(\n      req,\n      res,\n      context.page,\n      context.query,\n      context.renderOpts,\n      {\n        App: this.components.App,\n        Document: this.components.Document,\n      },\n      context.sharedContext,\n      context.renderContext\n    )\n  }\n}\n\nconst vendored = {\n  contexts: vendoredContexts,\n}\n\n// needed for the static build\nexport { renderToHTML, vendored }\n\nexport default PagesRouteModule\n"],"names":["RouteModule","renderToHTMLImpl","renderToHTML","vendoredContexts","PagesRouteModule","constructor","options","components","render","req","res","context","page","query","renderOpts","App","Document","sharedContext","renderContext","vendored","contexts"],"mappings":"AAkBA,SACEA,WAAW,QAGN,kBAAiB;AACxB,SAASC,gBAAgB,EAAEC,YAAY,QAAQ,eAAc;AAC7D,YAAYC,sBAAsB,kCAAiC;AAmGnE,OAAO,MAAMC,yBAAyBJ;IAMpCK,YAAYC,OAAgC,CAAE;QAC5C,KAAK,CAACA;QAEN,IAAI,CAACC,UAAU,GAAGD,QAAQC,UAAU;IACtC;IAEOC,OACLC,GAAoB,EACpBC,GAAmB,EACnBC,OAAiC,EACV;QACvB,OAAOV,iBACLQ,KACAC,KACAC,QAAQC,IAAI,EACZD,QAAQE,KAAK,EACbF,QAAQG,UAAU,EAClB;YACEC,KAAK,IAAI,CAACR,UAAU,CAACQ,GAAG;YACxBC,UAAU,IAAI,CAACT,UAAU,CAACS,QAAQ;QACpC,GACAL,QAAQM,aAAa,EACrBN,QAAQO,aAAa;IAEzB;AACF;AAEA,MAAMC,WAAW;IACfC,UAAUjB;AACZ;AAEA,8BAA8B;AAC9B,SAASD,YAAY,EAAEiB,QAAQ,GAAE;AAEjC,eAAef,iBAAgB","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.render.js

@@ -0,0 +1,10 @@
+export const lazyRenderPagesPage = (...args)=>{
+    if (process.env.NEXT_MINIMAL) {
+        throw new Error("Can't use lazyRenderPagesPage in minimal mode");
+    } else {
+        const render = require('./module.compiled').renderToHTML;
+        return render(...args);
+    }
+};
+
+//# sourceMappingURL=module.render.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/module.render.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages/module.render.ts"],"sourcesContent":["import type { PagesRender } from '../../render'\n\nexport const lazyRenderPagesPage: PagesRender = (...args) => {\n  if (process.env.NEXT_MINIMAL) {\n    throw new Error(\"Can't use lazyRenderPagesPage in minimal mode\")\n  } else {\n    const render: PagesRender = (\n      require('./module.compiled') as typeof import('./module.compiled')\n    ).renderToHTML\n\n    return render(...args)\n  }\n}\n"],"names":["lazyRenderPagesPage","args","process","env","NEXT_MINIMAL","Error","render","require","renderToHTML"],"mappings":"AAEA,OAAO,MAAMA,sBAAmC,CAAC,GAAGC;IAClD,IAAIC,QAAQC,GAAG,CAACC,YAAY,EAAE;QAC5B,MAAM,IAAIC,MAAM;IAClB,OAAO;QACL,MAAMC,SAAsB,AAC1BC,QAAQ,qBACRC,YAAY;QAEd,OAAOF,UAAUL;IACnB;AACF,EAAC","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/pages-handler.js

@@ -0,0 +1,561 @@
+import { RouteKind } from '../../route-kind';
+import { BaseServerSpan } from '../../lib/trace/constants';
+import { getTracer, SpanKind } from '../../lib/trace/tracer';
+import { formatUrl } from '../../../shared/lib/router/utils/format-url';
+import { addRequestMeta, getRequestMeta, setRequestMeta } from '../../request-meta';
+import { interopDefault } from '../../app-render/interop-default';
+import { getRevalidateReason } from '../../instrumentation/utils';
+import { normalizeDataPath } from '../../../shared/lib/page-path/normalize-data-path';
+import { CachedRouteKind } from '../../response-cache';
+import { getCacheControlHeader } from '../../lib/cache-control';
+import { normalizeRepeatedSlashes } from '../../../shared/lib/utils';
+import { getRedirectStatus } from '../../../lib/redirect-status';
+import { CACHE_ONE_YEAR_SECONDS, HTML_CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE_HEADER, NEXT_NAV_DEPLOYMENT_ID_HEADER } from '../../../lib/constants';
+import path from 'path';
+import { sendRenderResult } from '../../send-payload';
+import RenderResult from '../../render-result';
+import { toResponseCacheEntry } from '../../response-cache/utils';
+import { NoFallbackError } from '../../../shared/lib/no-fallback-error.external';
+import { RedirectStatusCode } from '../../../client/components/redirect-status-code';
+import { isBot } from '../../../shared/lib/router/utils/is-bot';
+import { addPathPrefix } from '../../../shared/lib/router/utils/add-path-prefix';
+import { removeTrailingSlash } from '../../../shared/lib/router/utils/remove-trailing-slash';
+import { isRouteCacheOwner } from '../../lib/route-cache-key';
+export const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, isFallbackError, getStaticPaths, getStaticProps, getServerSideProps })=>{
+    return async function handler(req, res, ctx) {
+        var _serverFilesManifest_config_experimental, _serverFilesManifest_config, _parsedUrl_pathname;
+        if (ctx.requestMeta) {
+            setRequestMeta(req, ctx.requestMeta);
+        }
+        if (routeModule.isDev) {
+            addRequestMeta(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint());
+        }
+        let srcPage = originalSrcPage;
+        // turbopack doesn't normalize `/index` in the page name
+        // so we need to to process dynamic routes properly
+        // TODO: fix turbopack providing differing value from webpack
+        if (process.env.TURBOPACK) {
+            srcPage = srcPage.replace(/\/index$/, '') || '/';
+        } else if (srcPage === '/index') {
+            // we always normalize /index specifically
+            srcPage = '/';
+        }
+        const multiZoneDraftMode = process.env.__NEXT_MULTI_ZONE_DRAFT_MODE;
+        const prepareResult = await routeModule.prepare(req, res, {
+            srcPage,
+            multiZoneDraftMode
+        });
+        if (!prepareResult) {
+            res.statusCode = 400;
+            res.end('Bad Request');
+            ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+            return;
+        }
+        const isMinimalMode = Boolean(getRequestMeta(req, 'minimalMode'));
+        const render404 = async ()=>{
+            // TODO: should route-module itself handle rendering the 404
+            if (routerServerContext == null ? void 0 : routerServerContext.render404) {
+                // When the Pages and App Routers coexist, a Pages Router 404 renders
+                // the App Router not-found page. A direct route-module invocation
+                // cannot provide the postponed state needed to resume that App Router
+                // output, so an empty postponed state signals that the renderer must
+                // perform a complete dynamic render instead.
+                //
+                // TODO: Re-enter routing with the App Router not-found output so its
+                // prerender and postponed state can be selected and resumed.
+                if (nextConfig.cacheComponents && !routerServerContext.isWrappedByNextServer && typeof getRequestMeta(req, 'postponed') !== 'string') {
+                    addRequestMeta(req, 'postponed', '');
+                }
+                await routerServerContext.render404(req, res, parsedUrl, false);
+            } else {
+                res.end('This page could not be found');
+            }
+        };
+        const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, previewProps, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname, deploymentId, clientAssetToken } = prepareResult;
+        const isExperimentalCompile = serverFilesManifest == null ? void 0 : (_serverFilesManifest_config = serverFilesManifest.config) == null ? void 0 : (_serverFilesManifest_config_experimental = _serverFilesManifest_config.experimental) == null ? void 0 : _serverFilesManifest_config_experimental.isExperimentalCompile;
+        const hasServerProps = Boolean(getServerSideProps);
+        const hasStaticProps = Boolean(getStaticProps);
+        const hasStaticPaths = Boolean(getStaticPaths);
+        const hasGetInitialProps = Boolean((userland.default || userland).getInitialProps);
+        let cacheKey = null;
+        let isIsrFallback = false;
+        let isNextDataRequest = prepareResult.isNextDataRequest && (hasStaticProps || hasServerProps);
+        const is404Page = srcPage === '/404';
+        const is500Page = srcPage === '/500';
+        const isErrorPage = srcPage === '/_error';
+        if (!routeModule.isDev && !isDraftMode && hasStaticProps) {
+            cacheKey = `${locale ? `/${locale}` : ''}${(srcPage === '/' || resolvedPathname === '/') && locale ? '' : resolvedPathname}`;
+            if (is404Page || is500Page || isErrorPage) {
+                cacheKey = `${locale ? `/${locale}` : ''}${srcPage}`;
+            }
+            // ensure /index and / is normalized to one key
+            cacheKey = cacheKey === '/index' ? '/' : cacheKey;
+        }
+        if (hasStaticPaths && !isDraftMode) {
+            var _nextConfig_i18n;
+            const decodedPathname = removeTrailingSlash(locale ? addPathPrefix(resolvedPathname, `/${locale}`) : resolvedPathname);
+            const isPrerendered = (Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname)) && // A sibling's positive or negative prerender cannot admit parameters
+            // that this route excluded. Development computes static paths on demand
+            // instead of reading build-time prerender metadata.
+            (routeModule.isDev || isRouteCacheOwner(decodedPathname, routeModule.cacheOwner, prerenderManifest.routes[decodedPathname], (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.locales));
+            const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage];
+            if (prerenderInfo) {
+                if (prerenderInfo.fallback === false && !isPrerendered) {
+                    if (nextConfig.adapterPath) {
+                        return await render404();
+                    }
+                    throw new NoFallbackError();
+                }
+                if (typeof prerenderInfo.fallback === 'string' && !isPrerendered && !isNextDataRequest) {
+                    isIsrFallback = true;
+                }
+            }
+        }
+        // When serving a bot request, we want to serve a blocking render and not
+        // the prerendered page. This ensures that the correct content is served
+        // to the bot in the head.
+        if (isIsrFallback && isBot(req.headers['user-agent'] || '') || isMinimalMode) {
+            isIsrFallback = false;
+        }
+        const tracer = getTracer();
+        const activeSpan = tracer.getActiveScopeSpan();
+        const isWrappedByNextServer = Boolean(routerServerContext == null ? void 0 : routerServerContext.isWrappedByNextServer);
+        const method = req.method || 'GET';
+        const resolvedUrl = formatUrl({
+            pathname: nextConfig.trailingSlash ? `${encodedResolvedPathname}${!encodedResolvedPathname.endsWith('/') && ((_parsedUrl_pathname = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname.endsWith('/')) ? '/' : ''}` : removeTrailingSlash(encodedResolvedPathname || '/'),
+            // make sure to only add query values from original URL
+            query: hasStaticProps ? {} : originalQuery
+        });
+        let parentSpan;
+        const handleResponse = async (span)=>{
+            const responseGenerator = async ({ previousCacheEntry })=>{
+                var _previousCacheEntry_value;
+                const doRender = async ()=>{
+                    try {
+                        var _nextConfig_i18n;
+                        return await routeModule.render(req, res, {
+                            query: hasStaticProps && !isExperimentalCompile ? {
+                                ...params
+                            } : {
+                                ...query,
+                                ...params
+                            },
+                            params,
+                            page: srcPage,
+                            renderContext: {
+                                isDraftMode,
+                                isFallback: isIsrFallback,
+                                developmentNotFoundSourcePage: getRequestMeta(req, 'developmentNotFoundSourcePage')
+                            },
+                            sharedContext: {
+                                buildId,
+                                customServer: Boolean(routerServerContext == null ? void 0 : routerServerContext.isCustomServer) || undefined,
+                                deploymentId,
+                                clientAssetToken
+                            },
+                            renderOpts: {
+                                params,
+                                routeModule,
+                                page: srcPage,
+                                pageConfig: config || {},
+                                Component: interopDefault(userland),
+                                ComponentMod: userland,
+                                getStaticProps,
+                                getStaticPaths,
+                                getServerSideProps,
+                                supportsDynamicResponse: !hasStaticProps,
+                                buildManifest: isFallbackError ? fallbackBuildManifest : buildManifest,
+                                nextFontManifest,
+                                reactLoadableManifest,
+                                assetPrefix: routeModule.getAssetPrefixForRender(routerServerContext, nextConfig.assetPrefix),
+                                previewProps,
+                                images: nextConfig.images,
+                                nextConfigOutput: nextConfig.output,
+                                optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
+                                nextScriptWorkers: Boolean(nextConfig.experimental.nextScriptWorkers),
+                                domainLocales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.domains,
+                                crossOrigin: nextConfig.crossOrigin,
+                                multiZoneDraftMode,
+                                basePath: nextConfig.basePath,
+                                disableOptimizedLoading: nextConfig.experimental.disableOptimizedLoading,
+                                largePageDataBytes: nextConfig.experimental.largePageDataBytes,
+                                isExperimentalCompile,
+                                experimental: {
+                                    clientTraceMetadata: nextConfig.experimental.clientTraceMetadata || []
+                                },
+                                locale,
+                                locales,
+                                defaultLocale,
+                                setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
+                                isNextDataRequest: isNextDataRequest && (hasServerProps || hasStaticProps),
+                                resolvedUrl,
+                                // For getServerSideProps and getInitialProps we need to ensure we use the original URL
+                                // and not the resolved URL to prevent a hydration mismatch on
+                                // asPath
+                                resolvedAsPath: hasServerProps || hasGetInitialProps ? formatUrl({
+                                    // we use the original URL pathname less the _next/data prefix if
+                                    // present
+                                    pathname: isNextDataRequest ? normalizeDataPath(originalPathname) : originalPathname,
+                                    query: originalQuery
+                                }) : resolvedUrl,
+                                isOnDemandRevalidate,
+                                ErrorDebug: getRequestMeta(req, 'PagesErrorDebug'),
+                                err: getRequestMeta(req, 'invokeError'),
+                                // needed for experimental.optimizeCss feature
+                                distDir: path.join(/* turbopackIgnore: true */ process.cwd(), routeModule.relativeProjectDir, routeModule.distDir)
+                            }
+                        }).then((renderResult)=>{
+                            const { metadata } = renderResult;
+                            let cacheControl = metadata.cacheControl;
+                            // Apply the `expireTime` fallback as soon as we have the
+                            // render's `cacheControl`, so every downstream consumer (the
+                            // cache stored via `incrementalCache.set`, the response
+                            // Cache-Control header, the outgoing entry returned from this
+                            // responseGenerator) sees a finalized `cacheControl` with a
+                            // populated `expire`. This mirrors the build-time fallback in
+                            // `build/index.ts` so we don't apply an expire to routes that
+                            // opt out of revalidation entirely (`revalidate: false`) or
+                            // that are dynamic (`revalidate: 0`).
+                            if (cacheControl && cacheControl.revalidate !== false && cacheControl.revalidate > 0 && cacheControl.expire === undefined) {
+                                cacheControl.expire = nextConfig.expireTime;
+                            }
+                            if ('isNotFound' in metadata && metadata.isNotFound) {
+                                return {
+                                    value: null,
+                                    cacheControl
+                                };
+                            }
+                            // Handle `isRedirect`.
+                            if (metadata.isRedirect) {
+                                return {
+                                    value: {
+                                        kind: CachedRouteKind.REDIRECT,
+                                        props: metadata.pageData ?? metadata.flightData
+                                    },
+                                    cacheControl
+                                };
+                            }
+                            return {
+                                value: {
+                                    kind: CachedRouteKind.PAGES,
+                                    html: renderResult,
+                                    pageData: renderResult.metadata.pageData,
+                                    headers: renderResult.metadata.headers,
+                                    status: renderResult.metadata.statusCode
+                                },
+                                cacheControl
+                            };
+                        });
+                    } catch (err) {
+                        // if this is a background revalidate we need to report
+                        // the request error here as it won't be bubbled
+                        if (previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) {
+                            const silenceLog = false;
+                            await routeModule.onRequestError(req, err, {
+                                routerKind: 'Pages Router',
+                                routePath: srcPage,
+                                routeType: 'render',
+                                revalidateReason: getRevalidateReason({
+                                    isStaticGeneration: hasStaticProps,
+                                    isOnDemandRevalidate
+                                })
+                            }, silenceLog, routerServerContext);
+                        }
+                        throw err;
+                    }
+                };
+                // if we've already generated this page we no longer
+                // serve the fallback
+                if (previousCacheEntry) {
+                    isIsrFallback = false;
+                }
+                if (isIsrFallback) {
+                    const fallbackResponse = await routeModule.getResponseCache(req).get(routeModule.isDev ? null : locale ? `/${locale}${srcPage}` : srcPage, async ({ previousCacheEntry: previousFallbackCacheEntry = null })=>{
+                        if (!routeModule.isDev) {
+                            return toResponseCacheEntry(previousFallbackCacheEntry);
+                        }
+                        return doRender();
+                    }, {
+                        routeKind: RouteKind.PAGES,
+                        isFallback: true,
+                        isRoutePPREnabled: false,
+                        isOnDemandRevalidate: false,
+                        incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, previewProps, prerenderManifest, isMinimalMode),
+                        waitUntil: ctx.waitUntil
+                    });
+                    if (fallbackResponse !== null && 'error' in fallbackResponse) {
+                        throw fallbackResponse.error;
+                    }
+                    if (fallbackResponse) {
+                        // Remove the cache control from the response to prevent it from being
+                        // used in the surrounding cache.
+                        delete fallbackResponse.cacheControl;
+                        fallbackResponse.isMiss = true;
+                        return fallbackResponse;
+                    }
+                }
+                if (!isMinimalMode && isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry) {
+                    res.statusCode = 404;
+                    // on-demand revalidate always sets this header
+                    res.setHeader('x-nextjs-cache', 'REVALIDATED');
+                    res.end('This page could not be found');
+                    return null;
+                }
+                if (isIsrFallback && (previousCacheEntry == null ? void 0 : (_previousCacheEntry_value = previousCacheEntry.value) == null ? void 0 : _previousCacheEntry_value.kind) === CachedRouteKind.PAGES) {
+                    return {
+                        value: {
+                            kind: CachedRouteKind.PAGES,
+                            html: new RenderResult(previousCacheEntry.value.html, {
+                                contentType: HTML_CONTENT_TYPE_HEADER,
+                                metadata: {
+                                    statusCode: previousCacheEntry.value.status,
+                                    headers: previousCacheEntry.value.headers
+                                }
+                            }),
+                            pageData: {},
+                            status: previousCacheEntry.value.status,
+                            headers: previousCacheEntry.value.headers
+                        },
+                        cacheControl: {
+                            revalidate: 0,
+                            expire: undefined
+                        }
+                    };
+                }
+                return doRender();
+            };
+            try {
+                const result = await routeModule.handleResponse({
+                    cacheKey,
+                    req,
+                    nextConfig,
+                    routeKind: RouteKind.PAGES,
+                    isOnDemandRevalidate,
+                    revalidateOnlyGenerated,
+                    waitUntil: ctx.waitUntil,
+                    responseGenerator: responseGenerator,
+                    previewProps,
+                    prerenderManifest,
+                    isMinimalMode
+                });
+                if (result !== null && 'error' in result) {
+                    throw result.error;
+                }
+                // if we got a cache hit this wasn't an ISR fallback
+                // but it wasn't generated during build so isn't in the
+                // prerender-manifest
+                if (isIsrFallback && !(result == null ? void 0 : result.isMiss)) {
+                    isIsrFallback = false;
+                }
+                // response is finished is no cache entry
+                if (!result) {
+                    return;
+                }
+                if (hasStaticProps && !isMinimalMode) {
+                    res.setHeader('x-nextjs-cache', isOnDemandRevalidate ? 'REVALIDATED' : result.isMiss ? 'MISS' : result.isStale ? 'STALE' : 'HIT');
+                }
+                let cacheControl;
+                if (!hasStaticProps || isIsrFallback) {
+                    if (!res.getHeader('Cache-Control')) {
+                        cacheControl = {
+                            revalidate: 0,
+                            expire: undefined
+                        };
+                    }
+                } else if (is404Page) {
+                    const notFoundRevalidate = getRequestMeta(req, 'notFoundRevalidate');
+                    cacheControl = {
+                        revalidate: typeof notFoundRevalidate === 'undefined' ? 0 : notFoundRevalidate,
+                        expire: undefined
+                    };
+                } else if (is500Page) {
+                    cacheControl = {
+                        revalidate: 0,
+                        expire: undefined
+                    };
+                } else if (result.cacheControl) {
+                    // If the cache entry has a cache control with a revalidate value that's
+                    // a number, use it.
+                    if (typeof result.cacheControl.revalidate === 'number') {
+                        if (result.cacheControl.revalidate < 1) {
+                            throw new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`);
+                        }
+                        cacheControl = {
+                            revalidate: result.cacheControl.revalidate,
+                            expire: result.cacheControl.expire
+                        };
+                    } else {
+                        // revalidate: false
+                        cacheControl = {
+                            revalidate: CACHE_ONE_YEAR_SECONDS,
+                            expire: undefined
+                        };
+                    }
+                }
+                // If cache control is already set on the response we don't
+                // override it to allow users to customize it via next.config
+                if (cacheControl && !res.getHeader('Cache-Control')) {
+                    res.setHeader('Cache-Control', getCacheControlHeader(cacheControl));
+                }
+                // notFound: true case
+                if (!result.value) {
+                    var _result_cacheControl;
+                    // add revalidate metadata before rendering 404 page
+                    // so that we can use this as source of truth for the
+                    // cache-control header instead of what the 404 page returns
+                    // for the revalidate value
+                    addRequestMeta(req, 'notFoundRevalidate', (_result_cacheControl = result.cacheControl) == null ? void 0 : _result_cacheControl.revalidate);
+                    res.statusCode = 404;
+                    if (isNextDataRequest) {
+                        if (deploymentId) {
+                            res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId);
+                        }
+                        res.end('{"notFound":true}');
+                        return;
+                    }
+                    return await render404();
+                }
+                if (result.value.kind === CachedRouteKind.REDIRECT) {
+                    if (isNextDataRequest) {
+                        if (deploymentId) {
+                            res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId);
+                        }
+                        res.setHeader('content-type', JSON_CONTENT_TYPE_HEADER);
+                        res.end(JSON.stringify(result.value.props));
+                        return;
+                    } else {
+                        const handleRedirect = (pageData)=>{
+                            const redirect = {
+                                destination: pageData.pageProps.__N_REDIRECT,
+                                statusCode: pageData.pageProps.__N_REDIRECT_STATUS,
+                                basePath: pageData.pageProps.__N_REDIRECT_BASE_PATH
+                            };
+                            const statusCode = getRedirectStatus(redirect);
+                            const { basePath } = nextConfig;
+                            if (basePath && redirect.basePath !== false && redirect.destination.startsWith('/')) {
+                                redirect.destination = `${basePath}${redirect.destination}`;
+                            }
+                            if (redirect.destination.startsWith('/')) {
+                                redirect.destination = normalizeRepeatedSlashes(redirect.destination);
+                            }
+                            res.statusCode = statusCode;
+                            res.setHeader('Location', redirect.destination);
+                            if (statusCode === RedirectStatusCode.PermanentRedirect) {
+                                res.setHeader('Refresh', `0;url=${redirect.destination}`);
+                            }
+                            res.end(redirect.destination);
+                        };
+                        await handleRedirect(result.value.props);
+                        return null;
+                    }
+                }
+                if (result.value.kind !== CachedRouteKind.PAGES) {
+                    throw new Error(`Invariant: received non-pages cache entry in pages handler`);
+                }
+                // Documents and data responses must not be stored in development.
+                // Browsers reuse a stored response for a history navigation without
+                // revalidating it, so a back navigation would restore a page from
+                // before the latest edit. Static assets never reach this code. They
+                // keep a revalidatable `Cache-Control`, so the browser caches them
+                // between page loads.
+                if (routeModule.isDev) {
+                    res.setHeader('Cache-Control', 'no-store');
+                }
+                // Draft mode should never be cached
+                if (isDraftMode) {
+                    res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
+                }
+                // when invoking _error before pages/500 we don't actually
+                // send the _error response
+                if (getRequestMeta(req, 'customErrorRender') || isErrorPage && isMinimalMode && res.statusCode === 500) {
+                    return null;
+                }
+                // Add deployment ID header for data requests
+                if (isNextDataRequest && !isErrorPage && !is500Page) {
+                    if (deploymentId) {
+                        res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId);
+                    }
+                }
+                await sendRenderResult({
+                    req,
+                    res,
+                    // If we are rendering the error page it's not a data request
+                    // anymore
+                    result: isNextDataRequest && !isErrorPage && !is500Page ? new RenderResult(JSON.stringify(result.value.pageData), {
+                        contentType: JSON_CONTENT_TYPE_HEADER,
+                        metadata: result.value.html.metadata
+                    }) : result.value.html,
+                    generateEtags: nextConfig.generateEtags,
+                    poweredByHeader: nextConfig.poweredByHeader,
+                    cacheControl: routeModule.isDev ? undefined : cacheControl
+                });
+            } catch (err) {
+                if (!(err instanceof NoFallbackError)) {
+                    const silenceLog = false;
+                    await routeModule.onRequestError(req, err, {
+                        routerKind: 'Pages Router',
+                        routePath: srcPage,
+                        routeType: 'render',
+                        revalidateReason: getRevalidateReason({
+                            isStaticGeneration: hasStaticProps,
+                            isOnDemandRevalidate
+                        })
+                    }, silenceLog, routerServerContext);
+                }
+                // rethrow so that we can handle serving error page
+                throw err;
+            } finally{
+                // An IIFE to make early returns easier.
+                ;
+                (()=>{
+                    if (!span) return;
+                    span.setAttributes({
+                        'http.status_code': res.statusCode,
+                        'next.rsc': false
+                    });
+                    const rootSpanAttributes = tracer.getRootSpanAttributes();
+                    // We were unable to get attributes, probably OTEL is not enabled
+                    if (!rootSpanAttributes) {
+                        return;
+                    }
+                    if (rootSpanAttributes.get('next.span_type') !== BaseServerSpan.handleRequest) {
+                        console.warn(`Unexpected root span type '${rootSpanAttributes.get('next.span_type')}'. Please report this Next.js issue https://github.com/vercel/next.js`);
+                        return;
+                    }
+                    const route = rootSpanAttributes.get('next.route') || srcPage;
+                    const name = `${method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                    // Propagate http.route to the parent span if one exists
+                    // (e.g. a platform-created HTTP span in adapter
+                    // deployments).
+                    if (parentSpan && parentSpan !== span) {
+                        parentSpan.setAttribute('http.route', route);
+                        parentSpan.updateName(name);
+                    }
+                })();
+            }
+        };
+        // TODO: activeSpan code path is for when wrapped by
+        // next-server can be removed when this is no longer used
+        if (isWrappedByNextServer && activeSpan) {
+            await handleResponse(activeSpan);
+        } else {
+            parentSpan = tracer.getActiveScopeSpan();
+            await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(BaseServerSpan.handleRequest, {
+                    spanName: `${method} ${srcPage}`,
+                    kind: SpanKind.SERVER,
+                    attributes: {
+                        'http.method': method,
+                        'http.target': req.url
+                    }
+                }, handleResponse), undefined, !isWrappedByNextServer);
+        }
+    };
+};
+
+//# sourceMappingURL=pages-handler.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/pages-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages/pages-handler.ts"],"sourcesContent":["import type { IncomingMessage, ServerResponse } from 'node:http'\nimport type { ParsedUrlQuery } from 'node:querystring'\nimport { RouteKind } from '../../route-kind'\nimport { BaseServerSpan } from '../../lib/trace/constants'\nimport { getTracer, SpanKind, type Span } from '../../lib/trace/tracer'\nimport { formatUrl } from '../../../shared/lib/router/utils/format-url'\nimport {\n  addRequestMeta,\n  getRequestMeta,\n  setRequestMeta,\n  type RequestMeta,\n} from '../../request-meta'\nimport { interopDefault } from '../../app-render/interop-default'\nimport { getRevalidateReason } from '../../instrumentation/utils'\nimport { normalizeDataPath } from '../../../shared/lib/page-path/normalize-data-path'\nimport {\n  CachedRouteKind,\n  type CachedPageValue,\n  type CachedRedirectValue,\n  type ResponseCacheEntry,\n  type ResponseGenerator,\n} from '../../response-cache'\n\nimport {\n  getCacheControlHeader,\n  type CacheControl,\n} from '../../lib/cache-control'\nimport { normalizeRepeatedSlashes } from '../../../shared/lib/utils'\nimport { getRedirectStatus } from '../../../lib/redirect-status'\nimport {\n  CACHE_ONE_YEAR_SECONDS,\n  HTML_CONTENT_TYPE_HEADER,\n  JSON_CONTENT_TYPE_HEADER,\n  NEXT_NAV_DEPLOYMENT_ID_HEADER,\n} from '../../../lib/constants'\nimport path from 'path'\nimport { sendRenderResult } from '../../send-payload'\nimport RenderResult from '../../render-result'\nimport { toResponseCacheEntry } from '../../response-cache/utils'\nimport { NoFallbackError } from '../../../shared/lib/no-fallback-error.external'\nimport { RedirectStatusCode } from '../../../client/components/redirect-status-code'\nimport { isBot } from '../../../shared/lib/router/utils/is-bot'\nimport { addPathPrefix } from '../../../shared/lib/router/utils/add-path-prefix'\nimport { removeTrailingSlash } from '../../../shared/lib/router/utils/remove-trailing-slash'\nimport { isRouteCacheOwner } from '../../lib/route-cache-key'\nimport type { PagesRouteModule } from './module.compiled'\nimport type {\n  GetServerSideProps,\n  GetStaticPaths,\n  GetStaticProps,\n} from '../../../types'\n\nexport const getHandler = ({\n  srcPage: originalSrcPage,\n  config,\n  userland,\n  routeModule,\n  isFallbackError,\n  getStaticPaths,\n  getStaticProps,\n  getServerSideProps,\n}: {\n  srcPage: string\n  config: Record<string, any> | undefined\n  userland: any\n  isFallbackError?: boolean\n  routeModule: PagesRouteModule\n  getStaticProps?: GetStaticProps\n  getStaticPaths?: GetStaticPaths\n  getServerSideProps?: GetServerSideProps\n}) => {\n  return async function handler(\n    req: IncomingMessage,\n    res: ServerResponse,\n    ctx: {\n      waitUntil?: (prom: Promise<void>) => void\n      requestMeta?: RequestMeta\n    }\n  ) {\n    if (ctx.requestMeta) {\n      setRequestMeta(req, ctx.requestMeta)\n    }\n    if (routeModule.isDev) {\n      addRequestMeta(\n        req,\n        'devRequestTimingInternalsEnd',\n        process.hrtime.bigint()\n      )\n    }\n    let srcPage = originalSrcPage\n    // turbopack doesn't normalize `/index` in the page name\n    // so we need to to process dynamic routes properly\n    // TODO: fix turbopack providing differing value from webpack\n    if (process.env.TURBOPACK) {\n      srcPage = srcPage.replace(/\\/index$/, '') || '/'\n    } else if (srcPage === '/index') {\n      // we always normalize /index specifically\n      srcPage = '/'\n    }\n    const multiZoneDraftMode = process.env\n      .__NEXT_MULTI_ZONE_DRAFT_MODE as any as boolean\n\n    const prepareResult = await routeModule.prepare(req, res, {\n      srcPage,\n      multiZoneDraftMode,\n    })\n\n    if (!prepareResult) {\n      res.statusCode = 400\n      res.end('Bad Request')\n      ctx.waitUntil?.(Promise.resolve())\n      return\n    }\n\n    const isMinimalMode = Boolean(getRequestMeta(req, 'minimalMode'))\n\n    const render404 = async () => {\n      // TODO: should route-module itself handle rendering the 404\n      if (routerServerContext?.render404) {\n        // When the Pages and App Routers coexist, a Pages Router 404 renders\n        // the App Router not-found page. A direct route-module invocation\n        // cannot provide the postponed state needed to resume that App Router\n        // output, so an empty postponed state signals that the renderer must\n        // perform a complete dynamic render instead.\n        //\n        // TODO: Re-enter routing with the App Router not-found output so its\n        // prerender and postponed state can be selected and resumed.\n        if (\n          nextConfig.cacheComponents &&\n          !routerServerContext.isWrappedByNextServer &&\n          typeof getRequestMeta(req, 'postponed') !== 'string'\n        ) {\n          addRequestMeta(req, 'postponed', '')\n        }\n        await routerServerContext.render404(req, res, parsedUrl, false)\n      } else {\n        res.end('This page could not be found')\n      }\n    }\n\n    const {\n      buildId,\n      query,\n      params,\n      parsedUrl,\n      originalQuery,\n      originalPathname,\n      buildManifest,\n      fallbackBuildManifest,\n      nextFontManifest,\n      serverFilesManifest,\n      reactLoadableManifest,\n      prerenderManifest,\n      previewProps,\n      isDraftMode,\n      isOnDemandRevalidate,\n      revalidateOnlyGenerated,\n      locale,\n      locales,\n      defaultLocale,\n      routerServerContext,\n      nextConfig,\n      resolvedPathname,\n      encodedResolvedPathname,\n      deploymentId,\n      clientAssetToken,\n    } = prepareResult\n\n    const isExperimentalCompile =\n      serverFilesManifest?.config?.experimental?.isExperimentalCompile\n\n    const hasServerProps = Boolean(getServerSideProps)\n    const hasStaticProps = Boolean(getStaticProps)\n    const hasStaticPaths = Boolean(getStaticPaths)\n    const hasGetInitialProps = Boolean(\n      (userland.default || userland).getInitialProps\n    )\n    let cacheKey: null | string = null\n    let isIsrFallback = false\n    let isNextDataRequest =\n      prepareResult.isNextDataRequest && (hasStaticProps || hasServerProps)\n\n    const is404Page = srcPage === '/404'\n    const is500Page = srcPage === '/500'\n    const isErrorPage = srcPage === '/_error'\n\n    if (!routeModule.isDev && !isDraftMode && hasStaticProps) {\n      cacheKey = `${locale ? `/${locale}` : ''}${\n        (srcPage === '/' || resolvedPathname === '/') && locale\n          ? ''\n          : resolvedPathname\n      }`\n\n      if (is404Page || is500Page || isErrorPage) {\n        cacheKey = `${locale ? `/${locale}` : ''}${srcPage}`\n      }\n\n      // ensure /index and / is normalized to one key\n      cacheKey = cacheKey === '/index' ? '/' : cacheKey\n    }\n\n    if (hasStaticPaths && !isDraftMode) {\n      const decodedPathname = removeTrailingSlash(\n        locale\n          ? addPathPrefix(resolvedPathname, `/${locale}`)\n          : resolvedPathname\n      )\n      const isPrerendered =\n        (Boolean(prerenderManifest.routes[decodedPathname]) ||\n          prerenderManifest.notFoundRoutes.includes(decodedPathname)) &&\n        // A sibling's positive or negative prerender cannot admit parameters\n        // that this route excluded. Development computes static paths on demand\n        // instead of reading build-time prerender metadata.\n        (routeModule.isDev ||\n          isRouteCacheOwner(\n            decodedPathname,\n            routeModule.cacheOwner,\n            prerenderManifest.routes[decodedPathname],\n            nextConfig.i18n?.locales\n          ))\n\n      const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage]\n\n      if (prerenderInfo) {\n        if (prerenderInfo.fallback === false && !isPrerendered) {\n          if (nextConfig.adapterPath) {\n            return await render404()\n          }\n          throw new NoFallbackError()\n        }\n\n        if (\n          typeof prerenderInfo.fallback === 'string' &&\n          !isPrerendered &&\n          !isNextDataRequest\n        ) {\n          isIsrFallback = true\n        }\n      }\n    }\n\n    // When serving a bot request, we want to serve a blocking render and not\n    // the prerendered page. This ensures that the correct content is served\n    // to the bot in the head.\n    if (\n      (isIsrFallback && isBot(req.headers['user-agent'] || '')) ||\n      isMinimalMode\n    ) {\n      isIsrFallback = false\n    }\n\n    const tracer = getTracer()\n    const activeSpan = tracer.getActiveScopeSpan()\n    const isWrappedByNextServer = Boolean(\n      routerServerContext?.isWrappedByNextServer\n    )\n\n    const method = req.method || 'GET'\n\n    const resolvedUrl = formatUrl({\n      pathname: nextConfig.trailingSlash\n        ? `${encodedResolvedPathname}${!encodedResolvedPathname.endsWith('/') && parsedUrl.pathname?.endsWith('/') ? '/' : ''}`\n        : removeTrailingSlash(encodedResolvedPathname || '/'),\n      // make sure to only add query values from original URL\n      query: hasStaticProps ? {} : originalQuery,\n    })\n\n    let parentSpan: Span | undefined\n    const handleResponse = async (span?: Span) => {\n      const responseGenerator: ResponseGenerator = async ({\n        previousCacheEntry,\n      }) => {\n        const doRender = async () => {\n          try {\n            return await routeModule\n              .render(req, res, {\n                query:\n                  hasStaticProps && !isExperimentalCompile\n                    ? ({\n                        ...params,\n                      } as ParsedUrlQuery)\n                    : {\n                        ...query,\n                        ...params,\n                      },\n                params,\n                page: srcPage,\n                renderContext: {\n                  isDraftMode,\n                  isFallback: isIsrFallback,\n                  developmentNotFoundSourcePage: getRequestMeta(\n                    req,\n                    'developmentNotFoundSourcePage'\n                  ),\n                },\n                sharedContext: {\n                  buildId,\n                  customServer:\n                    Boolean(routerServerContext?.isCustomServer) || undefined,\n                  deploymentId,\n                  clientAssetToken,\n                },\n                renderOpts: {\n                  params,\n                  routeModule,\n                  page: srcPage,\n                  pageConfig: config || {},\n                  Component: interopDefault(userland),\n                  ComponentMod: userland,\n                  getStaticProps,\n                  getStaticPaths,\n                  getServerSideProps,\n                  supportsDynamicResponse: !hasStaticProps,\n                  buildManifest: isFallbackError\n                    ? fallbackBuildManifest\n                    : buildManifest,\n                  nextFontManifest,\n                  reactLoadableManifest,\n\n                  assetPrefix: routeModule.getAssetPrefixForRender(\n                    routerServerContext,\n                    nextConfig.assetPrefix\n                  ),\n                  previewProps,\n                  images: nextConfig.images as any,\n                  nextConfigOutput: nextConfig.output,\n                  optimizeCss: Boolean(nextConfig.experimental.optimizeCss),\n                  nextScriptWorkers: Boolean(\n                    nextConfig.experimental.nextScriptWorkers\n                  ),\n                  domainLocales: nextConfig.i18n?.domains,\n                  crossOrigin: nextConfig.crossOrigin,\n\n                  multiZoneDraftMode,\n                  basePath: nextConfig.basePath,\n                  disableOptimizedLoading:\n                    nextConfig.experimental.disableOptimizedLoading,\n                  largePageDataBytes:\n                    nextConfig.experimental.largePageDataBytes,\n\n                  isExperimentalCompile,\n\n                  experimental: {\n                    clientTraceMetadata:\n                      nextConfig.experimental.clientTraceMetadata ||\n                      ([] as any),\n                  },\n\n                  locale,\n                  locales,\n                  defaultLocale,\n                  setIsrStatus: routerServerContext?.setIsrStatus,\n\n                  isNextDataRequest:\n                    isNextDataRequest && (hasServerProps || hasStaticProps),\n\n                  resolvedUrl,\n                  // For getServerSideProps and getInitialProps we need to ensure we use the original URL\n                  // and not the resolved URL to prevent a hydration mismatch on\n                  // asPath\n                  resolvedAsPath:\n                    hasServerProps || hasGetInitialProps\n                      ? formatUrl({\n                          // we use the original URL pathname less the _next/data prefix if\n                          // present\n                          pathname: isNextDataRequest\n                            ? normalizeDataPath(originalPathname)\n                            : originalPathname,\n                          query: originalQuery,\n                        })\n                      : resolvedUrl,\n\n                  isOnDemandRevalidate,\n\n                  ErrorDebug: getRequestMeta(req, 'PagesErrorDebug'),\n                  err: getRequestMeta(req, 'invokeError'),\n\n                  // needed for experimental.optimizeCss feature\n                  distDir: path.join(\n                    /* turbopackIgnore: true */\n                    process.cwd(),\n                    routeModule.relativeProjectDir,\n                    routeModule.distDir\n                  ),\n                },\n              })\n              .then((renderResult): ResponseCacheEntry => {\n                const { metadata } = renderResult\n\n                let cacheControl: CacheControl | undefined =\n                  metadata.cacheControl\n\n                // Apply the `expireTime` fallback as soon as we have the\n                // render's `cacheControl`, so every downstream consumer (the\n                // cache stored via `incrementalCache.set`, the response\n                // Cache-Control header, the outgoing entry returned from this\n                // responseGenerator) sees a finalized `cacheControl` with a\n                // populated `expire`. This mirrors the build-time fallback in\n                // `build/index.ts` so we don't apply an expire to routes that\n                // opt out of revalidation entirely (`revalidate: false`) or\n                // that are dynamic (`revalidate: 0`).\n                if (\n                  cacheControl &&\n                  cacheControl.revalidate !== false &&\n                  cacheControl.revalidate > 0 &&\n                  cacheControl.expire === undefined\n                ) {\n                  cacheControl.expire = nextConfig.expireTime\n                }\n\n                if ('isNotFound' in metadata && metadata.isNotFound) {\n                  return {\n                    value: null,\n                    cacheControl,\n                  } satisfies ResponseCacheEntry\n                }\n\n                // Handle `isRedirect`.\n                if (metadata.isRedirect) {\n                  return {\n                    value: {\n                      kind: CachedRouteKind.REDIRECT,\n                      props: metadata.pageData ?? metadata.flightData,\n                    } satisfies CachedRedirectValue,\n                    cacheControl,\n                  } satisfies ResponseCacheEntry\n                }\n\n                return {\n                  value: {\n                    kind: CachedRouteKind.PAGES,\n                    html: renderResult,\n                    pageData: renderResult.metadata.pageData,\n                    headers: renderResult.metadata.headers,\n                    status: renderResult.metadata.statusCode,\n                  },\n                  cacheControl,\n                }\n              })\n          } catch (err: unknown) {\n            // if this is a background revalidate we need to report\n            // the request error here as it won't be bubbled\n            if (previousCacheEntry?.isStale) {\n              const silenceLog = false\n              await routeModule.onRequestError(\n                req,\n                err,\n                {\n                  routerKind: 'Pages Router',\n                  routePath: srcPage,\n                  routeType: 'render',\n                  revalidateReason: getRevalidateReason({\n                    isStaticGeneration: hasStaticProps,\n                    isOnDemandRevalidate,\n                  }),\n                },\n                silenceLog,\n                routerServerContext\n              )\n            }\n            throw err\n          }\n        }\n\n        // if we've already generated this page we no longer\n        // serve the fallback\n        if (previousCacheEntry) {\n          isIsrFallback = false\n        }\n\n        if (isIsrFallback) {\n          const fallbackResponse = await routeModule.getResponseCache(req).get(\n            routeModule.isDev\n              ? null\n              : locale\n                ? `/${locale}${srcPage}`\n                : srcPage,\n            async ({\n              previousCacheEntry: previousFallbackCacheEntry = null,\n            }) => {\n              if (!routeModule.isDev) {\n                return toResponseCacheEntry(previousFallbackCacheEntry)\n              }\n              return doRender()\n            },\n            {\n              routeKind: RouteKind.PAGES,\n              isFallback: true,\n              isRoutePPREnabled: false,\n              isOnDemandRevalidate: false,\n              incrementalCache: await routeModule.getIncrementalCache(\n                req,\n                nextConfig,\n                previewProps,\n                prerenderManifest,\n                isMinimalMode\n              ),\n              waitUntil: ctx.waitUntil,\n            }\n          )\n          if (fallbackResponse !== null && 'error' in fallbackResponse) {\n            throw fallbackResponse.error\n          }\n\n          if (fallbackResponse) {\n            // Remove the cache control from the response to prevent it from being\n            // used in the surrounding cache.\n            delete fallbackResponse.cacheControl\n            fallbackResponse.isMiss = true\n            return fallbackResponse\n          }\n        }\n\n        if (\n          !isMinimalMode &&\n          isOnDemandRevalidate &&\n          revalidateOnlyGenerated &&\n          !previousCacheEntry\n        ) {\n          res.statusCode = 404\n          // on-demand revalidate always sets this header\n          res.setHeader('x-nextjs-cache', 'REVALIDATED')\n          res.end('This page could not be found')\n          return null\n        }\n\n        if (\n          isIsrFallback &&\n          previousCacheEntry?.value?.kind === CachedRouteKind.PAGES\n        ) {\n          return {\n            value: {\n              kind: CachedRouteKind.PAGES,\n              html: new RenderResult(previousCacheEntry.value.html, {\n                contentType: HTML_CONTENT_TYPE_HEADER,\n                metadata: {\n                  statusCode: previousCacheEntry.value.status,\n                  headers: previousCacheEntry.value.headers,\n                },\n              }),\n              pageData: {},\n              status: previousCacheEntry.value.status,\n              headers: previousCacheEntry.value.headers,\n            } satisfies CachedPageValue,\n            cacheControl: { revalidate: 0, expire: undefined },\n          } satisfies ResponseCacheEntry\n        }\n        return doRender()\n      }\n\n      try {\n        const result = await routeModule.handleResponse({\n          cacheKey,\n          req,\n          nextConfig,\n          routeKind: RouteKind.PAGES,\n          isOnDemandRevalidate,\n          revalidateOnlyGenerated,\n          waitUntil: ctx.waitUntil,\n          responseGenerator: responseGenerator,\n          previewProps,\n          prerenderManifest,\n          isMinimalMode,\n        })\n\n        if (result !== null && 'error' in result) {\n          throw result.error\n        }\n\n        // if we got a cache hit this wasn't an ISR fallback\n        // but it wasn't generated during build so isn't in the\n        // prerender-manifest\n        if (isIsrFallback && !result?.isMiss) {\n          isIsrFallback = false\n        }\n\n        // response is finished is no cache entry\n        if (!result) {\n          return\n        }\n\n        if (hasStaticProps && !isMinimalMode) {\n          res.setHeader(\n            'x-nextjs-cache',\n            isOnDemandRevalidate\n              ? 'REVALIDATED'\n              : result.isMiss\n                ? 'MISS'\n                : result.isStale\n                  ? 'STALE'\n                  : 'HIT'\n          )\n        }\n\n        let cacheControl: CacheControl | undefined\n\n        if (!hasStaticProps || isIsrFallback) {\n          if (!res.getHeader('Cache-Control')) {\n            cacheControl = { revalidate: 0, expire: undefined }\n          }\n        } else if (is404Page) {\n          const notFoundRevalidate = getRequestMeta(req, 'notFoundRevalidate')\n\n          cacheControl = {\n            revalidate:\n              typeof notFoundRevalidate === 'undefined'\n                ? 0\n                : notFoundRevalidate,\n            expire: undefined,\n          }\n        } else if (is500Page) {\n          cacheControl = { revalidate: 0, expire: undefined }\n        } else if (result.cacheControl) {\n          // If the cache entry has a cache control with a revalidate value that's\n          // a number, use it.\n          if (typeof result.cacheControl.revalidate === 'number') {\n            if (result.cacheControl.revalidate < 1) {\n              throw new Error(\n                `Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`\n              )\n            }\n            cacheControl = {\n              revalidate: result.cacheControl.revalidate,\n              expire: result.cacheControl.expire,\n            }\n          } else {\n            // revalidate: false\n            cacheControl = {\n              revalidate: CACHE_ONE_YEAR_SECONDS,\n              expire: undefined,\n            }\n          }\n        }\n\n        // If cache control is already set on the response we don't\n        // override it to allow users to customize it via next.config\n        if (cacheControl && !res.getHeader('Cache-Control')) {\n          res.setHeader('Cache-Control', getCacheControlHeader(cacheControl))\n        }\n\n        // notFound: true case\n        if (!result.value) {\n          // add revalidate metadata before rendering 404 page\n          // so that we can use this as source of truth for the\n          // cache-control header instead of what the 404 page returns\n          // for the revalidate value\n          addRequestMeta(\n            req,\n            'notFoundRevalidate',\n            result.cacheControl?.revalidate\n          )\n\n          res.statusCode = 404\n\n          if (isNextDataRequest) {\n            if (deploymentId) {\n              res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId)\n            }\n            res.end('{\"notFound\":true}')\n            return\n          }\n          return await render404()\n        }\n\n        if (result.value.kind === CachedRouteKind.REDIRECT) {\n          if (isNextDataRequest) {\n            if (deploymentId) {\n              res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId)\n            }\n            res.setHeader('content-type', JSON_CONTENT_TYPE_HEADER)\n            res.end(JSON.stringify(result.value.props))\n            return\n          } else {\n            const handleRedirect = (pageData: any) => {\n              const redirect = {\n                destination: pageData.pageProps.__N_REDIRECT,\n                statusCode: pageData.pageProps.__N_REDIRECT_STATUS,\n                basePath: pageData.pageProps.__N_REDIRECT_BASE_PATH,\n              }\n              const statusCode = getRedirectStatus(redirect)\n              const { basePath } = nextConfig\n\n              if (\n                basePath &&\n                redirect.basePath !== false &&\n                redirect.destination.startsWith('/')\n              ) {\n                redirect.destination = `${basePath}${redirect.destination}`\n              }\n\n              if (redirect.destination.startsWith('/')) {\n                redirect.destination = normalizeRepeatedSlashes(\n                  redirect.destination\n                )\n              }\n\n              res.statusCode = statusCode\n              res.setHeader('Location', redirect.destination)\n              if (statusCode === RedirectStatusCode.PermanentRedirect) {\n                res.setHeader('Refresh', `0;url=${redirect.destination}`)\n              }\n              res.end(redirect.destination)\n            }\n            await handleRedirect(result.value.props)\n            return null\n          }\n        }\n\n        if (result.value.kind !== CachedRouteKind.PAGES) {\n          throw new Error(\n            `Invariant: received non-pages cache entry in pages handler`\n          )\n        }\n\n        // Documents and data responses must not be stored in development.\n        // Browsers reuse a stored response for a history navigation without\n        // revalidating it, so a back navigation would restore a page from\n        // before the latest edit. Static assets never reach this code. They\n        // keep a revalidatable `Cache-Control`, so the browser caches them\n        // between page loads.\n        if (routeModule.isDev) {\n          res.setHeader('Cache-Control', 'no-store')\n        }\n\n        // Draft mode should never be cached\n        if (isDraftMode) {\n          res.setHeader(\n            'Cache-Control',\n            'private, no-cache, no-store, max-age=0, must-revalidate'\n          )\n        }\n\n        // when invoking _error before pages/500 we don't actually\n        // send the _error response\n        if (\n          getRequestMeta(req, 'customErrorRender') ||\n          (isErrorPage && isMinimalMode && res.statusCode === 500)\n        ) {\n          return null\n        }\n\n        // Add deployment ID header for data requests\n        if (isNextDataRequest && !isErrorPage && !is500Page) {\n          if (deploymentId) {\n            res.setHeader(NEXT_NAV_DEPLOYMENT_ID_HEADER, deploymentId)\n          }\n        }\n\n        await sendRenderResult({\n          req,\n          res,\n          // If we are rendering the error page it's not a data request\n          // anymore\n          result:\n            isNextDataRequest && !isErrorPage && !is500Page\n              ? new RenderResult(JSON.stringify(result.value.pageData), {\n                  contentType: JSON_CONTENT_TYPE_HEADER,\n                  metadata: result.value.html.metadata,\n                })\n              : result.value.html,\n          generateEtags: nextConfig.generateEtags,\n          poweredByHeader: nextConfig.poweredByHeader,\n          cacheControl: routeModule.isDev ? undefined : cacheControl,\n        })\n      } catch (err) {\n        if (!(err instanceof NoFallbackError)) {\n          const silenceLog = false\n          await routeModule.onRequestError(\n            req,\n            err,\n            {\n              routerKind: 'Pages Router',\n              routePath: srcPage,\n              routeType: 'render',\n              revalidateReason: getRevalidateReason({\n                isStaticGeneration: hasStaticProps,\n                isOnDemandRevalidate,\n              }),\n            },\n            silenceLog,\n            routerServerContext\n          )\n        }\n\n        // rethrow so that we can handle serving error page\n        throw err\n      } finally {\n        // An IIFE to make early returns easier.\n        ;(() => {\n          if (!span) return\n\n          span.setAttributes({\n            'http.status_code': res.statusCode,\n            'next.rsc': false,\n          })\n\n          const rootSpanAttributes = tracer.getRootSpanAttributes()\n          // We were unable to get attributes, probably OTEL is not enabled\n          if (!rootSpanAttributes) {\n            return\n          }\n\n          if (\n            rootSpanAttributes.get('next.span_type') !==\n            BaseServerSpan.handleRequest\n          ) {\n            console.warn(\n              `Unexpected root span type '${rootSpanAttributes.get(\n                'next.span_type'\n              )}'. Please report this Next.js issue https://github.com/vercel/next.js`\n            )\n            return\n          }\n\n          const route = rootSpanAttributes.get('next.route') || srcPage\n          const name = `${method} ${route}`\n\n          span.setAttributes({\n            'next.route': route,\n            'http.route': route,\n            'next.span_name': name,\n          })\n          span.updateName(name)\n\n          // Propagate http.route to the parent span if one exists\n          // (e.g. a platform-created HTTP span in adapter\n          // deployments).\n          if (parentSpan && parentSpan !== span) {\n            parentSpan.setAttribute('http.route', route)\n            parentSpan.updateName(name)\n          }\n        })()\n      }\n    }\n\n    // TODO: activeSpan code path is for when wrapped by\n    // next-server can be removed when this is no longer used\n    if (isWrappedByNextServer && activeSpan) {\n      await handleResponse(activeSpan)\n    } else {\n      parentSpan = tracer.getActiveScopeSpan()\n      await tracer.withPropagatedContext(\n        req.headers,\n        () =>\n          tracer.trace(\n            BaseServerSpan.handleRequest,\n            {\n              spanName: `${method} ${srcPage}`,\n              kind: SpanKind.SERVER,\n              attributes: {\n                'http.method': method,\n                'http.target': req.url,\n              },\n            },\n            handleResponse\n          ),\n        undefined,\n        !isWrappedByNextServer\n      )\n    }\n  }\n}\n"],"names":["RouteKind","BaseServerSpan","getTracer","SpanKind","formatUrl","addRequestMeta","getRequestMeta","setRequestMeta","interopDefault","getRevalidateReason","normalizeDataPath","CachedRouteKind","getCacheControlHeader","normalizeRepeatedSlashes","getRedirectStatus","CACHE_ONE_YEAR_SECONDS","HTML_CONTENT_TYPE_HEADER","JSON_CONTENT_TYPE_HEADER","NEXT_NAV_DEPLOYMENT_ID_HEADER","path","sendRenderResult","RenderResult","toResponseCacheEntry","NoFallbackError","RedirectStatusCode","isBot","addPathPrefix","removeTrailingSlash","isRouteCacheOwner","getHandler","srcPage","originalSrcPage","config","userland","routeModule","isFallbackError","getStaticPaths","getStaticProps","getServerSideProps","handler","req","res","ctx","serverFilesManifest","parsedUrl","requestMeta","isDev","process","hrtime","bigint","env","TURBOPACK","replace","multiZoneDraftMode","__NEXT_MULTI_ZONE_DRAFT_MODE","prepareResult","prepare","statusCode","end","waitUntil","Promise","resolve","isMinimalMode","Boolean","render404","routerServerContext","nextConfig","cacheComponents","isWrappedByNextServer","buildId","query","params","originalQuery","originalPathname","buildManifest","fallbackBuildManifest","nextFontManifest","reactLoadableManifest","prerenderManifest","previewProps","isDraftMode","isOnDemandRevalidate","revalidateOnlyGenerated","locale","locales","defaultLocale","resolvedPathname","encodedResolvedPathname","deploymentId","clientAssetToken","isExperimentalCompile","experimental","hasServerProps","hasStaticProps","hasStaticPaths","hasGetInitialProps","default","getInitialProps","cacheKey","isIsrFallback","isNextDataRequest","is404Page","is500Page","isErrorPage","decodedPathname","isPrerendered","routes","notFoundRoutes","includes","cacheOwner","i18n","prerenderInfo","dynamicRoutes","fallback","adapterPath","headers","tracer","activeSpan","getActiveScopeSpan","method","resolvedUrl","pathname","trailingSlash","endsWith","parentSpan","handleResponse","span","responseGenerator","previousCacheEntry","doRender","render","page","renderContext","isFallback","developmentNotFoundSourcePage","sharedContext","customServer","isCustomServer","undefined","renderOpts","pageConfig","Component","ComponentMod","supportsDynamicResponse","assetPrefix","getAssetPrefixForRender","images","nextConfigOutput","output","optimizeCss","nextScriptWorkers","domainLocales","domains","crossOrigin","basePath","disableOptimizedLoading","largePageDataBytes","clientTraceMetadata","setIsrStatus","resolvedAsPath","ErrorDebug","err","distDir","join","cwd","relativeProjectDir","then","renderResult","metadata","cacheControl","revalidate","expire","expireTime","isNotFound","value","isRedirect","kind","REDIRECT","props","pageData","flightData","PAGES","html","status","isStale","silenceLog","onRequestError","routerKind","routePath","routeType","revalidateReason","isStaticGeneration","fallbackResponse","getResponseCache","get","previousFallbackCacheEntry","routeKind","isRoutePPREnabled","incrementalCache","getIncrementalCache","error","isMiss","setHeader","contentType","result","getHeader","notFoundRevalidate","Error","JSON","stringify","handleRedirect","redirect","destination","pageProps","__N_REDIRECT","__N_REDIRECT_STATUS","__N_REDIRECT_BASE_PATH","startsWith","PermanentRedirect","generateEtags","poweredByHeader","setAttributes","rootSpanAttributes","getRootSpanAttributes","handleRequest","console","warn","route","name","updateName","setAttribute","withPropagatedContext","trace","spanName","SERVER","attributes","url"],"mappings":"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","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/app-router-context.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].AppRouterContext;
+
+//# sourceMappingURL=app-router-context.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/app-router-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/app-router-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].AppRouterContext\n"],"names":["module","exports","require","vendored","AppRouterContext"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,gBAAgB","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/entrypoints.js

@@ -0,0 +1,11 @@
+export * as RouterContext from '../../../../../shared/lib/router-context.shared-runtime';
+export * as LoadableContext from '../../../../../shared/lib/loadable-context.shared-runtime';
+export * as Loadable from '../../../../../shared/lib/loadable.shared-runtime';
+export * as ImageConfigContext from '../../../../../shared/lib/image-config-context.shared-runtime';
+export * as HtmlContext from '../../../../../shared/lib/html-context.shared-runtime';
+export * as HooksClientContext from '../../../../../shared/lib/hooks-client-context.shared-runtime';
+export * as HeadManagerContext from '../../../../../shared/lib/head-manager-context.shared-runtime';
+export * as AppRouterContext from '../../../../../shared/lib/app-router-context.shared-runtime';
+export * as ServerInsertedHtml from '../../../../../shared/lib/server-inserted-html.shared-runtime';
+
+//# sourceMappingURL=entrypoints.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/entrypoints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/entrypoints.ts"],"sourcesContent":["export * as RouterContext from '../../../../../shared/lib/router-context.shared-runtime'\nexport * as LoadableContext from '../../../../../shared/lib/loadable-context.shared-runtime'\nexport * as Loadable from '../../../../../shared/lib/loadable.shared-runtime'\nexport * as ImageConfigContext from '../../../../../shared/lib/image-config-context.shared-runtime'\nexport * as HtmlContext from '../../../../../shared/lib/html-context.shared-runtime'\nexport * as HooksClientContext from '../../../../../shared/lib/hooks-client-context.shared-runtime'\nexport * as HeadManagerContext from '../../../../../shared/lib/head-manager-context.shared-runtime'\nexport * as AppRouterContext from '../../../../../shared/lib/app-router-context.shared-runtime'\nexport * as ServerInsertedHtml from '../../../../../shared/lib/server-inserted-html.shared-runtime'\n"],"names":["RouterContext","LoadableContext","Loadable","ImageConfigContext","HtmlContext","HooksClientContext","HeadManagerContext","AppRouterContext","ServerInsertedHtml"],"mappings":"AAAA,OAAO,KAAKA,aAAa,MAAM,0DAAyD;AACxF,OAAO,KAAKC,eAAe,MAAM,4DAA2D;AAC5F,OAAO,KAAKC,QAAQ,MAAM,oDAAmD;AAC7E,OAAO,KAAKC,kBAAkB,MAAM,gEAA+D;AACnG,OAAO,KAAKC,WAAW,MAAM,wDAAuD;AACpF,OAAO,KAAKC,kBAAkB,MAAM,gEAA+D;AACnG,OAAO,KAAKC,kBAAkB,MAAM,gEAA+D;AACnG,OAAO,KAAKC,gBAAgB,MAAM,8DAA6D;AAC/F,OAAO,KAAKC,kBAAkB,MAAM,gEAA+D","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/head-manager-context.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].HeadManagerContext;
+
+//# sourceMappingURL=head-manager-context.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/head-manager-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/head-manager-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].HeadManagerContext\n"],"names":["module","exports","require","vendored","HeadManagerContext"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/hooks-client-context.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].HooksClientContext;
+
+//# sourceMappingURL=hooks-client-context.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/hooks-client-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/hooks-client-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].HooksClientContext\n"],"names":["module","exports","require","vendored","HooksClientContext"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/html-context.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].HtmlContext;
+
+//# sourceMappingURL=html-context.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/html-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/html-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].HtmlContext\n"],"names":["module","exports","require","vendored","HtmlContext"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,WAAW","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/image-config-context.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].ImageConfigContext;
+
+//# sourceMappingURL=image-config-context.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/image-config-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/image-config-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].ImageConfigContext\n"],"names":["module","exports","require","vendored","ImageConfigContext"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/loadable-context.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].LoadableContext;
+
+//# sourceMappingURL=loadable-context.js.map

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/loadable-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-modules/pages/vendored/contexts/loadable-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].LoadableContext\n"],"names":["module","exports","require","vendored","LoadableContext"],"mappings":"AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,eAAe","ignoreList":[0]}

e-commerce/node_modules/next/dist/esm/server/route-modules/pages/vendored/contexts/loadable.js

@@ -0,0 +1,3 @@
+module.exports = require('../../module.compiled').vendored['contexts'].Loadable;
+
+//# sourceMappingURL=loadable.js.map