@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/router-server.js

@@ -0,0 +1,826 @@
+// this must come first as it includes require hooks
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "initialize", {
+    enumerable: true,
+    get: function() {
+        return initialize;
+    }
+});
+require("../node-environment");
+require("../require-hook");
+const _url = /*#__PURE__*/ _interop_require_default(require("url"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _config = /*#__PURE__*/ _interop_require_default(require("../config"));
+const _bundler = require("../../lib/bundler");
+const _servestatic = require("../serve-static");
+const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _processerrorhandlers = require("../node-environment-extensions/process-error-handlers");
+const _utils = require("../../shared/lib/utils");
+const _magicidentifier = require("../../shared/lib/magic-identifier");
+const _findpagesdir = require("../../lib/find-pages-dir");
+const _filesystem = require("./router-utils/filesystem");
+const _proxyrequest = require("./router-utils/proxy-request");
+const _pipereadable = require("../pipe-readable");
+const _resolveroutes = require("./router-utils/resolve-routes");
+const _requestmeta = require("../request-meta");
+const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
+const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
+const _compression = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/compression"));
+const _releasecompressionstream = require("./release-compression-stream");
+const _nextrequest = require("../web/spec-extension/adapters/next-request");
+const _isnonhtmlsecfetchdest = require("./is-non-html-sec-fetch-dest");
+const _parseurl = require("../../shared/lib/router/utils/parse-url");
+const _constants = require("../../shared/lib/constants");
+const _redirectstatuscode = require("../../client/components/redirect-status-code");
+const _devbundlerservice = require("./dev-bundler-service");
+const _trace = require("../../trace");
+const _ensureleadingslash = require("../../shared/lib/page-path/ensure-leading-slash");
+const _getnextpathnameinfo = require("../../shared/lib/router/utils/get-next-pathname-info");
+const _gethostname = require("../../shared/lib/get-hostname");
+const _detectdomainlocale = require("../../shared/lib/i18n/detect-domain-locale");
+const _mockrequest = require("./mock-request");
+const _hotreloadertypes = require("../dev/hot-reloader-types");
+const _normalizedassetprefix = require("../../shared/lib/normalized-asset-prefix");
+const _patchfetchsymbol = require("./patch-fetch-symbol");
+const _utils1 = require("./server-ipc/utils");
+const _blockcrosssitedev = require("./router-utils/block-cross-site-dev");
+const _shared = require("../../trace/shared");
+const _nofallbackerrorexternal = require("../../shared/lib/no-fallback-error.external");
+const _routerservercontext = require("./router-utils/router-server-context");
+const _chromedevtoolsworkspace = require("./chrome-devtools-workspace");
+const _configshared = require("../config-shared");
+const _ciinfo = require("../ci-info");
+const _requestinsights = require("./trace/request-insights");
+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 debug = (0, _debug.default)('next:router-server:main');
+const isNextFont = (pathname)=>pathname && /\/media\/[^/]+\.(woff|woff2|eot|ttf|otf)$/.test(pathname);
+// ModuleBuildError can cross compiled module boundaries, so constructor
+// identity is not reliable. Check its stable fields and string prefix instead.
+function isModuleBuildError(error) {
+    var _maybeError_constructor;
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const maybeError = error;
+    const errorString = String(error);
+    return maybeError.name === 'ModuleBuildError' || maybeError.code === 'ModuleBuildError' || ((_maybeError_constructor = maybeError.constructor) == null ? void 0 : _maybeError_constructor.name) === 'ModuleBuildError' || errorString.startsWith('ModuleBuildError:') || errorString.startsWith('Error [ModuleBuildError]:');
+}
+function getErrorMessage(error) {
+    if (error && typeof error === 'object' && 'message' in error && typeof error.message === 'string') {
+        return (0, _magicidentifier.deobfuscateText)(error.message);
+    }
+    return (0, _magicidentifier.deobfuscateText)(String(error));
+}
+const requestHandlers = {};
+async function initialize(opts) {
+    var _development_bundler, _development_service, _development_service1, _development_service2, _development_service3, _development_service4, _development_bundler1;
+    if (!process.env.NODE_ENV) {
+        // @ts-ignore not readonly
+        process.env.NODE_ENV = opts.dev ? 'development' : 'production';
+    }
+    // Capture the bundler before loading the config
+    const bundlerBeforeConfig = opts.dev ? (0, _bundler.getBundlerFromEnv)() : undefined;
+    let experimentalFeatures = [];
+    const config = await (0, _config.default)(opts.dev ? _constants.PHASE_DEVELOPMENT_SERVER : _constants.PHASE_PRODUCTION_SERVER, opts.dir, {
+        silent: false,
+        reportExperimentalFeatures (features) {
+            experimentalFeatures = features.toSorted(({ key: a }, { key: b })=>a.localeCompare(b));
+        }
+    });
+    if (bundlerBeforeConfig !== undefined) {
+        (0, _bundler.finalizeBundlerFromConfig)(bundlerBeforeConfig);
+    }
+    let compress;
+    if ((config == null ? void 0 : config.compress) !== false) {
+        compress = (0, _compression.default)();
+    }
+    const fsChecker = await (0, _filesystem.setupFsCheck)({
+        dev: opts.dev,
+        dir: opts.dir,
+        config,
+        minimalMode: opts.minimalMode
+    });
+    const renderServer = {};
+    let development = undefined;
+    let originalFetch = globalThis.fetch;
+    let hasVulnerabilityInsight = Promise.resolve(false);
+    if (opts.dev) {
+        var _developmentConfig_experimental;
+        const { Telemetry } = require('../../telemetry/storage');
+        const telemetry = new Telemetry({
+            distDir: _path.default.join(opts.dir, config.distDir)
+        });
+        _shared.traceGlobals.set('telemetry', telemetry);
+        const { pagesDir, appDir } = (0, _findpagesdir.findPagesDir)(opts.dir);
+        const { setupDevBundler } = require('./router-utils/setup-dev-bundler');
+        const resetFetch = ()=>{
+            globalThis.fetch = originalFetch;
+            globalThis[_patchfetchsymbol.NEXT_PATCH_SYMBOL] = false;
+        };
+        const setupDevBundlerSpan = opts.startServerSpan ? opts.startServerSpan.traceChild('setup-dev-bundler') : (0, _trace.trace)('setup-dev-bundler');
+        // In development, it's always the complete config.
+        let developmentConfig = config;
+        // Check only development; production startup does not query advisories.
+        if (developmentConfig.experimental.agentUpgrade === 'security' || developmentConfig.experimental.agentUpgrade === 'latest' || developmentConfig.experimental.agentUpgrade === 'experimental-future' || process.env.__NEXT_AGENT_UPGRADE || process.env.__NEXT_AGENT_UPGRADE_FORCE_DEVTOOLS_FOR_TESTING === '1') {
+            const { nudgeUpgrade, getUpgradeContext, assessUpgrade } = require('../../lib/upgrade/nudge');
+            const upgradeContext = getUpgradeContext(developmentConfig);
+            const installedVersion = "16.4.3" || 'unknown';
+            const policy = upgradeContext.experimental.agentUpgrade;
+            const forced = process.env.__NEXT_AGENT_UPGRADE === policy;
+            const forceDevToolsForTesting = process.env.__NEXT_AGENT_UPGRADE_FORCE_DEVTOOLS_FOR_TESTING === '1';
+            const assessment = _ciinfo.isCI || forceDevToolsForTesting ? Promise.resolve(null) : assessUpgrade(opts.dir, upgradeContext, installedVersion, null, forced);
+            hasVulnerabilityInsight = assessment.then((result)=>(result == null ? void 0 : result.kind) === 'security' || forceDevToolsForTesting, (error)=>{
+                _log.warn(`Could not check the DevTools security insight: ${error}`);
+                return false;
+            });
+            if (process.env.NEXT_PRIVATE_UPGRADE_PROMPT === '1' && process.send) {
+                // The CLI shows the menu; keep serving instead of waiting for it.
+                void Promise.allSettled([
+                    assessment
+                ]).then(([promptAssessment])=>{
+                    if (process.connected) {
+                        process.send({
+                            nextUpgradeContext: upgradeContext,
+                            telemetryDisabled: process.env.NEXT_TELEMETRY_DISABLED,
+                            ...promptAssessment.status === 'fulfilled' ? {
+                                nextUpgradeAssessment: promptAssessment.value
+                            } : {}
+                        });
+                    }
+                });
+            } else {
+                // CI skips the DevTools assessment, but agents still need the nudge.
+                void nudgeUpgrade(opts.dir, upgradeContext, 'dev', null, _ciinfo.isCI || forceDevToolsForTesting ? null : assessment, {
+                    telemetry,
+                    onNudgeId: null
+                }).catch((error)=>{
+                    const { printAndExit } = require('./utils');
+                    const exitCode = error && typeof error === 'object' ? Reflect.get(error, 'exitCode') : undefined;
+                    printAndExit(error instanceof Error ? error.message : String(error), typeof exitCode === 'number' ? exitCode : 1);
+                });
+            }
+        }
+        // Resolve the effective serverFastRefresh value.
+        // Both default to enabled (true). CLI takes precedence over config.
+        const cliServerFastRefresh = opts.serverFastRefresh;
+        const configServerFastRefresh = (_developmentConfig_experimental = developmentConfig.experimental) == null ? void 0 : _developmentConfig_experimental.turbopackServerFastRefresh;
+        let effectiveServerFastRefresh;
+        if (cliServerFastRefresh !== undefined && configServerFastRefresh !== undefined && cliServerFastRefresh !== configServerFastRefresh) {
+            _log.warn(`The CLI flag "${cliServerFastRefresh === false ? '--no-server-fast-refresh' : '--server-fast-refresh'}" conflicts with "experimental.turbopackServerFastRefresh: ${configServerFastRefresh}" in your Next.js config. The CLI flag will take precedence.`);
+            effectiveServerFastRefresh = cliServerFastRefresh;
+        } else {
+            // Default to true when neither CLI nor config specifies a value.
+            effectiveServerFastRefresh = cliServerFastRefresh ?? configServerFastRefresh ?? true;
+        }
+        let developmentBundler = await setupDevBundlerSpan.traceAsyncFn(()=>setupDevBundler({
+                // Passed here but the initialization of this object happens below, doing the initialization before the setupDev call breaks.
+                renderServer,
+                appDir,
+                pagesDir,
+                telemetry,
+                fsChecker,
+                dir: opts.dir,
+                nextConfig: developmentConfig,
+                isCustomServer: opts.customServer,
+                turbo: !!process.env.TURBOPACK,
+                port: opts.port,
+                onDevServerCleanup: opts.onDevServerCleanup,
+                resetFetch,
+                serverFastRefresh: effectiveServerFastRefresh,
+                hasVulnerabilityInsight
+            }));
+        let devBundlerService = new _devbundlerservice.DevBundlerService(developmentBundler, // The request handler is assigned below, this allows us to create a lazy
+        // reference to it.
+        (req, res)=>{
+            return requestHandlers[opts.dir](req, res);
+        }, Boolean(developmentConfig.experimental.requestInsights));
+        development = {
+            bundler: developmentBundler,
+            service: devBundlerService,
+            config: developmentConfig
+        };
+    }
+    const devMemoryThresholdRestart = (development == null ? void 0 : development.config.experimental.devMemoryThresholdRestart) !== false;
+    renderServer.instance = require('./render-server');
+    const requestHandlerImpl = async (req, res)=>{
+        (0, _requestmeta.addRequestMeta)(req, 'relativeProjectDir', relativeProjectDir);
+        const assetPrefix = getAssetPrefix();
+        // internal headers should not be honored by the request handler
+        if (!process.env.NEXT_PRIVATE_TEST_HEADERS) {
+            (0, _utils1.filterInternalHeaders)(req.headers);
+        }
+        if (opts.dev && req.url) {
+            if (config.experimental.requestInsights) {
+                process.env.__NEXT_REQUEST_INSIGHTS = 'true';
+            }
+            const urlParts = req.url.split('?', 1);
+            const pathname = (0, _removepathprefix.removePathPrefix)(urlParts[0] || '', config.basePath);
+            if (pathname === _constants.REQUEST_INSIGHTS_DEV_ENDPOINT) {
+                if (development && (0, _blockcrosssitedev.blockCrossSiteDEV)(req, res, development.config.allowedDevOrigins, opts.hostname)) {
+                    return;
+                }
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                if (!config.experimental.requestInsights && !(0, _requestinsights.isRequestInsightsEnabled)()) {
+                    res.statusCode = 404;
+                    res.end(JSON.stringify({
+                        error: 'Request Insights is not enabled. Set experimental.requestInsights = true and restart next dev.'
+                    }));
+                    return;
+                }
+                res.statusCode = 200;
+                res.end(JSON.stringify((0, _requestinsights.getRequestInsightsSnapshot)()));
+                return;
+            }
+        }
+        if (!opts.minimalMode && config.i18n && config.i18n.localeDetection !== false) {
+            var _this;
+            const urlParts = (req.url || '').split('?', 1);
+            let urlNoQuery = urlParts[0] || '';
+            if (config.basePath) {
+                urlNoQuery = (0, _removepathprefix.removePathPrefix)(urlNoQuery, config.basePath);
+            }
+            const pathnameInfo = (0, _getnextpathnameinfo.getNextPathnameInfo)(urlNoQuery, {
+                nextConfig: config
+            });
+            const domainLocale = (0, _detectdomainlocale.detectDomainLocale)(config.i18n.domains, (0, _gethostname.getHostname)({
+                hostname: urlNoQuery
+            }, req.headers));
+            const defaultLocale = (domainLocale == null ? void 0 : domainLocale.defaultLocale) || config.i18n.defaultLocale;
+            const { getLocaleRedirect } = require('../../shared/lib/i18n/get-locale-redirect');
+            const parsedUrl = (0, _parseurl.parseUrl)((_this = req.url || '') == null ? void 0 : _this.replace(/^\/+/, '/'));
+            const redirect = getLocaleRedirect({
+                defaultLocale,
+                domainLocale,
+                headers: req.headers,
+                nextConfig: config,
+                pathLocale: pathnameInfo.locale,
+                urlParsed: {
+                    ...parsedUrl,
+                    pathname: pathnameInfo.locale ? `/${pathnameInfo.locale}${urlNoQuery}` : urlNoQuery
+                }
+            });
+            if (redirect) {
+                res.setHeader('Location', redirect);
+                res.statusCode = _redirectstatuscode.RedirectStatusCode.TemporaryRedirect;
+                res.end(redirect);
+                return;
+            }
+        }
+        if (compress) {
+            // @ts-expect-error not express req/res
+            compress(req, res, ()=>{});
+            // On client disconnect the middleware never ends its zlib stream, which
+            // then leaks past GC. See `releaseCompressionStream`.
+            res.once('close', ()=>{
+                if (res.writableFinished) return;
+                (0, _releasecompressionstream.releaseCompressionStream)(res);
+            });
+        }
+        req.on('error', (_err)=>{
+        // TODO: log socket errors?
+        });
+        res.on('error', (_err)=>{
+        // TODO: log socket errors?
+        });
+        const invokedOutputs = new Set();
+        async function invokeRender(parsedUrl, invokePath, handleIndex, additionalRequestMeta) {
+            var _fsChecker_getMiddlewareMatchers;
+            // invokeRender expects /api routes to not be locale prefixed
+            // so normalize here before continuing
+            if (config.i18n && (0, _removepathprefix.removePathPrefix)(invokePath, config.basePath).startsWith(`/${(0, _requestmeta.getRequestMeta)(req, 'locale')}/api`)) {
+                invokePath = fsChecker.handleLocale((0, _removepathprefix.removePathPrefix)(invokePath, config.basePath)).pathname;
+            }
+            if (req.headers['x-nextjs-data'] && ((_fsChecker_getMiddlewareMatchers = fsChecker.getMiddlewareMatchers()) == null ? void 0 : _fsChecker_getMiddlewareMatchers.length) && (0, _removepathprefix.removePathPrefix)(invokePath, config.basePath) === '/404') {
+                res.setHeader('x-nextjs-matched-path', parsedUrl.pathname || '');
+                res.statusCode = 404;
+                res.setHeader('content-type', 'application/json');
+                res.end('{}');
+                return null;
+            }
+            if (!handlers) {
+                throw new Error('Failed to initialize render server');
+            }
+            (0, _requestmeta.addRequestMeta)(req, 'invokePath', invokePath);
+            (0, _requestmeta.addRequestMeta)(req, 'invokeQuery', parsedUrl.query);
+            (0, _requestmeta.addRequestMeta)(req, 'middlewareInvoke', false);
+            for(const key in additionalRequestMeta || {}){
+                (0, _requestmeta.addRequestMeta)(req, key, additionalRequestMeta[key]);
+            }
+            debug('invokeRender', req.url, req.headers);
+            try {
+                var _renderServer_instance;
+                const initResult = await (renderServer == null ? void 0 : (_renderServer_instance = renderServer.instance) == null ? void 0 : _renderServer_instance.initialize(renderServerOpts));
+                try {
+                    await (initResult == null ? void 0 : initResult.requestHandler(req, res));
+                } catch (err) {
+                    if (err instanceof _nofallbackerrorexternal.NoFallbackError) {
+                        await handleRequest(handleIndex + 1);
+                        return;
+                    }
+                    throw err;
+                }
+                return;
+            } catch (e) {
+                // If the client aborts before we can receive a response object (when
+                // the headers are flushed), then we can early exit without further
+                // processing.
+                if ((0, _pipereadable.isAbortError)(e)) {
+                    return;
+                }
+                throw e;
+            }
+        }
+        const handleRequest = async (handleIndex)=>{
+            var _development_bundler;
+            if (handleIndex > 5) {
+                throw new Error(`Attempted to handle request too many times ${req.url}`);
+            }
+            // handle hot-reloader first
+            if (development) {
+                if ((0, _blockcrosssitedev.blockCrossSiteDEV)(req, res, development.config.allowedDevOrigins, opts.hostname)) {
+                    return;
+                }
+                const origUrl = req.url || '/';
+                // both the basePath and assetPrefix need to be stripped from the URL
+                // so that the development bundler can find the correct file
+                if (config.basePath && (0, _pathhasprefix.pathHasPrefix)(origUrl, config.basePath)) {
+                    req.url = (0, _removepathprefix.removePathPrefix)(origUrl, config.basePath);
+                } else if (assetPrefix && (0, _pathhasprefix.pathHasPrefix)(origUrl, assetPrefix)) {
+                    req.url = (0, _removepathprefix.removePathPrefix)(origUrl, assetPrefix);
+                }
+                const parsedUrl = (0, _parseurl.parseUrl)(req.url || '/');
+                const hotReloaderResult = await development.bundler.hotReloader.run(req, res, parsedUrl);
+                if (hotReloaderResult.finished) {
+                    return hotReloaderResult;
+                }
+                req.url = origUrl;
+            }
+            const { finished, parsedUrl, statusCode, resHeaders, bodyStream, matchedOutput } = await resolveRoutes({
+                req,
+                res,
+                isUpgradeReq: false,
+                signal: (0, _nextrequest.signalFromNodeResponse)(res),
+                invokedOutputs
+            });
+            if (res.closed || res.finished) {
+                return;
+            }
+            if (development && (matchedOutput == null ? void 0 : matchedOutput.type) === 'devVirtualFsItem') {
+                const origUrl = req.url || '/';
+                if (config.basePath && (0, _pathhasprefix.pathHasPrefix)(origUrl, config.basePath)) {
+                    req.url = (0, _removepathprefix.removePathPrefix)(origUrl, config.basePath);
+                } else if (assetPrefix && (0, _pathhasprefix.pathHasPrefix)(origUrl, assetPrefix)) {
+                    req.url = (0, _removepathprefix.removePathPrefix)(origUrl, assetPrefix);
+                }
+                if (resHeaders !== null) {
+                    for (const key of Object.keys(resHeaders)){
+                        res.setHeader(key, resHeaders[key]);
+                    }
+                }
+                const result = await development.bundler.requestHandler(req, res);
+                if (result.finished) {
+                    return;
+                }
+                // TODO: throw invariant if we resolved to this but it wasn't handled?
+                req.url = origUrl;
+            }
+            debug('requestHandler!', req.url, {
+                matchedOutput,
+                statusCode,
+                resHeaders,
+                bodyStream: !!bodyStream,
+                parsedUrl: {
+                    pathname: parsedUrl.pathname,
+                    query: parsedUrl.query
+                },
+                finished
+            });
+            // apply any response headers from routing
+            if (resHeaders !== null) {
+                for (const key of Object.keys(resHeaders)){
+                    res.setHeader(key, resHeaders[key]);
+                }
+            }
+            // handle redirect
+            if (!bodyStream && statusCode && statusCode > 300 && statusCode < 400) {
+                const destination = _url.default.format(parsedUrl);
+                res.statusCode = statusCode;
+                res.setHeader('location', destination);
+                if (statusCode === _redirectstatuscode.RedirectStatusCode.PermanentRedirect) {
+                    res.setHeader('Refresh', `0;url=${destination}`);
+                }
+                return res.end(destination);
+            }
+            // handle middleware body response
+            if (bodyStream) {
+                res.statusCode = statusCode || 200;
+                return await (0, _pipereadable.pipeToNodeResponse)(bodyStream, res);
+            }
+            if (finished && parsedUrl.protocol) {
+                var _getRequestMeta;
+                return await (0, _proxyrequest.proxyRequest)(req, res, parsedUrl, undefined, (_getRequestMeta = (0, _requestmeta.getRequestMeta)(req, 'clonableBody')) == null ? void 0 : _getRequestMeta.cloneBodyStream(), config.experimental.proxyTimeout);
+            }
+            if ((matchedOutput == null ? void 0 : matchedOutput.fsPath) && matchedOutput.itemPath) {
+                if (opts.dev && (fsChecker.appFiles.has(matchedOutput.itemPath) || fsChecker.pageFiles.has(matchedOutput.itemPath))) {
+                    res.statusCode = 500;
+                    const message = `A conflicting public file and page file was found for path ${matchedOutput.itemPath} https://nextjs.org/docs/messages/conflicting-public-file-page`;
+                    await invokeRender(parsedUrl, '/_error', handleIndex, {
+                        invokeStatus: 500,
+                        invokeError: new Error(message)
+                    });
+                    _log.error(message);
+                    return;
+                }
+                if (!res.getHeader('cache-control') && matchedOutput.type === 'nextStaticFolder') {
+                    if (matchedOutput.itemPath.startsWith('/service-worker/')) {
+                        res.setHeader('Cache-Control', 'public, max-age=0, must-revalidate');
+                        res.setHeader('Service-Worker-Allowed', config.basePath || '/');
+                    } else if (opts.dev && !isNextFont(parsedUrl.pathname)) {
+                        // Development assets stay revalidatable. `serveStatic` adds an
+                        // `ETag`, so the browser sends a conditional request and reuses the
+                        // stored body when the server answers `304`. This keeps the browser
+                        // from downloading every chunk again on each page load.
+                        res.setHeader('Cache-Control', 'no-cache, must-revalidate');
+                    } else {
+                        res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+                    }
+                }
+                if (!(req.method === 'GET' || req.method === 'HEAD')) {
+                    res.setHeader('Allow', [
+                        'GET',
+                        'HEAD'
+                    ]);
+                    res.statusCode = 405;
+                    return await invokeRender((0, _parseurl.parseUrl)('/405'), '/405', handleIndex, {
+                        invokeStatus: 405
+                    });
+                }
+                try {
+                    return await (0, _servestatic.serveStatic)(req, res, matchedOutput.itemPath, {
+                        root: matchedOutput.itemsRoot,
+                        // Ensures that etags are not generated for static files when disabled.
+                        etag: config.generateEtags
+                    });
+                } catch (err) {
+                    /**
+           * Hardcoded every possible error status code that could be thrown by "serveStatic" method
+           * This is done by searching "this.error" inside "send" module's source code:
+           * https://github.com/pillarjs/send/blob/master/index.js
+           * https://github.com/pillarjs/send/blob/develop/index.js
+           */ const POSSIBLE_ERROR_CODE_FROM_SERVE_STATIC = new Set([
+                        // send module will throw 500 when header is already sent or fs.stat error happens
+                        // https://github.com/pillarjs/send/blob/53f0ab476145670a9bdd3dc722ab2fdc8d358fc6/index.js#L392
+                        // Note: we will use Next.js built-in 500 page to handle 500 errors
+                        // 500,
+                        // send module will throw 404 when file is missing
+                        // https://github.com/pillarjs/send/blob/53f0ab476145670a9bdd3dc722ab2fdc8d358fc6/index.js#L421
+                        // Note: we will use Next.js built-in 404 page to handle 404 errors
+                        // 404,
+                        // send module will throw 403 when redirecting to a directory without enabling directory listing
+                        // https://github.com/pillarjs/send/blob/53f0ab476145670a9bdd3dc722ab2fdc8d358fc6/index.js#L484
+                        // Note: Next.js throws a different error (without status code) for directory listing
+                        // 403,
+                        // send module will throw 400 when fails to normalize the path
+                        // https://github.com/pillarjs/send/blob/53f0ab476145670a9bdd3dc722ab2fdc8d358fc6/index.js#L520
+                        400,
+                        // send module will throw 412 with conditional GET request
+                        // https://github.com/pillarjs/send/blob/53f0ab476145670a9bdd3dc722ab2fdc8d358fc6/index.js#L632
+                        412,
+                        // send module will throw 416 when range is not satisfiable
+                        // https://github.com/pillarjs/send/blob/53f0ab476145670a9bdd3dc722ab2fdc8d358fc6/index.js#L669
+                        416
+                    ]);
+                    let validErrorStatus = POSSIBLE_ERROR_CODE_FROM_SERVE_STATIC.has(err.statusCode);
+                    // normalize non-allowed status codes
+                    if (!validErrorStatus) {
+                        ;
+                        err.statusCode = 400;
+                    }
+                    if (typeof err.statusCode === 'number') {
+                        const invokePath = `/${err.statusCode}`;
+                        const invokeStatus = err.statusCode;
+                        res.statusCode = err.statusCode;
+                        return await invokeRender((0, _parseurl.parseUrl)(invokePath), invokePath, handleIndex, {
+                            invokeStatus
+                        });
+                    }
+                    throw err;
+                }
+            }
+            if (matchedOutput) {
+                invokedOutputs.add(matchedOutput.itemPath);
+                // fsChecker preserves compilation errors from its dev ensure step so
+                // the route remains matched. Log the compiler diagnostic, then render
+                // the matched route as a 500 instead of falling through to a 404.
+                if (matchedOutput.error && development) {
+                    development.bundler.logErrorWithOriginalStack(matchedOutput.error, matchedOutput.type === 'appFile' ? 'app-dir' : undefined);
+                }
+                return await invokeRender(parsedUrl, parsedUrl.pathname || '/', handleIndex, {
+                    invokeOutput: matchedOutput.itemPath,
+                    ...matchedOutput.error ? {
+                        invokeStatus: 500,
+                        invokeError: matchedOutput.error
+                    } : undefined,
+                    // fsChecker owns the route match for filesystem requests. Forward
+                    // it so BaseServer does not need the removed matcher manager.
+                    ...matchedOutput.route ? {
+                        match: {
+                            definition: matchedOutput.route,
+                            params: matchedOutput.params
+                        }
+                    } : undefined
+                });
+            }
+            // We want the original pathname without any basePath or proxy rewrites.
+            if (development && (0, _chromedevtoolsworkspace.isChromeDevtoolsWorkspaceUrl)(req.url)) {
+                await (0, _chromedevtoolsworkspace.handleChromeDevtoolsWorkspaceRequest)(res, opts, config);
+                return;
+            }
+            // 404 case
+            res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
+            let realRequestPathname = parsedUrl.pathname ?? '';
+            if (realRequestPathname) {
+                if (config.basePath) {
+                    realRequestPathname = (0, _removepathprefix.removePathPrefix)(realRequestPathname, config.basePath);
+                }
+                if (assetPrefix) {
+                    realRequestPathname = (0, _removepathprefix.removePathPrefix)(realRequestPathname, assetPrefix);
+                }
+                if (config.i18n) {
+                    realRequestPathname = (0, _removepathprefix.removePathPrefix)(realRequestPathname, '/' + ((0, _requestmeta.getRequestMeta)(req, 'locale') ?? ''));
+                }
+            }
+            // For not found static assets, return plain text 404 instead of
+            // full HTML 404 pages to save bandwidth.
+            if (realRequestPathname.startsWith('/_next/static/')) {
+                res.statusCode = 404;
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                res.end('Not Found');
+                return null;
+            }
+            // For subresource requests (e.g. images or fonts), return plain text
+            // 404 instead of rendering the not-found route.
+            if ((req.method === 'GET' || req.method === 'HEAD') && (0, _isnonhtmlsecfetchdest.isNonHtmlSecFetchDest)(req.headers['sec-fetch-dest'])) {
+                res.statusCode = 404;
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                res.end('Not Found');
+                return null;
+            }
+            // Short-circuit favicon.ico serving so that the 404 page doesn't get built as favicon is requested by the browser when loading any route.
+            if (opts.dev && !matchedOutput && parsedUrl.pathname === '/favicon.ico') {
+                res.statusCode = 404;
+                res.end('');
+                return null;
+            }
+            const appNotFound = opts.dev ? development == null ? void 0 : (_development_bundler = development.bundler) == null ? void 0 : _development_bundler.serverFields.hasAppNotFound : await fsChecker.getItem(_constants.UNDERSCORE_NOT_FOUND_ROUTE);
+            res.statusCode = 404;
+            if (appNotFound) {
+                return await invokeRender(parsedUrl, _constants.UNDERSCORE_NOT_FOUND_ROUTE, handleIndex, {
+                    invokeStatus: 404
+                });
+            }
+            await invokeRender(parsedUrl, '/404', handleIndex, {
+                invokeStatus: 404
+            });
+        };
+        try {
+            await handleRequest(0);
+        } catch (err) {
+            try {
+                let invokePath = '/500';
+                let invokeStatus = '500';
+                if (err instanceof _utils.DecodeError) {
+                    invokePath = '/400';
+                    invokeStatus = '400';
+                } else if (isModuleBuildError(err)) {
+                    // Webpack compilation failures may bubble out of invokeRender. Log
+                    // the readable diagnostic without printing the wrapper stack again.
+                    _log.error(getErrorMessage(err));
+                } else {
+                    console.error(err);
+                }
+                res.statusCode = Number(invokeStatus);
+                return await invokeRender((0, _parseurl.parseUrl)(invokePath), invokePath, 0, {
+                    invokeStatus: res.statusCode
+                });
+            } catch (err2) {
+                console.error(err2);
+            }
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+        }
+    };
+    let requestHandler = requestHandlerImpl;
+    if (config.experimental.testProxy) {
+        // Intercept fetch and other testmode apis.
+        const { wrapRequestHandlerWorker, interceptTestApis } = // eslint-disable-next-line @next/internal/typechecked-require -- experimental/testmode is not built ins next/dist/esm
+        require('next/dist/experimental/testmode/server');
+        requestHandler = wrapRequestHandlerWorker(requestHandler);
+        interceptTestApis();
+        // We treat the intercepted fetch as "original" fetch that should be reset to during HMR.
+        originalFetch = globalThis.fetch;
+    }
+    requestHandlers[opts.dir] = requestHandler;
+    const renderServerOpts = {
+        port: opts.port,
+        dir: opts.dir,
+        hostname: opts.hostname,
+        minimalMode: opts.minimalMode,
+        dev: !!opts.dev,
+        server: opts.server,
+        serverFields: {
+            ...(development == null ? void 0 : (_development_bundler = development.bundler) == null ? void 0 : _development_bundler.serverFields) || {},
+            setIsrStatus: development == null ? void 0 : (_development_service = development.service) == null ? void 0 : _development_service.setIsrStatus.bind(development == null ? void 0 : development.service)
+        },
+        experimentalTestProxy: !!config.experimental.testProxy,
+        experimentalHttpsServer: !!opts.experimentalHttpsServer,
+        bundlerService: development == null ? void 0 : development.service,
+        startServerSpan: opts.startServerSpan,
+        quiet: opts.quiet,
+        onDevServerCleanup: opts.onDevServerCleanup,
+        distDir: config.distDir,
+        experimentalFeatures,
+        cacheComponents: config.cacheComponents,
+        partialPrefetching: config.partialPrefetching,
+        devMemoryThresholdRestart
+    };
+    renderServerOpts.serverFields.routerServerHandler = requestHandlerImpl;
+    // pre-initialize workers
+    const handlers = await renderServer.instance.initialize(renderServerOpts);
+    const getAssetPrefix = ()=>handlers.server.getAssetPrefix();
+    // this must come after initialize of render server since it's
+    // using initialized methods
+    if (!_routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) {
+        _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol] = {};
+    }
+    const relativeProjectDir = _path.default.relative(process.cwd(), opts.dir);
+    _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir] = {
+        nextConfig: (0, _configshared.getNextConfigRuntime)(config),
+        getAssetPrefix,
+        hostname: handlers.server.hostname,
+        revalidate: handlers.server.revalidate.bind(handlers.server),
+        render404: handlers.server.render404.bind(handlers.server),
+        experimentalTestProxy: renderServerOpts.experimentalTestProxy,
+        logErrorWithOriginalStack: opts.dev ? handlers.server.logErrorWithOriginalStack.bind(handlers.server) : (err)=>!opts.quiet && _log.error(err),
+        setCacheStatus: config.cacheComponents ? development == null ? void 0 : (_development_service1 = development.service) == null ? void 0 : _development_service1.setCacheStatus.bind(development == null ? void 0 : development.service) : undefined,
+        setIsrStatus: development == null ? void 0 : (_development_service2 = development.service) == null ? void 0 : _development_service2.setIsrStatus.bind(development == null ? void 0 : development.service),
+        setReactDebugChannel: (development == null ? void 0 : development.config.experimental.reactDebugChannel) ? development == null ? void 0 : (_development_service3 = development.service) == null ? void 0 : _development_service3.setReactDebugChannel.bind(development == null ? void 0 : development.service) : undefined,
+        sendErrorsToBrowser: development == null ? void 0 : (_development_service4 = development.service) == null ? void 0 : _development_service4.sendErrorsToBrowser.bind(development == null ? void 0 : development.service)
+    };
+    const logError = async (err)=>{
+        _log.error('uncaughtException: ', err);
+    };
+    process.on('uncaughtException', logError);
+    // The render server may run in the same process and have already registered
+    // the unhandled rejection listener, in which case we must not register
+    // another one, to avoid logging unhandled rejections multiple times.
+    if (!(0, _processerrorhandlers.isUnhandledRejectionListenerRegistered)()) {
+        (0, _processerrorhandlers.registerUnhandledRejectionListener)();
+    }
+    const resolveRoutes = (0, _resolveroutes.getResolveRoutes)(fsChecker, config, getAssetPrefix, opts, renderServer.instance, renderServerOpts, development == null ? void 0 : (_development_bundler1 = development.bundler) == null ? void 0 : _development_bundler1.ensureMiddleware);
+    const upgradeHandler = async (req, socket, head)=>{
+        try {
+            req.on('error', (_err)=>{
+            // TODO: log socket errors?
+            // console.error(_err);
+            });
+            socket.on('error', (_err)=>{
+            // TODO: log socket errors?
+            // console.error(_err);
+            });
+            if (opts.dev && development && req.url) {
+                if ((0, _blockcrosssitedev.blockCrossSiteDEV)(req, socket, development.config.allowedDevOrigins, opts.hostname)) {
+                    return;
+                }
+                const { basePath } = config;
+                const assetPrefix = getAssetPrefix();
+                let hmrPrefix = basePath;
+                // assetPrefix overrides basePath for HMR path
+                if (assetPrefix) {
+                    hmrPrefix = (0, _normalizedassetprefix.normalizedAssetPrefix)(assetPrefix);
+                    if (URL.canParse(hmrPrefix)) {
+                        // remove trailing slash from pathname
+                        // return empty string if pathname is '/'
+                        // to avoid conflicts with '/_next' below
+                        hmrPrefix = new URL(hmrPrefix).pathname.replace(/\/$/, '');
+                    }
+                }
+                const isHMRRequest = req.url.startsWith((0, _ensureleadingslash.ensureLeadingSlash)(`${hmrPrefix}/_next/hmr`));
+                // only handle HMR requests if the basePath in the request
+                // matches the basePath for the handler responding to the request
+                if (isHMRRequest) {
+                    return development.bundler.hotReloader.onHMR(req, socket, head, (client, { isLegacyClient })=>{
+                        if (isLegacyClient) {
+                            var _development_service;
+                            // Only send the ISR manifest to legacy clients, i.e. Pages
+                            // Router clients, or App Router clients that have Cache
+                            // Components disabled. The ISR manifest is only used to inform
+                            // the static indicator, which currently does not provide useful
+                            // information if Cache Components is enabled due to its binary
+                            // nature (i.e. it does not support showing info for partially
+                            // static pages).
+                            client.send(JSON.stringify({
+                                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ISR_MANIFEST,
+                                data: ((_development_service = development.service) == null ? void 0 : _development_service.appIsrManifest) || {}
+                            }));
+                        }
+                    });
+                }
+            }
+            const res = new _mockrequest.MockedResponse({
+                resWriter: ()=>{
+                    throw new Error('Invariant: did not expect response writer to be written to for upgrade request');
+                }
+            });
+            const { finished, matchedOutput, parsedUrl, statusCode } = await resolveRoutes({
+                req,
+                res,
+                isUpgradeReq: true,
+                signal: (0, _nextrequest.signalFromNodeResponse)(socket)
+            });
+            // TODO: allow upgrade requests to pages/app paths?
+            // this was not previously supported
+            if (matchedOutput) {
+                return socket.end();
+            }
+            if (finished && parsedUrl.protocol) {
+                if (!statusCode) {
+                    return await (0, _proxyrequest.proxyRequest)(req, socket, parsedUrl, head);
+                }
+                return socket.end();
+            }
+        // If there's no matched output, we don't handle the request as user's
+        // custom WS server may be listening on the same path.
+        } catch (err) {
+            console.error('Error handling upgrade request', err);
+            socket.end();
+        }
+    };
+    return {
+        requestHandler,
+        upgradeHandler,
+        server: handlers.server,
+        closeUpgraded () {
+            var _development_bundler_hotReloader, _development_bundler;
+            development == null ? void 0 : (_development_bundler = development.bundler) == null ? void 0 : (_development_bundler_hotReloader = _development_bundler.hotReloader) == null ? void 0 : _development_bundler_hotReloader.close();
+        },
+        distDir: config.distDir,
+        experimentalFeatures,
+        cacheComponents: config.cacheComponents,
+        partialPrefetching: config.partialPrefetching,
+        agentRules: config.agentRules,
+        agentFeedback: config.experimental.agentFeedback,
+        devMemoryThresholdRestart
+    };
+}
+
+//# sourceMappingURL=router-server.js.map