@reckona/mreact-router 0.0.138 → 0.0.140

package/dist/render.js

@@ -3,7 +3,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { access, readFile, stat } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { formatDiagnostic, transform } from "@reckona/mreact-compiler";
-import { createQueryClient, dehydrate, __MREACT_QUERY_STATE_SCRIPT_ID, runWithQueryClient, } from "@reckona/mreact-query";
+import { createQueryClient, dehydrate, __MREACT_QUERY_STATE_SCRIPT_ID, installQueryAsyncStorage, runWithQueryClient, } from "@reckona/mreact-query";
 import { createStringSink, renderAsyncBoundary, renderOutOfOrderReorderScript, renderReactNodeToString, renderToReadableStream, } from "@reckona/mreact-server";
 import { createClientRouteInferenceCache, formatClientRouteInferenceDiagnostic, inferClientRouteModule, } from "./client-route-inference.js";
 import { hydrationMarkerParts, routeIdForPath, withHydrationMarkers, withRouteMarkers, } from "./navigation-runtime.js";
@@ -36,6 +36,7 @@ const nativeEscapeTransform = {
 };
 const authRuntimeStateKey = "__mreactAuthRuntimeState";
 const authSessionScriptId = "__mreact_auth_session";
+installQueryAsyncStorage(new AsyncLocalStorage());
 export async function preloadBuiltRequestModules(options) {
     const clientRouteInferenceCache = createClientRouteInferenceCache();
     const middlewareFiles = [
@@ -247,7 +248,7 @@ export async function renderAppRequest(options) {
         return authStorage.run({}, () => renderAppRequest(options));
     }
     const trace = traceContextFromRequest(options.request);
-    const url = new URL(options.request.url);
+    const url = options.requestUrl ?? new URL(options.request.url);
     const requestEvent = {
         method: options.request.method,
         path: url.pathname,
@@ -255,7 +256,7 @@ export async function renderAppRequest(options) {
         ...(trace === undefined ? {} : { trace }),
     };
     invokeRouterInstrumentation(options.instrumentation?.onRequestStart, requestEvent);
-    const response = await renderAppRequestInternal(options);
+    const response = await renderAppRequestInternal({ ...options, requestUrl: url });
     invokeRouterInstrumentation(options.instrumentation?.onRequestEnd, {
         ...requestEvent,
         status: response.status,
@@ -333,13 +334,13 @@ export async function resolveAppRouterMiddleware(options) {
 }
 async function renderAppRequestInternal(options) {
     const timing = createRenderTiming(options.logger);
-    const clientRouteInferenceCache = createClientRouteInferenceCache();
+    const clientRouteInferenceCache = options.clientRouteInferenceCache ?? createClientRouteInferenceCache();
     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 url = options.requestUrl ?? new URL(options.request.url);
     phaseStartedAt = renderTimingPhaseStartedAt(timing);
-    const matched = options.routeMatcher?.match(url.pathname) ?? matchRoute(routes, url.pathname);
+    const matched = options.matchedRoute ?? options.routeMatcher?.match(url.pathname) ?? matchRoute(routes, url.pathname);
     finishRenderTimingPhase(timing, phaseStartedAt, "routeMatchMs");
     const hasMiddleware = options.skipMiddleware === true
         ? false
@@ -380,7 +381,9 @@ async function renderAppRequestInternal(options) {
     if (middlewareResult.request !== options.request) {
         return renderAppRequestInternal({
             ...options,
+            matchedRoute: undefined,
             request: middlewareResult.request,
+            requestUrl: new URL(middlewareResult.request.url),
             skipMiddleware: true,
         });
     }
@@ -511,6 +514,7 @@ async function renderAppRequestInternal(options) {
             : await cachedRouteResponse({
                 cache: options.routeCache,
                 key: cacheKey,
+                request: options.request,
             });
         finishRenderTimingPhase(timing, phaseStartedAt, "routeCacheMs");
         if (cachedResponse !== undefined) {
@@ -694,6 +698,7 @@ async function renderAppRequestInternal(options) {
                     serverModules: options.serverModules,
                     serverModuleCacheVersion: options.serverModuleCacheVersion,
                     serverSourceFiles: options.serverSourceFiles,
+                    define: options.define,
                     vitePlugins: options.vitePlugins,
                 });
                 html = injectHeadMetadata(html, metadata);
@@ -949,6 +954,7 @@ async function renderAppRequestInternal(options) {
                 cache: options.routeCache,
                 path: matched.route.path,
                 policy: effectiveCachePolicy,
+                request: options.request,
                 response,
             });
         finishRenderTimingPhase(timing, phaseStartedAt, "responseBuildMs");
@@ -1010,7 +1016,7 @@ async function renderAppRequestInternal(options) {
             vitePlugins: options.vitePlugins,
             navigation: recoveryRoute,
             status: 500,
-            textFallback: error instanceof Error ? error.message : String(error),
+            textFallback: "Internal Server Error",
         });
         emitRenderTiming(options, timing, response.status);
         return response;
@@ -1716,9 +1722,7 @@ async function analyzeRouteSourceUncached(options) {
     };
 }
 function routeSourceFilesForAnalysis(options) {
-    return options.serverSourceFiles === undefined
-        ? { [options.filename]: options.code }
-        : { ...Object.fromEntries(options.serverSourceFiles), [options.filename]: options.code };
+    return (file) => file === options.filename ? options.code : options.serverSourceFiles?.get(file);
 }
 async function runServerModule(code, props, sourcefile, serverModules, serverModuleCacheVersion, define, vitePlugins) {
     const component = await loadServerComponent(code, sourcefile, serverModules, serverModuleCacheVersion, define, vitePlugins);
@@ -2126,8 +2130,16 @@ async function applyLayouts(options) {
     let html = options.html;
     let shellHasOutOfOrderBoundary = false;
     const slotContext = createSlotRenderContext(options.slots);
-    for (const shell of layoutFiles.reverse()) {
-        const rendered = await renderShellPrefixSuffix(options.appDir, shell, options.props, slotContext, options.serverModules, options.serverModuleCacheVersion, options.serverSourceFiles, options.clientRouteInferenceCache, options.timing, options.define, options.vitePlugins, options.importPolicy);
+    const renderShell = (shell) => renderShellPrefixSuffix(options.appDir, shell, options.props, slotContext, options.serverModules, options.serverModuleCacheVersion, options.serverSourceFiles, options.clientRouteInferenceCache, options.timing, options.define, options.vitePlugins, options.importPolicy);
+    const renderedShells = Object.keys(slotContext.namedSlots).length === 0
+        ? await Promise.all(layoutFiles.map(renderShell))
+        : undefined;
+    for (let index = layoutFiles.length - 1; index >= 0; index -= 1) {
+        const shell = layoutFiles[index];
+        if (shell === undefined) {
+            continue;
+        }
+        const rendered = renderedShells?.[index] ?? (await renderShell(shell));
         shellHasOutOfOrderBoundary ||= rendered.hasOutOfOrderBoundary;
         html = `${rendered.prefix}${html}${rendered.suffix}`;
     }
@@ -2148,10 +2160,15 @@ async function applyLayouts(options) {
 }
 async function layoutShellsForPage(appDir, pageFile, props, slots, serverModules, serverModuleCacheVersion, serverSourceFiles, clientRouteInferenceCache, define, vitePlugins, importPolicy) {
     const layoutFiles = await shellFilesForPage(appDir, pageFile, serverModuleCacheVersion);
-    const shells = [];
     const slotContext = createSlotRenderContext(slots);
-    for (const shell of layoutFiles) {
-        shells.push(await renderShellPrefixSuffix(appDir, shell, props, slotContext, serverModules, serverModuleCacheVersion, serverSourceFiles, clientRouteInferenceCache, undefined, define, vitePlugins, importPolicy));
+    const renderShell = (shell) => renderShellPrefixSuffix(appDir, shell, props, slotContext, serverModules, serverModuleCacheVersion, serverSourceFiles, clientRouteInferenceCache, undefined, define, vitePlugins, importPolicy);
+    const shells = Object.keys(slotContext.namedSlots).length === 0
+        ? await Promise.all(layoutFiles.map(renderShell))
+        : [];
+    if (shells.length === 0 && layoutFiles.length > 0) {
+        for (const shell of layoutFiles) {
+            shells.push(await renderShell(shell));
+        }
     }
     warnUnconsumedRouteSlots({
         appDir,
@@ -2172,64 +2189,32 @@ async function renderShellPrefixSuffix(appDir, shell, props, slotContext, server
             return cached;
         }
     }
-    let phaseStartedAt = renderTimingPhaseStartedAt(timing);
-    const code = await readServerSourceFile(shell.file, serverModuleCacheVersion, serverSourceFiles);
-    addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutSourceReadMs");
-    phaseStartedAt = renderTimingPhaseStartedAt(timing);
-    const shellUsesAwait = await mayRenderOutOfOrderBoundaryDeep({
-        code,
-        filename: shell.file,
-        serverModuleCacheVersion,
-        serverSourceFiles,
-    });
-    const serverOutput = shellUsesAwait ? "stream" : "string";
-    const artifact = serverModules?.get(shell.file)?.[serverOutput];
-    const clientInference = artifact !== undefined && artifact.sourceHash === memoizedHashText(code)
-        ? {
-            client: false,
-            clientBoundaryImports: [],
-            clientBoundaryFallbackImports: [],
-            diagnostics: [],
-        }
-        : await inferClientRouteModule({
-            cache: clientRouteInferenceCache,
-            code: stripRouteClientOnlyExports(code, shell.file),
-            filename: shell.file,
+    const staticEntry = cacheKey === undefined ? undefined : shellStaticRenderCache.get(cacheKey);
+    const loadedStaticEntry = staticEntry ??
+        (await loadShellStaticRenderEntry({
+            cacheKey,
+            clientRouteInferenceCache,
+            define,
+            importPolicy,
+            serverModuleCacheVersion,
+            serverModules,
+            serverSourceFiles,
+            shell,
+            timing,
             vitePlugins,
-        });
-    for (const diagnostic of clientInference.diagnostics) {
-        console.warn(formatClientRouteInferenceDiagnostic(diagnostic));
-    }
-    const output = transformServerModule({
-        code,
-        clientBoundaryImports: clientInference.clientBoundaryImports,
-        clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
-        filename: shell.file,
-        serverModules,
-        serverOutput,
-    });
-    addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutTransformMs");
-    const fatalDiagnostics = fatalServerDiagnostics(output.diagnostics);
-    if (fatalDiagnostics.length > 0) {
-        throw new Error(formatServerDiagnostics(shell.file, fatalDiagnostics));
-    }
-    phaseStartedAt = renderTimingPhaseStartedAt(timing);
-    const component = shellUsesAwait
-        ? selectStreamComponent(await loadServerStreamModule(output.code, shell.file, serverModules, serverModuleCacheVersion, define, vitePlugins, importPolicy))
-        : await loadServerComponent(output.code, shell.file, serverModules, serverModuleCacheVersion, define, vitePlugins, importPolicy);
-    addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutModuleLoadMs");
-    phaseStartedAt = renderTimingPhaseStartedAt(timing);
-    const layoutHtml = shellUsesAwait
-        ? await renderShellStreamComponent(component, props)
-        : await component(props);
+        }));
+    let phaseStartedAt = renderTimingPhaseStartedAt(timing);
+    const layoutHtml = loadedStaticEntry.shellUsesAwait
+        ? await renderShellStreamComponent(loadedStaticEntry.component, props)
+        : await loadedStaticEntry.component(props);
     addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutComponentRenderMs");
     phaseStartedAt = renderTimingPhaseStartedAt(timing);
     const rendered = {
         ...splitLayoutSlot(markShellBoundary(layoutHtml, shell), slotContext),
-        hasOutOfOrderBoundary: hasOutOfOrderBoundary(output.code),
+        hasOutOfOrderBoundary: loadedStaticEntry.hasOutOfOrderBoundary,
     };
     addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutSlotSplitMs");
-    const shellCacheKey = shellUsesAwait ? undefined : cacheKey;
+    const shellCacheKey = loadedStaticEntry.shellUsesAwait ? undefined : cacheKey;
     const cached = shellCacheKey !== undefined
         ? readRouterRuntimeCacheEntry(renderedShellCache, shellCacheKey, renderedShellCacheCounters)
         : undefined;
@@ -2239,7 +2224,7 @@ async function renderShellPrefixSuffix(appDir, shell, props, slotContext, server
     // entry on the first request that observes the function arity; on
     // an "impure" tag we never overwrite it.
     if (shellCacheKey !== undefined && cached !== "impure") {
-        if (component.length === 0) {
+        if (loadedStaticEntry.component.length === 0) {
             if (renderedShellCache.size >= MAX_RENDERED_SHELL_CACHE_ENTRIES) {
                 const oldestKey = renderedShellCache.keys().next().value;
                 if (oldestKey !== undefined) {
@@ -2258,6 +2243,69 @@ async function renderShellPrefixSuffix(appDir, shell, props, slotContext, server
     }
     return rendered;
 }
+async function loadShellStaticRenderEntry(options) {
+    let phaseStartedAt = renderTimingPhaseStartedAt(options.timing);
+    const code = await readServerSourceFile(options.shell.file, options.serverModuleCacheVersion, options.serverSourceFiles);
+    addRenderTimingPhaseDuration(options.timing, phaseStartedAt, "layoutSourceReadMs");
+    phaseStartedAt = renderTimingPhaseStartedAt(options.timing);
+    const shellUsesAwait = await mayRenderOutOfOrderBoundaryDeep({
+        code,
+        filename: options.shell.file,
+        serverModuleCacheVersion: options.serverModuleCacheVersion,
+        serverSourceFiles: options.serverSourceFiles,
+    });
+    const serverOutput = shellUsesAwait ? "stream" : "string";
+    const artifact = options.serverModules?.get(options.shell.file)?.[serverOutput];
+    const clientInference = artifact !== undefined && artifact.sourceHash === memoizedHashText(code)
+        ? {
+            client: false,
+            clientBoundaryImports: [],
+            clientBoundaryFallbackImports: [],
+            diagnostics: [],
+        }
+        : await inferClientRouteModule({
+            cache: options.clientRouteInferenceCache,
+            code: stripRouteClientOnlyExports(code, options.shell.file),
+            filename: options.shell.file,
+            vitePlugins: options.vitePlugins,
+        });
+    for (const diagnostic of clientInference.diagnostics) {
+        console.warn(formatClientRouteInferenceDiagnostic(diagnostic));
+    }
+    const output = transformServerModule({
+        code,
+        clientBoundaryImports: clientInference.clientBoundaryImports,
+        clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
+        filename: options.shell.file,
+        serverModules: options.serverModules,
+        serverOutput,
+    });
+    addRenderTimingPhaseDuration(options.timing, phaseStartedAt, "layoutTransformMs");
+    const fatalDiagnostics = fatalServerDiagnostics(output.diagnostics);
+    if (fatalDiagnostics.length > 0) {
+        throw new Error(formatServerDiagnostics(options.shell.file, fatalDiagnostics));
+    }
+    phaseStartedAt = renderTimingPhaseStartedAt(options.timing);
+    const component = shellUsesAwait
+        ? selectStreamComponent(await loadServerStreamModule(output.code, options.shell.file, options.serverModules, options.serverModuleCacheVersion, options.define, options.vitePlugins, options.importPolicy))
+        : await loadServerComponent(output.code, options.shell.file, options.serverModules, options.serverModuleCacheVersion, options.define, options.vitePlugins, options.importPolicy);
+    addRenderTimingPhaseDuration(options.timing, phaseStartedAt, "layoutModuleLoadMs");
+    const entry = {
+        component,
+        hasOutOfOrderBoundary: hasOutOfOrderBoundary(output.code),
+        shellUsesAwait,
+    };
+    if (options.cacheKey !== undefined) {
+        if (shellStaticRenderCache.size >= MAX_SHELL_STATIC_RENDER_CACHE_ENTRIES) {
+            const oldestKey = shellStaticRenderCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                shellStaticRenderCache.delete(oldestKey);
+            }
+        }
+        shellStaticRenderCache.set(options.cacheKey, entry);
+    }
+    return entry;
+}
 async function renderShellStreamComponent(component, props) {
     const sink = createStringSink();
     await component(sink, props);
@@ -2276,11 +2324,17 @@ async function renderShellStreamComponent(component, props) {
 // next request.
 const shellFilesCache = new Map();
 const MAX_SHELL_FILES_CACHE_ENTRIES = 1024;
+const devShellFilesCache = new Map();
+const shellStaticRenderCache = new Map();
+const MAX_SHELL_STATIC_RENDER_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 devAppMiddlewareFileCache = new Map();
 const routeMiddlewareControlSourceCache = new Map();
+const devServerSourceFileCache = new Map();
+const MAX_DEV_SERVER_SOURCE_FILE_CACHE_ENTRIES = 2048;
 async function shellFilesForPage(appDir, pageFile, serverModuleCacheVersion) {
     const cacheKey = serverModuleCacheVersion === undefined
         ? undefined
@@ -2291,6 +2345,31 @@ async function shellFilesForPage(appDir, pageFile, serverModuleCacheVersion) {
             return cached;
         }
     }
+    const devCacheKey = cacheKey === undefined ? `${appDir}\0${pageFile}` : undefined;
+    if (devCacheKey !== undefined) {
+        const directoryStats = await routeShellDirectoryStats(appDir, pageFile);
+        const cached = devShellFilesCache.get(devCacheKey);
+        if (cached !== undefined &&
+            sameFileStats(cached.directoryStats, directoryStats)) {
+            return cached.files;
+        }
+        const files = await shellFilesForPageUncached(appDir, pageFile);
+        devShellFilesCache.set(devCacheKey, { directoryStats, files });
+        return files;
+    }
+    const files = await shellFilesForPageUncached(appDir, pageFile);
+    if (cacheKey !== undefined) {
+        if (shellFilesCache.size >= MAX_SHELL_FILES_CACHE_ENTRIES) {
+            const oldestKey = shellFilesCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                shellFilesCache.delete(oldestKey);
+            }
+        }
+        shellFilesCache.set(cacheKey, files);
+    }
+    return files;
+}
+async function shellFilesForPageUncached(appDir, pageFile) {
     const shells = await existingRouteShellCandidates(appDir, pageFile, async (file) => {
         try {
             await access(file);
@@ -2305,15 +2384,6 @@ async function shellFilesForPage(appDir, pageFile, serverModuleCacheVersion) {
         id: shellBoundaryId(appDir, shell.directory),
         kind: shell.kind,
     }));
-    if (cacheKey !== undefined) {
-        if (shellFilesCache.size >= MAX_SHELL_FILES_CACHE_ENTRIES) {
-            const oldestKey = shellFilesCache.keys().next().value;
-            if (oldestKey !== undefined) {
-                shellFilesCache.delete(oldestKey);
-            }
-        }
-        shellFilesCache.set(cacheKey, files);
-    }
     return files;
 }
 function withRouteCacheHeader(response, policy) {
@@ -2339,21 +2409,28 @@ async function hasAppMiddleware(options) {
             return cached;
         }
     }
-    const loaded = hasAppMiddlewareUncached(middlewareFiles).catch((error) => {
-        if (cacheKey !== undefined) {
-            appMiddlewareFileCache.delete(cacheKey);
+    if (cacheKey === undefined) {
+        const directoryStat = await fileStat(options.appDir);
+        const cached = devAppMiddlewareFileCache.get(options.appDir);
+        if (cached !== undefined &&
+            sameFileStat(cached.directoryStat, directoryStat)) {
+            return cached.hasMiddleware;
         }
+        const hasMiddleware = await hasAppMiddlewareUncached(middlewareFiles);
+        devAppMiddlewareFileCache.set(options.appDir, { directoryStat, hasMiddleware });
+        return hasMiddleware;
+    }
+    const loaded = hasAppMiddlewareUncached(middlewareFiles).catch((error) => {
+        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);
-            }
+    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);
     }
+    appMiddlewareFileCache.set(cacheKey, loaded);
     return loaded;
 }
 async function hasAppMiddlewareUncached(files) {
@@ -2368,6 +2445,48 @@ async function hasAppMiddlewareUncached(files) {
     }
     return false;
 }
+async function routeShellDirectoryStats(appDir, pageFile) {
+    const directories = [];
+    let current = dirname(pageFile);
+    const resolvedAppDir = resolve(appDir);
+    while (true) {
+        directories.push(current);
+        if (resolve(current) === resolvedAppDir) {
+            break;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return await Promise.all(directories.map((directory) => fileStatOrMissing(directory)));
+}
+async function fileStat(file) {
+    const stats = await stat(file);
+    return { mtimeMs: stats.mtimeMs, size: stats.size };
+}
+async function fileStatOrMissing(file) {
+    try {
+        return await fileStat(file);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return { mtimeMs: -1, size: -1 };
+        }
+        throw error;
+    }
+}
+function sameFileStats(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => {
+            const other = right[index];
+            return other !== undefined && sameFileStat(value, other);
+        }));
+}
+function sameFileStat(left, right) {
+    return left.mtimeMs === right.mtimeMs && left.size === right.size;
+}
 async function loadRouteMiddlewareControl(options) {
     const cacheKey = options.serverModuleCacheVersion === undefined
         ? undefined
@@ -2658,12 +2777,11 @@ async function loadComposedRouteMetadataUncached(options) {
     const layoutFiles = await shellFilesForPage(options.appDir, options.filename, options.serverModuleCacheVersion);
     const metadata = [];
     let dynamic = hasGenerateMetadataExport(options.code);
-    for (const shell of layoutFiles) {
+    const layoutMetadataTasks = layoutFiles.map(async (shell) => {
         if (shell.kind !== "layout") {
-            continue;
+            return { code: undefined, metadata: undefined };
         }
         const code = await readServerSourceFile(shell.file, options.serverModuleCacheVersion, options.serverSourceFiles);
-        dynamic ||= hasGenerateMetadataExport(code);
         const shellMetadata = await loadRouteMetadata({
             appDir: options.appDir,
             code,
@@ -2675,11 +2793,9 @@ async function loadComposedRouteMetadataUncached(options) {
             define: options.define,
             vitePlugins: options.vitePlugins,
         });
-        if (shellMetadata !== undefined) {
-            metadata.push(shellMetadata);
-        }
-    }
-    const pageMetadata = await loadRouteMetadata({
+        return { code, metadata: shellMetadata };
+    });
+    const pageMetadataTask = loadRouteMetadata({
         appDir: options.appDir,
         code: options.code,
         context: options.context,
@@ -2690,6 +2806,16 @@ async function loadComposedRouteMetadataUncached(options) {
         define: options.define,
         vitePlugins: options.vitePlugins,
     });
+    for (const task of layoutMetadataTasks) {
+        const shell = await task;
+        if (shell.code !== undefined) {
+            dynamic ||= hasGenerateMetadataExport(shell.code);
+        }
+        if (shell.metadata !== undefined) {
+            metadata.push(shell.metadata);
+        }
+    }
+    const pageMetadata = await pageMetadataTask;
     if (pageMetadata !== undefined) {
         metadata.push(pageMetadata);
     }
@@ -2852,7 +2978,7 @@ function readServerSourceFile(file, serverModuleCacheVersion, serverSourceFiles)
         return Promise.resolve(manifestSource);
     }
     if (serverModuleCacheVersion === undefined) {
-        return readFile(file, "utf8");
+        return readDevServerSourceFile(file);
     }
     const key = `${serverModuleCacheVersion}:${file}`;
     const cached = readRouterRuntimeCacheEntry(serverSourceFileCache, key, serverSourceFileCacheCounters);
@@ -2866,6 +2992,24 @@ function readServerSourceFile(file, serverModuleCacheVersion, serverSourceFiles)
     setBoundedCacheEntry(serverSourceFileCache, key, loaded, maxServerSourceFileCacheEntries, serverSourceFileCacheCounters);
     return loaded;
 }
+async function readDevServerSourceFile(file) {
+    const stats = await fileStat(file);
+    const cached = devServerSourceFileCache.get(file);
+    if (cached !== undefined &&
+        cached.mtimeMs === stats.mtimeMs &&
+        cached.size === stats.size) {
+        return cached.source;
+    }
+    const source = await readFile(file, "utf8");
+    if (devServerSourceFileCache.size >= MAX_DEV_SERVER_SOURCE_FILE_CACHE_ENTRIES) {
+        const oldestKey = devServerSourceFileCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            devServerSourceFileCache.delete(oldestKey);
+        }
+    }
+    devServerSourceFileCache.set(file, { ...stats, source });
+    return source;
+}
 function setBoundedCacheEntry(cache, key, value, maxEntries, counters) {
     if (cache.size >= maxEntries) {
         const oldestKey = cache.keys().next().value;