@reckona/mreact-router 0.0.16 → 0.0.18

package/dist/render.js

@@ -1,23 +1,27 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { access, readFile } from "node:fs/promises";
+import { access, readFile, stat } from "node:fs/promises";
 import { dirname, join, relative, sep } from "node:path";
 import { transform, } from "@reckona/mreact-compiler";
 import { createQueryClient, dehydrate, __MREACT_QUERY_STATE_SCRIPT_ID, runWithQueryClient, } from "@reckona/mreact-query";
 import { build as bundle } from "esbuild";
 import { createStringSink, renderAsyncBoundary, renderOutOfOrderReorderScript, renderToReadableStream, } from "@reckona/mreact-server";
-import { hydrationMarkerParts, inferClientRouteModule, withHydrationMarkers, withRouteMarkers, } from "./client.js";
+import { hydrationMarkerParts, inferClientRouteModule, routeIdForPath, withHydrationMarkers, withRouteMarkers, } from "./client.js";
 import { assetPath } from "./assets.js";
 import { escapeHtmlAttribute, escapeHtmlText as escapeHtml, } from "@reckona/mreact-shared/html-escape";
 import { matchRoute, scanAppRoutes } from "./routes.js";
 import { dispatchServerActionRequest, prepareRouteServerActions, serverActionCookie, } from "./actions.js";
 import { beginRouteCacheContext, cachedRouteResponse, cacheRouteResponse, routeCacheKey, routeCachePolicyFromSource, } from "./cache.js";
+import { resolveRouterCacheLimit } from "./cache-config.js";
 import { importAppRouterFileModule, importAppRouterSourceModule } from "./module-runner.js";
 import { contentSecurityPolicy } from "./csp.js";
 import { htmlResponse } from "./http.js";
 import { isNotFoundError, isRedirectError, rewriteLocation } from "./navigation.js";
 import { createAppRouterImportPolicyPlugin } from "./import-policy.js";
 import { hasLoaderExport, isStreamRouteSource, stripRouteModuleExports } from "./route-source.js";
+import { emitRouterLog, logDurationMs, logNow } from "./logger.js";
+import { createRouterRuntimeCacheCounters, readRouterRuntimeCacheEntry, routerRuntimeCacheStat, } from "./cache-stats.js";
+import { invokeRouterInstrumentation, traceContextFromRequest, } from "./trace.js";
 const nativeEscapeTransform = {
     batchImportName: "escapeHtmlBatch",
     batchImportSource: "@reckona/mreact-router/native-escape",
@@ -52,6 +56,18 @@ export async function preloadBuiltRequestModules(options) {
             });
             continue;
         }
+        const analysis = await analyzeRouteSource({
+            code,
+            filename: route.file,
+            routePath: route.path,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+        });
+        await preloadBuiltPageRouteModules({
+            ...options,
+            analysis,
+            code,
+            file: route.file,
+        });
         if (hasLoaderExport(code)) {
             await loadRouteLoaderModule({
                 appDir: options.appDir,
@@ -64,22 +80,103 @@ export async function preloadBuiltRequestModules(options) {
         }
     }
 }
+async function preloadBuiltPageRouteModules(options) {
+    const routeCode = options.analysis.routeCode;
+    const stringOutput = transformServerModule({
+        code: routeCode,
+        clientBoundaryImports: options.analysis.clientInference.clientBoundaryImports,
+        filename: options.file,
+        serverModules: options.serverModules,
+        serverOutput: "string",
+    });
+    assertNoFatalServerDiagnostics(stringOutput.diagnostics);
+    await loadServerModule(stringOutput.code, options.file, options.serverModules, options.serverModuleCacheVersion);
+    if (options.analysis.streamRoute) {
+        const streamOutput = transformServerModule({
+            code: routeCode,
+            clientBoundaryImports: options.analysis.clientInference.clientBoundaryImports,
+            filename: options.file,
+            serverModules: options.serverModules,
+            serverOutput: "stream",
+            serverAwaitHydration: options.analysis.clientInference.client,
+        });
+        assertNoFatalServerDiagnostics(streamOutput.diagnostics);
+        await loadServerStreamModule(streamOutput.code, options.file, options.serverModules, options.serverModuleCacheVersion);
+    }
+    await preloadShellModulesForPage({
+        appDir: options.appDir,
+        pageFile: options.file,
+        serverModules: options.serverModules,
+        serverModuleCacheVersion: options.serverModuleCacheVersion,
+        serverSourceFiles: options.serverSourceFiles,
+    });
+    await loadComposedRouteMetadata({
+        appDir: options.appDir,
+        code: options.code,
+        filename: options.file,
+        importPolicy: options.importPolicy,
+        serverModules: options.serverModules,
+        serverModuleCacheVersion: options.serverModuleCacheVersion,
+        serverSourceFiles: options.serverSourceFiles,
+    });
+}
+async function preloadShellModulesForPage(options) {
+    const shellFiles = await shellFilesForPage(options.appDir, options.pageFile, options.serverModuleCacheVersion);
+    for (const shell of shellFiles) {
+        const code = await readServerSourceFile(shell.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+        const output = transformServerModule({
+            code,
+            filename: shell.file,
+            serverModules: options.serverModules,
+            serverOutput: "string",
+        });
+        assertNoFatalServerDiagnostics(output.diagnostics);
+        await loadServerModule(output.code, shell.file, options.serverModules, options.serverModuleCacheVersion);
+    }
+}
+function assertNoFatalServerDiagnostics(diagnostics) {
+    const fatalDiagnostics = diagnostics.filter((diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER");
+    if (fatalDiagnostics.length > 0) {
+        throw new Error(fatalDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+    }
+}
 const serverTransformCache = new Map();
+const serverTransformCacheCounters = createRouterRuntimeCacheCounters();
 const serverSourceFileCache = new Map();
+const serverSourceFileCacheCounters = createRouterRuntimeCacheCounters();
 const routeSourceAnalysisCache = new Map();
+const routeSourceAnalysisCacheCounters = createRouterRuntimeCacheCounters();
 const routeOutOfOrderBoundaryAnalysisCache = new Map();
+const routeOutOfOrderBoundaryAnalysisCacheCounters = createRouterRuntimeCacheCounters();
 const routeLoaderModuleCache = new Map();
+const routeLoaderModuleCacheCounters = createRouterRuntimeCacheCounters();
 const middlewareModuleCache = new Map();
+const middlewareModuleCacheCounters = createRouterRuntimeCacheCounters();
 const serverRouteModuleCache = new Map();
+const serverRouteModuleCacheCounters = createRouterRuntimeCacheCounters();
 const composedRouteMetadataCache = new Map();
-const maxServerTransformCacheEntries = 512;
-const maxServerSourceFileCacheEntries = 512;
-const maxRouteSourceAnalysisCacheEntries = 512;
-const maxRouteOutOfOrderBoundaryAnalysisCacheEntries = 512;
-const maxRouteLoaderModuleCacheEntries = 512;
-const maxMiddlewareModuleCacheEntries = 64;
-const maxServerRouteModuleCacheEntries = 512;
-const maxComposedRouteMetadataCacheEntries = 512;
+const composedRouteMetadataCacheCounters = createRouterRuntimeCacheCounters();
+const maxServerTransformCacheEntries = resolveRouterCacheLimit("SERVER_TRANSFORM", 512);
+const maxServerSourceFileCacheEntries = resolveRouterCacheLimit("SERVER_SOURCE_FILE", 512);
+const maxRouteSourceAnalysisCacheEntries = resolveRouterCacheLimit("ROUTE_SOURCE_ANALYSIS", 512);
+const maxRouteOutOfOrderBoundaryAnalysisCacheEntries = resolveRouterCacheLimit("ROUTE_OUT_OF_ORDER_BOUNDARY_ANALYSIS", 512);
+const maxRouteLoaderModuleCacheEntries = resolveRouterCacheLimit("ROUTE_LOADER_MODULE", 512);
+const maxMiddlewareModuleCacheEntries = resolveRouterCacheLimit("MIDDLEWARE_MODULE", 64);
+const maxServerRouteModuleCacheEntries = resolveRouterCacheLimit("SERVER_ROUTE_MODULE", 512);
+const maxComposedRouteMetadataCacheEntries = resolveRouterCacheLimit("COMPOSED_ROUTE_METADATA", 512);
+export function routerRenderRuntimeCacheStats() {
+    return [
+        routerRuntimeCacheStat("server-transform", serverTransformCache, maxServerTransformCacheEntries, serverTransformCacheCounters),
+        routerRuntimeCacheStat("server-source-file", serverSourceFileCache, maxServerSourceFileCacheEntries, serverSourceFileCacheCounters),
+        routerRuntimeCacheStat("route-source-analysis", routeSourceAnalysisCache, maxRouteSourceAnalysisCacheEntries, routeSourceAnalysisCacheCounters),
+        routerRuntimeCacheStat("route-out-of-order-boundary-analysis", routeOutOfOrderBoundaryAnalysisCache, maxRouteOutOfOrderBoundaryAnalysisCacheEntries, routeOutOfOrderBoundaryAnalysisCacheCounters),
+        routerRuntimeCacheStat("route-loader-module", routeLoaderModuleCache, maxRouteLoaderModuleCacheEntries, routeLoaderModuleCacheCounters),
+        routerRuntimeCacheStat("middleware-module", middlewareModuleCache, maxMiddlewareModuleCacheEntries, middlewareModuleCacheCounters),
+        routerRuntimeCacheStat("server-route-module", serverRouteModuleCache, maxServerRouteModuleCacheEntries, serverRouteModuleCacheCounters),
+        routerRuntimeCacheStat("composed-route-metadata", composedRouteMetadataCache, maxComposedRouteMetadataCacheEntries, composedRouteMetadataCacheCounters),
+        routerRuntimeCacheStat("rendered-shell", renderedShellCache, MAX_RENDERED_SHELL_CACHE_ENTRIES, renderedShellCacheCounters),
+    ];
+}
 // Issue 086: per-shell prefix/suffix cache. Pure layouts (whose
 // exported component takes zero arguments and therefore cannot
 // depend on the request props) produce the same HTML for every
@@ -93,14 +190,52 @@ const maxComposedRouteMetadataCacheEntries = 512;
 // edits without server restart.
 const renderedShellCache = new Map();
 const MAX_RENDERED_SHELL_CACHE_ENTRIES = 1024;
+const renderedShellCacheCounters = createRouterRuntimeCacheCounters();
 export async function renderAppRequest(options) {
     const authStorage = authRequestStorage();
     if (authStorage.getStore() === undefined) {
         return authStorage.run({}, () => renderAppRequest(options));
     }
+    const trace = traceContextFromRequest(options.request);
+    const url = new URL(options.request.url);
+    const requestEvent = {
+        method: options.request.method,
+        path: url.pathname,
+        request: options.request,
+        ...(trace === undefined ? {} : { trace }),
+    };
+    invokeRouterInstrumentation(options.instrumentation?.onRequestStart, requestEvent);
     const response = await renderAppRequestInternal(options);
+    invokeRouterInstrumentation(options.instrumentation?.onRequestEnd, {
+        ...requestEvent,
+        status: response.status,
+    });
     return applyAppRouterResponseHook(response, options);
 }
+function createRenderTiming(logger) {
+    return logger?.debug === undefined ? undefined : { phases: {} };
+}
+function renderTimingPhaseStartedAt(timing) {
+    return timing === undefined ? undefined : logNow();
+}
+function finishRenderTimingPhase(timing, startedAt, phaseName) {
+    if (timing === undefined || startedAt === undefined) {
+        return;
+    }
+    timing.phases[phaseName] = logDurationMs(startedAt);
+}
+function emitRenderTiming(options, timing, status) {
+    if (timing === undefined) {
+        return;
+    }
+    emitRouterLog(options.logger, "debug", {
+        method: options.request.method,
+        path: new URL(options.request.url).pathname,
+        phases: timing.phases,
+        status,
+        type: "router:render:timing",
+    });
+}
 export async function resolveAppRouterMiddleware(options) {
     const middlewareResponse = await runMiddleware(options);
     if (middlewareResponse === undefined) {
@@ -116,18 +251,43 @@ export async function resolveAppRouterMiddleware(options) {
     return { response: middlewareResponse, type: "response" };
 }
 async function renderAppRequestInternal(options) {
+    const timing = createRenderTiming(options.logger);
+    let phaseStartedAt = renderTimingPhaseStartedAt(timing);
     const routes = options.routes ?? (await scanAppRoutes({ appDir: options.appDir }));
+    finishRenderTimingPhase(timing, phaseStartedAt, "routeScanMs");
     const url = new URL(options.request.url);
-    const middlewareResult = options.skipMiddleware === true
+    phaseStartedAt = renderTimingPhaseStartedAt(timing);
+    const matched = options.routeMatcher?.match(url.pathname) ?? matchRoute(routes, url.pathname);
+    finishRenderTimingPhase(timing, phaseStartedAt, "routeMatchMs");
+    const hasMiddleware = options.skipMiddleware === true
+        ? false
+        : await hasAppMiddleware({
+            appDir: options.appDir,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+            serverSourceFiles: options.serverSourceFiles,
+        });
+    const middlewareControl = hasMiddleware && matched?.route.kind === "page"
+        ? await loadRouteMiddlewareControl({
+            appDir: options.appDir,
+            pageFile: matched.route.file,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+            serverSourceFiles: options.serverSourceFiles,
+        })
+        : undefined;
+    phaseStartedAt = renderTimingPhaseStartedAt(timing);
+    const middlewareResult = options.skipMiddleware === true || !hasMiddleware
         ? { request: options.request, type: "continue" }
         : await resolveAppRouterMiddleware({
             appDir: options.appDir,
             importPolicy: options.importPolicy,
+            instrumentation: options.instrumentation,
+            middlewareControl,
             request: options.request,
             serverModules: options.serverModules,
             serverModuleCacheVersion: options.serverModuleCacheVersion,
             serverSourceFiles: options.serverSourceFiles,
         });
+    finishRenderTimingPhase(timing, phaseStartedAt, "middlewareMs");
     if (middlewareResult.type === "response") {
         return middlewareResult.response;
     }
@@ -150,7 +310,6 @@ async function renderAppRequestInternal(options) {
             serverActions: options.serverActions,
         });
     }
-    const matched = options.routeMatcher?.match(url.pathname) ?? matchRoute(routes, url.pathname);
     if (matched === undefined) {
         const notFoundFile = await nearestBoundaryFileForPath({
             appDir: options.appDir,
@@ -162,6 +321,7 @@ async function renderAppRequestInternal(options) {
             assetBaseUrl: options.assetBaseUrl,
             error: undefined,
             request: options.request,
+            routePath: url.pathname,
             routeFile: notFoundFile,
             routeScripts: options.clientScripts,
             serverModules: options.serverModules,
@@ -204,35 +364,44 @@ async function renderAppRequestInternal(options) {
         }
         routeCacheContext = beginRouteCacheContext(options.routeCache);
         const clientScript = options.clientScripts?.get(matched.route.path);
+        phaseStartedAt = renderTimingPhaseStartedAt(timing);
         const originalCode = await readServerSourceFile(matched.route.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+        finishRenderTimingPhase(timing, phaseStartedAt, "readSourceMs");
+        phaseStartedAt = renderTimingPhaseStartedAt(timing);
         const originalAnalysis = await analyzeRouteSource({
             code: originalCode,
             filename: matched.route.file,
             routePath: matched.route.path,
             serverModuleCacheVersion: options.serverModuleCacheVersion,
         });
+        finishRenderTimingPhase(timing, phaseStartedAt, "sourceAnalysisMs");
         const cachePolicy = originalAnalysis.cachePolicy;
         const navigationScript = options.navigationScripts?.get(matched.route.path);
         const cacheKey = routeCacheKey(options.appDir, matched.route.path, url);
         const mayUseRouteCache = cachePolicy === undefined
             ? originalAnalysis.usesRuntimeCacheControl
             : cachePolicy.revalidateSeconds !== 0;
+        phaseStartedAt = renderTimingPhaseStartedAt(timing);
         const cachedResponse = !mayUseRouteCache
             ? undefined
             : await cachedRouteResponse({
                 cache: options.routeCache,
                 key: cacheKey,
             });
+        finishRenderTimingPhase(timing, phaseStartedAt, "routeCacheMs");
         if (cachedResponse !== undefined) {
             return cachedResponse;
         }
+        phaseStartedAt = renderTimingPhaseStartedAt(timing);
         const preparedActions = await prepareRouteServerActions({
             appDir: options.appDir,
             code: originalCode,
             pageFile: matched.route.file,
             request: options.request,
         });
+        finishRenderTimingPhase(timing, phaseStartedAt, "serverActionsMs");
         const code = preparedActions.code;
+        phaseStartedAt = renderTimingPhaseStartedAt(timing);
         const routeAnalysis = code === originalCode
             ? originalAnalysis
             : await analyzeRouteSource({
@@ -241,25 +410,32 @@ async function renderAppRequestInternal(options) {
                 routePath: matched.route.path,
                 serverModuleCacheVersion: undefined,
             });
+        finishRenderTimingPhase(timing, phaseStartedAt, "routeCodeAnalysisMs");
         const routeCode = routeAnalysis.routeCode;
         const streamRoute = routeAnalysis.streamRoute;
         const clientInference = routeAnalysis.clientInference;
         const clientRoute = clientInference.client;
+        phaseStartedAt = renderTimingPhaseStartedAt(timing);
         const dataPromise = routeAnalysis.hasLoader
-            ? loadRouteData({
+            ? loadRouteDataWithInstrumentation({
+                appDir: options.appDir,
                 code,
                 context: {
                     params: matched.params,
                     queryClient,
                     request: options.request,
                 },
-                appDir: options.appDir,
                 filename: matched.route.file,
                 importPolicy: options.importPolicy,
+                instrumentation: options.instrumentation,
+                request: options.request,
+                routeId: routeIdForPath(matched.route.path),
+                routePath: matched.route.path,
                 serverModules: options.serverModules,
                 serverModuleCacheVersion: options.serverModuleCacheVersion,
             })
             : undefined;
+        finishRenderTimingPhase(timing, phaseStartedAt, "loaderStartMs");
         recoveryRoute = {
             clientRoute,
             props: {
@@ -270,22 +446,28 @@ async function renderAppRequestInternal(options) {
             script: clientScript,
         };
         if (streamRoute) {
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
             const loadingFile = await nearestExistingBoundaryFileForPage({
                 appDir: options.appDir,
                 filename: "loading.mreact.tsx",
                 pageFile: matched.route.file,
+                serverSourceFiles: options.serverSourceFiles,
             });
+            finishRenderTimingPhase(timing, phaseStartedAt, "loadingBoundaryLookupMs");
             const streamShellResponseHeaders = {
                 "content-type": "text/html; charset=utf-8",
                 "x-mreact-stream": "1",
             };
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
             const mayRenderOutOfOrder = await mayRenderOutOfOrderBoundaryDeep({
                 code: routeCode,
                 filename: matched.route.file,
                 serverModuleCacheVersion: options.serverModuleCacheVersion,
                 serverSourceFiles: options.serverSourceFiles,
             });
+            finishRenderTimingPhase(timing, phaseStartedAt, "outOfOrderAnalysisMs");
             if (loadingFile === undefined && !mayRenderOutOfOrder) {
+                phaseStartedAt = renderTimingPhaseStartedAt(timing);
                 const stringOutput = transformServerModule({
                     code: routeCode,
                     clientBoundaryImports: clientInference.clientBoundaryImports,
@@ -293,6 +475,7 @@ async function renderAppRequestInternal(options) {
                     serverModules: options.serverModules,
                     serverOutput: "string",
                 });
+                finishRenderTimingPhase(timing, phaseStartedAt, "stringTransformMs");
                 const stringFatalDiagnostics = stringOutput.diagnostics.filter((diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER");
                 if (stringFatalDiagnostics.length > 0) {
                     return new Response(stringFatalDiagnostics.map((diagnostic) => diagnostic.message).join("\n"), {
@@ -357,15 +540,20 @@ async function renderAppRequestInternal(options) {
                 html = injectHeadMetadata(html, metadata);
                 html = injectAuthSessionClaims(html, originalAnalysis.authIncludesClaims ? currentAuthClaims() : undefined);
                 html = injectQueryState(html, dehydrate(queryClient));
-                const headers = new Headers(responseHeadersForMetadata(metadata));
-                headers.set("x-mreact-stream", "1");
-                return withOptionalActionCookie(htmlResponse(`<!DOCTYPE html>${clientNavigationHeadTags({
+                const response = withOptionalActionCookie(htmlResponse(`<!DOCTYPE html>${clientNavigationHeadTags({
                     assetBaseUrl: options.assetBaseUrl,
                     currentScript: clientRoute ? clientScript : undefined,
                     currentNavigationScript: clientRoute ? undefined : navigationScript,
                     routeScripts: options.clientScripts,
-                })}${html}`, { headers }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+                })}${html}`, {
+                    headers: responseHeadersForMetadata(metadata, {
+                        "x-mreact-stream": "1",
+                    }),
+                }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+                emitRenderTiming(options, timing, response.status);
+                return response;
             }
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
             const output = transformServerModule({
                 code: routeCode,
                 clientBoundaryImports: clientInference.clientBoundaryImports,
@@ -374,6 +562,7 @@ async function renderAppRequestInternal(options) {
                 serverOutput: "stream",
                 serverAwaitHydration: clientRoute,
             });
+            finishRenderTimingPhase(timing, phaseStartedAt, "streamTransformMs");
             const fatalDiagnostics = output.diagnostics.filter((diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER");
             if (fatalDiagnostics.length > 0) {
                 return new Response(fatalDiagnostics.map((diagnostic) => diagnostic.message).join("\n"), {
@@ -382,6 +571,7 @@ async function renderAppRequestInternal(options) {
                 });
             }
             if (loadingFile !== undefined) {
+                phaseStartedAt = renderTimingPhaseStartedAt(timing);
                 const stream = await runServerStreamModuleWithLoading(output.code, {
                     appDir: options.appDir,
                     assetBaseUrl: options.assetBaseUrl,
@@ -400,9 +590,12 @@ async function renderAppRequestInternal(options) {
                     script: clientScript,
                     clientReferenceManifest: output.metadata.clientReferenceManifest,
                 });
-                return withOptionalActionCookie(new Response(stream, {
+                finishRenderTimingPhase(timing, phaseStartedAt, "streamConstructionMs");
+                const response = withOptionalActionCookie(new Response(stream, {
                     headers: streamShellResponseHeaders,
                 }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+                emitRenderTiming(options, timing, response.status);
+                return response;
             }
             const data = dataPromise === undefined ? undefined : await dataPromise;
             if (data instanceof Response) {
@@ -414,6 +607,7 @@ async function renderAppRequestInternal(options) {
                 queryClient,
                 request: options.request,
             };
+            phaseStartedAt = renderTimingPhaseStartedAt(timing);
             const stream = runServerStreamModule(output.code, {
                 appDir: options.appDir,
                 assetBaseUrl: options.assetBaseUrl,
@@ -428,9 +622,12 @@ async function renderAppRequestInternal(options) {
                 script: clientScript,
                 clientReferenceManifest: output.metadata.clientReferenceManifest,
             });
-            return withOptionalActionCookie(new Response(stream, {
+            finishRenderTimingPhase(timing, phaseStartedAt, "streamConstructionMs");
+            const response = withOptionalActionCookie(new Response(stream, {
                 headers: streamShellResponseHeaders,
             }), preparedActions.csrfToken, preparedActions.csrfTokenIsNew === true);
+            emitRenderTiming(options, timing, response.status);
+            return response;
         }
         const output = transformServerModule({
             code: routeCode,
@@ -545,6 +742,7 @@ async function renderAppRequestInternal(options) {
                 assetBaseUrl: options.assetBaseUrl,
                 error: undefined,
                 request: options.request,
+                routePath: matched.route.path,
                 routeFile: notFoundFile,
                 routeScripts: options.clientScripts,
                 serverModules: options.serverModules,
@@ -565,6 +763,7 @@ async function renderAppRequestInternal(options) {
             assetBaseUrl: options.assetBaseUrl,
             error,
             request: options.request,
+            routePath: matched.route.path,
             routeFile: errorFile,
             routeScripts: options.clientScripts,
             serverModules: options.serverModules,
@@ -641,6 +840,7 @@ async function nearestExistingBoundaryFileForPage(options) {
         appDir: options.appDir,
         filename: options.filename,
         parts,
+        serverSourceFiles: options.serverSourceFiles,
     });
 }
 async function nearestBoundaryFileForPath(options) {
@@ -673,6 +873,12 @@ async function nearestExistingBoundaryFileFromParts(options) {
     for (let count = options.parts.length; count >= 0; count -= 1) {
         for (const filename of boundaryFilenameCandidates(options.filename)) {
             const candidate = join(options.appDir, ...options.parts.slice(0, count), filename);
+            if (options.serverSourceFiles !== undefined) {
+                if (options.serverSourceFiles.has(candidate)) {
+                    return candidate;
+                }
+                continue;
+            }
             try {
                 await access(candidate);
                 return candidate;
@@ -700,10 +906,14 @@ async function renderSpecialRoute(options) {
     }
     const props = {
         data: undefined,
+        debug: errorDebugContext(options.error, options.routePath),
         error: normalizeErrorForProps(options.error),
         params: {},
         queryClient: createQueryClient(),
         request: options.request,
+        requestId: requestIdForErrorContext(options.request),
+        routeId: routeIdForPath(options.routePath ?? new URL(options.request.url).pathname),
+        traceId: traceContextFromRequest(options.request)?.traceId,
     };
     const pageHtml = await renderServerFileToHtml(options.routeFile, props, options.serverModules, options.serverModuleCacheVersion, options.serverSourceFiles);
     const pageHtmlForLayout = options.navigation?.clientRoute === true
@@ -754,6 +964,19 @@ function normalizeErrorForProps(error) {
     }
     return { message: String(error) };
 }
+function requestIdForErrorContext(request) {
+    return request.headers.get("x-request-id") ?? randomUUID();
+}
+function errorDebugContext(error, routePath) {
+    if (process.env.NODE_ENV === "production" || !(error instanceof Error)) {
+        return undefined;
+    }
+    return {
+        ...(error.cause === undefined ? {} : { cause: error.cause }),
+        ...(routePath === undefined ? {} : { route: { matched: routePath } }),
+        ...(error.stack === undefined ? {} : { stack: error.stack }),
+    };
+}
 async function dispatchServerRoute(options) {
     const module = await loadServerRouteModule(options);
     const handler = module[options.request.method] ?? module.ALL ?? module.default;
@@ -783,7 +1006,7 @@ async function loadServerRouteModule(options) {
     const codeHash = memoizedHashText(code);
     const moduleCode = artifactCode !== undefined && artifactCode.sourceHash === codeHash ? artifactCode.code : code;
     const cacheKey = `server-route\0${options.file}\0${options.serverModuleCacheVersion}\0${codeHash}\0${memoizedHashText(moduleCode)}`;
-    const cached = serverRouteModuleCache.get(cacheKey);
+    const cached = readRouterRuntimeCacheEntry(serverRouteModuleCache, cacheKey, serverRouteModuleCacheCounters);
     if (cached !== undefined) {
         return cached;
     }
@@ -797,7 +1020,7 @@ async function loadServerRouteModule(options) {
         serverRouteModuleCache.delete(cacheKey);
         throw error;
     });
-    setBoundedCacheEntry(serverRouteModuleCache, cacheKey, loaded, maxServerRouteModuleCacheEntries);
+    setBoundedCacheEntry(serverRouteModuleCache, cacheKey, loaded, maxServerRouteModuleCacheEntries, serverRouteModuleCacheCounters);
     return loaded;
 }
 async function runMiddleware(options) {
@@ -820,6 +1043,9 @@ async function runMiddleware(options) {
             serverModuleCacheVersion: options.serverModuleCacheVersion,
             serverSourceFiles: options.serverSourceFiles,
         });
+        if (shouldSkipMiddleware(module.config, options.middlewareControl)) {
+            return undefined;
+        }
         if (!middlewareMatches(module.config, new URL(options.request.url).pathname)) {
             return undefined;
         }
@@ -827,11 +1053,25 @@ async function runMiddleware(options) {
         if (typeof middleware !== "function") {
             return undefined;
         }
+        const trace = traceContextFromRequest(options.request);
+        const event = {
+            method: options.request.method,
+            name: "middleware",
+            path: new URL(options.request.url).pathname,
+            request: options.request,
+            ...(trace === undefined ? {} : { trace }),
+        };
+        invokeRouterInstrumentation(options.instrumentation?.onMiddlewareStart, event);
         try {
             const response = await middleware(options.request);
+            invokeRouterInstrumentation(options.instrumentation?.onMiddlewareEnd, event);
             return response instanceof Response ? response : undefined;
         }
         catch (error) {
+            invokeRouterInstrumentation(options.instrumentation?.onMiddlewareEnd, {
+                ...event,
+                error,
+            });
             if (isRedirectError(error)) {
                 return new Response(null, {
                     headers: { location: error.location },
@@ -846,13 +1086,22 @@ async function runMiddleware(options) {
     }
     return undefined;
 }
+function shouldSkipMiddleware(config, control) {
+    if (control?.skip === true) {
+        return true;
+    }
+    if (!Array.isArray(control?.skip)) {
+        return false;
+    }
+    return typeof config?.id === "string" && control.skip.includes(config.id);
+}
 async function loadMiddlewareModule(options) {
     const code = await readServerSourceFile(options.file, options.serverModuleCacheVersion, options.serverSourceFiles);
     const cacheKey = options.serverModuleCacheVersion === undefined
         ? undefined
         : `middleware\0${options.appDir}\0${options.file}\0${options.serverModuleCacheVersion}\0${memoizedHashText(code)}\0${importPolicyCacheKey(options.importPolicy)}`;
     if (cacheKey !== undefined) {
-        const cached = middlewareModuleCache.get(cacheKey);
+        const cached = readRouterRuntimeCacheEntry(middlewareModuleCache, cacheKey, middlewareModuleCacheCounters);
         if (cached !== undefined) {
             return cached;
         }
@@ -871,7 +1120,7 @@ async function loadMiddlewareModule(options) {
         throw error;
     });
     if (cacheKey !== undefined) {
-        setBoundedCacheEntry(middlewareModuleCache, cacheKey, loaded, maxMiddlewareModuleCacheEntries);
+        setBoundedCacheEntry(middlewareModuleCache, cacheKey, loaded, maxMiddlewareModuleCacheEntries, middlewareModuleCacheCounters);
     }
     return loaded;
 }
@@ -975,7 +1224,7 @@ function transformServerModule(options) {
     }
     const awaitHydrationKey = options.serverAwaitHydration === true ? "1" : "0";
     const key = `${options.filename}\0${options.serverOutput}\0${sourceHash}\0${awaitHydrationKey}`;
-    const cached = serverTransformCache.get(key);
+    const cached = readRouterRuntimeCacheEntry(serverTransformCache, key, serverTransformCacheCounters);
     if (cached !== undefined) {
         return cached;
     }
@@ -991,13 +1240,13 @@ function transformServerModule(options) {
         target: "server",
         ...(options.serverAwaitHydration === true ? { serverAwaitHydration: true } : {}),
     });
-    setBoundedCacheEntry(serverTransformCache, key, output, maxServerTransformCacheEntries);
+    setBoundedCacheEntry(serverTransformCache, key, output, maxServerTransformCacheEntries, serverTransformCacheCounters);
     return output;
 }
 async function analyzeRouteSource(options) {
     const sourceHash = memoizedHashText(options.code);
     const cacheKey = `${options.serverModuleCacheVersion ?? "dev"}\0${options.filename}\0${sourceHash}`;
-    const cached = routeSourceAnalysisCache.get(cacheKey);
+    const cached = readRouterRuntimeCacheEntry(routeSourceAnalysisCache, cacheKey, routeSourceAnalysisCacheCounters);
     if (cached !== undefined) {
         return cached;
     }
@@ -1005,7 +1254,7 @@ async function analyzeRouteSource(options) {
         routeSourceAnalysisCache.delete(cacheKey);
         throw error;
     });
-    setBoundedCacheEntry(routeSourceAnalysisCache, cacheKey, pending, maxRouteSourceAnalysisCacheEntries);
+    setBoundedCacheEntry(routeSourceAnalysisCache, cacheKey, pending, maxRouteSourceAnalysisCacheEntries, routeSourceAnalysisCacheCounters);
     return pending;
 }
 async function analyzeRouteSourceUncached(options) {
@@ -1162,7 +1411,7 @@ async function mayRenderOutOfOrderBoundaryDeepInner(options, seen) {
     seen.add(options.filename);
     const sourceHash = memoizedHashText(options.code);
     const cacheKey = `${options.serverModuleCacheVersion ?? "dev"}\0${options.filename}\0${sourceHash}`;
-    const cached = routeOutOfOrderBoundaryAnalysisCache.get(cacheKey);
+    const cached = readRouterRuntimeCacheEntry(routeOutOfOrderBoundaryAnalysisCache, cacheKey, routeOutOfOrderBoundaryAnalysisCacheCounters);
     if (cached !== undefined) {
         return cached;
     }
@@ -1170,7 +1419,7 @@ async function mayRenderOutOfOrderBoundaryDeepInner(options, seen) {
         routeOutOfOrderBoundaryAnalysisCache.delete(cacheKey);
         throw error;
     });
-    setBoundedCacheEntry(routeOutOfOrderBoundaryAnalysisCache, cacheKey, pending, maxRouteOutOfOrderBoundaryAnalysisCacheEntries);
+    setBoundedCacheEntry(routeOutOfOrderBoundaryAnalysisCache, cacheKey, pending, maxRouteOutOfOrderBoundaryAnalysisCacheEntries, routeOutOfOrderBoundaryAnalysisCacheCounters);
     return pending;
 }
 async function mayRenderImportedOutOfOrderBoundary(options, seen) {
@@ -1394,7 +1643,7 @@ async function renderShellPrefixSuffix(appDir, shell, props, slotContext, server
         ? undefined
         : `${appDir}\0${shell.file}\0${serverModuleCacheVersion}`;
     if (cacheKey !== undefined) {
-        const cached = renderedShellCache.get(cacheKey);
+        const cached = readRouterRuntimeCacheEntry(renderedShellCache, cacheKey, renderedShellCacheCounters);
         if (cached !== undefined && cached !== "impure") {
             return cached;
         }
@@ -1412,7 +1661,9 @@ async function renderShellPrefixSuffix(appDir, shell, props, slotContext, server
     }
     const component = await loadServerComponent(output.code, shell.file, serverModules, serverModuleCacheVersion);
     const rendered = splitLayoutSlot(markShellBoundary(await component(props), shell), slotContext);
-    const cached = cacheKey !== undefined ? renderedShellCache.get(cacheKey) : undefined;
+    const cached = cacheKey !== undefined
+        ? readRouterRuntimeCacheEntry(renderedShellCache, cacheKey, renderedShellCacheCounters)
+        : undefined;
     // Detect purity: a zero-arg component cannot depend on props. The
     // markShellBoundary + splitLayoutSlot output is then constant for
     // the (appDir, shellFile, version) tuple. We only set the cache
@@ -1424,6 +1675,7 @@ async function renderShellPrefixSuffix(appDir, shell, props, slotContext, server
                 const oldestKey = renderedShellCache.keys().next().value;
                 if (oldestKey !== undefined) {
                     renderedShellCache.delete(oldestKey);
+                    renderedShellCacheCounters.evictions += 1;
                 }
             }
             renderedShellCache.set(cacheKey, rendered);
@@ -1460,6 +1712,11 @@ function splitLayoutSlot(layoutHtml, slotContext = createSlotRenderContext()) {
 // next request.
 const shellFilesCache = new Map();
 const MAX_SHELL_FILES_CACHE_ENTRIES = 1024;
+const routeMiddlewareControlCache = new Map();
+const MAX_ROUTE_MIDDLEWARE_CONTROL_CACHE_ENTRIES = 1024;
+const appMiddlewareFileCache = new Map();
+const MAX_APP_MIDDLEWARE_FILE_CACHE_ENTRIES = 1024;
+const routeMiddlewareControlSourceCache = new Map();
 async function shellFilesForPage(appDir, pageFile, serverModuleCacheVersion) {
     const cacheKey = serverModuleCacheVersion === undefined
         ? undefined
@@ -1518,6 +1775,144 @@ function shellBoundaryId(appDir, directory) {
         ? "root"
         : relativeDirectory.replaceAll(sep, "/").replace(/[^A-Za-z0-9_$/-]/g, "_");
 }
+async function hasAppMiddleware(options) {
+    const middlewareFiles = [
+        join(options.appDir, "middleware.ts"),
+        join(options.appDir, "middleware.mreact.ts"),
+    ];
+    if (options.serverSourceFiles !== undefined) {
+        return middlewareFiles.some((file) => options.serverSourceFiles?.has(file) === true);
+    }
+    const cacheKey = options.serverModuleCacheVersion === undefined
+        ? undefined
+        : `${options.appDir}\0${options.serverModuleCacheVersion}`;
+    if (cacheKey !== undefined) {
+        const cached = appMiddlewareFileCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+    }
+    const loaded = hasAppMiddlewareUncached(middlewareFiles).catch((error) => {
+        if (cacheKey !== undefined) {
+            appMiddlewareFileCache.delete(cacheKey);
+        }
+        throw error;
+    });
+    if (cacheKey !== undefined) {
+        if (appMiddlewareFileCache.size >= MAX_APP_MIDDLEWARE_FILE_CACHE_ENTRIES) {
+            const oldestKey = appMiddlewareFileCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                appMiddlewareFileCache.delete(oldestKey);
+            }
+        }
+        appMiddlewareFileCache.set(cacheKey, loaded);
+    }
+    return loaded;
+}
+async function hasAppMiddlewareUncached(files) {
+    for (const file of files) {
+        try {
+            await access(file);
+            return true;
+        }
+        catch {
+            // Missing middleware files are allowed.
+        }
+    }
+    return false;
+}
+async function loadRouteMiddlewareControl(options) {
+    const cacheKey = options.serverModuleCacheVersion === undefined
+        ? undefined
+        : `${options.appDir}\0${options.pageFile}\0${options.serverModuleCacheVersion}`;
+    if (cacheKey !== undefined) {
+        const cached = routeMiddlewareControlCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+    }
+    const loaded = loadRouteMiddlewareControlUncached(options).catch((error) => {
+        if (cacheKey !== undefined) {
+            routeMiddlewareControlCache.delete(cacheKey);
+        }
+        throw error;
+    });
+    if (cacheKey !== undefined) {
+        if (routeMiddlewareControlCache.size >= MAX_ROUTE_MIDDLEWARE_CONTROL_CACHE_ENTRIES) {
+            const oldestKey = routeMiddlewareControlCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                routeMiddlewareControlCache.delete(oldestKey);
+            }
+        }
+        routeMiddlewareControlCache.set(cacheKey, loaded);
+    }
+    return loaded;
+}
+async function loadRouteMiddlewareControlUncached(options) {
+    const controls = [];
+    const shellFiles = await shellFilesForPage(options.appDir, options.pageFile, options.serverModuleCacheVersion);
+    for (const shell of shellFiles) {
+        if (shell.kind !== "layout") {
+            continue;
+        }
+        controls.push(await loadRouteMiddlewareControlFile({
+            file: shell.file,
+            serverModuleCacheVersion: options.serverModuleCacheVersion,
+            serverSourceFiles: options.serverSourceFiles,
+        }));
+    }
+    controls.push(await loadRouteMiddlewareControlFile({
+        file: options.pageFile,
+        serverModuleCacheVersion: options.serverModuleCacheVersion,
+        serverSourceFiles: options.serverSourceFiles,
+    }));
+    return mergeRouteMiddlewareControls(controls);
+}
+async function loadRouteMiddlewareControlFile(options) {
+    if (options.serverSourceFiles !== undefined || options.serverModuleCacheVersion !== undefined) {
+        return parseRouteMiddlewareControl(await readServerSourceFile(options.file, options.serverModuleCacheVersion, options.serverSourceFiles));
+    }
+    const fileStat = await stat(options.file);
+    const cached = routeMiddlewareControlSourceCache.get(options.file);
+    if (cached !== undefined && cached.mtimeMs === fileStat.mtimeMs) {
+        return cached.control;
+    }
+    const control = parseRouteMiddlewareControl(await readFile(options.file, "utf8"));
+    routeMiddlewareControlSourceCache.set(options.file, {
+        control,
+        mtimeMs: fileStat.mtimeMs,
+    });
+    return control;
+}
+function parseRouteMiddlewareControl(code) {
+    if (!/\bexport\s+const\s+middleware\s*=/.test(code)) {
+        return undefined;
+    }
+    if (/\bmiddleware\s*=\s*\{[\s\S]*?\bskip\s*:\s*true\b/.test(code)) {
+        return { skip: true };
+    }
+    const skipArray = /\bmiddleware\s*=\s*\{[\s\S]*?\bskip\s*:\s*\[([\s\S]*?)\]/.exec(code);
+    if (skipArray === null) {
+        return undefined;
+    }
+    const ids = Array.from(skipArray[1]?.matchAll(/["']([^"']+)["']/g) ?? [], (match) => match[1])
+        .filter((id) => id !== undefined);
+    return ids.length === 0 ? undefined : { skip: ids };
+}
+function mergeRouteMiddlewareControls(controls) {
+    const skippedIds = new Set();
+    for (const control of controls) {
+        if (control?.skip === true) {
+            return { skip: true };
+        }
+        if (Array.isArray(control?.skip)) {
+            for (const id of control.skip) {
+                skippedIds.add(id);
+            }
+        }
+    }
+    return skippedIds.size === 0 ? undefined : { skip: [...skippedIds] };
+}
 function markShellBoundary(html, shell) {
     const attributeName = shell.kind === "layout" ? "data-mreact-layout-boundary" : "data-mreact-template-boundary";
     if (html.includes(`${attributeName}=`)) {
@@ -1588,12 +1983,36 @@ async function loadRouteData(options) {
     const module = await loadRouteLoaderModule(options);
     return module.loader === undefined ? undefined : await module.loader(options.context);
 }
+async function loadRouteDataWithInstrumentation(options) {
+    const trace = traceContextFromRequest(options.request);
+    const event = {
+        method: options.request.method,
+        path: new URL(options.request.url).pathname,
+        request: options.request,
+        routeId: options.routeId,
+        routePath: options.routePath,
+        ...(trace === undefined ? {} : { trace }),
+    };
+    invokeRouterInstrumentation(options.instrumentation?.onLoaderStart, event);
+    try {
+        const data = await loadRouteData(options);
+        invokeRouterInstrumentation(options.instrumentation?.onLoaderEnd, event);
+        return data;
+    }
+    catch (error) {
+        invokeRouterInstrumentation(options.instrumentation?.onLoaderEnd, {
+            ...event,
+            error,
+        });
+        throw error;
+    }
+}
 async function loadRouteLoaderModule(options) {
     const cacheKey = options.serverModuleCacheVersion === undefined
         ? undefined
         : `${options.appDir}\0${options.filename}\0${options.serverModuleCacheVersion}\0${memoizedHashText(options.code)}\0${importPolicyCacheKey(options.importPolicy)}`;
     if (cacheKey !== undefined) {
-        const cached = routeLoaderModuleCache.get(cacheKey);
+        const cached = readRouterRuntimeCacheEntry(routeLoaderModuleCache, cacheKey, routeLoaderModuleCacheCounters);
         if (cached !== undefined) {
             return cached;
         }
@@ -1608,7 +2027,7 @@ async function loadRouteLoaderModule(options) {
         throw error;
     });
     if (cacheKey !== undefined) {
-        setBoundedCacheEntry(routeLoaderModuleCache, cacheKey, loaded, maxRouteLoaderModuleCacheEntries);
+        setBoundedCacheEntry(routeLoaderModuleCache, cacheKey, loaded, maxRouteLoaderModuleCacheEntries, routeLoaderModuleCacheCounters);
     }
     return loaded;
 }
@@ -1728,7 +2147,7 @@ async function loadComposedRouteMetadata(options) {
         ? undefined
         : `${options.appDir}\0${options.filename}\0${options.serverModuleCacheVersion}\0${memoizedHashText(options.code)}`;
     if (cacheKey !== undefined) {
-        const cached = composedRouteMetadataCache.get(cacheKey);
+        const cached = readRouterRuntimeCacheEntry(composedRouteMetadataCache, cacheKey, composedRouteMetadataCacheCounters);
         if (cached !== undefined) {
             return cached;
         }
@@ -1740,7 +2159,7 @@ async function loadComposedRouteMetadata(options) {
         throw error;
     });
     if (cacheKey !== undefined) {
-        setBoundedCacheEntry(composedRouteMetadataCache, cacheKey, loaded, maxComposedRouteMetadataCacheEntries);
+        setBoundedCacheEntry(composedRouteMetadataCache, cacheKey, loaded, maxComposedRouteMetadataCacheEntries, composedRouteMetadataCacheCounters);
     }
     return loaded;
 }
@@ -1825,8 +2244,22 @@ function mergeReadonlyArrays(left, right) {
     return [...left, ...right];
 }
 function mergeCspMetadata(left, right) {
+    if (right?.disable === true) {
+        return { disable: true };
+    }
     if (left === undefined) {
-        return right;
+        if (right === undefined) {
+            return undefined;
+        }
+        const merged = { ...right };
+        const directives = applyCspOverrides(undefined, right);
+        if (directives !== undefined) {
+            merged.directives = directives;
+        }
+        else {
+            delete merged.directives;
+        }
+        return merged;
     }
     if (right === undefined) {
         return left;
@@ -1835,12 +2268,28 @@ function mergeCspMetadata(left, right) {
         ...left,
         ...right,
     };
-    const directives = mergeObject(left.directives, right.directives);
+    const directives = applyCspOverrides(left.directives, right);
     if (directives !== undefined) {
         merged.directives = directives;
     }
+    else {
+        delete merged.directives;
+    }
     return merged;
 }
+function applyCspOverrides(left, right) {
+    if (right === undefined) {
+        return left;
+    }
+    const merged = { ...left, ...right.directives };
+    for (const [name, value] of Object.entries(right.replace ?? {})) {
+        merged[name] = value;
+    }
+    for (const name of right.remove ?? []) {
+        delete merged[name];
+    }
+    return Object.keys(merged).length === 0 ? undefined : merged;
+}
 function mergeOpenGraphMetadata(left, right) {
     if (left === undefined) {
         return right;
@@ -1913,13 +2362,19 @@ function injectHeadMetadata(html, metadata) {
     }
     return `<head>${tags}</head>${html}`;
 }
-function responseHeadersForMetadata(metadata) {
-    const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
+const DEFAULT_HTML_RESPONSE_HEADERS = Object.freeze({
+    "content-type": "text/html; charset=utf-8",
+});
+function responseHeadersForMetadata(metadata, extra) {
     const csp = contentSecurityPolicy(metadata?.csp);
-    if (csp !== undefined) {
-        headers.set("content-security-policy", csp);
+    if (csp === undefined && extra === undefined) {
+        return DEFAULT_HTML_RESPONSE_HEADERS;
     }
-    return headers;
+    return {
+        ...DEFAULT_HTML_RESPONSE_HEADERS,
+        ...(csp === undefined ? undefined : { "content-security-policy": csp }),
+        ...extra,
+    };
 }
 function injectQueryState(html, state) {
     if (state.queries.length === 0) {
@@ -2054,7 +2509,7 @@ function readServerSourceFile(file, serverModuleCacheVersion, serverSourceFiles)
         return readFile(file, "utf8");
     }
     const key = `${serverModuleCacheVersion}:${file}`;
-    const cached = serverSourceFileCache.get(key);
+    const cached = readRouterRuntimeCacheEntry(serverSourceFileCache, key, serverSourceFileCacheCounters);
     if (cached !== undefined) {
         return cached;
     }
@@ -2062,17 +2517,20 @@ function readServerSourceFile(file, serverModuleCacheVersion, serverSourceFiles)
         serverSourceFileCache.delete(key);
         throw error;
     });
-    setBoundedCacheEntry(serverSourceFileCache, key, loaded, maxServerSourceFileCacheEntries);
+    setBoundedCacheEntry(serverSourceFileCache, key, loaded, maxServerSourceFileCacheEntries, serverSourceFileCacheCounters);
     return loaded;
 }
 function hashText(text) {
     return createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
-function setBoundedCacheEntry(cache, key, value, maxEntries) {
+function setBoundedCacheEntry(cache, key, value, maxEntries, counters) {
     if (cache.size >= maxEntries) {
         const oldestKey = cache.keys().next().value;
         if (oldestKey !== undefined) {
             cache.delete(oldestKey);
+            if (counters !== undefined) {
+                counters.evictions += 1;
+            }
         }
     }
     cache.set(key, value);