@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/server/lib/patch-fetch.js

@@ -33,6 +33,8 @@ _export(exports, {
     }
 });
 const _constants = require("./trace/constants");
+const _requestinsights = require("./trace/request-insights");
+const _requestinsightsidentity = require("./trace/request-insights-identity");
 const _tracer = require("./trace/tracer");
 const _constants1 = require("../../lib/constants");
 const _dynamicrendering = require("../app-render/dynamic-rendering");
@@ -42,6 +44,7 @@ const _workunitasyncstorageexternal = require("../app-render/work-unit-async-sto
 const _responsecache = require("../response-cache");
 const _cloneresponse = require("./clone-response");
 const _stagedrendering = require("../app-render/staged-rendering");
+const _encodeheadersafe = require("./encode-header-safe");
 const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
 function isFetchPatched() {
@@ -50,7 +53,9 @@ function isFetchPatched() {
 function validateRevalidate(revalidateVal, route) {
     try {
         let normalizedRevalidate = undefined;
-        if (revalidateVal === false) {
+        if (revalidateVal === false || revalidateVal === Infinity) {
+            // Unlike Infinity, INFINITE_CACHE survives JSON serialization (e.g. in
+            // the fetch cache).
             normalizedRevalidate = _constants1.INFINITE_CACHE;
         } else if (typeof revalidateVal === 'number' && !isNaN(revalidateVal) && revalidateVal > -1) {
             normalizedRevalidate = revalidateVal;
@@ -86,7 +91,10 @@ function validateTags(tags, description) {
                 reason: `exceeded max length of ${_constants1.NEXT_CACHE_TAG_MAX_LENGTH}`
             });
         } else {
-            validTags.push(tag);
+            // Encode so a non-ASCII tag can be safely serialized into the
+            // `x-next-cache-tags` HTTP header without tripping Node's header
+            // validation. Length is checked on the raw input above.
+            validTags.push((0, _encodeheadersafe.encodeHeaderSafe)(tag));
         }
         if (validTags.length > _constants1.NEXT_CACHE_TAG_MAX_ITEMS) {
             console.warn(`Warning: exceeded max tag count for ${description}, dropped tags:`, tags.slice(i).join(', '));
@@ -101,16 +109,44 @@ function validateTags(tags, description) {
     }
     return validTags;
 }
-function trackFetchMetric(workStore, ctx) {
-    if (!workStore.shouldTrackFetchMetrics) {
-        return;
-    }
-    workStore.fetchMetrics ??= [];
-    workStore.fetchMetrics.push({
+function trackFetchMetric(workStore, span, ctx) {
+    const metric = {
         ...ctx,
         end: performance.timeOrigin + performance.now(),
         idx: workStore.nextFetchId || 0
+    };
+    span == null ? void 0 : span.setAttributes({
+        'http.status_code': metric.status,
+        'next.fetch.idx': metric.idx,
+        'next.fetch.cache_status': metric.cacheStatus,
+        'next.fetch.cache_reason': metric.cacheReason
     });
+    if ((0, _requestinsights.isRequestInsightsEnabled)()) {
+        const requestInsightsIdentity = (0, _requestinsightsidentity.getRequestInsightsIdentity)();
+        const requestInsightsRequestId = (requestInsightsIdentity == null ? void 0 : requestInsightsIdentity.requestId) ?? workStore.requestId;
+        if (requestInsightsRequestId) {
+            (0, _requestinsights.recordRequestInsightFetch)({
+                requestId: requestInsightsRequestId,
+                kind: requestInsightsIdentity == null ? void 0 : requestInsightsIdentity.kind,
+                htmlRequestId: (requestInsightsIdentity == null ? void 0 : requestInsightsIdentity.htmlRequestId) ?? workStore.htmlRequestId,
+                route: workStore.route
+            }, {
+                url: metric.url,
+                method: metric.method,
+                statusCode: metric.status,
+                startTime: metric.start,
+                durationMs: metric.end - metric.start,
+                cacheStatus: metric.cacheStatus,
+                cacheReason: metric.cacheReason,
+                index: metric.idx
+            });
+        }
+    }
+    if (!workStore.shouldTrackFetchMetrics) {
+        return;
+    }
+    workStore.fetchMetrics ??= [];
+    workStore.fetchMetrics.push(metric);
 }
 async function createCachedPrerenderResponse(res, cacheKey, incrementalCacheContext, incrementalCache, revalidate, handleUnlock) {
     // We are prerendering at build time or revalidate time with cacheComponents so we
@@ -232,7 +268,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 'net.peer.name': url == null ? void 0 : url.hostname,
                 'net.peer.port': (url == null ? void 0 : url.port) || undefined
             }
-        }, async ()=>{
+        }, async (span)=>{
             var _getRequestMeta;
             // If this is an internal fetch, we should not do any special treatment.
             if (isInternal) {
@@ -250,6 +286,19 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 return originFetch(input, init);
             }
             const isRequestInput = input && typeof input === 'object' && typeof input.method === 'string';
+            // With `fetch(new Request(url), init)`, native fetch lets `init`
+            // override the base Request. Merge them into a single effective Request
+            // so cacheability, the cache key, and the upstream request all describe
+            // the same thing.
+            if (isRequestInput && init) {
+                // `next` (revalidate/tags) is Next-specific and dropped by
+                // `new Request`, so keep it on `init` and move the rest onto input.
+                const { next, ...overrides } = init;
+                input = new Request(input, overrides);
+                init = next ? {
+                    next
+                } : undefined;
+            }
             const getRequestMeta = (field)=>{
                 // If request input is present but init is not, retrieve from input first.
                 const value = init == null ? void 0 : init[field];
@@ -406,7 +455,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                             cacheSignal.endRead();
                             cacheSignal = null;
                         }
-                        return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
+                        return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
                     case 'validation-client':
                         break;
                     case 'request':
@@ -520,7 +569,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                     cacheSignal.endRead();
                                     cacheSignal = null;
                                 }
-                                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
+                                return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
                             case 'request':
                                 if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering) {
                                     if (cacheSignal) {
@@ -579,8 +628,8 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
             if (incrementalCache && (isCacheableRevalidate || serverComponentsHmrCache)) {
                 try {
                     cacheKey = await incrementalCache.generateCacheKey(fetchUrl, isRequestInput ? input : init);
-                } catch (err) {
-                    console.error(`Failed to generate cache key for`, input);
+                } catch (cause) {
+                    console.error(`Failed to generate cache key for`, input, cause);
                 }
             }
             const fetchIdx = workStore.nextFetchId ?? 1;
@@ -634,7 +683,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 };
                 return originFetch(input, clonedInit).then(async (res)=>{
                     if (!isStale && fetchStart) {
-                        trackFetchMetric(workStore, {
+                        trackFetchMetric(workStore, span, {
                             start: fetchStart,
                             url: fetchUrl,
                             cacheReason: cacheReasonOverride || cacheReason,
@@ -776,7 +825,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 }
                 if (cachedFetchData) {
                     if (fetchStart) {
-                        trackFetchMetric(workStore, {
+                        trackFetchMetric(workStore, span, {
                             start: fetchStart,
                             url: fetchUrl,
                             cacheReason,
@@ -813,7 +862,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                     cacheSignal.endRead();
                                     cacheSignal = null;
                                 }
-                                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
+                                return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
                             case 'request':
                                 if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering) {
                                     if (cacheSignal) {
@@ -847,7 +896,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                                 case 'prerender-client':
                                 case 'prerender-runtime':
                                 case 'validation-client':
-                                    return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
+                                    return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(workUnitStore.renderSignal, workStore.route, 'fetch()');
                                 case 'request':
                                     if (process.env.NODE_ENV === 'development' && workUnitStore.stagedRendering) {
                                         await workUnitStore.stagedRendering.waitForStage(_stagedrendering.RenderStage.Dynamic);

package/dist/node_modules/next/dist/server/lib/release-compression-stream.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "releaseCompressionStream", {
+    enumerable: true,
+    get: function() {
+        return releaseCompressionStream;
+    }
+});
+const _nodestream = require("node:stream");
+const noop = ()=>{};
+function releaseCompressionStream(res) {
+    const maybeStream = res.on('drain', noop);
+    // The `Duplex` check keeps a future middleware change from turning this into a
+    // `destroy()` on a non-stream, which would throw from a `close` handler.
+    if (maybeStream === res || !(maybeStream instanceof _nodestream.Duplex)) {
+        res.off('drain', noop);
+        return;
+    }
+    maybeStream.destroy();
+}
+
+//# sourceMappingURL=release-compression-stream.js.map

package/dist/node_modules/next/dist/server/lib/render-server.js

@@ -140,7 +140,9 @@ async function initializeImpl(opts) {
         },
         distDir: opts.distDir,
         experimentalFeatures: opts.experimentalFeatures,
-        cacheComponents: opts.cacheComponents
+        cacheComponents: opts.cacheComponents,
+        partialPrefetching: opts.partialPrefetching,
+        devMemoryThresholdRestart: opts.devMemoryThresholdRestart
     };
 }
 async function initialize(opts) {

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

@@ -14,9 +14,11 @@ 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 _findpagesdir = require("../../lib/find-pages-dir");
 const _filesystem = require("./router-utils/filesystem");
@@ -27,8 +29,10 @@ 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 _ispostpone = require("./router-utils/is-postpone");
+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");
@@ -49,6 +53,7 @@ const _nofallbackerrorexternal = require("../../shared/lib/no-fallback-error.ext
 const _routerservercontext = require("./router-utils/router-server-context");
 const _chromedevtoolsworkspace = require("./chrome-devtools-workspace");
 const _configshared = require("../config-shared");
+const _requestinsights = require("./trace/request-insights");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -104,6 +109,8 @@ async function initialize(opts) {
         // @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,
@@ -111,6 +118,9 @@ async function initialize(opts) {
             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)();
@@ -172,13 +182,14 @@ async function initialize(opts) {
         // 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);
@@ -186,6 +197,29 @@ async function initialize(opts) {
         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);
@@ -223,6 +257,12 @@ async function initialize(opts) {
         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?
@@ -392,7 +432,10 @@ async function initialize(opts) {
                     return;
                 }
                 if (!res.getHeader('cache-control') && matchedOutput.type === 'nextStaticFolder') {
-                    if (opts.dev && !isNextFont(parsedUrl.pathname)) {
+                    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)) {
                         res.setHeader('Cache-Control', 'no-cache, must-revalidate');
                     } else {
                         res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
@@ -493,6 +536,14 @@ async function initialize(opts) {
                 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;
@@ -563,7 +614,9 @@ async function initialize(opts) {
         onDevServerCleanup: opts.onDevServerCleanup,
         distDir: config.distDir,
         experimentalFeatures,
-        cacheComponents: config.cacheComponents
+        cacheComponents: config.cacheComponents,
+        partialPrefetching: config.partialPrefetching,
+        devMemoryThresholdRestart
     };
     renderServerOpts.serverFields.routerServerHandler = requestHandlerImpl;
     // pre-initialize workers
@@ -586,20 +639,21 @@ async function initialize(opts) {
         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 (type, err)=>{
+    const logError = async (err)=>{
         if ((0, _ispostpone.isPostpone)(err)) {
             // React postpones that are unhandled might end up logged here but they're
             // not really errors. They're just part of rendering.
             return;
         }
-        if (type === 'unhandledRejection') {
-            _log.error('unhandledRejection: ', err);
-        } else if (type === 'uncaughtException') {
-            _log.error('uncaughtException: ', err);
-        }
+        _log.error('uncaughtException: ', err);
     };
-    process.on('uncaughtException', logError.bind(null, 'uncaughtException'));
-    process.on('unhandledRejection', logError.bind(null, 'unhandledRejection'));
+    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, 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 {
@@ -627,7 +681,7 @@ async function initialize(opts) {
                         hmrPrefix = new URL(hmrPrefix).pathname.replace(/\/$/, '');
                     }
                 }
-                const isHMRRequest = req.url.startsWith((0, _ensureleadingslash.ensureLeadingSlash)(`${hmrPrefix}/_next/webpack-hmr`));
+                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) {
@@ -692,7 +746,10 @@ async function initialize(opts) {
         },
         distDir: config.distDir,
         experimentalFeatures,
-        cacheComponents: config.cacheComponents
+        cacheComponents: config.cacheComponents,
+        partialPrefetching: config.partialPrefetching,
+        agentRules: config.agentRules,
+        devMemoryThresholdRestart
     };
 }
 

package/dist/node_modules/next/dist/server/lib/router-utils/block-cross-site-dev.js

@@ -68,7 +68,7 @@ function isInternalEndpoint(req) {
         const isInternalAsset = req.url.includes('/_next');
         // Static media requests are excluded, as they might be loaded via CSS and would fail
         // CORS checks.
-        const isIgnoredRequest = req.url.includes('/_next/image') || req.url.includes('/_next/static/media');
+        const isIgnoredRequest = req.url.includes('/_next/image') || req.url.includes('/_next/static/media') || req.url.includes('/_next/static/immutable/media');
         return !isIgnoredRequest && (isInternalAsset || isMiddlewareRequest);
     } catch (err) {
         return false;
@@ -76,7 +76,7 @@ function isInternalEndpoint(req) {
 }
 const blockCrossSiteDEV = (req, res, allowedDevOrigins, hostname)=>{
     const allowedOrigins = [
-        '*.localhost',
+        '**.localhost',
         'localhost',
         ...allowedDevOrigins ?? []
     ];

package/dist/node_modules/next/dist/server/lib/router-utils/cache-life-type-utils.js

@@ -183,6 +183,7 @@ declare module 'next/cache' {
     refresh,
   } from 'next/dist/server/web/spec-extension/revalidate'
   export { unstable_noStore } from 'next/dist/server/web/spec-extension/unstable-no-store'
+  export { io } from 'next/dist/server/request/io'
 
   ${overloads}
 

package/dist/node_modules/next/dist/server/lib/router-utils/filesystem.js

@@ -117,13 +117,32 @@ const buildCustomRoute = (type, item, basePath, caseSensitive)=>{
         match
     };
 };
+// Measured retained cost of a cache entry beyond its strings (LRUNode,
+// Map slot, string header): ~120 bytes. Counting it keeps the entry count
+// bounded even when keys are short, so the budget approximates retained
+// bytes.
+const FS_LRU_ENTRY_OVERHEAD = 128;
+const FS_LRU_MAX_SIZE = 8 * 1024 * 1024;
+// The pathname passed to getItem is usually a V8 slice of the full request
+// URL, and a sliced string retains its parent — including the query string —
+// for as long as the cache holds the key. Store a flat copy instead.
+// The JSON round-trip returns an equal string for every input (unlike a
+// Buffer round-trip, which replaces lone surrogates), so distinct keys can
+// never collide on the stored copy.
+function flatKeyCopy(key) {
+    return JSON.parse(JSON.stringify(key));
+}
+// Cached result for paths that resolve to nothing. Not null, so that a
+// cached miss can't be conflated with an uncached key (undefined).
+const notFound = Symbol('not-found');
 async function setupFsCheck(opts) {
-    const getItemsLru = !opts.dev ? new _lrucache.LRUCache(1024 * 1024, function length(value) {
-        if (!value) {
-            // Null entries (negative cache) still need a non-zero size for LRU eviction
-            return 1;
+    const getItemsLru = !opts.dev ? new _lrucache.LRUCache(FS_LRU_MAX_SIZE, function length(value, key) {
+        const size = FS_LRU_ENTRY_OVERHEAD + key.length;
+        if (value === notFound) {
+            // Negative cache entries only retain their key.
+            return size;
         }
-        return (value.fsPath || '').length + value.itemPath.length + value.type.length;
+        return size + (value.fsPath || '').length + value.itemPath.length + value.type.length;
     }) : undefined;
     // routes that have _next/data endpoints (SSG/SSP)
     const nextDataRoutes = new Set();
@@ -347,8 +366,8 @@ async function setupFsCheck(opts) {
             const originalItemPath = itemPath;
             const itemKey = originalItemPath;
             const lruResult = getItemsLru == null ? void 0 : getItemsLru.get(itemKey);
-            if (lruResult) {
-                return lruResult;
+            if (lruResult !== undefined) {
+                return lruResult === notFound ? null : lruResult;
             }
             const { basePath } = opts.config;
             const hasBasePath = (0, _pathhasprefix.pathHasPrefix)(itemPath, basePath);
@@ -569,13 +588,15 @@ async function setupFsCheck(opts) {
                         fsPath,
                         locale,
                         itemsRoot,
-                        itemPath: curItemPath
+                        // itemPath is usually a slice of the request URL too; keep a
+                        // flat copy so the cached value doesn't retain the full URL.
+                        itemPath: flatKeyCopy(curItemPath)
                     };
-                    getItemsLru == null ? void 0 : getItemsLru.set(itemKey, itemResult);
+                    getItemsLru == null ? void 0 : getItemsLru.set(flatKeyCopy(itemKey), itemResult);
                     return itemResult;
                 }
             }
-            getItemsLru == null ? void 0 : getItemsLru.set(itemKey, null);
+            getItemsLru == null ? void 0 : getItemsLru.set(flatKeyCopy(itemKey), notFound);
             return null;
         },
         getDynamicRoutes () {

package/dist/node_modules/next/dist/server/lib/router-utils/instrumentation-node-extensions.js

@@ -24,6 +24,9 @@ function afterRegistration() {
     }
     extendTracerProviderForCacheComponents();
 }
+function isProxyTracerProvider(provider) {
+    return 'getDelegateTracer' in provider && typeof provider.getDelegateTracer === 'function';
+}
 // In theory we only want to enable this extension when cacheComponents is enabled
 // however there are certain servers that might load instrumentation before nextConfig is available
 // and so gating it on the config might lead to skipping this extension even when it is necessary.
@@ -48,45 +51,60 @@ function extendTracerProviderForCacheComponents() {
     // to exit the workUnitAsyncStorage context when generating spans.
     const originalGetTracer = provider.getTracer.bind(provider);
     provider.getTracer = (...args)=>{
-        const tracer = originalGetTracer.apply(provider, args);
-        if (WeakTracers.has(tracer)) {
-            return tracer;
-        }
-        const originalStartSpan = tracer.startSpan;
-        tracer.startSpan = (...startSpanArgs)=>{
-            return _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>originalStartSpan.apply(tracer, startSpanArgs));
-        };
-        const originalStartActiveSpan = tracer.startActiveSpan;
-        // @ts-ignore TS doesn't recognize the overloads correctly
-        tracer.startActiveSpan = (...startActiveSpanArgs)=>{
-            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            if (!workUnitStore) {
-                // @ts-ignore TS doesn't recognize the overloads correctly
-                return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
-            }
-            let fnIdx = 0;
-            if (startActiveSpanArgs.length === 2 && typeof startActiveSpanArgs[1] === 'function') {
-                fnIdx = 1;
-            } else if (startActiveSpanArgs.length === 3 && typeof startActiveSpanArgs[2] === 'function') {
-                fnIdx = 2;
-            } else if (startActiveSpanArgs.length > 3 && typeof startActiveSpanArgs[3] === 'function') {
-                fnIdx = 3;
-            }
-            if (fnIdx) {
-                const originalFn = startActiveSpanArgs[fnIdx];
-                if ((0, _clientandserverreferences.isUseCacheFunction)(originalFn)) {
-                    console.error('A Cache Function (`use cache`) was passed to startActiveSpan which means it will receive a Span argument with a possibly random ID on every invocation leading to cache misses. Provide a wrapping function around the Cache Function that does not forward the Span argument to avoid this issue.');
-                }
-                startActiveSpanArgs[fnIdx] = withWorkUnitContext(workUnitStore, originalFn);
-            }
-            return _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>{
-                // @ts-ignore TS doesn't recognize the overloads correctly
-                return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
-            });
+        return instrumentTracerForCacheComponents(originalGetTracer.apply(provider, args));
+    };
+    // Tracers acquired before registration can use getDelegateTracer() from the
+    // proxy provider to get a tracer from the registered provider, bypassing the
+    // getTracer() patch above. This can be problematic when third-party
+    // instrumentation creates spans that call dynamic APIs like Math.random(),
+    // causing a prerendering error. Therefore, patch getDelegateTracer() to apply
+    // the same tracer instrumentation as getTracer().
+    if (isProxyTracerProvider(provider)) {
+        const originalGetDelegateTracer = provider.getDelegateTracer.bind(provider);
+        provider.getDelegateTracer = (...args)=>{
+            const tracer = originalGetDelegateTracer(...args);
+            return tracer === undefined ? undefined : instrumentTracerForCacheComponents(tracer);
         };
-        WeakTracers.add(tracer);
+    }
+}
+function instrumentTracerForCacheComponents(tracer) {
+    if (WeakTracers.has(tracer)) {
         return tracer;
+    }
+    const originalStartSpan = tracer.startSpan;
+    tracer.startSpan = (...startSpanArgs)=>{
+        return _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>originalStartSpan.apply(tracer, startSpanArgs));
+    };
+    const originalStartActiveSpan = tracer.startActiveSpan;
+    // @ts-ignore TS doesn't recognize the overloads correctly
+    tracer.startActiveSpan = (...startActiveSpanArgs)=>{
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        if (!workUnitStore) {
+            // @ts-ignore TS doesn't recognize the overloads correctly
+            return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
+        }
+        let fnIdx = 0;
+        if (startActiveSpanArgs.length === 2 && typeof startActiveSpanArgs[1] === 'function') {
+            fnIdx = 1;
+        } else if (startActiveSpanArgs.length === 3 && typeof startActiveSpanArgs[2] === 'function') {
+            fnIdx = 2;
+        } else if (startActiveSpanArgs.length > 3 && typeof startActiveSpanArgs[3] === 'function') {
+            fnIdx = 3;
+        }
+        if (fnIdx) {
+            const originalFn = startActiveSpanArgs[fnIdx];
+            if ((0, _clientandserverreferences.isUseCacheFunction)(originalFn)) {
+                console.error('A Cache Function (`use cache`) was passed to startActiveSpan which means it will receive a Span argument with a possibly random ID on every invocation leading to cache misses. Provide a wrapping function around the Cache Function that does not forward the Span argument to avoid this issue.');
+            }
+            startActiveSpanArgs[fnIdx] = withWorkUnitContext(workUnitStore, originalFn);
+        }
+        return _workunitasyncstorageexternal.workUnitAsyncStorage.exit(()=>{
+            // @ts-ignore TS doesn't recognize the overloads correctly
+            return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
+        });
     };
+    WeakTracers.add(tracer);
+    return tracer;
 }
 const WeakTracers = new WeakSet();
 function withWorkUnitContext(workUnitStore, fn) {