@reckona/mreact-router 0.0.138 → 0.0.139

package/src/render.ts

@@ -12,6 +12,7 @@ import {
   createQueryClient,
   dehydrate,
   __MREACT_QUERY_STATE_SCRIPT_ID,
+  installQueryAsyncStorage,
   runWithQueryClient,
   type DehydratedQueryClient,
   type QueryClient,
@@ -40,7 +41,7 @@ import {
 import { assetPath } from "./assets.js";
 import { escapeHtmlAttribute } from "@reckona/mreact-shared/html-escape";
 import { matchRoute, scanAppRoutes } from "./routes.js";
-import type { AppRoute, RouteMatcher } from "./routes.js";
+import type { AppRoute, MatchedRoute, RouteMatcher } from "./routes.js";
 import { appFileConventionContentType } from "./file-conventions.js";
 import {
   type AppRouterServerActionOptions,
@@ -144,6 +145,8 @@ const nativeEscapeTransform = {
 const authRuntimeStateKey = "__mreactAuthRuntimeState";
 const authSessionScriptId = "__mreact_auth_session";
 
+installQueryAsyncStorage(new AsyncLocalStorage<QueryClient>());
+
 interface AuthRuntimeRequestState {
   claims?: unknown;
 }
@@ -159,6 +162,7 @@ interface RenderTiming {
 export interface RenderAppRequestOptions {
   appDir: string;
   assetBaseUrl?: string | undefined;
+  clientRouteInferenceCache?: ClientRouteInferenceCache | undefined;
   clientScripts?: ReadonlyMap<string, string>;
   clientStylesByFile?: ReadonlyMap<string, readonly string[]>;
   clientStyles?: ReadonlyMap<string, readonly string[]>;
@@ -171,6 +175,8 @@ export interface RenderAppRequestOptions {
   onResponse?: AppRouterResponseHook | undefined;
   queryClient?: QueryClient | undefined;
   request: Request;
+  requestUrl?: URL | undefined;
+  matchedRoute?: MatchedRoute | undefined;
   routeCache?: AppRouterCache | undefined;
   routeMatcher?: RouteMatcher | undefined;
   routes?: readonly AppRoute[] | undefined;
@@ -595,7 +601,7 @@ export async function renderAppRequest(options: RenderAppRequestOptions): Promis
   }
 
   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,
@@ -603,7 +609,7 @@ export async function renderAppRequest(options: RenderAppRequestOptions): Promis
     ...(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,
@@ -738,13 +744,15 @@ export async function resolveAppRouterMiddleware(options: {
 
 async function renderAppRequestInternal(options: RenderAppRequestOptions): Promise<Response> {
   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
@@ -790,7 +798,9 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
   if (middlewareResult.request !== options.request) {
     return renderAppRequestInternal({
       ...options,
+      matchedRoute: undefined,
       request: middlewareResult.request,
+      requestUrl: new URL(middlewareResult.request.url),
       skipMiddleware: true,
     });
   }
@@ -943,6 +953,7 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
         : await cachedRouteResponse({
             cache: options.routeCache,
             key: cacheKey,
+            request: options.request,
           });
     finishRenderTimingPhase(timing, phaseStartedAt, "routeCacheMs");
 
@@ -1146,6 +1157,7 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
           serverModules: options.serverModules,
           serverModuleCacheVersion: options.serverModuleCacheVersion,
           serverSourceFiles: options.serverSourceFiles,
+          define: options.define,
           vitePlugins: options.vitePlugins,
         });
         html = injectHeadMetadata(html, metadata);
@@ -1454,6 +1466,7 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
           cache: options.routeCache,
           path: matched.route.path,
           policy: effectiveCachePolicy,
+          request: options.request,
           response,
         });
     finishRenderTimingPhase(timing, phaseStartedAt, "responseBuildMs");
@@ -1518,7 +1531,7 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
       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;
@@ -2633,10 +2646,9 @@ function routeSourceFilesForAnalysis(options: {
   code: string;
   filename: string;
   serverSourceFiles?: ReadonlyMap<string, string> | undefined;
-}): Record<string, string> {
-  return options.serverSourceFiles === undefined
-    ? { [options.filename]: options.code }
-    : { ...Object.fromEntries(options.serverSourceFiles), [options.filename]: options.code };
+}): (file: string) => string | undefined {
+  return (file) =>
+    file === options.filename ? options.code : options.serverSourceFiles?.get(file);
 }
 
 async function runServerModule(
@@ -3445,9 +3457,8 @@ 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(
+  const renderShell = (shell: ShellFile) =>
+    renderShellPrefixSuffix(
       options.appDir,
       shell,
       options.props,
@@ -3461,6 +3472,18 @@ async function applyLayouts(options: {
       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}`;
   }
@@ -3497,12 +3520,9 @@ async function layoutShellsForPage(
   importPolicy?: AppRouterImportPolicy | undefined,
 ): Promise<RenderedShell[]> {
   const layoutFiles = await shellFilesForPage(appDir, pageFile, serverModuleCacheVersion);
-  const shells: RenderedShell[] = [];
   const slotContext = createSlotRenderContext(slots);
-
-  for (const shell of layoutFiles) {
-    shells.push(
-      await renderShellPrefixSuffix(
+  const renderShell = (shell: ShellFile) =>
+    renderShellPrefixSuffix(
         appDir,
         shell,
         props,
@@ -3515,8 +3535,16 @@ async function layoutShellsForPage(
         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({
@@ -3559,18 +3587,94 @@ async function renderShellPrefixSuffix(
     }
   }
 
+  const staticEntry =
+    cacheKey === undefined ? undefined : shellStaticRenderCache.get(cacheKey);
+  const loadedStaticEntry =
+    staticEntry ??
+    (await loadShellStaticRenderEntry({
+      cacheKey,
+      clientRouteInferenceCache,
+      define,
+      importPolicy,
+      serverModuleCacheVersion,
+      serverModules,
+      serverSourceFiles,
+      shell,
+      timing,
+      vitePlugins,
+    }));
+
   let phaseStartedAt = renderTimingPhaseStartedAt(timing);
-  const code = await readServerSourceFile(shell.file, serverModuleCacheVersion, serverSourceFiles);
-  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutSourceReadMs");
+  const layoutHtml = loadedStaticEntry.shellUsesAwait
+    ? await renderShellStreamComponent(loadedStaticEntry.component as StreamComponent, props)
+    : await (loadedStaticEntry.component as ServerComponent)(props);
+  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutComponentRenderMs");
   phaseStartedAt = renderTimingPhaseStartedAt(timing);
+  const rendered = {
+    ...splitLayoutSlot(markShellBoundary(layoutHtml, shell), slotContext),
+    hasOutOfOrderBoundary: loadedStaticEntry.hasOutOfOrderBoundary,
+  };
+  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutSlotSplitMs");
+  const shellCacheKey = loadedStaticEntry.shellUsesAwait ? undefined : cacheKey;
+  const cached =
+    shellCacheKey !== undefined
+      ? readRouterRuntimeCacheEntry(renderedShellCache, shellCacheKey, 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
+  // entry on the first request that observes the function arity; on
+  // an "impure" tag we never overwrite it.
+  if (shellCacheKey !== undefined && cached !== "impure") {
+    if (loadedStaticEntry.component.length === 0) {
+      if (renderedShellCache.size >= MAX_RENDERED_SHELL_CACHE_ENTRIES) {
+        const oldestKey = renderedShellCache.keys().next().value;
+        if (oldestKey !== undefined) {
+          renderedShellCache.delete(oldestKey);
+          renderedShellCacheCounters.evictions += 1;
+        }
+      }
+      renderedShellCache.set(shellCacheKey, rendered);
+    } else {
+      // Impure — stamp the cache so subsequent lookups short-circuit
+      // without re-checking arity. We still run the per-request
+      // render path above so the props are honoured.
+      renderedShellCache.set(shellCacheKey, "impure");
+    }
+  }
+
+  return rendered;
+}
+
+async function loadShellStaticRenderEntry(options: {
+  cacheKey: string | undefined;
+  clientRouteInferenceCache?: ClientRouteInferenceCache | undefined;
+  define?: UserConfig["define"] | undefined;
+  importPolicy?: AppRouterImportPolicy | undefined;
+  serverModuleCacheVersion: string | undefined;
+  serverModules: ReadonlyMap<string, BuiltServerModuleArtifact> | undefined;
+  serverSourceFiles: ReadonlyMap<string, string> | undefined;
+  shell: ShellFile;
+  timing?: RenderTiming | undefined;
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<ShellStaticRenderEntry> {
+  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: shell.file,
-    serverModuleCacheVersion,
-    serverSourceFiles,
+    filename: options.shell.file,
+    serverModuleCacheVersion: options.serverModuleCacheVersion,
+    serverSourceFiles: options.serverSourceFiles,
   });
   const serverOutput: ServerOutputMode = shellUsesAwait ? "stream" : "string";
-  const artifact = serverModules?.get(shell.file)?.[serverOutput];
+  const artifact = options.serverModules?.get(options.shell.file)?.[serverOutput];
   const clientInference =
     artifact !== undefined && artifact.sourceHash === memoizedHashText(code)
       ? {
@@ -3580,10 +3684,10 @@ async function renderShellPrefixSuffix(
           diagnostics: [],
         }
       : await inferClientRouteModule({
-          cache: clientRouteInferenceCache,
-          code: stripRouteClientOnlyExports(code, shell.file),
-          filename: shell.file,
-          vitePlugins,
+          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));
@@ -3592,81 +3696,57 @@ async function renderShellPrefixSuffix(
     code,
     clientBoundaryImports: clientInference.clientBoundaryImports,
     clientBoundaryFallbackImports: clientInference.clientBoundaryFallbackImports,
-    filename: shell.file,
-    serverModules,
+    filename: options.shell.file,
+    serverModules: options.serverModules,
     serverOutput,
   });
-  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutTransformMs");
+  addRenderTimingPhaseDuration(options.timing, phaseStartedAt, "layoutTransformMs");
   const fatalDiagnostics = fatalServerDiagnostics(output.diagnostics);
 
   if (fatalDiagnostics.length > 0) {
-    throw new Error(formatServerDiagnostics(shell.file, fatalDiagnostics));
+    throw new Error(formatServerDiagnostics(options.shell.file, fatalDiagnostics));
   }
 
-  phaseStartedAt = renderTimingPhaseStartedAt(timing);
+  phaseStartedAt = renderTimingPhaseStartedAt(options.timing);
   const component = shellUsesAwait
     ? selectStreamComponent(
         await loadServerStreamModule(
           output.code,
-          shell.file,
-          serverModules,
-          serverModuleCacheVersion,
-          define,
-          vitePlugins,
-          importPolicy,
+          options.shell.file,
+          options.serverModules,
+          options.serverModuleCacheVersion,
+          options.define,
+          options.vitePlugins,
+          options.importPolicy,
         ),
       )
     : await loadServerComponent(
         output.code,
-        shell.file,
-        serverModules,
-        serverModuleCacheVersion,
-        define,
-        vitePlugins,
-        importPolicy,
+        options.shell.file,
+        options.serverModules,
+        options.serverModuleCacheVersion,
+        options.define,
+        options.vitePlugins,
+        options.importPolicy,
       );
-  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutModuleLoadMs");
-  phaseStartedAt = renderTimingPhaseStartedAt(timing);
-  const layoutHtml = shellUsesAwait
-    ? await renderShellStreamComponent(component as StreamComponent, props)
-    : await (component as ServerComponent)(props);
-  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutComponentRenderMs");
-  phaseStartedAt = renderTimingPhaseStartedAt(timing);
-  const rendered = {
-    ...splitLayoutSlot(markShellBoundary(layoutHtml, shell), slotContext),
+  addRenderTimingPhaseDuration(options.timing, phaseStartedAt, "layoutModuleLoadMs");
+  const entry = {
+    component,
     hasOutOfOrderBoundary: hasOutOfOrderBoundary(output.code),
+    shellUsesAwait,
   };
-  addRenderTimingPhaseDuration(timing, phaseStartedAt, "layoutSlotSplitMs");
-  const shellCacheKey = shellUsesAwait ? undefined : cacheKey;
-  const cached =
-    shellCacheKey !== undefined
-      ? readRouterRuntimeCacheEntry(renderedShellCache, shellCacheKey, 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
-  // 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 (renderedShellCache.size >= MAX_RENDERED_SHELL_CACHE_ENTRIES) {
-        const oldestKey = renderedShellCache.keys().next().value;
-        if (oldestKey !== undefined) {
-          renderedShellCache.delete(oldestKey);
-          renderedShellCacheCounters.evictions += 1;
-        }
+  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);
       }
-      renderedShellCache.set(shellCacheKey, rendered);
-    } else {
-      // Impure — stamp the cache so subsequent lookups short-circuit
-      // without re-checking arity. We still run the per-request
-      // render path above so the props are honoured.
-      renderedShellCache.set(shellCacheKey, "impure");
     }
+    shellStaticRenderCache.set(options.cacheKey, entry);
   }
 
-  return rendered;
+  return entry;
 }
 
 async function renderShellStreamComponent(
@@ -3691,14 +3771,31 @@ async function renderShellStreamComponent(
 // next request.
 const shellFilesCache = new Map<string, ShellFile[]>();
 const MAX_SHELL_FILES_CACHE_ENTRIES = 1024;
+const devShellFilesCache = new Map<string, { directoryStats: readonly FileStat[]; files: ShellFile[] }>();
+const shellStaticRenderCache = new Map<string, ShellStaticRenderEntry>();
+const MAX_SHELL_STATIC_RENDER_CACHE_ENTRIES = 1024;
 const routeMiddlewareControlCache = new Map<string, Promise<RouteMiddlewareControl | undefined>>();
 const MAX_ROUTE_MIDDLEWARE_CONTROL_CACHE_ENTRIES = 1024;
 const appMiddlewareFileCache = new Map<string, Promise<boolean>>();
 const MAX_APP_MIDDLEWARE_FILE_CACHE_ENTRIES = 1024;
+const devAppMiddlewareFileCache = new Map<string, { directoryStat: FileStat; hasMiddleware: boolean }>();
 const routeMiddlewareControlSourceCache = new Map<
   string,
   { control: RouteMiddlewareControl | undefined; mtimeMs: number }
 >();
+const devServerSourceFileCache = new Map<string, { mtimeMs: number; size: number; source: string }>();
+const MAX_DEV_SERVER_SOURCE_FILE_CACHE_ENTRIES = 2048;
+
+interface FileStat {
+  mtimeMs: number;
+  size: number;
+}
+
+interface ShellStaticRenderEntry {
+  component: ServerComponent | StreamComponent;
+  hasOutOfOrderBoundary: boolean;
+  shellUsesAwait: boolean;
+}
 
 async function shellFilesForPage(
   appDir: string,
@@ -3716,6 +3813,36 @@ async function shellFilesForPage(
     }
   }
 
+  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: string, pageFile: string): Promise<ShellFile[]> {
   const shells = await existingRouteShellCandidates(appDir, pageFile, async (file) => {
     try {
       await access(file);
@@ -3730,15 +3857,6 @@ async function shellFilesForPage(
     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;
 }
 
@@ -3779,22 +3897,33 @@ async function hasAppMiddleware(options: {
     }
   }
 
-  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;
 }
@@ -3812,6 +3941,57 @@ async function hasAppMiddlewareUncached(files: readonly string[]): Promise<boole
   return false;
 }
 
+async function routeShellDirectoryStats(appDir: string, pageFile: string): Promise<FileStat[]> {
+  const directories: string[] = [];
+  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: string): Promise<FileStat> {
+  const stats = await stat(file);
+  return { mtimeMs: stats.mtimeMs, size: stats.size };
+}
+
+async function fileStatOrMissing(file: string): Promise<FileStat> {
+  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: readonly FileStat[], right: readonly FileStat[]): boolean {
+  return (
+    left.length === right.length &&
+    left.every((value, index) => {
+      const other = right[index];
+      return other !== undefined && sameFileStat(value, other);
+    })
+  );
+}
+
+function sameFileStat(left: FileStat, right: FileStat): boolean {
+  return left.mtimeMs === right.mtimeMs && left.size === right.size;
+}
+
 async function loadRouteMiddlewareControl(options: {
   appDir: string;
   pageFile: string;
@@ -4335,10 +4515,9 @@ async function loadComposedRouteMetadataUncached(options: {
   );
   const metadata: RouteMetadata[] = [];
   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(
@@ -4346,7 +4525,6 @@ async function loadComposedRouteMetadataUncached(options: {
       options.serverModuleCacheVersion,
       options.serverSourceFiles,
     );
-    dynamic ||= hasGenerateMetadataExport(code);
     const shellMetadata = await loadRouteMetadata({
       appDir: options.appDir,
       code,
@@ -4359,12 +4537,9 @@ async function loadComposedRouteMetadataUncached(options: {
       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,
@@ -4376,6 +4551,17 @@ async function loadComposedRouteMetadataUncached(options: {
     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);
   }
@@ -4632,7 +4818,7 @@ function readServerSourceFile(
   }
 
   if (serverModuleCacheVersion === undefined) {
-    return readFile(file, "utf8");
+    return readDevServerSourceFile(file);
   }
 
   const key = `${serverModuleCacheVersion}:${file}`;
@@ -4661,6 +4847,28 @@ function readServerSourceFile(
   return loaded;
 }
 
+async function readDevServerSourceFile(file: string): Promise<string> {
+  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<K, V>(
   cache: Map<K, V>,
   key: K,