feat: frontend PWA scaffolding with React and Tailwind

frontend/node_modules/next/dist/build/templates/app-page.d.ts

@@ -0,0 +1,21 @@
+import type { LoaderTree } from '../../server/lib/app-dir-module';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { AppPageRouteModule } from '../../server/route-modules/app-page/module.compiled';
+/**
+ * The tree created in next-app-loader that holds component segments and modules
+ * and I've updated it.
+ */
+declare const tree: LoaderTree;
+declare const pages: any;
+export { tree, pages };
+import GlobalError from 'VAR_MODULE_GLOBAL_ERROR';
+export { GlobalError };
+export declare const __next_app__: {
+    require: (id: string | number) => unknown;
+    loadChunk: (id: string | number) => Promise<unknown>;
+};
+export * from '../../server/app-render/entry-base';
+export declare const routeModule: AppPageRouteModule;
+export declare function handler(req: IncomingMessage, res: ServerResponse, ctx: {
+    waitUntil: (prom: Promise<void>) => void;
+}): Promise<void | null>;

frontend/node_modules/next/dist/build/templates/app-page.js

@@ -0,0 +1,994 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    GlobalError: null,
+    __next_app__: null,
+    handler: null,
+    pages: null,
+    routeModule: null,
+    tree: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    GlobalError: function() {
+        return _VAR_MODULE_GLOBAL_ERROR.default;
+    },
+    __next_app__: function() {
+        return __next_app__;
+    },
+    handler: function() {
+        return handler;
+    },
+    pages: function() {
+        return pages;
+    },
+    routeModule: function() {
+        return routeModule;
+    },
+    tree: function() {
+        return tree;
+    }
+});
+0 && __export(require("../../server/app-render/entry-base"));
+const _modulecompiled = require("../../server/route-modules/app-page/module.compiled");
+const _routekind = require("../../server/route-kind");
+const _utils = require("../../server/instrumentation/utils");
+const _tracer = require("../../server/lib/trace/tracer");
+const _requestmeta = require("../../server/request-meta");
+const _constants = require("../../server/lib/trace/constants");
+const _interopdefault = require("../../server/app-render/interop-default");
+const _stripflightheaders = require("../../server/app-render/strip-flight-headers");
+const _node = require("../../server/base-http/node");
+const _ppr = require("../../server/lib/experimental/ppr");
+const _fallbackparams = require("../../server/request/fallback-params");
+const _encryptionutils = require("../../server/app-render/encryption-utils");
+const _streamingmetadata = require("../../server/lib/streaming-metadata");
+const _actionutils = require("../../server/app-render/action-utils");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _serveractionrequestmeta = require("../../server/lib/server-action-request-meta");
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _isbot = require("../../shared/lib/router/utils/is-bot");
+const _responsecache = require("../../server/response-cache");
+const _fallback = require("../../lib/fallback");
+const _renderresult = /*#__PURE__*/ _interop_require_default(require("../../server/render-result"));
+const _constants1 = require("../../lib/constants");
+const _encodedtags = require("../../server/stream-utils/encoded-tags");
+const _sendpayload = require("../../server/send-payload");
+const _nofallbackerrorexternal = require("../../shared/lib/no-fallback-error.external");
+const _VAR_MODULE_GLOBAL_ERROR = /*#__PURE__*/ _interop_require_default(require("VAR_MODULE_GLOBAL_ERROR"));
+const _entrybase = /*#__PURE__*/ _interop_require_wildcard(_export_star(require("../../server/app-render/entry-base"), exports));
+const _redirectstatuscode = require("../../client/components/redirect-status-code");
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const __next_app__ = {
+    require: __next_app_require__,
+    loadChunk: __next_app_load_chunk__
+};
+const routeModule = new _modulecompiled.AppPageRouteModule({
+    definition: {
+        kind: _routekind.RouteKind.APP_PAGE,
+        page: 'VAR_DEFINITION_PAGE',
+        pathname: 'VAR_DEFINITION_PATHNAME',
+        // The following aren't used in production.
+        bundlePath: '',
+        filename: '',
+        appPaths: []
+    },
+    userland: {
+        loaderTree: tree
+    },
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || ''
+});
+async function handler(req, res, ctx) {
+    var _this;
+    let srcPage = 'VAR_DEFINITION_PAGE';
+    // 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 initialPostponed = (0, _requestmeta.getRequestMeta)(req, 'postponed');
+    // TODO: replace with more specific flags
+    const minimalMode = (0, _requestmeta.getRequestMeta)(req, 'minimalMode');
+    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 null;
+    }
+    const { buildId, query, params, parsedUrl, pageIsDynamic, buildManifest, nextFontManifest, reactLoadableManifest, serverActionsManifest, clientReferenceManifest, subresourceIntegrityManifest, prerenderManifest, isDraftMode, resolvedPathname, revalidateOnlyGenerated, routerServerContext, nextConfig, interceptionRoutePatterns } = prepareResult;
+    const pathname = parsedUrl.pathname || '/';
+    const normalizedSrcPage = (0, _apppaths.normalizeAppPath)(srcPage);
+    let { isOnDemandRevalidate } = prepareResult;
+    const prerenderInfo = routeModule.match(pathname, prerenderManifest);
+    const isPrerendered = !!prerenderManifest.routes[resolvedPathname];
+    let isSSG = Boolean(prerenderInfo || isPrerendered || prerenderManifest.routes[normalizedSrcPage]);
+    const userAgent = req.headers['user-agent'] || '';
+    const botType = (0, _isbot.getBotType)(userAgent);
+    const isHtmlBot = (0, _streamingmetadata.isHtmlBotRequest)(req);
+    /**
+   * If true, this indicates that the request being made is for an app
+   * prefetch request.
+   */ const isPrefetchRSCRequest = (0, _requestmeta.getRequestMeta)(req, 'isPrefetchRSCRequest') ?? req.headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '1' // exclude runtime prefetches, which use '2'
+    ;
+    // NOTE: Don't delete headers[RSC] yet, it still needs to be used in renderToHTML later
+    const isRSCRequest = (0, _requestmeta.getRequestMeta)(req, 'isRSCRequest') ?? Boolean(req.headers[_approuterheaders.RSC_HEADER]);
+    const isPossibleServerAction = (0, _serveractionrequestmeta.getIsPossibleServerAction)(req);
+    /**
+   * If the route being rendered is an app page, and the ppr feature has been
+   * enabled, then the given route _could_ support PPR.
+   */ const couldSupportPPR = (0, _ppr.checkIsAppPPREnabled)(nextConfig.experimental.ppr);
+    // When enabled, this will allow the use of the `?__nextppronly` query to
+    // enable debugging of the static shell.
+    const hasDebugStaticShellQuery = process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING === '1' && typeof query.__nextppronly !== 'undefined' && couldSupportPPR;
+    // When enabled, this will allow the use of the `?__nextppronly` query
+    // to enable debugging of the fallback shell.
+    const hasDebugFallbackShellQuery = hasDebugStaticShellQuery && query.__nextppronly === 'fallback';
+    // This page supports PPR if it is marked as being `PARTIALLY_STATIC` in the
+    // prerender manifest and this is an app page.
+    const isRoutePPREnabled = couldSupportPPR && (((_this = prerenderManifest.routes[normalizedSrcPage] ?? prerenderManifest.dynamicRoutes[normalizedSrcPage]) == null ? void 0 : _this.renderingMode) === 'PARTIALLY_STATIC' || // Ideally we'd want to check the appConfig to see if this page has PPR
+    // enabled or not, but that would require plumbing the appConfig through
+    // to the server during development. We assume that the page supports it
+    // but only during development.
+    hasDebugStaticShellQuery && (routeModule.isDev === true || (routerServerContext == null ? void 0 : routerServerContext.experimentalTestProxy) === true));
+    const isDebugStaticShell = hasDebugStaticShellQuery && isRoutePPREnabled;
+    // We should enable debugging dynamic accesses when the static shell
+    // debugging has been enabled and we're also in development mode.
+    const isDebugDynamicAccesses = isDebugStaticShell && routeModule.isDev === true;
+    const isDebugFallbackShell = hasDebugFallbackShellQuery && isRoutePPREnabled;
+    // If we're in minimal mode, then try to get the postponed information from
+    // the request metadata. If available, use it for resuming the postponed
+    // render.
+    const minimalPostponed = isRoutePPREnabled ? initialPostponed : undefined;
+    // If PPR is enabled, and this is a RSC request (but not a prefetch), then
+    // we can use this fact to only generate the flight data for the request
+    // because we can't cache the HTML (as it's also dynamic).
+    const isDynamicRSCRequest = isRoutePPREnabled && isRSCRequest && !isPrefetchRSCRequest;
+    // Need to read this before it's stripped by stripFlightHeaders. We don't
+    // need to transfer it to the request meta because it's only read
+    // within this function; the static segment data should have already been
+    // generated, so we will always either return a static response or a 404.
+    const segmentPrefetchHeader = (0, _requestmeta.getRequestMeta)(req, 'segmentPrefetchRSCRequest');
+    // TODO: investigate existing bug with shouldServeStreamingMetadata always
+    // being true for a revalidate due to modifying the base-server this.renderOpts
+    // when fixing this to correct logic it causes hydration issue since we set
+    // serveStreamingMetadata to true during export
+    let serveStreamingMetadata = !userAgent ? true : (0, _streamingmetadata.shouldServeStreamingMetadata)(userAgent, nextConfig.htmlLimitedBots);
+    if (isHtmlBot && isRoutePPREnabled) {
+        isSSG = false;
+        serveStreamingMetadata = false;
+    }
+    // In development, we always want to generate dynamic HTML.
+    let supportsDynamicResponse = // If we're in development, we always support dynamic HTML, unless it's
+    // a data request, in which case we only produce static HTML.
+    routeModule.isDev === true || // If this is not SSG or does not have static paths, then it supports
+    // dynamic HTML.
+    !isSSG || // If this request has provided postponed data, it supports dynamic
+    // HTML.
+    typeof initialPostponed === 'string' || // If this is a dynamic RSC request, then this render supports dynamic
+    // HTML (it's dynamic).
+    isDynamicRSCRequest;
+    // When html bots request PPR page, perform the full dynamic rendering.
+    const shouldWaitOnAllReady = isHtmlBot && isRoutePPREnabled;
+    let ssgCacheKey = null;
+    if (!isDraftMode && isSSG && !supportsDynamicResponse && !isPossibleServerAction && !minimalPostponed && !isDynamicRSCRequest) {
+        ssgCacheKey = resolvedPathname;
+    }
+    // the staticPathKey differs from ssgCacheKey since
+    // ssgCacheKey is null in dev since we're always in "dynamic"
+    // mode in dev to bypass the cache, but we still need to honor
+    // dynamicParams = false in dev mode
+    let staticPathKey = ssgCacheKey;
+    if (!staticPathKey && routeModule.isDev) {
+        staticPathKey = resolvedPathname;
+    }
+    // If this is a request for an app path that should be statically generated
+    // and we aren't in the edge runtime, strip the flight headers so it will
+    // generate the static response.
+    if (!routeModule.isDev && !isDraftMode && isSSG && isRSCRequest && !isDynamicRSCRequest) {
+        (0, _stripflightheaders.stripFlightHeaders)(req.headers);
+    }
+    const ComponentMod = {
+        ..._entrybase,
+        tree,
+        pages,
+        GlobalError: _VAR_MODULE_GLOBAL_ERROR.default,
+        handler,
+        routeModule,
+        __next_app__
+    };
+    // Before rendering (which initializes component tree modules), we have to
+    // set the reference manifests to our global store so Server Action's
+    // encryption util can access to them at the top level of the page module.
+    if (serverActionsManifest && clientReferenceManifest) {
+        (0, _encryptionutils.setReferenceManifestsSingleton)({
+            page: srcPage,
+            clientReferenceManifest,
+            serverActionsManifest,
+            serverModuleMap: (0, _actionutils.createServerModuleMap)({
+                serverActionsManifest
+            })
+        });
+    }
+    const method = req.method || 'GET';
+    const tracer = (0, _tracer.getTracer)();
+    const activeSpan = tracer.getActiveScopeSpan();
+    try {
+        const varyHeader = routeModule.getVaryHeader(resolvedPathname, interceptionRoutePatterns);
+        res.setHeader('Vary', varyHeader);
+        const invokeRouteModule = async (span, context)=>{
+            const nextReq = new _node.NodeNextRequest(req);
+            const nextRes = new _node.NodeNextResponse(res);
+            // TODO: adapt for putting the RDC inside the postponed data
+            // If we're in dev, and this isn't a prefetch or a server action,
+            // we should seed the resume data cache.
+            if (process.env.NODE_ENV === 'development') {
+                if (nextConfig.experimental.cacheComponents && !isPrefetchRSCRequest && !context.renderOpts.isPossibleServerAction) {
+                    const warmup = await routeModule.warmup(nextReq, nextRes, context);
+                    // If the warmup is successful, we should use the resume data
+                    // cache from the warmup.
+                    if (warmup.metadata.renderResumeDataCache) {
+                        context.renderOpts.renderResumeDataCache = warmup.metadata.renderResumeDataCache;
+                    }
+                }
+            }
+            return routeModule.render(nextReq, nextRes, context).finally(()=>{
+                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') !== _constants.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');
+                if (route) {
+                    const name = `${method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                } else {
+                    span.updateName(`${method} ${req.url}`);
+                }
+            });
+        };
+        const doRender = async ({ span, postponed, fallbackRouteParams })=>{
+            const context = {
+                query,
+                params,
+                page: normalizedSrcPage,
+                sharedContext: {
+                    buildId
+                },
+                serverComponentsHmrCache: (0, _requestmeta.getRequestMeta)(req, 'serverComponentsHmrCache'),
+                fallbackRouteParams,
+                renderOpts: {
+                    App: ()=>null,
+                    Document: ()=>null,
+                    pageConfig: {},
+                    ComponentMod,
+                    Component: (0, _interopdefault.interopDefault)(ComponentMod),
+                    params,
+                    routeModule,
+                    page: srcPage,
+                    postponed,
+                    shouldWaitOnAllReady,
+                    serveStreamingMetadata,
+                    supportsDynamicResponse: typeof postponed === 'string' || supportsDynamicResponse,
+                    buildManifest,
+                    nextFontManifest,
+                    reactLoadableManifest,
+                    subresourceIntegrityManifest,
+                    serverActionsManifest,
+                    clientReferenceManifest,
+                    setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
+                    dir: process.env.NEXT_RUNTIME === 'nodejs' ? require('path').join(/* turbopackIgnore: true */ process.cwd(), routeModule.relativeProjectDir) : `${process.cwd()}/${routeModule.relativeProjectDir}`,
+                    isDraftMode,
+                    isRevalidate: isSSG && !postponed && !isDynamicRSCRequest,
+                    botType,
+                    isOnDemandRevalidate,
+                    isPossibleServerAction,
+                    assetPrefix: nextConfig.assetPrefix,
+                    nextConfigOutput: nextConfig.output,
+                    crossOrigin: nextConfig.crossOrigin,
+                    trailingSlash: nextConfig.trailingSlash,
+                    previewProps: prerenderManifest.preview,
+                    deploymentId: nextConfig.deploymentId,
+                    enableTainting: nextConfig.experimental.taint,
+                    htmlLimitedBots: nextConfig.htmlLimitedBots,
+                    devtoolSegmentExplorer: nextConfig.experimental.devtoolSegmentExplorer,
+                    reactMaxHeadersLength: nextConfig.reactMaxHeadersLength,
+                    multiZoneDraftMode,
+                    incrementalCache: (0, _requestmeta.getRequestMeta)(req, 'incrementalCache'),
+                    cacheLifeProfiles: nextConfig.experimental.cacheLife,
+                    basePath: nextConfig.basePath,
+                    serverActions: nextConfig.experimental.serverActions,
+                    ...isDebugStaticShell || isDebugDynamicAccesses ? {
+                        nextExport: true,
+                        supportsDynamicResponse: false,
+                        isStaticGeneration: true,
+                        isRevalidate: true,
+                        isDebugDynamicAccesses: isDebugDynamicAccesses
+                    } : {},
+                    experimental: {
+                        isRoutePPREnabled,
+                        expireTime: nextConfig.expireTime,
+                        staleTimes: nextConfig.experimental.staleTimes,
+                        cacheComponents: Boolean(nextConfig.experimental.cacheComponents),
+                        clientSegmentCache: Boolean(nextConfig.experimental.clientSegmentCache),
+                        clientParamParsing: Boolean(nextConfig.experimental.clientParamParsing),
+                        dynamicOnHover: Boolean(nextConfig.experimental.dynamicOnHover),
+                        inlineCss: Boolean(nextConfig.experimental.inlineCss),
+                        authInterrupts: Boolean(nextConfig.experimental.authInterrupts),
+                        clientTraceMetadata: nextConfig.experimental.clientTraceMetadata || []
+                    },
+                    waitUntil: ctx.waitUntil,
+                    onClose: (cb)=>{
+                        res.on('close', cb);
+                    },
+                    onAfterTaskError: ()=>{},
+                    onInstrumentationRequestError: (error, _request, errorContext)=>routeModule.onRequestError(req, error, errorContext, routerServerContext),
+                    err: (0, _requestmeta.getRequestMeta)(req, 'invokeError'),
+                    dev: routeModule.isDev
+                }
+            };
+            const result = await invokeRouteModule(span, context);
+            const { metadata } = result;
+            const { cacheControl, headers = {}, // Add any fetch tags that were on the page to the response headers.
+            fetchTags: cacheTags } = metadata;
+            if (cacheTags) {
+                headers[_constants1.NEXT_CACHE_TAGS_HEADER] = cacheTags;
+            }
+            // Pull any fetch metrics from the render onto the request.
+            ;
+            req.fetchMetrics = metadata.fetchMetrics;
+            // we don't throw static to dynamic errors in dev as isSSG
+            // is a best guess in dev since we don't have the prerender pass
+            // to know whether the path is actually static or not
+            if (isSSG && (cacheControl == null ? void 0 : cacheControl.revalidate) === 0 && !routeModule.isDev && !isRoutePPREnabled) {
+                const staticBailoutInfo = metadata.staticBailoutInfo;
+                const err = Object.defineProperty(new Error(`Page changed from static to dynamic at runtime ${resolvedPathname}${(staticBailoutInfo == null ? void 0 : staticBailoutInfo.description) ? `, reason: ${staticBailoutInfo.description}` : ``}` + `\nsee more here https://nextjs.org/docs/messages/app-static-to-dynamic-error`), "__NEXT_ERROR_CODE", {
+                    value: "E132",
+                    enumerable: false,
+                    configurable: true
+                });
+                if (staticBailoutInfo == null ? void 0 : staticBailoutInfo.stack) {
+                    const stack = staticBailoutInfo.stack;
+                    err.stack = err.message + stack.substring(stack.indexOf('\n'));
+                }
+                throw err;
+            }
+            return {
+                value: {
+                    kind: _responsecache.CachedRouteKind.APP_PAGE,
+                    html: result,
+                    headers,
+                    rscData: metadata.flightData,
+                    postponed: metadata.postponed,
+                    status: metadata.statusCode,
+                    segmentData: metadata.segmentData
+                },
+                cacheControl
+            };
+        };
+        const responseGenerator = async ({ hasResolved, previousCacheEntry, isRevalidating, span })=>{
+            const isProduction = routeModule.isDev === false;
+            const didRespond = hasResolved || res.writableEnded;
+            // skip on-demand revalidate if cache is not present and
+            // revalidate-if-generated is set
+            if (isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry && !minimalMode) {
+                if (routerServerContext == null ? void 0 : routerServerContext.render404) {
+                    await routerServerContext.render404(req, res);
+                } else {
+                    res.statusCode = 404;
+                    res.end('This page could not be found');
+                }
+                return null;
+            }
+            let fallbackMode;
+            if (prerenderInfo) {
+                fallbackMode = (0, _fallback.parseFallbackField)(prerenderInfo.fallback);
+            }
+            // When serving a HTML 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 (fallbackMode === _fallback.FallbackMode.PRERENDER && (0, _isbot.isBot)(userAgent)) {
+                if (!isRoutePPREnabled || isHtmlBot) {
+                    fallbackMode = _fallback.FallbackMode.BLOCKING_STATIC_RENDER;
+                }
+            }
+            if ((previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) === -1) {
+                isOnDemandRevalidate = true;
+            }
+            // TODO: adapt for PPR
+            // only allow on-demand revalidate for fallback: true/blocking
+            // or for prerendered fallback: false paths
+            if (isOnDemandRevalidate && (fallbackMode !== _fallback.FallbackMode.NOT_FOUND || previousCacheEntry)) {
+                fallbackMode = _fallback.FallbackMode.BLOCKING_STATIC_RENDER;
+            }
+            if (!minimalMode && fallbackMode !== _fallback.FallbackMode.BLOCKING_STATIC_RENDER && staticPathKey && !didRespond && !isDraftMode && pageIsDynamic && (isProduction || !isPrerendered)) {
+                // if the page has dynamicParams: false and this pathname wasn't
+                // prerendered trigger the no fallback handling
+                if (// In development, fall through to render to handle missing
+                // getStaticPaths.
+                (isProduction || prerenderInfo) && // When fallback isn't present, abort this render so we 404
+                fallbackMode === _fallback.FallbackMode.NOT_FOUND) {
+                    throw new _nofallbackerrorexternal.NoFallbackError();
+                }
+                let fallbackResponse;
+                if (isRoutePPREnabled && !isRSCRequest) {
+                    const cacheKey = typeof (prerenderInfo == null ? void 0 : prerenderInfo.fallback) === 'string' ? prerenderInfo.fallback : isProduction ? normalizedSrcPage : null;
+                    // We use the response cache here to handle the revalidation and
+                    // management of the fallback shell.
+                    fallbackResponse = await routeModule.handleResponse({
+                        cacheKey,
+                        req,
+                        nextConfig,
+                        routeKind: _routekind.RouteKind.APP_PAGE,
+                        isFallback: true,
+                        prerenderManifest,
+                        isRoutePPREnabled,
+                        responseGenerator: async ()=>doRender({
+                                span,
+                                // We pass `undefined` as rendering a fallback isn't resumed
+                                // here.
+                                postponed: undefined,
+                                fallbackRouteParams: // If we're in production or we're debugging the fallback
+                                // shell then we should postpone when dynamic params are
+                                // accessed.
+                                isProduction || isDebugFallbackShell ? (0, _fallbackparams.getFallbackRouteParams)(normalizedSrcPage) : null
+                            }),
+                        waitUntil: ctx.waitUntil
+                    });
+                    // If the fallback response was set to null, then we should return null.
+                    if (fallbackResponse === null) return null;
+                    // Otherwise, if we did get a fallback response, we should return it.
+                    if (fallbackResponse) {
+                        // Remove the cache control from the response to prevent it from being
+                        // used in the surrounding cache.
+                        delete fallbackResponse.cacheControl;
+                        return fallbackResponse;
+                    }
+                }
+            }
+            // Only requests that aren't revalidating can be resumed. If we have the
+            // minimal postponed data, then we should resume the render with it.
+            const postponed = !isOnDemandRevalidate && !isRevalidating && minimalPostponed ? minimalPostponed : undefined;
+            // When we're in minimal mode, if we're trying to debug the static shell,
+            // we should just return nothing instead of resuming the dynamic render.
+            if ((isDebugStaticShell || isDebugDynamicAccesses) && typeof postponed !== 'undefined') {
+                return {
+                    cacheControl: {
+                        revalidate: 1,
+                        expire: undefined
+                    },
+                    value: {
+                        kind: _responsecache.CachedRouteKind.PAGES,
+                        html: _renderresult.default.EMPTY,
+                        pageData: {},
+                        headers: undefined,
+                        status: undefined
+                    }
+                };
+            }
+            // If this is a dynamic route with PPR enabled and the default route
+            // matches were set, then we should pass the fallback route params to
+            // the renderer as this is a fallback revalidation request.
+            const fallbackRouteParams = pageIsDynamic && isRoutePPREnabled && ((0, _requestmeta.getRequestMeta)(req, 'renderFallbackShell') || isDebugFallbackShell) ? (0, _fallbackparams.getFallbackRouteParams)(pathname) : null;
+            // Perform the render.
+            return doRender({
+                span,
+                postponed,
+                fallbackRouteParams
+            });
+        };
+        const handleResponse = async (span)=>{
+            var _cacheEntry_value, _cachedData_headers;
+            const cacheEntry = await routeModule.handleResponse({
+                cacheKey: ssgCacheKey,
+                responseGenerator: (c)=>responseGenerator({
+                        span,
+                        ...c
+                    }),
+                routeKind: _routekind.RouteKind.APP_PAGE,
+                isOnDemandRevalidate,
+                isRoutePPREnabled,
+                req,
+                nextConfig,
+                prerenderManifest,
+                waitUntil: ctx.waitUntil
+            });
+            if (isDraftMode) {
+                res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
+            }
+            // In dev, we should not cache pages for any reason.
+            if (routeModule.isDev) {
+                res.setHeader('Cache-Control', 'no-store, must-revalidate');
+            }
+            if (!cacheEntry) {
+                if (ssgCacheKey) {
+                    // A cache entry might not be generated if a response is written
+                    // in `getInitialProps` or `getServerSideProps`, but those shouldn't
+                    // have a cache key. If we do have a cache key but we don't end up
+                    // with a cache entry, then either Next.js or the application has a
+                    // bug that needs fixing.
+                    throw Object.defineProperty(new Error('invariant: cache entry required but not generated'), "__NEXT_ERROR_CODE", {
+                        value: "E62",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                return null;
+            }
+            if (((_cacheEntry_value = cacheEntry.value) == null ? void 0 : _cacheEntry_value.kind) !== _responsecache.CachedRouteKind.APP_PAGE) {
+                var _cacheEntry_value1;
+                throw Object.defineProperty(new Error(`Invariant app-page handler received invalid cache entry ${(_cacheEntry_value1 = cacheEntry.value) == null ? void 0 : _cacheEntry_value1.kind}`), "__NEXT_ERROR_CODE", {
+                    value: "E707",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            const didPostpone = typeof cacheEntry.value.postponed === 'string';
+            if (isSSG && // We don't want to send a cache header for requests that contain dynamic
+            // data. If this is a Dynamic RSC request or wasn't a Prefetch RSC
+            // request, then we should set the cache header.
+            !isDynamicRSCRequest && (!didPostpone || isPrefetchRSCRequest)) {
+                if (!minimalMode) {
+                    // set x-nextjs-cache header to match the header
+                    // we set for the image-optimizer
+                    res.setHeader('x-nextjs-cache', isOnDemandRevalidate ? 'REVALIDATED' : cacheEntry.isMiss ? 'MISS' : cacheEntry.isStale ? 'STALE' : 'HIT');
+                }
+                // Set a header used by the client router to signal the response is static
+                // and should respect the `static` cache staleTime value.
+                res.setHeader(_approuterheaders.NEXT_IS_PRERENDER_HEADER, '1');
+            }
+            const { value: cachedData } = cacheEntry;
+            // Coerce the cache control parameter from the render.
+            let cacheControl;
+            // If this is a resume request in minimal mode it is streamed with dynamic
+            // content and should not be cached.
+            if (minimalPostponed) {
+                cacheControl = {
+                    revalidate: 0,
+                    expire: undefined
+                };
+            } else if (minimalMode && isRSCRequest && !isPrefetchRSCRequest && isRoutePPREnabled) {
+                cacheControl = {
+                    revalidate: 0,
+                    expire: undefined
+                };
+            } else if (!routeModule.isDev) {
+                // If this is a preview mode request, we shouldn't cache it
+                if (isDraftMode) {
+                    cacheControl = {
+                        revalidate: 0,
+                        expire: undefined
+                    };
+                } else if (!isSSG) {
+                    if (!res.getHeader('Cache-Control')) {
+                        cacheControl = {
+                            revalidate: 0,
+                            expire: undefined
+                        };
+                    }
+                } else if (cacheEntry.cacheControl) {
+                    // If the cache entry has a cache control with a revalidate value that's
+                    // a number, use it.
+                    if (typeof cacheEntry.cacheControl.revalidate === 'number') {
+                        var _cacheEntry_cacheControl;
+                        if (cacheEntry.cacheControl.revalidate < 1) {
+                            throw Object.defineProperty(new Error(`Invalid revalidate configuration provided: ${cacheEntry.cacheControl.revalidate} < 1`), "__NEXT_ERROR_CODE", {
+                                value: "E22",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        cacheControl = {
+                            revalidate: cacheEntry.cacheControl.revalidate,
+                            expire: ((_cacheEntry_cacheControl = cacheEntry.cacheControl) == null ? void 0 : _cacheEntry_cacheControl.expire) ?? nextConfig.expireTime
+                        };
+                    } else {
+                        cacheControl = {
+                            revalidate: _constants1.CACHE_ONE_YEAR,
+                            expire: undefined
+                        };
+                    }
+                }
+            }
+            cacheEntry.cacheControl = cacheControl;
+            if (typeof segmentPrefetchHeader === 'string' && (cachedData == null ? void 0 : cachedData.kind) === _responsecache.CachedRouteKind.APP_PAGE && cachedData.segmentData) {
+                var _cachedData_headers1;
+                // This is a prefetch request issued by the client Segment Cache. These
+                // should never reach the application layer (lambda). We should either
+                // respond from the cache (HIT) or respond with 204 No Content (MISS).
+                // Set a header to indicate that PPR is enabled for this route. This
+                // lets the client distinguish between a regular cache miss and a cache
+                // miss due to PPR being disabled. In other contexts this header is used
+                // to indicate that the response contains dynamic data, but here we're
+                // only using it to indicate that the feature is enabled — the segment
+                // response itself contains whether the data is dynamic.
+                res.setHeader(_approuterheaders.NEXT_DID_POSTPONE_HEADER, '2');
+                // Add the cache tags header to the response if it exists and we're in
+                // minimal mode while rendering a static page.
+                const tags = (_cachedData_headers1 = cachedData.headers) == null ? void 0 : _cachedData_headers1[_constants1.NEXT_CACHE_TAGS_HEADER];
+                if (minimalMode && isSSG && tags && typeof tags === 'string') {
+                    res.setHeader(_constants1.NEXT_CACHE_TAGS_HEADER, tags);
+                }
+                const matchedSegment = cachedData.segmentData.get(segmentPrefetchHeader);
+                if (matchedSegment !== undefined) {
+                    // Cache hit
+                    return (0, _sendpayload.sendRenderResult)({
+                        req,
+                        res,
+                        generateEtags: nextConfig.generateEtags,
+                        poweredByHeader: nextConfig.poweredByHeader,
+                        result: _renderresult.default.fromStatic(matchedSegment, _approuterheaders.RSC_CONTENT_TYPE_HEADER),
+                        cacheControl: cacheEntry.cacheControl
+                    });
+                }
+                // Cache miss. Either a cache entry for this route has not been generated
+                // (which technically should not be possible when PPR is enabled, because
+                // at a minimum there should always be a fallback entry) or there's no
+                // match for the requested segment. Respond with a 204 No Content. We
+                // don't bother to respond with 404, because these requests are only
+                // issued as part of a prefetch.
+                res.statusCode = 204;
+                return (0, _sendpayload.sendRenderResult)({
+                    req,
+                    res,
+                    generateEtags: nextConfig.generateEtags,
+                    poweredByHeader: nextConfig.poweredByHeader,
+                    result: _renderresult.default.EMPTY,
+                    cacheControl: cacheEntry.cacheControl
+                });
+            }
+            // If there's a callback for `onCacheEntry`, call it with the cache entry
+            // and the revalidate options.
+            const onCacheEntry = (0, _requestmeta.getRequestMeta)(req, 'onCacheEntry');
+            if (onCacheEntry) {
+                const finished = await onCacheEntry({
+                    ...cacheEntry,
+                    // TODO: remove this when upstream doesn't
+                    // always expect this value to be "PAGE"
+                    value: {
+                        ...cacheEntry.value,
+                        kind: 'PAGE'
+                    }
+                }, {
+                    url: (0, _requestmeta.getRequestMeta)(req, 'initURL')
+                });
+                if (finished) {
+                    // TODO: maybe we have to end the request?
+                    return null;
+                }
+            }
+            // If the request has a postponed state and it's a resume request we
+            // should error.
+            if (didPostpone && minimalPostponed) {
+                throw Object.defineProperty(new Error('Invariant: postponed state should not be present on a resume request'), "__NEXT_ERROR_CODE", {
+                    value: "E396",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            if (cachedData.headers) {
+                const headers = {
+                    ...cachedData.headers
+                };
+                if (!minimalMode || !isSSG) {
+                    delete headers[_constants1.NEXT_CACHE_TAGS_HEADER];
+                }
+                for (let [key, value] of Object.entries(headers)){
+                    if (typeof value === 'undefined') continue;
+                    if (Array.isArray(value)) {
+                        for (const v of value){
+                            res.appendHeader(key, v);
+                        }
+                    } else if (typeof value === 'number') {
+                        value = value.toString();
+                        res.appendHeader(key, value);
+                    } else {
+                        res.appendHeader(key, value);
+                    }
+                }
+            }
+            // Add the cache tags header to the response if it exists and we're in
+            // minimal mode while rendering a static page.
+            const tags = (_cachedData_headers = cachedData.headers) == null ? void 0 : _cachedData_headers[_constants1.NEXT_CACHE_TAGS_HEADER];
+            if (minimalMode && isSSG && tags && typeof tags === 'string') {
+                res.setHeader(_constants1.NEXT_CACHE_TAGS_HEADER, tags);
+            }
+            // If the request is a data request, then we shouldn't set the status code
+            // from the response because it should always be 200. This should be gated
+            // behind the experimental PPR flag.
+            if (cachedData.status && (!isRSCRequest || !isRoutePPREnabled)) {
+                res.statusCode = cachedData.status;
+            }
+            // Redirect information is encoded in RSC payload, so we don't need to use redirect status codes
+            if (!minimalMode && cachedData.status && _redirectstatuscode.RedirectStatusCode[cachedData.status] && isRSCRequest) {
+                res.statusCode = 200;
+            }
+            // Mark that the request did postpone.
+            if (didPostpone) {
+                res.setHeader(_approuterheaders.NEXT_DID_POSTPONE_HEADER, '1');
+            }
+            // we don't go through this block when preview mode is true
+            // as preview mode is a dynamic request (bypasses cache) and doesn't
+            // generate both HTML and payloads in the same request so continue to just
+            // return the generated payload
+            if (isRSCRequest && !isDraftMode) {
+                // If this is a dynamic RSC request, then stream the response.
+                if (typeof cachedData.rscData === 'undefined') {
+                    if (cachedData.postponed) {
+                        throw Object.defineProperty(new Error('Invariant: Expected postponed to be undefined'), "__NEXT_ERROR_CODE", {
+                            value: "E372",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    return (0, _sendpayload.sendRenderResult)({
+                        req,
+                        res,
+                        generateEtags: nextConfig.generateEtags,
+                        poweredByHeader: nextConfig.poweredByHeader,
+                        result: cachedData.html,
+                        // Dynamic RSC responses cannot be cached, even if they're
+                        // configured with `force-static` because we have no way of
+                        // distinguishing between `force-static` and pages that have no
+                        // postponed state.
+                        // TODO: distinguish `force-static` from pages with no postponed state (static)
+                        cacheControl: isDynamicRSCRequest ? {
+                            revalidate: 0,
+                            expire: undefined
+                        } : cacheEntry.cacheControl
+                    });
+                }
+                // As this isn't a prefetch request, we should serve the static flight
+                // data.
+                return (0, _sendpayload.sendRenderResult)({
+                    req,
+                    res,
+                    generateEtags: nextConfig.generateEtags,
+                    poweredByHeader: nextConfig.poweredByHeader,
+                    result: _renderresult.default.fromStatic(cachedData.rscData, _approuterheaders.RSC_CONTENT_TYPE_HEADER),
+                    cacheControl: cacheEntry.cacheControl
+                });
+            }
+            // This is a request for HTML data.
+            let body = cachedData.html;
+            // If there's no postponed state, we should just serve the HTML. This
+            // should also be the case for a resume request because it's completed
+            // as a server render (rather than a static render).
+            if (!didPostpone || minimalMode || isRSCRequest) {
+                // If we're in test mode, we should add a sentinel chunk to the response
+                // that's between the static and dynamic parts so we can compare the
+                // chunks and add assertions.
+                if (process.env.__NEXT_TEST_MODE && minimalMode && isRoutePPREnabled && body.contentType === _constants1.HTML_CONTENT_TYPE_HEADER) {
+                    // As we're in minimal mode, the static part would have already been
+                    // streamed first. The only part that this streams is the dynamic part
+                    // so we should FIRST stream the sentinel and THEN the dynamic part.
+                    body.unshift(createPPRBoundarySentinel());
+                }
+                return (0, _sendpayload.sendRenderResult)({
+                    req,
+                    res,
+                    generateEtags: nextConfig.generateEtags,
+                    poweredByHeader: nextConfig.poweredByHeader,
+                    result: body,
+                    cacheControl: cacheEntry.cacheControl
+                });
+            }
+            // If we're debugging the static shell or the dynamic API accesses, we
+            // should just serve the HTML without resuming the render. The returned
+            // HTML will be the static shell so all the Dynamic API's will be used
+            // during static generation.
+            if (isDebugStaticShell || isDebugDynamicAccesses) {
+                // Since we're not resuming the render, we need to at least add the
+                // closing body and html tags to create valid HTML.
+                body.push(new ReadableStream({
+                    start (controller) {
+                        controller.enqueue(_encodedtags.ENCODED_TAGS.CLOSED.BODY_AND_HTML);
+                        controller.close();
+                    }
+                }));
+                return (0, _sendpayload.sendRenderResult)({
+                    req,
+                    res,
+                    generateEtags: nextConfig.generateEtags,
+                    poweredByHeader: nextConfig.poweredByHeader,
+                    result: body,
+                    cacheControl: {
+                        revalidate: 0,
+                        expire: undefined
+                    }
+                });
+            }
+            // If we're in test mode, we should add a sentinel chunk to the response
+            // that's between the static and dynamic parts so we can compare the
+            // chunks and add assertions.
+            if (process.env.__NEXT_TEST_MODE) {
+                body.push(createPPRBoundarySentinel());
+            }
+            // This request has postponed, so let's create a new transformer that the
+            // dynamic data can pipe to that will attach the dynamic data to the end
+            // of the response.
+            const transformer = new TransformStream();
+            body.push(transformer.readable);
+            // Perform the render again, but this time, provide the postponed state.
+            // We don't await because we want the result to start streaming now, and
+            // we've already chained the transformer's readable to the render result.
+            doRender({
+                span,
+                postponed: cachedData.postponed,
+                // This is a resume render, not a fallback render, so we don't need to
+                // set this.
+                fallbackRouteParams: null
+            }).then(async (result)=>{
+                var _result_value;
+                if (!result) {
+                    throw Object.defineProperty(new Error('Invariant: expected a result to be returned'), "__NEXT_ERROR_CODE", {
+                        value: "E463",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                if (((_result_value = result.value) == null ? void 0 : _result_value.kind) !== _responsecache.CachedRouteKind.APP_PAGE) {
+                    var _result_value1;
+                    throw Object.defineProperty(new Error(`Invariant: expected a page response, got ${(_result_value1 = result.value) == null ? void 0 : _result_value1.kind}`), "__NEXT_ERROR_CODE", {
+                        value: "E305",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                // Pipe the resume result to the transformer.
+                await result.value.html.pipeTo(transformer.writable);
+            }).catch((err)=>{
+                // An error occurred during piping or preparing the render, abort
+                // the transformers writer so we can terminate the stream.
+                transformer.writable.abort(err).catch((e)=>{
+                    console.error("couldn't abort transformer", e);
+                });
+            });
+            return (0, _sendpayload.sendRenderResult)({
+                req,
+                res,
+                generateEtags: nextConfig.generateEtags,
+                poweredByHeader: nextConfig.poweredByHeader,
+                result: body,
+                // We don't want to cache the response if it has postponed data because
+                // the response being sent to the client it's dynamic parts are streamed
+                // to the client on the same request.
+                cacheControl: {
+                    revalidate: 0,
+                    expire: undefined
+                }
+            });
+        };
+        // TODO: activeSpan code path is for when wrapped by
+        // next-server can be removed when this is no longer used
+        if (activeSpan) {
+            await handleResponse(activeSpan);
+        } else {
+            return await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+                    spanName: `${method} ${req.url}`,
+                    kind: _tracer.SpanKind.SERVER,
+                    attributes: {
+                        'http.method': method,
+                        'http.target': req.url
+                    }
+                }, handleResponse));
+        }
+    } catch (err) {
+        if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
+            await routeModule.onRequestError(req, err, {
+                routerKind: 'App Router',
+                routePath: srcPage,
+                routeType: 'render',
+                revalidateReason: (0, _utils.getRevalidateReason)({
+                    isRevalidate: isSSG,
+                    isOnDemandRevalidate
+                })
+            }, routerServerContext);
+        }
+        // rethrow so that we can handle serving error page
+        throw err;
+    }
+}
+// TODO: omit this from production builds, only test builds should include it
+/**
+ * Creates a readable stream that emits a PPR boundary sentinel.
+ *
+ * @returns A readable stream that emits a PPR boundary sentinel.
+ */ function createPPRBoundarySentinel() {
+    return new ReadableStream({
+        start (controller) {
+            controller.enqueue(new TextEncoder().encode('<!-- PPR_BOUNDARY_SENTINEL -->'));
+            controller.close();
+        }
+    });
+}
+
+//# sourceMappingURL=app-page.js.map

frontend/node_modules/next/dist/build/templates/app-route.d.ts

@@ -0,0 +1,9 @@
+import { AppRouteRouteModule } from '../../server/route-modules/app-route/module.compiled';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+declare const routeModule: AppRouteRouteModule;
+declare const workAsyncStorage: import("../../server/app-render/work-async-storage.external").WorkAsyncStorage, workUnitAsyncStorage: import("../../server/app-render/work-unit-async-storage.external").WorkUnitAsyncStorage, serverHooks: typeof import("../../client/components/hooks-server-context");
+declare function patchFetch(): void;
+export { routeModule, workAsyncStorage, workUnitAsyncStorage, serverHooks, patchFetch, };
+export declare function handler(req: IncomingMessage, res: ServerResponse, ctx: {
+    waitUntil: (prom: Promise<void>) => void;
+}): Promise<null | undefined>;

frontend/node_modules/next/dist/build/templates/app-route.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handler: null,
+    patchFetch: null,
+    routeModule: null,
+    serverHooks: null,
+    workAsyncStorage: null,
+    workUnitAsyncStorage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handler: function() {
+        return handler;
+    },
+    patchFetch: function() {
+        return patchFetch;
+    },
+    routeModule: function() {
+        return routeModule;
+    },
+    serverHooks: function() {
+        return serverHooks;
+    },
+    workAsyncStorage: function() {
+        return workAsyncStorage;
+    },
+    workUnitAsyncStorage: function() {
+        return workUnitAsyncStorage;
+    }
+});
+const _modulecompiled = require("../../server/route-modules/app-route/module.compiled");
+const _routekind = require("../../server/route-kind");
+const _patchfetch = require("../../server/lib/patch-fetch");
+const _requestmeta = require("../../server/request-meta");
+const _tracer = require("../../server/lib/trace/tracer");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _node = require("../../server/base-http/node");
+const _nextrequest = require("../../server/web/spec-extension/adapters/next-request");
+const _constants = require("../../server/lib/trace/constants");
+const _utils = require("../../server/instrumentation/utils");
+const _sendresponse = require("../../server/send-response");
+const _utils1 = require("../../server/web/utils");
+const _cachecontrol = require("../../server/lib/cache-control");
+const _constants1 = require("../../lib/constants");
+const _nofallbackerrorexternal = require("../../shared/lib/no-fallback-error.external");
+const _responsecache = require("../../server/response-cache");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+// We inject the nextConfigOutput here so that we can use them in the route
+// module.
+// INJECT:nextConfigOutput
+const routeModule = new _modulecompiled.AppRouteRouteModule({
+    definition: {
+        kind: _routekind.RouteKind.APP_ROUTE,
+        page: 'VAR_DEFINITION_PAGE',
+        pathname: 'VAR_DEFINITION_PATHNAME',
+        filename: 'VAR_DEFINITION_FILENAME',
+        bundlePath: 'VAR_DEFINITION_BUNDLE_PATH'
+    },
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
+    resolvedPagePath: 'VAR_RESOLVED_PAGE_PATH',
+    nextConfigOutput,
+    userland: _VAR_USERLAND
+});
+// Pull out the exports that we need to expose from the module. This should
+// be eliminated when we've moved the other routes to the new format. These
+// are used to hook into the route.
+const { workAsyncStorage, workUnitAsyncStorage, serverHooks } = routeModule;
+function patchFetch() {
+    return (0, _patchfetch.patchFetch)({
+        workAsyncStorage,
+        workUnitAsyncStorage
+    });
+}
+async function handler(req, res, ctx) {
+    var _nextConfig_experimental;
+    let srcPage = 'VAR_DEFINITION_PAGE';
+    // 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 null;
+    }
+    const { buildId, params, nextConfig, isDraftMode, prerenderManifest, routerServerContext, isOnDemandRevalidate, revalidateOnlyGenerated, resolvedPathname } = prepareResult;
+    const normalizedSrcPage = (0, _apppaths.normalizeAppPath)(srcPage);
+    let isIsr = Boolean(prerenderManifest.dynamicRoutes[normalizedSrcPage] || prerenderManifest.routes[resolvedPathname]);
+    if (isIsr && !isDraftMode) {
+        const isPrerendered = Boolean(prerenderManifest.routes[resolvedPathname]);
+        const prerenderInfo = prerenderManifest.dynamicRoutes[normalizedSrcPage];
+        if (prerenderInfo) {
+            if (prerenderInfo.fallback === false && !isPrerendered) {
+                throw new _nofallbackerrorexternal.NoFallbackError();
+            }
+        }
+    }
+    let cacheKey = null;
+    if (isIsr && !routeModule.isDev && !isDraftMode) {
+        cacheKey = resolvedPathname;
+        // ensure /index and / is normalized to one key
+        cacheKey = cacheKey === '/index' ? '/' : cacheKey;
+    }
+    const supportsDynamicResponse = // If we're in development, we always support dynamic HTML
+    routeModule.isDev === true || // If this is not SSG or does not have static paths, then it supports
+    // dynamic HTML.
+    !isIsr;
+    // This is a revalidation request if the request is for a static
+    // page and it is not being resumed from a postponed render and
+    // it is not a dynamic RSC request then it is a revalidation
+    // request.
+    const isRevalidate = isIsr && !supportsDynamicResponse;
+    const method = req.method || 'GET';
+    const tracer = (0, _tracer.getTracer)();
+    const activeSpan = tracer.getActiveScopeSpan();
+    const context = {
+        params,
+        prerenderManifest,
+        renderOpts: {
+            experimental: {
+                cacheComponents: Boolean(nextConfig.experimental.cacheComponents),
+                authInterrupts: Boolean(nextConfig.experimental.authInterrupts)
+            },
+            supportsDynamicResponse,
+            incrementalCache: (0, _requestmeta.getRequestMeta)(req, 'incrementalCache'),
+            cacheLifeProfiles: (_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.cacheLife,
+            isRevalidate,
+            waitUntil: ctx.waitUntil,
+            onClose: (cb)=>{
+                res.on('close', cb);
+            },
+            onAfterTaskError: undefined,
+            onInstrumentationRequestError: (error, _request, errorContext)=>routeModule.onRequestError(req, error, errorContext, routerServerContext)
+        },
+        sharedContext: {
+            buildId
+        }
+    };
+    const nodeNextReq = new _node.NodeNextRequest(req);
+    const nodeNextRes = new _node.NodeNextResponse(res);
+    const nextReq = _nextrequest.NextRequestAdapter.fromNodeNextRequest(nodeNextReq, (0, _nextrequest.signalFromNodeResponse)(res));
+    try {
+        const invokeRouteModule = async (span)=>{
+            return routeModule.handle(nextReq, context).finally(()=>{
+                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') !== _constants.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');
+                if (route) {
+                    const name = `${method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                } else {
+                    span.updateName(`${method} ${req.url}`);
+                }
+            });
+        };
+        const handleResponse = async (currentSpan)=>{
+            var _cacheEntry_value;
+            const responseGenerator = async ({ previousCacheEntry })=>{
+                try {
+                    if (!(0, _requestmeta.getRequestMeta)(req, 'minimalMode') && 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;
+                    }
+                    const response = await invokeRouteModule(currentSpan);
+                    req.fetchMetrics = context.renderOpts.fetchMetrics;
+                    let pendingWaitUntil = context.renderOpts.pendingWaitUntil;
+                    // Attempt using provided waitUntil if available
+                    // if it's not we fallback to sendResponse's handling
+                    if (pendingWaitUntil) {
+                        if (ctx.waitUntil) {
+                            ctx.waitUntil(pendingWaitUntil);
+                            pendingWaitUntil = undefined;
+                        }
+                    }
+                    const cacheTags = context.renderOpts.collectedTags;
+                    // If the request is for a static response, we can cache it so long
+                    // as it's not edge.
+                    if (isIsr) {
+                        const blob = await response.blob();
+                        // Copy the headers from the response.
+                        const headers = (0, _utils1.toNodeOutgoingHttpHeaders)(response.headers);
+                        if (cacheTags) {
+                            headers[_constants1.NEXT_CACHE_TAGS_HEADER] = cacheTags;
+                        }
+                        if (!headers['content-type'] && blob.type) {
+                            headers['content-type'] = blob.type;
+                        }
+                        const revalidate = typeof context.renderOpts.collectedRevalidate === 'undefined' || context.renderOpts.collectedRevalidate >= _constants1.INFINITE_CACHE ? false : context.renderOpts.collectedRevalidate;
+                        const expire = typeof context.renderOpts.collectedExpire === 'undefined' || context.renderOpts.collectedExpire >= _constants1.INFINITE_CACHE ? undefined : context.renderOpts.collectedExpire;
+                        // Create the cache entry for the response.
+                        const cacheEntry = {
+                            value: {
+                                kind: _responsecache.CachedRouteKind.APP_ROUTE,
+                                status: response.status,
+                                body: Buffer.from(await blob.arrayBuffer()),
+                                headers
+                            },
+                            cacheControl: {
+                                revalidate,
+                                expire
+                            }
+                        };
+                        return cacheEntry;
+                    } else {
+                        // send response without caching if not ISR
+                        await (0, _sendresponse.sendResponse)(nodeNextReq, nodeNextRes, response, context.renderOpts.pendingWaitUntil);
+                        return null;
+                    }
+                } 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) {
+                        await routeModule.onRequestError(req, err, {
+                            routerKind: 'App Router',
+                            routePath: srcPage,
+                            routeType: 'route',
+                            revalidateReason: (0, _utils.getRevalidateReason)({
+                                isRevalidate,
+                                isOnDemandRevalidate
+                            })
+                        }, routerServerContext);
+                    }
+                    throw err;
+                }
+            };
+            const cacheEntry = await routeModule.handleResponse({
+                req,
+                nextConfig,
+                cacheKey,
+                routeKind: _routekind.RouteKind.APP_ROUTE,
+                isFallback: false,
+                prerenderManifest,
+                isRoutePPREnabled: false,
+                isOnDemandRevalidate,
+                revalidateOnlyGenerated,
+                responseGenerator,
+                waitUntil: ctx.waitUntil
+            });
+            // we don't create a cacheEntry for ISR
+            if (!isIsr) {
+                return null;
+            }
+            if ((cacheEntry == null ? void 0 : (_cacheEntry_value = cacheEntry.value) == null ? void 0 : _cacheEntry_value.kind) !== _responsecache.CachedRouteKind.APP_ROUTE) {
+                var _cacheEntry_value1;
+                throw Object.defineProperty(new Error(`Invariant: app-route received invalid cache entry ${cacheEntry == null ? void 0 : (_cacheEntry_value1 = cacheEntry.value) == null ? void 0 : _cacheEntry_value1.kind}`), "__NEXT_ERROR_CODE", {
+                    value: "E701",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            if (!(0, _requestmeta.getRequestMeta)(req, 'minimalMode')) {
+                res.setHeader('x-nextjs-cache', isOnDemandRevalidate ? 'REVALIDATED' : cacheEntry.isMiss ? 'MISS' : cacheEntry.isStale ? 'STALE' : 'HIT');
+            }
+            // Draft mode should never be cached
+            if (isDraftMode) {
+                res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
+            }
+            const headers = (0, _utils1.fromNodeOutgoingHttpHeaders)(cacheEntry.value.headers);
+            if (!((0, _requestmeta.getRequestMeta)(req, 'minimalMode') && isIsr)) {
+                headers.delete(_constants1.NEXT_CACHE_TAGS_HEADER);
+            }
+            // If cache control is already set on the response we don't
+            // override it to allow users to customize it via next.config
+            if (cacheEntry.cacheControl && !res.getHeader('Cache-Control') && !headers.get('Cache-Control')) {
+                headers.set('Cache-Control', (0, _cachecontrol.getCacheControlHeader)(cacheEntry.cacheControl));
+            }
+            await (0, _sendresponse.sendResponse)(nodeNextReq, nodeNextRes, new Response(cacheEntry.value.body, {
+                headers,
+                status: cacheEntry.value.status || 200
+            }));
+            return null;
+        };
+        // TODO: activeSpan code path is for when wrapped by
+        // next-server can be removed when this is no longer used
+        if (activeSpan) {
+            await handleResponse(activeSpan);
+        } else {
+            await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+                    spanName: `${method} ${req.url}`,
+                    kind: _tracer.SpanKind.SERVER,
+                    attributes: {
+                        'http.method': method,
+                        'http.target': req.url
+                    }
+                }, handleResponse));
+        }
+    } catch (err) {
+        if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
+            await routeModule.onRequestError(req, err, {
+                routerKind: 'App Router',
+                routePath: normalizedSrcPage,
+                routeType: 'route',
+                revalidateReason: (0, _utils.getRevalidateReason)({
+                    isRevalidate,
+                    isOnDemandRevalidate
+                })
+            });
+        }
+        // rethrow so that we can handle serving error page
+        // If this is during static generation, throw the error again.
+        if (isIsr) throw err;
+        // Otherwise, send a 500 response.
+        await (0, _sendresponse.sendResponse)(nodeNextReq, nodeNextRes, new Response(null, {
+            status: 500
+        }));
+        return null;
+    }
+}
+
+//# sourceMappingURL=app-route.js.map

frontend/node_modules/next/dist/build/templates/edge-app-route.d.ts

@@ -0,0 +1,3 @@
+export declare const ComponentMod: any;
+declare const _default: (opts: import("../../server/web/adapter").AdapterOptions) => Promise<import("../../server/web/types").FetchEventResult>;
+export default _default;

frontend/node_modules/next/dist/build/templates/edge-app-route.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ComponentMod: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ComponentMod: function() {
+        return ComponentMod;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _actionutils = require("../../server/app-render/action-utils");
+const _encryptionutils = require("../../server/app-render/encryption-utils");
+const _edgeroutemodulewrapper = require("../../server/web/edge-route-module-wrapper");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _self___RSC_MANIFEST;
+// INJECT:nextConfig
+const maybeJSONParse = (str)=>str ? JSON.parse(str) : undefined;
+const rscManifest = (_self___RSC_MANIFEST = self.__RSC_MANIFEST) == null ? void 0 : _self___RSC_MANIFEST['VAR_PAGE'];
+const rscServerManifest = maybeJSONParse(self.__RSC_SERVER_MANIFEST);
+if (rscManifest && rscServerManifest) {
+    (0, _encryptionutils.setReferenceManifestsSingleton)({
+        page: 'VAR_PAGE',
+        clientReferenceManifest: rscManifest,
+        serverActionsManifest: rscServerManifest,
+        serverModuleMap: (0, _actionutils.createServerModuleMap)({
+            serverActionsManifest: rscServerManifest
+        })
+    });
+}
+const ComponentMod = _VAR_USERLAND;
+const _default = _edgeroutemodulewrapper.EdgeRouteModuleWrapper.wrap(_VAR_USERLAND.routeModule, {
+    nextConfig
+});
+
+//# sourceMappingURL=edge-app-route.js.map

frontend/node_modules/next/dist/build/templates/edge-app-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/templates/edge-app-route.ts"],"sourcesContent":["import { createServerModuleMap } from '../../server/app-render/action-utils'\nimport { setReferenceManifestsSingleton } from '../../server/app-render/encryption-utils'\nimport type { NextConfigComplete } from '../../server/config-shared'\nimport { EdgeRouteModuleWrapper } from '../../server/web/edge-route-module-wrapper'\n\n// Import the userland code.\nimport * as module from 'VAR_USERLAND'\n\n// injected by the loader afterwards.\ndeclare const nextConfig: NextConfigComplete\n// INJECT:nextConfig\n\nconst maybeJSONParse = (str?: string) => (str ? JSON.parse(str) : undefined)\n\nconst rscManifest = self.__RSC_MANIFEST?.['VAR_PAGE']\nconst rscServerManifest = maybeJSONParse(self.__RSC_SERVER_MANIFEST)\n\nif (rscManifest && rscServerManifest) {\n  setReferenceManifestsSingleton({\n    page: 'VAR_PAGE',\n    clientReferenceManifest: rscManifest,\n    serverActionsManifest: rscServerManifest,\n    serverModuleMap: createServerModuleMap({\n      serverActionsManifest: rscServerManifest,\n    }),\n  })\n}\n\nexport const ComponentMod = module\n\nexport default EdgeRouteModuleWrapper.wrap(module.routeModule, { nextConfig })\n"],"names":["ComponentMod","self","maybeJSONParse","str","JSON","parse","undefined","rscManifest","__RSC_MANIFEST","rscServerManifest","__RSC_SERVER_MANIFEST","setReferenceManifestsSingleton","page","clientReferenceManifest","serverActionsManifest","serverModuleMap","createServerModuleMap","module","EdgeRouteModuleWrapper","wrap","routeModule","nextConfig"],"mappings":";;;;;;;;;;;;;;;IA4BaA,YAAY;eAAZA;;IAEb,OAA8E;eAA9E;;;6BA9BsC;iCACS;wCAER;sEAGf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQJC;AAJpB,oBAAoB;AAEpB,MAAMC,iBAAiB,CAACC,MAAkBA,MAAMC,KAAKC,KAAK,CAACF,OAAOG;AAElE,MAAMC,eAAcN,uBAAAA,KAAKO,cAAc,qBAAnBP,oBAAqB,CAAC,WAAW;AACrD,MAAMQ,oBAAoBP,eAAeD,KAAKS,qBAAqB;AAEnE,IAAIH,eAAeE,mBAAmB;IACpCE,IAAAA,+CAA8B,EAAC;QAC7BC,MAAM;QACNC,yBAAyBN;QACzBO,uBAAuBL;QACvBM,iBAAiBC,IAAAA,kCAAqB,EAAC;YACrCF,uBAAuBL;QACzB;IACF;AACF;AAEO,MAAMT,eAAeiB;MAE5B,WAAeC,8CAAsB,CAACC,IAAI,CAACF,cAAOG,WAAW,EAAE;IAAEC;AAAW","ignoreList":[0]}

frontend/node_modules/next/dist/build/templates/edge-ssr-app.d.ts

@@ -0,0 +1,7 @@
+import '../../server/web/globals';
+import type { RequestData } from '../../server/web/types';
+export declare const ComponentMod: any;
+export default function nHandler(opts: {
+    page: string;
+    request: RequestData;
+}): Promise<import("../../server/web/types").FetchEventResult>;

frontend/node_modules/next/dist/build/templates/edge-ssr-app.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ComponentMod: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ComponentMod: function() {
+        return ComponentMod;
+    },
+    default: function() {
+        return nHandler;
+    }
+});
+require("../../server/web/globals");
+const _adapter = require("../../server/web/adapter");
+const _incrementalcache = require("../../server/lib/incremental-cache");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _encryptionutils = require("../../server/app-render/encryption-utils");
+const _actionutils = require("../../server/app-render/action-utils");
+const _handlers = require("../../server/use-cache/handlers");
+const _constants = require("../../server/lib/trace/constants");
+const _tracer = require("../../server/lib/trace/tracer");
+const _web = require("../../server/base-http/web");
+const _serveractionrequestmeta = require("../../server/lib/server-action-request-meta");
+const _isbot = require("../../shared/lib/router/utils/is-bot");
+const _interopdefault = require("../../lib/interop-default");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _apiutils = require("../../server/api-utils");
+const _webonclose = require("../../server/web/web-on-close");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _self___RSC_MANIFEST;
+// OPTIONAL_IMPORT:incrementalCacheHandler
+// Initialize the cache handlers interface.
+(0, _handlers.initializeCacheHandlers)();
+// INJECT:nextConfig
+const maybeJSONParse = (str)=>str ? JSON.parse(str) : undefined;
+const rscManifest = (_self___RSC_MANIFEST = self.__RSC_MANIFEST) == null ? void 0 : _self___RSC_MANIFEST['VAR_PAGE'];
+const rscServerManifest = maybeJSONParse(self.__RSC_SERVER_MANIFEST);
+if (rscManifest && rscServerManifest) {
+    (0, _encryptionutils.setReferenceManifestsSingleton)({
+        page: 'VAR_PAGE',
+        clientReferenceManifest: rscManifest,
+        serverActionsManifest: rscServerManifest,
+        serverModuleMap: (0, _actionutils.createServerModuleMap)({
+            serverActionsManifest: rscServerManifest
+        })
+    });
+}
+const ComponentMod = _VAR_USERLAND;
+async function requestHandler(req, event) {
+    let srcPage = 'VAR_PAGE';
+    const normalizedSrcPage = (0, _apppaths.normalizeAppPath)(srcPage);
+    const relativeUrl = `${req.nextUrl.pathname}${req.nextUrl.search}`;
+    const baseReq = new _web.WebNextRequest(req);
+    const baseRes = new _web.WebNextResponse(undefined);
+    const pageRouteModule = _VAR_USERLAND.routeModule;
+    const prepareResult = await pageRouteModule.prepare(baseReq, null, {
+        srcPage,
+        multiZoneDraftMode: false
+    });
+    if (!prepareResult) {
+        return new Response('Bad Request', {
+            status: 400
+        });
+    }
+    const { query, params, buildId, buildManifest, prerenderManifest, reactLoadableManifest, clientReferenceManifest, subresourceIntegrityManifest, dynamicCssManifest, nextFontManifest, resolvedPathname, serverActionsManifest, interceptionRoutePatterns, routerServerContext } = prepareResult;
+    const isPossibleServerAction = (0, _serveractionrequestmeta.getIsPossibleServerAction)(req);
+    const botType = (0, _isbot.getBotType)(req.headers.get('User-Agent') || '');
+    const { isOnDemandRevalidate } = (0, _apiutils.checkIsOnDemandRevalidate)(req, prerenderManifest.preview);
+    const closeController = new _webonclose.CloseController();
+    const renderContext = {
+        page: normalizedSrcPage,
+        query,
+        params,
+        sharedContext: {
+            buildId
+        },
+        fallbackRouteParams: null,
+        renderOpts: {
+            App: ()=>null,
+            Document: ()=>null,
+            pageConfig: {},
+            ComponentMod,
+            Component: (0, _interopdefault.interopDefault)(ComponentMod),
+            routeModule: pageRouteModule,
+            params,
+            page: srcPage,
+            postponed: undefined,
+            shouldWaitOnAllReady: false,
+            serveStreamingMetadata: true,
+            supportsDynamicResponse: true,
+            buildManifest,
+            nextFontManifest,
+            reactLoadableManifest,
+            subresourceIntegrityManifest,
+            dynamicCssManifest,
+            serverActionsManifest,
+            clientReferenceManifest,
+            setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
+            dir: pageRouteModule.relativeProjectDir,
+            botType,
+            isDraftMode: false,
+            isRevalidate: false,
+            isOnDemandRevalidate,
+            isPossibleServerAction,
+            assetPrefix: nextConfig.assetPrefix,
+            nextConfigOutput: nextConfig.output,
+            crossOrigin: nextConfig.crossOrigin,
+            trailingSlash: nextConfig.trailingSlash,
+            previewProps: prerenderManifest.preview,
+            deploymentId: nextConfig.deploymentId,
+            enableTainting: nextConfig.experimental.taint,
+            htmlLimitedBots: nextConfig.htmlLimitedBots,
+            devtoolSegmentExplorer: nextConfig.experimental.devtoolSegmentExplorer,
+            reactMaxHeadersLength: nextConfig.reactMaxHeadersLength,
+            multiZoneDraftMode: false,
+            cacheLifeProfiles: nextConfig.experimental.cacheLife,
+            basePath: nextConfig.basePath,
+            serverActions: nextConfig.experimental.serverActions,
+            experimental: {
+                isRoutePPREnabled: false,
+                expireTime: nextConfig.expireTime,
+                staleTimes: nextConfig.experimental.staleTimes,
+                cacheComponents: Boolean(nextConfig.experimental.cacheComponents),
+                clientSegmentCache: Boolean(nextConfig.experimental.clientSegmentCache),
+                clientParamParsing: Boolean(nextConfig.experimental.clientParamParsing),
+                dynamicOnHover: Boolean(nextConfig.experimental.dynamicOnHover),
+                inlineCss: Boolean(nextConfig.experimental.inlineCss),
+                authInterrupts: Boolean(nextConfig.experimental.authInterrupts),
+                clientTraceMetadata: nextConfig.experimental.clientTraceMetadata || []
+            },
+            incrementalCache: await pageRouteModule.getIncrementalCache(baseReq, nextConfig, prerenderManifest),
+            waitUntil: event.waitUntil.bind(event),
+            onClose: (cb)=>{
+                closeController.onClose(cb);
+            },
+            onAfterTaskError: ()=>{},
+            onInstrumentationRequestError: (error, _request, errorContext)=>pageRouteModule.onRequestError(baseReq, error, errorContext, routerServerContext),
+            dev: pageRouteModule.isDev
+        }
+    };
+    let finalStatus = 200;
+    const renderResultToResponse = (result)=>{
+        const varyHeader = pageRouteModule.getVaryHeader(resolvedPathname, interceptionRoutePatterns);
+        // Handle null responses
+        if (result.isNull) {
+            finalStatus = 500;
+            closeController.dispatchClose();
+            return new Response(null, {
+                status: 500
+            });
+        }
+        // Extract metadata
+        const { metadata } = result;
+        const headers = new Headers();
+        finalStatus = metadata.statusCode || baseRes.statusCode || 200;
+        req.fetchMetrics = metadata.fetchMetrics;
+        // Set content type
+        const contentType = result.contentType || 'text/html; charset=utf-8';
+        headers.set('Content-Type', contentType);
+        headers.set('x-edge-runtime', '1');
+        if (varyHeader) {
+            headers.set('Vary', varyHeader);
+        }
+        // Add existing headers
+        for (const [key, value] of Object.entries({
+            ...baseRes.getHeaders(),
+            ...metadata.headers
+        })){
+            if (value !== undefined) {
+                if (Array.isArray(value)) {
+                    // Handle multiple header values
+                    for (const v of value){
+                        headers.append(key, String(v));
+                    }
+                } else {
+                    headers.set(key, String(value));
+                }
+            }
+        }
+        // Handle static response
+        if (!result.isDynamic) {
+            const body = result.toUnchunkedString();
+            headers.set('Content-Length', String(new TextEncoder().encode(body).length));
+            closeController.dispatchClose();
+            return new Response(body, {
+                status: finalStatus,
+                headers
+            });
+        }
+        // Handle dynamic/streaming response
+        // For edge runtime, we need to create a readable stream that pipes from the result
+        const { readable, writable } = new TransformStream();
+        // Start piping the result to the writable stream
+        // This is done asynchronously to avoid blocking the response creation
+        result.pipeTo(writable).catch((err)=>{
+            console.error('Error piping RenderResult to response:', err);
+        }).finally(()=>closeController.dispatchClose());
+        return new Response(readable, {
+            status: finalStatus,
+            headers
+        });
+    };
+    const invokeRender = async (span)=>{
+        try {
+            const result = await pageRouteModule.render(baseReq, baseRes, renderContext).finally(()=>{
+                if (!span) return;
+                span.setAttributes({
+                    'http.status_code': finalStatus,
+                    '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') !== _constants.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 = normalizedSrcPage;
+                if (route) {
+                    const name = `${req.method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                } else {
+                    span.updateName(`${req.method} ${relativeUrl}`);
+                }
+            });
+            return renderResultToResponse(result);
+        } catch (err) {
+            await pageRouteModule.onRequestError(baseReq, err, {
+                routerKind: 'App Router',
+                routePath: normalizedSrcPage,
+                routeType: 'render',
+                revalidateReason: undefined
+            });
+            // rethrow so that we can handle serving error page
+            throw err;
+        }
+    };
+    const tracer = (0, _tracer.getTracer)();
+    return tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+            spanName: `${req.method} ${relativeUrl}`,
+            kind: _tracer.SpanKind.SERVER,
+            attributes: {
+                'http.method': req.method,
+                'http.target': relativeUrl,
+                'http.route': normalizedSrcPage
+            }
+        }, invokeRender));
+}
+function nHandler(opts) {
+    return (0, _adapter.adapter)({
+        ...opts,
+        IncrementalCache: _incrementalcache.IncrementalCache,
+        handler: requestHandler,
+        incrementalCacheHandler
+    });
+}
+
+//# sourceMappingURL=edge-ssr-app.js.map

frontend/node_modules/next/dist/build/templates/edge-ssr.d.ts

@@ -0,0 +1,7 @@
+import '../../server/web/globals';
+import type { RequestData } from '../../server/web/types';
+export declare const ComponentMod: any;
+export default function nHandler(opts: {
+    page: string;
+    request: RequestData;
+}): Promise<import("../../server/web/types").FetchEventResult>;

frontend/node_modules/next/dist/build/templates/edge-ssr.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ComponentMod: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ComponentMod: function() {
+        return ComponentMod;
+    },
+    default: function() {
+        return nHandler;
+    }
+});
+require("../../server/web/globals");
+const _adapter = require("../../server/web/adapter");
+const _incrementalcache = require("../../server/lib/incremental-cache");
+const _handlers = require("../../server/use-cache/handlers");
+const _VAR_MODULE_DOCUMENT = /*#__PURE__*/ _interop_require_default(require("VAR_MODULE_DOCUMENT"));
+const _VAR_MODULE_APP = /*#__PURE__*/ _interop_require_wildcard(require("VAR_MODULE_APP"));
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _VAR_MODULE_GLOBAL_ERROR = /*#__PURE__*/ _interop_require_wildcard(require("VAR_MODULE_GLOBAL_ERROR"));
+const _module = /*#__PURE__*/ _interop_require_default(require("../../server/route-modules/pages/module"));
+const _web = require("../../server/base-http/web");
+const _tracer = require("../../server/lib/trace/tracer");
+const _constants = require("../../server/lib/trace/constants");
+const _constants1 = require("../../lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+// INJECT:nextConfig
+// INJECT:pageRouteModuleOptions
+// INJECT:errorRouteModuleOptions
+// INJECT:user500RouteModuleOptions
+// Initialize the cache handlers interface.
+(0, _handlers.initializeCacheHandlers)();
+globalThis.nextConfig = nextConfig;
+const pageMod = {
+    ..._VAR_USERLAND,
+    routeModule: new _module.default({
+        ...pageRouteModuleOptions,
+        components: {
+            App: _VAR_MODULE_APP.default,
+            Document: _VAR_MODULE_DOCUMENT.default
+        },
+        userland: _VAR_USERLAND
+    })
+};
+const errorMod = {
+    ..._VAR_MODULE_GLOBAL_ERROR,
+    routeModule: new _module.default({
+        ...errorRouteModuleOptions,
+        components: {
+            App: _VAR_MODULE_APP.default,
+            Document: _VAR_MODULE_DOCUMENT.default
+        },
+        userland: _VAR_MODULE_GLOBAL_ERROR
+    })
+};
+// FIXME: this needs to be made compatible with the template
+const error500Mod = userland500Page ? {
+    ...userland500Page,
+    routeModule: new _module.default({
+        ...user500RouteModuleOptions,
+        components: {
+            App: _VAR_MODULE_APP.default,
+            Document: _VAR_MODULE_DOCUMENT.default
+        },
+        userland: userland500Page
+    })
+} : null;
+const ComponentMod = pageMod;
+async function requestHandler(req, _event) {
+    var _nextConfig_experimental_amp, _nextConfig_i18n;
+    let srcPage = 'VAR_PAGE';
+    const relativeUrl = `${req.nextUrl.pathname}${req.nextUrl.search}`;
+    const baseReq = new _web.WebNextRequest(req);
+    const pageRouteModule = pageMod.routeModule;
+    const prepareResult = await pageRouteModule.prepare(baseReq, null, {
+        srcPage,
+        multiZoneDraftMode: false
+    });
+    if (!prepareResult) {
+        return new Response('Bad Request', {
+            status: 400
+        });
+    }
+    const { query, params, buildId, isNextDataRequest, buildManifest, prerenderManifest, reactLoadableManifest, clientReferenceManifest, subresourceIntegrityManifest, dynamicCssManifest } = prepareResult;
+    const renderContext = {
+        page: srcPage,
+        query,
+        params,
+        sharedContext: {
+            buildId,
+            deploymentId: process.env.NEXT_DEPLOYMENT_ID,
+            customServer: undefined
+        },
+        renderContext: {
+            isFallback: false,
+            isDraftMode: false,
+            developmentNotFoundSourcePage: undefined
+        },
+        renderOpts: {
+            params,
+            page: srcPage,
+            supportsDynamicResponse: true,
+            Component: pageMod.Component,
+            ComponentMod: pageMod,
+            pageConfig: pageMod.pageConfig,
+            routeModule: pageMod.routeModule,
+            canonicalBase: nextConfig.amp.canonicalBase || '',
+            previewProps: prerenderManifest.preview,
+            ampOptimizerConfig: (_nextConfig_experimental_amp = nextConfig.experimental.amp) == null ? void 0 : _nextConfig_experimental_amp.optimizer,
+            basePath: nextConfig.basePath,
+            assetPrefix: nextConfig.assetPrefix,
+            images: nextConfig.images,
+            optimizeCss: nextConfig.experimental.optimizeCss,
+            nextConfigOutput: nextConfig.output,
+            nextScriptWorkers: nextConfig.experimental.nextScriptWorkers,
+            disableOptimizedLoading: nextConfig.experimental.disableOptimizedLoading,
+            domainLocales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.domains,
+            distDir: '',
+            crossOrigin: nextConfig.crossOrigin ? nextConfig.crossOrigin : undefined,
+            largePageDataBytes: nextConfig.experimental.largePageDataBytes,
+            // Only the `publicRuntimeConfig` key is exposed to the client side
+            // It'll be rendered as part of __NEXT_DATA__ on the client side
+            runtimeConfig: Object.keys(nextConfig.publicRuntimeConfig).length > 0 ? nextConfig.publicRuntimeConfig : undefined,
+            isExperimentalCompile: nextConfig.experimental.isExperimentalCompile,
+            // `htmlLimitedBots` is passed to server as serialized config in string format
+            experimental: {
+                clientTraceMetadata: nextConfig.experimental.clientTraceMetadata
+            },
+            buildManifest,
+            subresourceIntegrityManifest,
+            reactLoadableManifest,
+            clientReferenceManifest,
+            dynamicCssManifest
+        }
+    };
+    let finalStatus = 200;
+    const renderResultToResponse = (result)=>{
+        // Handle null responses
+        if (result.isNull) {
+            finalStatus = 500;
+            return new Response(null, {
+                status: 500
+            });
+        }
+        // Extract metadata
+        const { metadata } = result;
+        finalStatus = metadata.statusCode || 200;
+        const headers = new Headers();
+        // Set content type
+        const contentType = result.contentType || _constants1.HTML_CONTENT_TYPE_HEADER;
+        headers.set('Content-Type', contentType);
+        // Add metadata headers
+        if (metadata.headers) {
+            for (const [key, value] of Object.entries(metadata.headers)){
+                if (value !== undefined) {
+                    if (Array.isArray(value)) {
+                        // Handle multiple header values
+                        for (const v of value){
+                            headers.append(key, String(v));
+                        }
+                    } else {
+                        headers.set(key, String(value));
+                    }
+                }
+            }
+        }
+        // Handle static response
+        if (!result.isDynamic) {
+            const body = result.toUnchunkedString();
+            headers.set('Content-Length', String(new TextEncoder().encode(body).length));
+            return new Response(body, {
+                status: finalStatus,
+                headers
+            });
+        }
+        // Handle dynamic/streaming response
+        // For edge runtime, we need to create a readable stream that pipes from the result
+        const { readable, writable } = new TransformStream();
+        // Start piping the result to the writable stream
+        // This is done asynchronously to avoid blocking the response creation
+        result.pipeTo(writable).catch((err)=>{
+            console.error('Error piping RenderResult to response:', err);
+        });
+        return new Response(readable, {
+            status: finalStatus,
+            headers
+        });
+    };
+    const invokeRender = async (span)=>{
+        try {
+            const result = await pageRouteModule.render(// @ts-expect-error we don't type this for edge
+            baseReq, new _web.WebNextResponse(undefined), {
+                ...renderContext,
+                renderOpts: {
+                    ...renderContext.renderOpts,
+                    getServerSideProps: pageMod.getServerSideProps,
+                    Component: pageMod.default || pageMod,
+                    ComponentMod: pageMod,
+                    pageConfig: pageMod.config,
+                    isNextDataRequest
+                }
+            }).finally(()=>{
+                if (!span) return;
+                span.setAttributes({
+                    'http.status_code': finalStatus,
+                    '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') !== _constants.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');
+                if (route) {
+                    const name = `${req.method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                } else {
+                    span.updateName(`${req.method} ${relativeUrl}`);
+                }
+            });
+            return renderResultToResponse(result);
+        } catch (err) {
+            const errModule = error500Mod || errorMod;
+            const errRouteModule = errModule.routeModule;
+            if (errRouteModule.isDev) {
+                throw err;
+            }
+            await errRouteModule.onRequestError(baseReq, err, {
+                routerKind: 'Pages Router',
+                routePath: srcPage,
+                routeType: 'render',
+                revalidateReason: undefined
+            });
+            const errResult = await errRouteModule.render(// @ts-expect-error we don't type this for edge
+            baseReq, new _web.WebNextResponse(undefined), {
+                ...renderContext,
+                page: error500Mod ? '/500' : '/_error',
+                renderOpts: {
+                    ...renderContext.renderOpts,
+                    getServerSideProps: errModule.getServerSideProps,
+                    Component: errModule.default || errModule,
+                    ComponentMod: errModule,
+                    pageConfig: errModule.config
+                }
+            });
+            return renderResultToResponse(errResult);
+        }
+    };
+    const tracer = (0, _tracer.getTracer)();
+    return tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+            spanName: `${req.method} ${relativeUrl}`,
+            kind: _tracer.SpanKind.SERVER,
+            attributes: {
+                'http.method': req.method,
+                'http.target': relativeUrl,
+                'http.route': srcPage
+            }
+        }, invokeRender));
+}
+function nHandler(opts) {
+    return (0, _adapter.adapter)({
+        ...opts,
+        IncrementalCache: _incrementalcache.IncrementalCache,
+        handler: requestHandler,
+        incrementalCacheHandler,
+        bypassNextUrl: true
+    });
+}
+
+//# sourceMappingURL=edge-ssr.js.map

frontend/node_modules/next/dist/build/templates/helpers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hoists a name from a module or promised module.
+ *
+ * @param module the module to hoist the name from
+ * @param name the name to hoist
+ * @returns the value on the module (or promised module)
+ */
+export declare function hoist(module: any, name: string): any;

frontend/node_modules/next/dist/build/templates/helpers.js

@@ -0,0 +1,36 @@
+/**
+ * Hoists a name from a module or promised module.
+ *
+ * @param module the module to hoist the name from
+ * @param name the name to hoist
+ * @returns the value on the module (or promised module)
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hoist", {
+    enumerable: true,
+    get: function() {
+        return hoist;
+    }
+});
+function hoist(module, name) {
+    // If the name is available in the module, return it.
+    if (name in module) {
+        return module[name];
+    }
+    // If a property called `then` exists, assume it's a promise and
+    // return a promise that resolves to the name.
+    if ('then' in module && typeof module.then === 'function') {
+        return module.then((mod)=>hoist(mod, name));
+    }
+    // If we're trying to hoise the default export, and the module is a function,
+    // return the module itself.
+    if (typeof module === 'function' && name === 'default') {
+        return module;
+    }
+    // Otherwise, return undefined.
+    return undefined;
+}
+
+//# sourceMappingURL=helpers.js.map

frontend/node_modules/next/dist/build/templates/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/templates/helpers.ts"],"sourcesContent":["/**\n * Hoists a name from a module or promised module.\n *\n * @param module the module to hoist the name from\n * @param name the name to hoist\n * @returns the value on the module (or promised module)\n */\nexport function hoist(module: any, name: string) {\n  // If the name is available in the module, return it.\n  if (name in module) {\n    return module[name]\n  }\n\n  // If a property called `then` exists, assume it's a promise and\n  // return a promise that resolves to the name.\n  if ('then' in module && typeof module.then === 'function') {\n    return module.then((mod: any) => hoist(mod, name))\n  }\n\n  // If we're trying to hoise the default export, and the module is a function,\n  // return the module itself.\n  if (typeof module === 'function' && name === 'default') {\n    return module\n  }\n\n  // Otherwise, return undefined.\n  return undefined\n}\n"],"names":["hoist","module","name","then","mod","undefined"],"mappings":"AAAA;;;;;;CAMC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,MAAMC,MAAW,EAAEC,IAAY;IAC7C,qDAAqD;IACrD,IAAIA,QAAQD,QAAQ;QAClB,OAAOA,MAAM,CAACC,KAAK;IACrB;IAEA,gEAAgE;IAChE,8CAA8C;IAC9C,IAAI,UAAUD,UAAU,OAAOA,OAAOE,IAAI,KAAK,YAAY;QACzD,OAAOF,OAAOE,IAAI,CAAC,CAACC,MAAaJ,MAAMI,KAAKF;IAC9C;IAEA,6EAA6E;IAC7E,4BAA4B;IAC5B,IAAI,OAAOD,WAAW,cAAcC,SAAS,WAAW;QACtD,OAAOD;IACT;IAEA,+BAA+B;IAC/B,OAAOI;AACT","ignoreList":[0]}

frontend/node_modules/next/dist/build/templates/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterOptions } from '../../server/web/adapter';
+import '../../server/web/globals';
+export default function nHandler(opts: Omit<AdapterOptions, 'IncrementalCache' | 'page' | 'handler'>): Promise<import("../../server/web/types").FetchEventResult>;

frontend/node_modules/next/dist/build/templates/middleware.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return nHandler;
+    }
+});
+const _globals = require("../../server/web/globals");
+const _adapter = require("../../server/web/adapter");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _isnextroutererror = require("../../client/components/is-next-router-error");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const mod = {
+    ..._VAR_USERLAND
+};
+const handler = mod.middleware || mod.default;
+const page = 'VAR_DEFINITION_PAGE';
+if (typeof handler !== 'function') {
+    throw Object.defineProperty(new Error(`The Middleware "${page}" must export a \`middleware\` or a \`default\` function`), "__NEXT_ERROR_CODE", {
+        value: "E120",
+        enumerable: false,
+        configurable: true
+    });
+}
+// Middleware will only sent out the FetchEvent to next server,
+// so load instrumentation module here and track the error inside middleware module.
+function errorHandledHandler(fn) {
+    return async (...args)=>{
+        try {
+            return await fn(...args);
+        } catch (err) {
+            // In development, error the navigation API usage in runtime,
+            // since it's not allowed to be used in middleware as it's outside of react component tree.
+            if (process.env.NODE_ENV !== 'production') {
+                if ((0, _isnextroutererror.isNextRouterError)(err)) {
+                    err.message = `Next.js navigation API is not allowed to be used in Middleware.`;
+                    throw err;
+                }
+            }
+            const req = args[0];
+            const url = new URL(req.url);
+            const resource = url.pathname + url.search;
+            await (0, _globals.edgeInstrumentationOnRequestError)(err, {
+                path: resource,
+                method: req.method,
+                headers: Object.fromEntries(req.headers.entries())
+            }, {
+                routerKind: 'Pages Router',
+                routePath: '/middleware',
+                routeType: 'middleware',
+                revalidateReason: undefined
+            });
+            throw err;
+        }
+    };
+}
+function nHandler(opts) {
+    return (0, _adapter.adapter)({
+        ...opts,
+        page,
+        handler: errorHandledHandler(handler)
+    });
+}
+
+//# sourceMappingURL=middleware.js.map

frontend/node_modules/next/dist/build/templates/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/templates/middleware.ts"],"sourcesContent":["import type { AdapterOptions } from '../../server/web/adapter'\n\nimport '../../server/web/globals'\n\nimport { adapter } from '../../server/web/adapter'\n\n// Import the userland code.\nimport * as _mod from 'VAR_USERLAND'\nimport { edgeInstrumentationOnRequestError } from '../../server/web/globals'\nimport { isNextRouterError } from '../../client/components/is-next-router-error'\n\nconst mod = { ..._mod }\nconst handler = mod.middleware || mod.default\n\nconst page = 'VAR_DEFINITION_PAGE'\n\nif (typeof handler !== 'function') {\n  throw new Error(\n    `The Middleware \"${page}\" must export a \\`middleware\\` or a \\`default\\` function`\n  )\n}\n\n// Middleware will only sent out the FetchEvent to next server,\n// so load instrumentation module here and track the error inside middleware module.\nfunction errorHandledHandler(fn: AdapterOptions['handler']) {\n  return async (...args: Parameters<AdapterOptions['handler']>) => {\n    try {\n      return await fn(...args)\n    } catch (err) {\n      // In development, error the navigation API usage in runtime,\n      // since it's not allowed to be used in middleware as it's outside of react component tree.\n      if (process.env.NODE_ENV !== 'production') {\n        if (isNextRouterError(err)) {\n          err.message = `Next.js navigation API is not allowed to be used in Middleware.`\n          throw err\n        }\n      }\n      const req = args[0]\n      const url = new URL(req.url)\n      const resource = url.pathname + url.search\n      await edgeInstrumentationOnRequestError(\n        err,\n        {\n          path: resource,\n          method: req.method,\n          headers: Object.fromEntries(req.headers.entries()),\n        },\n        {\n          routerKind: 'Pages Router',\n          routePath: '/middleware',\n          routeType: 'middleware',\n          revalidateReason: undefined,\n        }\n      )\n\n      throw err\n    }\n  }\n}\n\nexport default function nHandler(\n  opts: Omit<AdapterOptions, 'IncrementalCache' | 'page' | 'handler'>\n) {\n  return adapter({\n    ...opts,\n    page,\n    handler: errorHandledHandler(handler),\n  })\n}\n"],"names":["nHandler","mod","_mod","handler","middleware","default","page","Error","errorHandledHandler","fn","args","err","process","env","NODE_ENV","isNextRouterError","message","req","url","URL","resource","pathname","search","edgeInstrumentationOnRequestError","path","method","headers","Object","fromEntries","entries","routerKind","routePath","routeType","revalidateReason","undefined","opts","adapter"],"mappings":";;;;+BA4DA;;;eAAwBA;;;yBA1DjB;yBAEiB;sEAGF;mCAEY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElC,MAAMC,MAAM;IAAE,GAAGC,aAAI;AAAC;AACtB,MAAMC,UAAUF,IAAIG,UAAU,IAAIH,IAAII,OAAO;AAE7C,MAAMC,OAAO;AAEb,IAAI,OAAOH,YAAY,YAAY;IACjC,MAAM,qBAEL,CAFK,IAAII,MACR,CAAC,gBAAgB,EAAED,KAAK,wDAAwD,CAAC,GAD7E,qBAAA;eAAA;oBAAA;sBAAA;IAEN;AACF;AAEA,+DAA+D;AAC/D,oFAAoF;AACpF,SAASE,oBAAoBC,EAA6B;IACxD,OAAO,OAAO,GAAGC;QACf,IAAI;YACF,OAAO,MAAMD,MAAMC;QACrB,EAAE,OAAOC,KAAK;YACZ,6DAA6D;YAC7D,2FAA2F;YAC3F,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,IAAIC,IAAAA,oCAAiB,EAACJ,MAAM;oBAC1BA,IAAIK,OAAO,GAAG,CAAC,+DAA+D,CAAC;oBAC/E,MAAML;gBACR;YACF;YACA,MAAMM,MAAMP,IAAI,CAAC,EAAE;YACnB,MAAMQ,MAAM,IAAIC,IAAIF,IAAIC,GAAG;YAC3B,MAAME,WAAWF,IAAIG,QAAQ,GAAGH,IAAII,MAAM;YAC1C,MAAMC,IAAAA,0CAAiC,EACrCZ,KACA;gBACEa,MAAMJ;gBACNK,QAAQR,IAAIQ,MAAM;gBAClBC,SAASC,OAAOC,WAAW,CAACX,IAAIS,OAAO,CAACG,OAAO;YACjD,GACA;gBACEC,YAAY;gBACZC,WAAW;gBACXC,WAAW;gBACXC,kBAAkBC;YACpB;YAGF,MAAMvB;QACR;IACF;AACF;AAEe,SAASX,SACtBmC,IAAmE;IAEnE,OAAOC,IAAAA,gBAAO,EAAC;QACb,GAAGD,IAAI;QACP7B;QACAH,SAASK,oBAAoBL;IAC/B;AACF","ignoreList":[0]}

frontend/node_modules/next/dist/build/templates/pages-api.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+declare const _default: any;
+export default _default;
+export declare const config: any;
+export declare function handler(req: IncomingMessage, res: ServerResponse, ctx: {
+    waitUntil?: (prom: Promise<void>) => void;
+}): Promise<void>;

frontend/node_modules/next/dist/build/templates/pages-api.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    config: null,
+    default: null,
+    handler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    config: function() {
+        return config;
+    },
+    // Re-export the handler (should be the default export).
+    default: function() {
+        return _default;
+    },
+    handler: function() {
+        return handler;
+    }
+});
+const _apiutils = require("../../server/api-utils");
+const _routekind = require("../../server/route-kind");
+const _modulecompiled = require("../../server/route-modules/pages-api/module.compiled");
+const _helpers = require("./helpers");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _tracer = require("../../server/lib/trace/tracer");
+const _constants = require("../../server/lib/trace/constants");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const _default = (0, _helpers.hoist)(_VAR_USERLAND, 'default');
+const config = (0, _helpers.hoist)(_VAR_USERLAND, 'config');
+// Create and export the route module that will be consumed.
+const routeModule = new _modulecompiled.PagesAPIRouteModule({
+    definition: {
+        kind: _routekind.RouteKind.PAGES_API,
+        page: 'VAR_DEFINITION_PAGE',
+        pathname: 'VAR_DEFINITION_PATHNAME',
+        // The following aren't used in production.
+        bundlePath: '',
+        filename: ''
+    },
+    userland: _VAR_USERLAND,
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || ''
+});
+async function handler(req, res, ctx) {
+    let srcPage = 'VAR_DEFINITION_PAGE';
+    // 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$/, '') || '/';
+    }
+    const prepareResult = await routeModule.prepare(req, res, {
+        srcPage
+    });
+    if (!prepareResult) {
+        res.statusCode = 400;
+        res.end('Bad Request');
+        ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+        return;
+    }
+    const { query, params, prerenderManifest, routerServerContext } = prepareResult;
+    try {
+        const method = req.method || 'GET';
+        const tracer = (0, _tracer.getTracer)();
+        const activeSpan = tracer.getActiveScopeSpan();
+        const onRequestError = routeModule.instrumentationOnRequestError.bind(routeModule);
+        const invokeRouteModule = async (span)=>routeModule.render(req, res, {
+                query: {
+                    ...query,
+                    ...params
+                },
+                params,
+                allowedRevalidateHeaderKeys: process.env.__NEXT_ALLOWED_REVALIDATE_HEADERS,
+                multiZoneDraftMode: Boolean(process.env.__NEXT_MULTI_ZONE_DRAFT_MODE),
+                trustHostHeader: process.env.__NEXT_TRUST_HOST_HEADER,
+                // TODO: get this from from runtime env so manifest
+                // doesn't need to load
+                previewProps: prerenderManifest.preview,
+                propagateError: false,
+                dev: routeModule.isDev,
+                page: 'VAR_DEFINITION_PAGE',
+                internalRevalidate: routerServerContext == null ? void 0 : routerServerContext.revalidate,
+                onError: (...args)=>onRequestError(req, ...args)
+            }).finally(()=>{
+                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') !== _constants.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');
+                if (route) {
+                    const name = `${method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                } else {
+                    span.updateName(`${method} ${req.url}`);
+                }
+            });
+        // TODO: activeSpan code path is for when wrapped by
+        // next-server can be removed when this is no longer used
+        if (activeSpan) {
+            await invokeRouteModule(activeSpan);
+        } else {
+            await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+                    spanName: `${method} ${req.url}`,
+                    kind: _tracer.SpanKind.SERVER,
+                    attributes: {
+                        'http.method': method,
+                        'http.target': req.url
+                    }
+                }, invokeRouteModule));
+        }
+    } catch (err) {
+        // we re-throw in dev to show the error overlay
+        if (routeModule.isDev) {
+            throw err;
+        }
+        // this is technically an invariant as error handling
+        // should be done inside of api-resolver onError
+        (0, _apiutils.sendError)(res, 500, 'Internal Server Error');
+    } finally{
+        // We don't allow any waitUntil work in pages API routes currently
+        // so if callback is present return with resolved promise since no
+        // pending work
+        ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+    }
+}
+
+//# sourceMappingURL=pages-api.js.map

frontend/node_modules/next/dist/build/templates/pages-edge-api.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterOptions } from '../../server/web/adapter';
+import '../../server/web/globals';
+export default function (opts: Omit<AdapterOptions, 'IncrementalCache' | 'page' | 'handler'>): Promise<import("../../server/web/types").FetchEventResult>;

frontend/node_modules/next/dist/build/templates/pages-edge-api.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+require("../../server/web/globals");
+const _adapter = require("../../server/web/adapter");
+const _incrementalcache = require("../../server/lib/incremental-cache");
+const _apiutils = require("../../server/api-utils");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_default(require("VAR_USERLAND"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const page = 'VAR_DEFINITION_PAGE';
+if (typeof _VAR_USERLAND.default !== 'function') {
+    throw Object.defineProperty(new Error(`The Edge Function "pages${page}" must export a \`default\` function`), "__NEXT_ERROR_CODE", {
+        value: "E162",
+        enumerable: false,
+        configurable: true
+    });
+}
+function _default(opts) {
+    return (0, _adapter.adapter)({
+        ...opts,
+        IncrementalCache: _incrementalcache.IncrementalCache,
+        page: 'VAR_DEFINITION_PATHNAME',
+        handler: (0, _apiutils.wrapApiHandler)(page, _VAR_USERLAND.default)
+    });
+}
+
+//# sourceMappingURL=pages-edge-api.js.map

frontend/node_modules/next/dist/build/templates/pages-edge-api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/templates/pages-edge-api.ts"],"sourcesContent":["import type { AdapterOptions } from '../../server/web/adapter'\n\nimport '../../server/web/globals'\n\nimport { adapter } from '../../server/web/adapter'\nimport { IncrementalCache } from '../../server/lib/incremental-cache'\nimport { wrapApiHandler } from '../../server/api-utils'\n\n// Import the userland code.\nimport handler from 'VAR_USERLAND'\n\nconst page = 'VAR_DEFINITION_PAGE'\n\nif (typeof handler !== 'function') {\n  throw new Error(\n    `The Edge Function \"pages${page}\" must export a \\`default\\` function`\n  )\n}\n\nexport default function (\n  opts: Omit<AdapterOptions, 'IncrementalCache' | 'page' | 'handler'>\n) {\n  return adapter({\n    ...opts,\n    IncrementalCache,\n    page: 'VAR_DEFINITION_PATHNAME',\n    handler: wrapApiHandler(page, handler),\n  })\n}\n"],"names":["page","handler","Error","opts","adapter","IncrementalCache","wrapApiHandler"],"mappings":";;;;+BAmBA;;;eAAA;;;QAjBO;yBAEiB;kCACS;0BACF;qEAGX;;;;;;AAEpB,MAAMA,OAAO;AAEb,IAAI,OAAOC,qBAAO,KAAK,YAAY;IACjC,MAAM,qBAEL,CAFK,IAAIC,MACR,CAAC,wBAAwB,EAAEF,KAAK,oCAAoC,CAAC,GADjE,qBAAA;eAAA;oBAAA;sBAAA;IAEN;AACF;AAEe,SAAf,SACEG,IAAmE;IAEnE,OAAOC,IAAAA,gBAAO,EAAC;QACb,GAAGD,IAAI;QACPE,kBAAAA,kCAAgB;QAChBL,MAAM;QACNC,SAASK,IAAAA,wBAAc,EAACN,MAAMC,qBAAO;IACvC;AACF","ignoreList":[0]}

frontend/node_modules/next/dist/build/templates/pages.d.ts

@@ -0,0 +1,17 @@
+import { PagesRouteModule } from '../../server/route-modules/pages/module.compiled';
+declare const _default: any;
+export default _default;
+export declare const getStaticProps: any;
+export declare const getStaticPaths: any;
+export declare const getServerSideProps: any;
+export declare const config: any;
+export declare const reportWebVitals: any;
+export declare const unstable_getStaticProps: any;
+export declare const unstable_getStaticPaths: any;
+export declare const unstable_getStaticParams: any;
+export declare const unstable_getServerProps: any;
+export declare const unstable_getServerSideProps: any;
+export declare const routeModule: PagesRouteModule;
+export declare const handler: (req: import("http").IncomingMessage, res: import("http").ServerResponse, ctx: {
+    waitUntil: (prom: Promise<void>) => void;
+}) => Promise<void>;

frontend/node_modules/next/dist/build/templates/pages.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    config: null,
+    default: null,
+    getServerSideProps: null,
+    getStaticPaths: null,
+    getStaticProps: null,
+    handler: null,
+    reportWebVitals: null,
+    routeModule: null,
+    unstable_getServerProps: null,
+    unstable_getServerSideProps: null,
+    unstable_getStaticParams: null,
+    unstable_getStaticPaths: null,
+    unstable_getStaticProps: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    config: function() {
+        return config;
+    },
+    // Re-export the component (should be the default export).
+    default: function() {
+        return _default;
+    },
+    getServerSideProps: function() {
+        return getServerSideProps;
+    },
+    getStaticPaths: function() {
+        return getStaticPaths;
+    },
+    getStaticProps: function() {
+        return getStaticProps;
+    },
+    handler: function() {
+        return handler;
+    },
+    reportWebVitals: function() {
+        return reportWebVitals;
+    },
+    routeModule: function() {
+        return routeModule;
+    },
+    unstable_getServerProps: function() {
+        return unstable_getServerProps;
+    },
+    unstable_getServerSideProps: function() {
+        return unstable_getServerSideProps;
+    },
+    unstable_getStaticParams: function() {
+        return unstable_getStaticParams;
+    },
+    unstable_getStaticPaths: function() {
+        return unstable_getStaticPaths;
+    },
+    unstable_getStaticProps: function() {
+        return unstable_getStaticProps;
+    }
+});
+const _modulecompiled = require("../../server/route-modules/pages/module.compiled");
+const _routekind = require("../../server/route-kind");
+const _helpers = require("./helpers");
+const _VAR_MODULE_DOCUMENT = /*#__PURE__*/ _interop_require_wildcard(require("VAR_MODULE_DOCUMENT"));
+const _VAR_MODULE_APP = /*#__PURE__*/ _interop_require_wildcard(require("VAR_MODULE_APP"));
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _pageshandler = require("../../server/route-modules/pages/pages-handler");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const _default = (0, _helpers.hoist)(_VAR_USERLAND, 'default');
+const getStaticProps = (0, _helpers.hoist)(_VAR_USERLAND, 'getStaticProps');
+const getStaticPaths = (0, _helpers.hoist)(_VAR_USERLAND, 'getStaticPaths');
+const getServerSideProps = (0, _helpers.hoist)(_VAR_USERLAND, 'getServerSideProps');
+const config = (0, _helpers.hoist)(_VAR_USERLAND, 'config');
+const reportWebVitals = (0, _helpers.hoist)(_VAR_USERLAND, 'reportWebVitals');
+const unstable_getStaticProps = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getStaticProps');
+const unstable_getStaticPaths = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getStaticPaths');
+const unstable_getStaticParams = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getStaticParams');
+const unstable_getServerProps = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getServerProps');
+const unstable_getServerSideProps = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getServerSideProps');
+const routeModule = new _modulecompiled.PagesRouteModule({
+    definition: {
+        kind: _routekind.RouteKind.PAGES,
+        page: 'VAR_DEFINITION_PAGE',
+        pathname: 'VAR_DEFINITION_PATHNAME',
+        // The following aren't used in production.
+        bundlePath: '',
+        filename: ''
+    },
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
+    components: {
+        // default export might not exist when optimized for data only
+        App: _VAR_MODULE_APP.default,
+        Document: _VAR_MODULE_DOCUMENT.default
+    },
+    userland: _VAR_USERLAND
+});
+const handler = (0, _pageshandler.getHandler)({
+    srcPage: 'VAR_DEFINITION_PAGE',
+    config,
+    userland: _VAR_USERLAND,
+    routeModule,
+    getStaticPaths,
+    getStaticProps,
+    getServerSideProps
+});
+
+//# sourceMappingURL=pages.js.map

frontend/node_modules/next/dist/build/templates/pages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/templates/pages.ts"],"sourcesContent":["import { PagesRouteModule } from '../../server/route-modules/pages/module.compiled'\nimport { RouteKind } from '../../server/route-kind'\n\nimport { hoist } from './helpers'\n\n// Import the app and document modules.\nimport * as document from 'VAR_MODULE_DOCUMENT'\nimport * as app from 'VAR_MODULE_APP'\n\n// Import the userland code.\nimport * as userland from 'VAR_USERLAND'\nimport { getHandler } from '../../server/route-modules/pages/pages-handler'\n\n// Re-export the component (should be the default export).\nexport default hoist(userland, 'default')\n\n// Re-export methods.\nexport const getStaticProps = hoist(userland, 'getStaticProps')\nexport const getStaticPaths = hoist(userland, 'getStaticPaths')\nexport const getServerSideProps = hoist(userland, 'getServerSideProps')\nexport const config = hoist(userland, 'config')\nexport const reportWebVitals = hoist(userland, 'reportWebVitals')\n\n// Re-export legacy methods.\nexport const unstable_getStaticProps = hoist(\n  userland,\n  'unstable_getStaticProps'\n)\nexport const unstable_getStaticPaths = hoist(\n  userland,\n  'unstable_getStaticPaths'\n)\nexport const unstable_getStaticParams = hoist(\n  userland,\n  'unstable_getStaticParams'\n)\nexport const unstable_getServerProps = hoist(\n  userland,\n  'unstable_getServerProps'\n)\nexport const unstable_getServerSideProps = hoist(\n  userland,\n  'unstable_getServerSideProps'\n)\n\n// Create and export the route module that will be consumed.\nexport const routeModule = new PagesRouteModule({\n  definition: {\n    kind: RouteKind.PAGES,\n    page: 'VAR_DEFINITION_PAGE',\n    pathname: 'VAR_DEFINITION_PATHNAME',\n    // The following aren't used in production.\n    bundlePath: '',\n    filename: '',\n  },\n  distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',\n  relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',\n  components: {\n    // default export might not exist when optimized for data only\n    App: app.default,\n    Document: document.default,\n  },\n  userland,\n})\n\nexport const handler = getHandler({\n  srcPage: 'VAR_DEFINITION_PAGE',\n  config,\n  userland,\n  routeModule,\n  getStaticPaths,\n  getStaticProps,\n  getServerSideProps,\n})\n"],"names":["config","getServerSideProps","getStaticPaths","getStaticProps","handler","reportWebVitals","routeModule","unstable_getServerProps","unstable_getServerSideProps","unstable_getStaticParams","unstable_getStaticPaths","unstable_getStaticProps","hoist","userland","PagesRouteModule","definition","kind","RouteKind","PAGES","page","pathname","bundlePath","filename","distDir","process","env","__NEXT_RELATIVE_DIST_DIR","relativeProjectDir","__NEXT_RELATIVE_PROJECT_DIR","components","App","app","default","Document","document","getHandler","srcPage"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;IAoBaA,MAAM;eAANA;;IAPb,0DAA0D;IAC1D,OAAyC;eAAzC;;IAKaC,kBAAkB;eAAlBA;;IADAC,cAAc;eAAdA;;IADAC,cAAc;eAAdA;;IAgDAC,OAAO;eAAPA;;IA5CAC,eAAe;eAAfA;;IAyBAC,WAAW;eAAXA;;IAVAC,uBAAuB;eAAvBA;;IAIAC,2BAA2B;eAA3BA;;IARAC,wBAAwB;eAAxBA;;IAJAC,uBAAuB;eAAvBA;;IAJAC,uBAAuB;eAAvBA;;;gCAxBoB;2BACP;yBAEJ;6EAGI;wEACL;sEAGK;8BACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAG3B,WAAeC,IAAAA,cAAK,EAACC,eAAU;AAGxB,MAAMV,iBAAiBS,IAAAA,cAAK,EAACC,eAAU;AACvC,MAAMX,iBAAiBU,IAAAA,cAAK,EAACC,eAAU;AACvC,MAAMZ,qBAAqBW,IAAAA,cAAK,EAACC,eAAU;AAC3C,MAAMb,SAASY,IAAAA,cAAK,EAACC,eAAU;AAC/B,MAAMR,kBAAkBO,IAAAA,cAAK,EAACC,eAAU;AAGxC,MAAMF,0BAA0BC,IAAAA,cAAK,EAC1CC,eACA;AAEK,MAAMH,0BAA0BE,IAAAA,cAAK,EAC1CC,eACA;AAEK,MAAMJ,2BAA2BG,IAAAA,cAAK,EAC3CC,eACA;AAEK,MAAMN,0BAA0BK,IAAAA,cAAK,EAC1CC,eACA;AAEK,MAAML,8BAA8BI,IAAAA,cAAK,EAC9CC,eACA;AAIK,MAAMP,cAAc,IAAIQ,gCAAgB,CAAC;IAC9CC,YAAY;QACVC,MAAMC,oBAAS,CAACC,KAAK;QACrBC,MAAM;QACNC,UAAU;QACV,2CAA2C;QAC3CC,YAAY;QACZC,UAAU;IACZ;IACAC,SAASC,QAAQC,GAAG,CAACC,wBAAwB,IAAI;IACjDC,oBAAoBH,QAAQC,GAAG,CAACG,2BAA2B,IAAI;IAC/DC,YAAY;QACV,8DAA8D;QAC9DC,KAAKC,gBAAIC,OAAO;QAChBC,UAAUC,qBAASF,OAAO;IAC5B;IACAnB,UAAAA;AACF;AAEO,MAAMT,UAAU+B,IAAAA,wBAAU,EAAC;IAChCC,SAAS;IACTpC;IACAa,UAAAA;IACAP;IACAJ;IACAC;IACAF;AACF","ignoreList":[0]}