@reckona/mreact-router 0.0.138 → 0.0.139

package/src/route-source.ts

@@ -142,7 +142,7 @@ export function mayUseAwaitBoundarySource(code: string): boolean {
 
 export function routeClosureMayUseAwaitBoundary(options: {
   filename: string;
-  files: Record<string, string>;
+  files: RouteSourceLookup;
   projectRoot: string;
   seen?: Set<string> | undefined;
   source: string;
@@ -184,16 +184,13 @@ export function routeClosureMayUseAwaitBoundary(options: {
         continue;
       }
 
-      const importedSource = options.files[resolved];
-
       if (
-        importedSource !== undefined &&
         routeClosureMayUseAwaitBoundary({
-          filename: resolved,
+          filename: resolved.filename,
           files: options.files,
           projectRoot: options.projectRoot,
           seen,
-          source: importedSource,
+          source: resolved.source,
         })
       ) {
         return true;
@@ -243,10 +240,10 @@ function isRenderedStaticImportReference(
 }
 
 function resolveLocalSourceImport(
-  files: Record<string, string>,
+  files: RouteSourceLookup,
   importer: string,
   specifier: string,
-): string | undefined {
+): { filename: string; source: string } | undefined {
   if (!specifier.startsWith(".")) {
     return undefined;
   }
@@ -254,14 +251,21 @@ function resolveLocalSourceImport(
   const base = join(dirname(importer), specifier);
 
   for (const candidate of sourceModuleCandidates(base)) {
-    if (files[candidate] !== undefined) {
-      return candidate;
+    const source = readRouteSourceLookup(files, candidate);
+    if (source !== undefined) {
+      return { filename: candidate, source };
     }
   }
 
   return undefined;
 }
 
+type RouteSourceLookup = Record<string, string> | ((file: string) => string | undefined);
+
+function readRouteSourceLookup(files: RouteSourceLookup, file: string): string | undefined {
+  return typeof files === "function" ? files(file) : files[file];
+}
+
 function sourceFilenameForCompiler(projectRoot: string, filename: string): string {
   return isAbsolute(filename) ? filename : join(projectRoot, filename);
 }

package/src/route-styles.ts

@@ -7,21 +7,27 @@ export async function collectRouteCssFiles(options: {
   appDir: string;
   pageFile: string;
   projectRoot: string;
+  readSource?: ((file: string) => Promise<string | undefined> | string | undefined) | undefined;
 }): Promise<string[]> {
   return await collectRouteCssFilesFromSources({
     ...options,
-    readSource: (file) => readFile(file, "utf8"),
+    readSource: options.readSource ?? ((file) => readFile(file, "utf8")),
   });
 }
 
 export async function collectRouteCssFilesFromSources(options: {
   appDir: string;
+  isFile?: ((file: string) => Promise<boolean> | boolean) | undefined;
   pageFile: string;
   projectRoot: string;
   readSource: (file: string) => Promise<string | undefined> | string | undefined;
 }): Promise<string[]> {
-  const shellFiles = (await existingRouteShellCandidates(options.appDir, options.pageFile, isFile))
-    .map((candidate) => candidate.file);
+  const fileExists = options.isFile ?? isFile;
+  const shellFiles = (
+    await existingRouteShellCandidates(options.appDir, options.pageFile, async (file) =>
+      fileExists(file),
+    )
+  ).map((candidate) => candidate.file);
   const files = [...shellFiles, options.pageFile];
   const seen = new Set<string>();
   const cssFiles: string[] = [];
@@ -57,6 +63,7 @@ export async function collectRouteCssHrefs(options: {
   hrefPrefix?: string | undefined;
   pageFile: string;
   projectRoot: string;
+  readSource?: ((file: string) => Promise<string | undefined> | string | undefined) | undefined;
 }): Promise<string[]> {
   return (await collectRouteCssFiles(options)).map((file) => {
     const href = `/${relative(options.projectRoot, file).split(sep).join("/")}`;
@@ -65,6 +72,24 @@ export async function collectRouteCssHrefs(options: {
   });
 }
 
+export function createCachedRouteSourceReader(
+  readSource: (file: string) => Promise<string | undefined> | string | undefined = (file) =>
+    readFile(file, "utf8"),
+): (file: string) => Promise<string | undefined> {
+  const cache = new Map<string, Promise<string | undefined>>();
+
+  return (file) => {
+    const cached = cache.get(file);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const loaded = Promise.resolve(readSource(file));
+    cache.set(file, loaded);
+    return loaded;
+  };
+}
+
 export async function collectSpecialBoundaryFiles(directory: string): Promise<string[]> {
   const entries = await readdir(directory, { withFileTypes: true });
   const files: string[] = [];

package/src/serve.ts

@@ -9,7 +9,12 @@ import type {
 } from "./build.js";
 import type { AppRouterCache } from "./cache.js";
 import type { ClientRouteManifestEntry } from "./client-route-inference.js";
-import { createRouteMatcher, type AppRoute, type RouteMatcher } from "./routes.js";
+import {
+  createRouteMatcher,
+  type AppRoute,
+  type MatchedRoute,
+  type RouteMatcher,
+} from "./routes.js";
 import type { AppRouterServerActionOptions } from "./actions.js";
 import type { AppRouterImportPolicy } from "./import-policy.js";
 import {
@@ -76,6 +81,7 @@ interface BuiltRuntime {
   >;
   serverActionManifest?: readonly { moduleId: string; exportName: string; inferred?: boolean }[] | undefined;
   serverModuleArtifactLoads: Map<string, Promise<void>>;
+  serverModuleClosureFiles: Map<string, readonly string[]>;
   serverModuleFiles: ReadonlyMap<string, string>;
   serverModuleRenderFiles: ReadonlyMap<string, string>;
   serverModuleRequestFiles: ReadonlyMap<string, string>;
@@ -436,9 +442,11 @@ async function renderBuiltAppRequestWithRuntime(
     emitBuiltRenderTiming(options, request, timing, middlewareResult.response.status);
     return middlewareResult.response;
   }
-  request = middlewareResult.request;
-  normalizedPath = normalizeRoutePath(new URL(request.url).pathname);
-  matched = options.runtime.routeMatcher.match(normalizedPath);
+  if (middlewareResult.request !== request) {
+    request = middlewareResult.request;
+    normalizedPath = normalizeRoutePath(new URL(request.url).pathname);
+    matched = options.runtime.routeMatcher.match(normalizedPath);
+  }
 
   if (request.method === "GET" && options.runtime.prerenderableRoutes.has(normalizedPath)) {
     await loadBuiltServerModuleArtifactsForRequest(options.runtime, matched?.route.file, {
@@ -450,7 +458,12 @@ async function renderBuiltAppRequestWithRuntime(
   await loadBuiltServerModuleArtifactsForRequest(options.runtime, matched?.route.file, {
     includeRender: false,
   });
-  const response = await renderBuiltDynamicResponse({ ...options, request });
+  const response = await renderBuiltDynamicResponse({
+    ...options,
+    matchedRoute: matched,
+    request,
+    requestUrl: new URL(request.url),
+  });
 
   await applyBuiltPrerenderInvalidations(
     options.runtime,
@@ -1002,6 +1015,7 @@ async function materializeBuiltRuntime(options: {
       ? {}
       : { serverActionManifest: serverManifest.serverActionManifest }),
     serverModuleArtifactLoads: new Map(),
+    serverModuleClosureFiles: new Map(),
     serverModuleFiles,
     serverModuleRenderFiles,
     serverModuleRequestFiles,
@@ -1273,34 +1287,63 @@ async function loadBuiltServerModuleArtifactClosure(
   seen: Set<string>,
   kind: BuiltServerModuleArtifactKind,
 ): Promise<void> {
+  for (const closureFile of builtServerModuleClosureFiles(runtime, file)) {
+    if (seen.has(closureFile)) {
+      continue;
+    }
+    seen.add(closureFile);
+    await loadBuiltServerModuleArtifact(runtime, closureFile, kind);
+  }
+}
+
+function builtServerModuleClosureFiles(
+  runtime: BuiltRuntime,
+  file: string,
+): readonly string[] {
+  const cached = runtime.serverModuleClosureFiles.get(file);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const closure: string[] = [];
+  collectBuiltServerModuleClosureFiles(runtime, file, new Set(), closure);
+  runtime.serverModuleClosureFiles.set(file, closure);
+  return closure;
+}
+
+function collectBuiltServerModuleClosureFiles(
+  runtime: BuiltRuntime,
+  file: string,
+  seen: Set<string>,
+  closure: string[],
+): void {
   if (seen.has(file)) {
     return;
   }
   seen.add(file);
-
-  await loadBuiltServerModuleArtifact(runtime, file, kind);
+  closure.push(file);
 
   const source = runtime.serverSourceFiles.get(file);
-
   if (source === undefined) {
     return;
   }
 
   for (const specifier of localServerModuleSpecifiers(source)) {
     const resolved = resolveBuiltLocalServerSourceImport(runtime, file, specifier);
-
     if (resolved !== undefined) {
-      await loadBuiltServerModuleArtifactClosure(runtime, resolved, seen, kind);
+      collectBuiltServerModuleClosureFiles(runtime, resolved, seen, closure);
     }
   }
 }
 
+const localServerModuleImportPattern =
+  /\b(?:import|export)\s+(?:type\s+)?(?:[^"']*?\s+from\s*)?["'](?<source>\.{1,2}\/[^"']+)["']/g;
+
 function localServerModuleSpecifiers(code: string): string[] {
   const specifiers = new Set<string>();
-  const importPattern =
-    /\b(?:import|export)\s+(?:type\s+)?(?:[^"']*?\s+from\s*)?["'](?<source>\.{1,2}\/[^"']+)["']/g;
+  localServerModuleImportPattern.lastIndex = 0;
 
-  for (const match of code.matchAll(importPattern)) {
+  for (const match of code.matchAll(localServerModuleImportPattern)) {
     const source = match.groups?.source;
 
     if (source !== undefined) {
@@ -1380,13 +1423,21 @@ async function readPrerenderedRoute(
 }
 
 function renderBuiltDynamicResponse(
-  options: RenderBuiltAppRequestOptions & { runtime: BuiltRuntime },
+  options: RenderBuiltAppRequestOptions & {
+    matchedRoute?: MatchedRoute | undefined;
+    requestUrl?: URL | undefined;
+    runtime: BuiltRuntime;
+  },
 ): Promise<Response> {
   return renderAppRequest(builtRenderAppRequestOptions(options));
 }
 
 function builtRenderAppRequestOptions(
-  options: RenderBuiltAppRequestOptions & { runtime: BuiltRuntime },
+  options: RenderBuiltAppRequestOptions & {
+    matchedRoute?: MatchedRoute | undefined;
+    requestUrl?: URL | undefined;
+    runtime: BuiltRuntime;
+  },
 ): RenderAppRequestOptions {
   const renderOptions: RenderAppRequestOptions & {
     __mreactLoadServerRenderArtifacts?: ((routeFile: string) => Promise<void>) | undefined;
@@ -1404,9 +1455,11 @@ function builtRenderAppRequestOptions(
     request: options.request,
     instrumentation: options.instrumentation,
     logger: options.logger,
+    matchedRoute: options.matchedRoute,
     navigationScripts: options.runtime.navigationScripts,
     routeCache: options.routeCache,
     routeMatcher: options.runtime.routeMatcher,
+    requestUrl: options.requestUrl,
     routes: options.runtime.routes,
     __mreactLoadServerRenderArtifacts: async (routeFile: string) => {
       await loadBuiltServerModuleArtifactsForRequest(options.runtime, routeFile, {

package/src/server-action-inference.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
 import { dirname, relative, sep } from "node:path";
 import {
   analyzeBoundaryGraph,
@@ -10,6 +11,8 @@ import type * as Ts from "typescript";
 
 let ts = undefined as unknown as typeof Ts;
 let typescriptLoaded = false;
+const runtimeInferenceCache = new Map<string, RuntimeInferenceCacheEntry>();
+const maxRuntimeInferenceCacheEntries = 512;
 
 export interface InferredServerActionReference {
   exportName: string;
@@ -63,6 +66,16 @@ export async function collectRuntimeInferredServerActions(options: {
     return { diagnostics: [], references: new Map() };
   }
 
+  const sourceHash = formActionSourceHash(options.code);
+  const cacheKey = `${options.appDir}\0${options.pageFile}\0${sourceHash}`;
+  const cached = runtimeInferenceCache.get(cacheKey);
+  if (cached !== undefined && (await runtimeInferenceCacheEntryIsFresh(cached))) {
+    return {
+      diagnostics: cached.diagnostics.map((diagnostic) => ({ ...diagnostic })),
+      references: new Map(cached.references),
+    };
+  }
+
   await loadTypeScript();
   const program = ts.createProgram({
     host: createRuntimeProgramHost({
@@ -121,6 +134,17 @@ export async function collectRuntimeInferredServerActions(options: {
     }
   }
 
+  const dependencies = await runtimeProgramDependencyStats({
+    appDir: options.appDir,
+    pageFile: options.pageFile,
+    program,
+  });
+  setRuntimeInferenceCacheEntry(cacheKey, {
+    dependencies,
+    diagnostics: diagnostics.map((diagnostic) => ({ ...diagnostic })),
+    references: new Map(references),
+  });
+
   return { diagnostics, references };
 }
 
@@ -792,6 +816,67 @@ function createRuntimeProgramHost(options: {
   };
 }
 
+interface RuntimeInferenceCacheEntry {
+  dependencies: readonly RuntimeInferenceDependency[];
+  diagnostics: readonly ServerActionInferenceDiagnostic[];
+  references: ReadonlyMap<string, InferredServerActionReference>;
+}
+
+interface RuntimeInferenceDependency {
+  file: string;
+  mtimeMs: number;
+  size: number;
+}
+
+async function runtimeProgramDependencyStats(options: {
+  appDir: string;
+  pageFile: string;
+  program: Ts.Program;
+}): Promise<RuntimeInferenceDependency[]> {
+  const dependencies = options.program
+    .getSourceFiles()
+    .map((sourceFile) => sourceFile.fileName)
+    .filter((file) => file !== options.pageFile && isInsideAppDir(options.appDir, file));
+  const uniqueDependencies = [...new Set(dependencies)];
+
+  return await Promise.all(
+    uniqueDependencies.map(async (file) => {
+      const stats = await stat(file);
+      return { file, mtimeMs: stats.mtimeMs, size: stats.size };
+    }),
+  );
+}
+
+async function runtimeInferenceCacheEntryIsFresh(
+  entry: RuntimeInferenceCacheEntry,
+): Promise<boolean> {
+  for (const dependency of entry.dependencies) {
+    try {
+      const stats = await stat(dependency.file);
+      if (stats.mtimeMs !== dependency.mtimeMs || stats.size !== dependency.size) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function setRuntimeInferenceCacheEntry(
+  key: string,
+  entry: RuntimeInferenceCacheEntry,
+): void {
+  if (runtimeInferenceCache.size >= maxRuntimeInferenceCacheEntries) {
+    const oldestKey = runtimeInferenceCache.keys().next().value;
+    if (oldestKey !== undefined) {
+      runtimeInferenceCache.delete(oldestKey);
+    }
+  }
+  runtimeInferenceCache.set(key, entry);
+}
+
 function defaultCompilerOptions(): Ts.CompilerOptions {
   return {
     allowJs: true,
@@ -819,6 +904,7 @@ export function __readServerActionInferenceTypeScriptLoadedForTests(): boolean {
 export function __resetServerActionInferenceTypeScriptForTests(): void {
   ts = undefined as unknown as typeof Ts;
   typescriptLoaded = false;
+  runtimeInferenceCache.clear();
 }
 
 function formActionOccurrenceKey(reference: {

package/src/vite.ts

@@ -39,8 +39,12 @@ import {
 import { nodeRequestToWebRequest, sendResponse } from "./http.js";
 import { renderAppRequest } from "./render.js";
 import { stripRouteClientOnlyExports } from "./route-source.js";
-import { collectRouteCssHrefs, collectSpecialBoundaryFiles } from "./route-styles.js";
-import { scanAppRoutes } from "./routes.js";
+import {
+  collectRouteCssHrefs,
+  collectSpecialBoundaryFiles,
+  createCachedRouteSourceReader,
+} from "./route-styles.js";
+import { createRouteMatcher, scanAppRoutes, type AppRoute } from "./routes.js";
 import { resolveRequestHost, type RequestHostPolicy } from "./serve.js";
 import { hasJsxSyntax } from "./source-jsx.js";
 import { workspacePackageFile } from "./workspace-packages.js";
@@ -521,6 +525,20 @@ async function handleAppRouterViteRequest(
 
     const request = nodeRequestToWebRequest(incoming, origin);
     const routeTransformPlugins = options.navigationScanVitePlugins ?? options.vitePlugins;
+    const routes = await scanAppRoutes({ appDir: project.routesDir });
+    const routeMatcher = createRouteMatcher(routes);
+    const readRouteSource = createCachedRouteSourceReader();
+    const [clientStyles, clientStylesByFile, navigationScripts] = await Promise.all([
+      devRouteStyles(project, routes, readRouteSource),
+      devSpecialRouteStyles(project, readRouteSource),
+      devNavigationScripts(
+        project.routesDir,
+        routes,
+        readRouteSource,
+        options.clientRouteInferenceCache,
+        routeTransformPlugins,
+      ),
+    ]);
 
     await sendResponse(
       outgoing,
@@ -532,15 +550,14 @@ async function handleAppRouterViteRequest(
           allowedSourceDirs: project.allowedSourceDirs,
           projectRoot: project.projectRoot,
         },
-        clientStyles: await devRouteStyles(project),
-        clientStylesByFile: await devSpecialRouteStyles(project),
-        navigationScripts: await devNavigationScripts(
-          project.routesDir,
-          options.clientRouteInferenceCache,
-          routeTransformPlugins,
-        ),
+        clientStyles,
+        clientStylesByFile,
+        clientRouteInferenceCache: options.clientRouteInferenceCache,
+        navigationScripts,
         request,
         routeCache: options.routeCache,
+        routeMatcher,
+        routes,
         serverActions: options.serverActions,
         vitePlugins: routeTransformPlugins,
       }),
@@ -796,9 +813,11 @@ function clientAssetBuildErrorResponse(filename: string, error: unknown): Respon
 
 async function devRouteStyles(
   project: ResolvedAppRouterProject,
+  routes: readonly AppRoute[],
+  readSource: (file: string) => Promise<string | undefined>,
 ): Promise<ReadonlyMap<string, readonly string[]>> {
   const entries = await Promise.all(
-    (await scanAppRoutes({ appDir: project.routesDir })).map(async (route) => {
+    routes.map(async (route) => {
       if (route.kind !== "page") {
         return undefined;
       }
@@ -808,6 +827,7 @@ async function devRouteStyles(
         hrefPrefix: devCssPrefix,
         pageFile: route.file,
         projectRoot: project.projectRoot,
+        readSource,
       });
 
       return hrefs.length === 0 ? undefined : ([route.path, hrefs as readonly string[]] as const);
@@ -822,6 +842,7 @@ async function devRouteStyles(
 
 async function devSpecialRouteStyles(
   project: ResolvedAppRouterProject,
+  readSource: (file: string) => Promise<string | undefined>,
 ): Promise<ReadonlyMap<string, readonly string[]>> {
   const entries = await Promise.all(
     (await collectSpecialBoundaryFiles(project.routesDir)).map(async (file) => {
@@ -830,6 +851,7 @@ async function devSpecialRouteStyles(
         hrefPrefix: devCssPrefix,
         pageFile: file,
         projectRoot: project.projectRoot,
+        readSource,
       });
 
       return hrefs.length === 0 ? undefined : ([file, hrefs as readonly string[]] as const);
@@ -844,17 +866,22 @@ async function devSpecialRouteStyles(
 
 async function devNavigationScripts(
   appDir: string,
+  routes: readonly AppRoute[],
+  readSource: (file: string) => Promise<string | undefined>,
   inferenceCache?: ClientRouteInferenceCache | undefined,
   vitePlugins?: readonly PluginOption[] | undefined,
 ): Promise<ReadonlyMap<string, string>> {
   const cache = inferenceCache ?? createClientRouteInferenceCache();
   const entries = await Promise.all(
-    (await scanAppRoutes({ appDir })).map(async (route) => {
+    routes.map(async (route) => {
       if (route.kind !== "page") {
         return undefined;
       }
 
-      const source = await readFile(route.file, "utf8");
+      const source = await readSource(route.file);
+      if (source === undefined) {
+        return undefined;
+      }
       const navigation = await resolveNavigationRuntime({
         appDir,
         cache,