@reckona/mreact-router 0.0.96 → 0.0.98

package/src/build.ts

@@ -2,7 +2,9 @@ import { createHash } from "node:crypto";
 import type { Dirent } from "node:fs";
 import { copyFile, cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
+import { availableParallelism } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   collectStaticImportReferences,
   collectTopLevelValueExportNames,
@@ -30,7 +32,11 @@ import {
   routeIdForPath,
   type BuildClientRouteOutputOptions,
 } from "./navigation-runtime.js";
-import { bundleAppRouterSourceModule, importAppRouterSourceModule } from "./module-runner.js";
+import {
+  bundleAppRouterSourceModule,
+  fileImportMetaUrlPlugin,
+  importAppRouterSourceModule,
+} from "./module-runner.js";
 import { scanAppRoutes } from "./routes.js";
 import type { AppRoute } from "./routes.js";
 import {
@@ -64,12 +70,16 @@ import {
 } from "./route-source.js";
 import {
   bundleRouterModule,
+  bundleRouterModules,
   type RouterCompatPlugin,
+  type RouterBundleChunkOutput,
+  type RouterBundleOutput,
 } from "./bundle-pipeline.js";
-import { collectRouteCssFiles } from "./route-styles.js";
+import { collectRouteCssFilesFromSources } from "./route-styles.js";
 import { existingRouteShellCandidates } from "./route-shells.js";
 import { sourceModuleCandidates } from "./source-modules.js";
 import { collectBuildInferredServerActions } from "./server-action-inference.js";
+import { vitePluginsCacheKey } from "./vite-plugin-cache-key.js";
 import { workspacePackageFile } from "./workspace-packages.js";
 import type { PluginOption, UserConfig } from "vite";
 
@@ -78,12 +88,42 @@ const nativeEscapeTransform = {
   batchImportSource: "@reckona/mreact-router/native-escape",
 } as const;
 
+const defaultBuildConcurrency = Math.max(1, Math.min(2, availableParallelism()));
+const serverArtifactFilesystemConcurrency = 2;
+
+type ServerTransformOutput = ReturnType<typeof transform>;
+type ServerTransformCache = Map<string, Promise<ServerTransformOutput>>;
+
 export interface BuildAppOptions extends AppRouterProjectOptions {
+  onBuildPhaseTiming?: ((timing: BuildAppPhaseTiming) => void) | undefined;
   outDir: string;
   targets?: readonly AppRouterBuildTarget[] | undefined;
   viteConfig?: Pick<UserConfig, "plugins"> | undefined;
 }
 
+export type BuildAppPhase =
+  | "scan"
+  | "collectFiles"
+  | "analyzeSources"
+  | "validate"
+  | "prepareOutput"
+  | "publicAssets"
+  | "serverActionManifest"
+  | "serverModules"
+  | "importPolicy"
+  | "serverModuleArtifacts"
+  | "clientBundles"
+  | "navigationRuntime"
+  | "prerender"
+  | "cloudflare"
+  | "writeManifests"
+  | "adapterArtifacts";
+
+export interface BuildAppPhaseTiming {
+  ms: number;
+  phase: BuildAppPhase;
+}
+
 export interface BuildAppResult {
   routes: AppRoute[];
 }
@@ -112,6 +152,7 @@ export interface CloudflarePagesArtifactManifest {
 
 export interface PackageAwsLambdaArtifactOptions {
   fromDir: string;
+  handlerEntry?: string | undefined;
   outDir: string;
   skipRuntimeDependencyCheck?: boolean | undefined;
 }
@@ -178,6 +219,32 @@ export interface BuiltRouteSourceAnalysisSummary {
   usesRuntimeCacheControl: boolean;
 }
 
+interface BuildSourceAnalysis {
+  authIncludesClaims: boolean;
+  cachePolicy?: RouteCachePolicy | undefined;
+  hasGenerateStaticParams: boolean;
+  hasLoader: boolean;
+  hasMetadata: boolean;
+  hasPrerender: boolean;
+  source: string;
+  sourceHash: string;
+  usesRuntimeCacheControl: boolean;
+}
+
+interface BuildRouteSourceAnalysis extends BuildSourceAnalysis {
+  clientBoundaryImports: readonly string[];
+  clientRoute: boolean;
+  file: string;
+  route: AppRoute & { kind: "page" };
+  routeCode: string;
+  streamRoute: boolean;
+}
+
+interface BuildSourceAnalysisScope {
+  byFile: ReadonlyMap<string, BuildSourceAnalysis>;
+  byRouteFile: ReadonlyMap<string, BuildRouteSourceAnalysis>;
+}
+
 export interface BuiltServerModuleOutput {
   bundleCode?: string;
   code: string;
@@ -195,84 +262,217 @@ export interface BuiltPrerenderedRoute {
 type StaticParams = Record<string, string | number | boolean | readonly string[]>;
 
 export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult> {
+  const timingSink = options.onBuildPhaseTiming;
   const project = resolveAppRouterProjectOptions(options);
   const buildTargets = resolveBuildTargets(options.targets ?? project.buildTargets);
   const shouldBuildCloudflare = buildTargets.includes("cloudflare");
   const shouldBuildAwsLambda = buildTargets.includes("aws-lambda");
-  const routes = await scanAppRoutes({ appDir: project.routesDir });
+  const routes =
+    timingSink === undefined
+      ? await scanAppRoutes({ appDir: project.routesDir })
+      : await timeBuildPhase(timingSink, "scan", () =>
+          scanAppRoutes({ appDir: project.routesDir }),
+        );
   const vitePlugins = options.viteConfig?.plugins;
-  const files = await collectBuildFiles(
-    project.projectRoot,
-    project.allowedSourceDirs,
-    project.routesDir,
-  );
+  const files =
+    timingSink === undefined
+      ? await collectBuildFiles(project.projectRoot, project.allowedSourceDirs, project.routesDir)
+      : await timeBuildPhase(timingSink, "collectFiles", () =>
+          collectBuildFiles(project.projectRoot, project.allowedSourceDirs, project.routesDir),
+        );
+  const serverClientRouteInferenceCache = createClientRouteInferenceCache();
+  const serverTransformCache: ServerTransformCache = new Map();
   const serverDir = join(options.outDir, "server");
   const clientDir = join(options.outDir, "client");
   const cloudflareDir = join(options.outDir, "cloudflare");
+  const sourceAnalysis =
+    timingSink === undefined
+      ? await analyzeBuildRouteSources({
+          clientRouteInferenceCache: serverClientRouteInferenceCache,
+          files,
+          project,
+          projectRoot: project.projectRoot,
+          routes,
+          vitePlugins,
+        })
+      : await timeBuildPhase(timingSink, "analyzeSources", () =>
+          analyzeBuildRouteSources({
+            clientRouteInferenceCache: serverClientRouteInferenceCache,
+            files,
+            project,
+            projectRoot: project.projectRoot,
+            routes,
+            vitePlugins,
+          }),
+        );
 
-  await validateProductionRoutes({ files, projectRoot: project.projectRoot, routes });
+  if (timingSink === undefined) {
+    await validateProductionRoutes({
+      clientRouteInferenceCache: serverClientRouteInferenceCache,
+      files,
+      project,
+      projectRoot: project.projectRoot,
+      routes,
+      sourceAnalysis,
+      serverTransformCache,
+      vitePlugins,
+    });
+  } else {
+    await timeBuildPhase(timingSink, "validate", () =>
+      validateProductionRoutes({
+        clientRouteInferenceCache: serverClientRouteInferenceCache,
+        files,
+        project,
+        projectRoot: project.projectRoot,
+        routes,
+        sourceAnalysis,
+        serverTransformCache,
+        vitePlugins,
+      }),
+    );
+  }
 
-  await rm(options.outDir, { force: true, recursive: true });
-  await mkdir(serverDir, { recursive: true });
-  await mkdir(clientDir, { recursive: true });
-  if (shouldBuildCloudflare) {
-    await mkdir(cloudflareDir, { recursive: true });
-  }
-  await mkdir(join(clientDir, ".vite"), { recursive: true });
-  await mkdir(join(clientDir, "assets", "routes"), { recursive: true });
-  await copyPublicAssets(project.publicDir, join(clientDir, "public"));
-  const appConventionPublicAssets = await copyAppFileConventionAssets(
-    project.routesDir,
-    clientDir,
-  );
-  await copyPublicAssets(project.publicDir, clientDir);
-  const publicAssets = [
-    ...new Set([...(await collectPublicAssetPaths(project.publicDir)), ...appConventionPublicAssets]),
-  ].sort();
+  if (timingSink === undefined) {
+    await rm(options.outDir, { force: true, recursive: true });
+    await Promise.all([
+      mkdir(serverDir, { recursive: true }),
+      mkdir(clientDir, { recursive: true }),
+      ...(shouldBuildCloudflare ? [mkdir(cloudflareDir, { recursive: true })] : []),
+      mkdir(join(clientDir, ".vite"), { recursive: true }),
+      mkdir(join(clientDir, "assets", "routes"), { recursive: true }),
+    ]);
+  } else {
+    await timeBuildPhase(timingSink, "prepareOutput", async () => {
+      await rm(options.outDir, { force: true, recursive: true });
+      await Promise.all([
+        mkdir(serverDir, { recursive: true }),
+        mkdir(clientDir, { recursive: true }),
+        ...(shouldBuildCloudflare ? [mkdir(cloudflareDir, { recursive: true })] : []),
+        mkdir(join(clientDir, ".vite"), { recursive: true }),
+        mkdir(join(clientDir, "assets", "routes"), { recursive: true }),
+      ]);
+    });
+  }
+
+  const publicAssets =
+    timingSink === undefined
+      ? await buildPublicAssetManifest(project, clientDir)
+      : await timeBuildPhase(timingSink, "publicAssets", () =>
+          buildPublicAssetManifest(project, clientDir),
+        );
 
-  const serverActionManifest = await collectBuildServerActionManifest({
-    files,
-    projectRoot: project.projectRoot,
-    routes,
-    routesDir: project.routesDir,
-  });
   const clientRouteInferenceCache = createClientRouteInferenceCache();
-  const serverModules = await buildServerModuleArtifacts({
-    clientRouteInferenceCache,
-    files,
-    prebundleServerComponents: buildTargets.includes("node") || shouldBuildAwsLambda,
-    project,
-    projectRoot: project.projectRoot,
-    routes,
-    vitePlugins,
-  });
-  const generatedImportPolicy = await buildGeneratedImportPolicy({
-    files,
-    projectRoot: project.projectRoot,
-    routes,
-    routesDir: project.routesDir,
-  });
-  const serverModuleArtifacts = await writeServerModuleArtifactFiles(serverDir, serverModules);
+  const [serverActionManifest, serverModules, generatedImportPolicy] = await Promise.all([
+    timingSink === undefined
+      ? collectBuildServerActionManifest({
+          files,
+          projectRoot: project.projectRoot,
+          routes,
+          routesDir: project.routesDir,
+        })
+      : timeBuildPhase(timingSink, "serverActionManifest", () =>
+          collectBuildServerActionManifest({
+            files,
+            projectRoot: project.projectRoot,
+            routes,
+            routesDir: project.routesDir,
+          }),
+        ),
+    timingSink === undefined
+      ? buildServerModuleArtifacts({
+          bundleCache: new Map(),
+          clientRouteInferenceCache: serverClientRouteInferenceCache,
+          files,
+          prebundleServerComponents: buildTargets.includes("node") || shouldBuildAwsLambda,
+          project,
+          projectRoot: project.projectRoot,
+          routes,
+          sourceAnalysis,
+          serverTransformCache,
+          vitePlugins,
+        })
+      : timeBuildPhase(timingSink, "serverModules", () =>
+          buildServerModuleArtifacts({
+            bundleCache: new Map(),
+            clientRouteInferenceCache: serverClientRouteInferenceCache,
+            files,
+            prebundleServerComponents: buildTargets.includes("node") || shouldBuildAwsLambda,
+            project,
+            projectRoot: project.projectRoot,
+            routes,
+            sourceAnalysis,
+            serverTransformCache,
+            vitePlugins,
+          }),
+        ),
+    timingSink === undefined
+      ? buildGeneratedImportPolicy({
+          files,
+          projectRoot: project.projectRoot,
+          routes,
+          routesDir: project.routesDir,
+        })
+      : timeBuildPhase(timingSink, "importPolicy", () =>
+          buildGeneratedImportPolicy({
+            files,
+            projectRoot: project.projectRoot,
+            routes,
+            routesDir: project.routesDir,
+          }),
+        ),
+  ]);
   const serverRoutes = routes.map((route) => ({
     ...route,
     file: relative(project.projectRoot, route.file),
   }));
-  const clientRoutes = await writeClientRouteBundles({
-    appDir: project.routesDir,
-    assetBaseUrl: project.assetBaseUrl,
-    clientDir,
-    clientConsolePureFunctions: project.clientConsolePureFunctions,
-    clientRouteInferenceCache,
-    projectRoot: project.projectRoot,
-    routes,
-    sourceMapDir: join(options.outDir, "source-maps", "client"),
-    sourceMaps: project.clientSourceMaps,
-    vitePlugins,
-  });
+  const [serverModuleArtifacts, clientRoutes] = await Promise.all([
+    timingSink === undefined
+      ? writeServerModuleArtifactFiles(serverDir, serverModules, generatedImportPolicy.runtimePackages)
+      : timeBuildPhase(timingSink, "serverModuleArtifacts", () =>
+          writeServerModuleArtifactFiles(
+            serverDir,
+            serverModules,
+            generatedImportPolicy.runtimePackages,
+          ),
+        ),
+    timingSink === undefined
+      ? writeClientRouteBundles({
+          appDir: project.routesDir,
+          assetBaseUrl: project.assetBaseUrl,
+          clientDir,
+          clientConsolePureFunctions: project.clientConsolePureFunctions,
+          clientRouteInferenceCache,
+          projectRoot: project.projectRoot,
+          routes,
+          sourceAnalysis,
+          sourceMapDir: join(options.outDir, "source-maps", "client"),
+          sourceMaps: project.clientSourceMaps,
+          vitePlugins,
+        })
+      : timeBuildPhase(timingSink, "clientBundles", () =>
+          writeClientRouteBundles({
+            appDir: project.routesDir,
+            assetBaseUrl: project.assetBaseUrl,
+            clientDir,
+            clientConsolePureFunctions: project.clientConsolePureFunctions,
+            clientRouteInferenceCache,
+            projectRoot: project.projectRoot,
+            routes,
+            sourceAnalysis,
+            sourceMapDir: join(options.outDir, "source-maps", "client"),
+            sourceMaps: project.clientSourceMaps,
+            vitePlugins,
+          }),
+        ),
+  ]);
   const navigationRuntimeScript = clientRoutes.some(
     (route) => route.navigation === true && !route.client,
   )
-    ? await writeNavigationRuntimeBundle(clientDir, project.clientConsolePureFunctions)
+    ? timingSink === undefined
+      ? await writeNavigationRuntimeBundle(clientDir, project.clientConsolePureFunctions)
+      : await timeBuildPhase(timingSink, "navigationRuntime", () =>
+          writeNavigationRuntimeBundle(clientDir, project.clientConsolePureFunctions),
+        )
     : undefined;
   const clientManifestRoutes =
     navigationRuntimeScript === undefined
@@ -282,27 +482,58 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
             ? { ...route, navigationScript: navigationRuntimeScript }
             : route,
         );
-  const prerenderedRoutes = await prerenderStaticRoutes({
-    appDir: project.routesDir,
-    assetBaseUrl: project.assetBaseUrl,
-    clientRoutes: clientManifestRoutes,
-    project,
-    routes,
-    serverModules,
-    vitePlugins,
-  });
+  const prerenderedRoutes =
+    timingSink === undefined
+      ? await prerenderStaticRoutes({
+          appDir: project.routesDir,
+          assetBaseUrl: project.assetBaseUrl,
+          clientRoutes: clientManifestRoutes,
+          project,
+          routes,
+          serverModules,
+          sourceAnalysis,
+          vitePlugins,
+        })
+      : await timeBuildPhase(timingSink, "prerender", () =>
+          prerenderStaticRoutes({
+            appDir: project.routesDir,
+            assetBaseUrl: project.assetBaseUrl,
+            clientRoutes: clientManifestRoutes,
+            project,
+            routes,
+            serverModules,
+            sourceAnalysis,
+            vitePlugins,
+          }),
+        );
   let cloudflareRouteModules: CloudflareRouteModulesOutput | undefined;
   if (shouldBuildCloudflare) {
-    cloudflareRouteModules = await writeCloudflareRouteModules({
-      cloudflareDir,
-      files,
-      prerenderedRoutes,
-      projectRoot: project.projectRoot,
-      routesDir: project.routesDir,
-      routes,
-      serverModules,
-      vitePlugins,
-    });
+    cloudflareRouteModules =
+      timingSink === undefined
+        ? await writeCloudflareRouteModules({
+            cloudflareDir,
+            files,
+            prerenderedRoutes,
+            projectRoot: project.projectRoot,
+            routesDir: project.routesDir,
+            routes,
+            serverModules,
+            sourceAnalysis,
+            vitePlugins,
+          })
+        : await timeBuildPhase(timingSink, "cloudflare", () =>
+            writeCloudflareRouteModules({
+              cloudflareDir,
+              files,
+              prerenderedRoutes,
+              projectRoot: project.projectRoot,
+              routesDir: project.routesDir,
+              routes,
+              serverModules,
+              sourceAnalysis,
+              vitePlugins,
+            }),
+          );
   }
 
   const routeServerActionReferences = Object.fromEntries(
@@ -343,40 +574,246 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
     ...(publicAssets.length === 0 ? {} : { publicAssets }),
     routes: clientManifestRoutes,
   };
-  await writeFile(
-    join(serverDir, "manifest.json"),
-    JSON.stringify(serverManifest, null, 2),
-  );
-  await writeFile(
-    join(serverDir, "import-policy.json"),
-    JSON.stringify(generatedImportPolicy, null, 2),
-  );
-  await writeFile(
-    join(clientDir, "manifest.json"),
-    JSON.stringify(clientManifest, null, 2),
-  );
-  await writeFile(
-    join(clientDir, ".vite", "manifest.json"),
-    JSON.stringify(viteManifestFromClientRoutes(clientManifestRoutes), null, 2),
-  );
-  if (shouldBuildAwsLambda) {
-    await writeAwsLambdaHandlerArtifact(options.outDir);
+  const writeManifestFiles = async () => {
+    await Promise.all([
+      writeFile(join(serverDir, "manifest.json"), JSON.stringify(serverManifest, null, 2)),
+      writeFile(
+        join(serverDir, "import-policy.json"),
+        JSON.stringify(generatedImportPolicy, null, 2),
+      ),
+      writeFile(join(clientDir, "manifest.json"), JSON.stringify(clientManifest, null, 2)),
+      writeFile(
+        join(clientDir, ".vite", "manifest.json"),
+        JSON.stringify(viteManifestFromClientRoutes(clientManifestRoutes), null, 2),
+      ),
+    ]);
+  };
+  if (timingSink === undefined) {
+    await writeManifestFiles();
+  } else {
+    await timeBuildPhase(timingSink, "writeManifests", writeManifestFiles);
   }
-  if (shouldBuildCloudflare) {
-    await writeCloudflareWorkerArtifact({
-      cloudflareDir,
-      clientManifest,
-      modulesFile: cloudflareRouteModules?.registryFile ?? "route-modules.mjs",
-      serverManifest,
+
+  if (timingSink === undefined) {
+    await Promise.all([
+      ...(shouldBuildAwsLambda ? [writeAwsLambdaHandlerArtifact(options.outDir)] : []),
+      ...(shouldBuildCloudflare
+        ? [
+            writeCloudflareWorkerArtifact({
+              cloudflareDir,
+              clientManifest,
+              modulesFile: cloudflareRouteModules?.registryFile ?? "route-modules.mjs",
+              serverManifest,
+            }),
+          ]
+        : []),
+    ]);
+  } else {
+    await timeBuildPhase(timingSink, "adapterArtifacts", async () => {
+      await Promise.all([
+        ...(shouldBuildAwsLambda ? [writeAwsLambdaHandlerArtifact(options.outDir)] : []),
+        ...(shouldBuildCloudflare
+          ? [
+              writeCloudflareWorkerArtifact({
+                cloudflareDir,
+                clientManifest,
+                modulesFile: cloudflareRouteModules?.registryFile ?? "route-modules.mjs",
+                serverManifest,
+              }),
+            ]
+          : []),
+      ]);
     });
   }
 
   return { routes };
 }
 
+async function timeBuildPhase<T>(
+  sink: (timing: BuildAppPhaseTiming) => void,
+  phase: BuildAppPhase,
+  run: () => Promise<T>,
+): Promise<T> {
+  const startedAt = performance.now();
+
+  try {
+    return await run();
+  } finally {
+    sink({
+      ms: roundBuildPhaseMs(performance.now() - startedAt),
+      phase,
+    });
+  }
+}
+
+function roundBuildPhaseMs(value: number): number {
+  return Math.round(value * 100) / 100;
+}
+
+async function mapWithBuildConcurrency<T, R>(
+  items: readonly T[],
+  map: (item: T, index: number) => Promise<R>,
+  concurrency = defaultBuildConcurrency,
+): Promise<R[]> {
+  if (items.length === 0) {
+    return [];
+  }
+
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  const results: R[] = [];
+  results.length = items.length;
+  let nextIndex = 0;
+
+  async function runWorker(): Promise<void> {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await map(items[index] as T, index);
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      await runWorker();
+    }),
+  );
+
+  return results;
+}
+
+export async function __mapWithBuildConcurrencyForTests<T, R>(
+  items: readonly T[],
+  map: (item: T, index: number) => Promise<R>,
+  concurrency?: number,
+): Promise<R[]> {
+  return await mapWithBuildConcurrency(items, map, concurrency);
+}
+
+async function analyzeBuildRouteSources(options: {
+  clientRouteInferenceCache: ClientRouteInferenceCache;
+  files: Record<string, string>;
+  project: ResolvedAppRouterProject;
+  projectRoot: string;
+  routes: readonly AppRoute[];
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<BuildSourceAnalysisScope> {
+  const byFile = new Map<string, BuildSourceAnalysis>();
+
+  for (const [file, source] of Object.entries(options.files)) {
+    byFile.set(file, analyzeBuildSource(source, join(options.projectRoot, file)));
+  }
+
+  const routeAnalyses = await mapWithBuildConcurrency(
+    options.routes.filter((route): route is AppRoute & { kind: "page" } => route.kind === "page"),
+    async (route) => {
+      const file = relative(options.projectRoot, route.file).split(sep).join("/");
+      const source = options.files[file];
+
+      if (source === undefined) {
+        return undefined;
+      }
+
+      const routeCode = stripRouteBuildExports(source, route.file);
+      const clientInference = await inferClientRouteModule({
+        appDir: options.project.routesDir,
+        cache: options.clientRouteInferenceCache,
+        code: stripRouteClientSource({ code: source, filename: route.file }),
+        filename: route.file,
+        routePath: route.path,
+        vitePlugins: options.vitePlugins,
+      });
+
+      for (const diagnostic of clientInference.diagnostics) {
+        console.warn(formatClientRouteInferenceDiagnostic(diagnostic));
+      }
+
+      return [
+        file,
+        {
+          ...analyzeBuildSource(source, route.file),
+          clientBoundaryImports: clientInference.clientBoundaryImports,
+          clientRoute: clientInference.client,
+          file,
+          route,
+          routeCode,
+          streamRoute: shouldBuildRouteAsStream({
+            filename: file,
+            files: options.files,
+            projectRoot: options.projectRoot,
+            source,
+          }),
+        },
+      ] as const;
+    },
+  );
+  const byRouteFile = new Map<string, BuildRouteSourceAnalysis>();
+
+  for (const entry of routeAnalyses) {
+    if (entry !== undefined) {
+      byRouteFile.set(entry[0], entry[1]);
+    }
+  }
+
+  return { byFile, byRouteFile };
+}
+
+function analyzeBuildSource(source: string, filename: string): BuildSourceAnalysis {
+  const cachePolicy = routeCachePolicyFromSource(source);
+  const sourceHash = hashText(source);
+
+  if (!isSourceModuleFile(filename)) {
+    return {
+      authIncludesClaims: false,
+      ...(cachePolicy === undefined ? {} : { cachePolicy }),
+      hasGenerateStaticParams: false,
+      hasLoader: false,
+      hasMetadata: false,
+      hasPrerender: false,
+      source,
+      sourceHash,
+      usesRuntimeCacheControl: usesRuntimeCacheControl(source),
+    };
+  }
+
+  return {
+    authIncludesClaims: authIncludesClaims(source),
+    ...(cachePolicy === undefined ? {} : { cachePolicy }),
+    hasGenerateStaticParams: hasGenerateStaticParamsExport(source, filename),
+    hasLoader: hasLoaderExport(source, filename),
+    hasMetadata: hasMetadataExport(source),
+    hasPrerender: hasPrerenderExport(source, filename),
+    source,
+    sourceHash,
+    usesRuntimeCacheControl: usesRuntimeCacheControl(source),
+  };
+}
+
+function buildSourceAnalysisForFile(
+  sourceAnalysis: BuildSourceAnalysisScope,
+  projectRoot: string,
+  file: string,
+): BuildSourceAnalysis | undefined {
+  return sourceAnalysis.byFile.get(relative(projectRoot, file).split(sep).join("/"));
+}
+
+async function buildPublicAssetManifest(
+  project: ResolvedAppRouterProject,
+  clientDir: string,
+): Promise<string[]> {
+  const [publicAssetPaths, appConventionPublicAssets] = await Promise.all([
+    collectPublicAssetPaths(project.publicDir),
+    copyAppFileConventionAssets(project.routesDir, clientDir),
+    copyPublicAssets(project.publicDir, join(clientDir, "public")),
+    copyPublicAssets(project.publicDir, clientDir),
+  ]);
+
+  return [...new Set([...publicAssetPaths, ...appConventionPublicAssets])].sort();
+}
+
 async function writeServerModuleArtifactFiles(
   serverDir: string,
   serverModules: Record<string, BuiltServerModuleArtifact>,
+  portableRuntimePackages: readonly string[] = [],
 ): Promise<{
   files: Record<string, string>;
   renderFiles: Record<string, string>;
@@ -386,48 +823,94 @@ async function writeServerModuleArtifactFiles(
   const renderFiles: Record<string, string> = {};
   const requestFiles: Record<string, string> = {};
   const modulesDir = join(serverDir, "server-modules");
+  const artifactEntries = Object.entries(serverModules);
+  type WrittenServerModuleArtifact =
+    | { artifactFile: string; file: string }
+    | { file: string; renderArtifactFile: string; requestArtifactFile: string };
+
+  await Promise.all([
+    mkdir(modulesDir, { recursive: true }),
+    mkdir(join(modulesDir, "code"), { recursive: true }),
+    mkdir(join(modulesDir, "request"), { recursive: true }),
+    mkdir(join(modulesDir, "render"), { recursive: true }),
+  ]);
+
+  const writtenArtifacts = await mapWithBuildConcurrency<
+    [string, BuiltServerModuleArtifact],
+    WrittenServerModuleArtifact
+  >(
+    artifactEntries,
+    async ([file, artifact]) => {
+      const externalized = await externalizeServerModuleArtifactCode(
+        serverDir,
+        artifact,
+        portableRuntimePackages,
+      );
+      const requestArtifact = requestServerModuleArtifact(externalized);
+      const renderArtifact = renderServerModuleArtifact(externalized);
+
+      if (Object.keys(requestArtifact).length > 0 && Object.keys(renderArtifact).length > 0) {
+        const requestJson = JSON.stringify(requestArtifact);
+        const requestArtifactFile = `server-modules/request/${hashText(`${file}\0request\0${requestJson}`).slice(0, 16)}.json`;
+        await writeFile(join(serverDir, requestArtifactFile), requestJson);
+
+        const renderJson = JSON.stringify(renderArtifact);
+        const renderArtifactFile = `server-modules/render/${hashText(`${file}\0render\0${renderJson}`).slice(0, 16)}.json`;
+        await writeFile(join(serverDir, renderArtifactFile), renderJson);
+
+        return { file, renderArtifactFile, requestArtifactFile };
+      }
+
+      const json = JSON.stringify(externalized);
+      const artifactFile = `server-modules/${hashText(`${file}\0${json}`).slice(0, 16)}.json`;
 
-  for (const [file, artifact] of Object.entries(serverModules)) {
-    const externalized = await externalizeServerModuleArtifactCode(serverDir, artifact);
-    const requestArtifact = requestServerModuleArtifact(externalized);
-    const renderArtifact = renderServerModuleArtifact(externalized);
-
-    await mkdir(modulesDir, { recursive: true });
-
-    if (Object.keys(requestArtifact).length > 0 && Object.keys(renderArtifact).length > 0) {
-      const requestJson = JSON.stringify(requestArtifact);
-      const requestArtifactFile = `server-modules/request/${hashText(`${file}\0request\0${requestJson}`).slice(0, 16)}.json`;
-      await mkdir(join(modulesDir, "request"), { recursive: true });
-      await writeFile(join(serverDir, requestArtifactFile), requestJson);
-      requestFiles[file] = requestArtifactFile;
-
-      const renderJson = JSON.stringify(renderArtifact);
-      const renderArtifactFile = `server-modules/render/${hashText(`${file}\0render\0${renderJson}`).slice(0, 16)}.json`;
-      await mkdir(join(modulesDir, "render"), { recursive: true });
-      await writeFile(join(serverDir, renderArtifactFile), renderJson);
-      renderFiles[file] = renderArtifactFile;
+      await writeFile(join(serverDir, artifactFile), json);
+      return { artifactFile, file };
+    },
+    serverArtifactFilesystemConcurrency,
+  );
+
+  for (const artifact of writtenArtifacts) {
+    if ("requestArtifactFile" in artifact) {
+      requestFiles[artifact.file] = artifact.requestArtifactFile;
+      renderFiles[artifact.file] = artifact.renderArtifactFile;
       continue;
     }
 
-    const json = JSON.stringify(externalized);
-    const artifactFile = `server-modules/${hashText(`${file}\0${json}`).slice(0, 16)}.json`;
-
-    await writeFile(join(serverDir, artifactFile), json);
-    files[file] = artifactFile;
+    files[artifact.file] = artifact.artifactFile;
   }
 
   return { files, renderFiles, requestFiles };
 }
 
+export async function __writeServerModuleArtifactFilesForTests(
+  serverDir: string,
+  serverModules: Record<string, BuiltServerModuleArtifact>,
+): Promise<{
+  files: Record<string, string>;
+  renderFiles: Record<string, string>;
+  requestFiles: Record<string, string>;
+}> {
+  return await writeServerModuleArtifactFiles(serverDir, serverModules);
+}
+
 async function externalizeServerModuleArtifactCode(
   serverDir: string,
   artifact: BuiltServerModuleArtifact,
+  portableRuntimePackages: readonly string[],
 ): Promise<BuiltServerModuleArtifact> {
   return {
     ...(artifact.analysis === undefined ? {} : { analysis: artifact.analysis }),
     ...(artifact.loader === undefined
       ? {}
-      : { loader: await externalizeServerModuleOutputCode(serverDir, artifact.loader, "code") }),
+      : {
+          loader: await externalizeServerModuleOutputCode(
+            serverDir,
+            artifact.loader,
+            "code",
+            portableRuntimePackages,
+          ),
+        }),
     ...(artifact.routeMetadata === undefined
       ? {}
       : {
@@ -435,17 +918,39 @@ async function externalizeServerModuleArtifactCode(
             serverDir,
             artifact.routeMetadata,
             "code",
+            portableRuntimePackages,
           ),
         }),
     ...(artifact.request === undefined
       ? {}
-      : { request: await externalizeServerModuleOutputCode(serverDir, artifact.request, "code") }),
+      : {
+          request: await externalizeServerModuleOutputCode(
+            serverDir,
+            artifact.request,
+            "code",
+            portableRuntimePackages,
+          ),
+        }),
     ...(artifact.stream === undefined
       ? {}
-      : { stream: await externalizeServerModuleOutputCode(serverDir, artifact.stream, "bundle") }),
+      : {
+          stream: await externalizeServerModuleOutputCode(
+            serverDir,
+            artifact.stream,
+            "bundle",
+            portableRuntimePackages,
+          ),
+        }),
     ...(artifact.string === undefined
       ? {}
-      : { string: await externalizeServerModuleOutputCode(serverDir, artifact.string, "bundle") }),
+      : {
+          string: await externalizeServerModuleOutputCode(
+            serverDir,
+            artifact.string,
+            "bundle",
+            portableRuntimePackages,
+          ),
+        }),
   };
 }
 
@@ -453,15 +958,19 @@ async function externalizeServerModuleOutputCode(
   serverDir: string,
   output: BuiltServerModuleOutput,
   kind: "bundle" | "code",
+  portableRuntimePackages: readonly string[],
 ): Promise<BuiltServerModuleOutput> {
-  const moduleCode = kind === "bundle" ? output.bundleCode : output.code;
+  const sourceCode = kind === "bundle" ? output.bundleCode : output.code;
+  const moduleCode =
+    sourceCode === undefined
+      ? undefined
+      : rewritePortableRuntimePackageImports(sourceCode, portableRuntimePackages);
 
   if (moduleCode === undefined || moduleCode.length === 0) {
     return output;
   }
 
   const moduleFile = `server-modules/code/${hashText(moduleCode).slice(0, 16)}.mjs`;
-  await mkdir(join(serverDir, "server-modules", "code"), { recursive: true });
   await writeFile(join(serverDir, moduleFile), moduleCode);
 
   return {
@@ -472,6 +981,42 @@ async function externalizeServerModuleOutputCode(
   };
 }
 
+function rewritePortableRuntimePackageImports(
+  code: string,
+  runtimePackages: readonly string[],
+): string {
+  if (runtimePackages.length === 0 || !code.includes("file://")) {
+    return code;
+  }
+
+  return code.replace(
+    /\b(from\s+|import\s*)["'](?<specifier>file:\/\/[^"']+)["']/gu,
+    (match, prefix: string, specifier: string | undefined) => {
+      const packageName =
+        specifier === undefined ? undefined : runtimePackageForFileUrl(specifier, runtimePackages);
+
+      return packageName === undefined ? match : `${prefix}"${packageName}"`;
+    },
+  );
+}
+
+function runtimePackageForFileUrl(
+  specifier: string,
+  runtimePackages: readonly string[],
+): string | undefined {
+  let filePath: string;
+
+  try {
+    filePath = fileURLToPath(specifier).split(sep).join("/");
+  } catch {
+    return undefined;
+  }
+
+  return [...runtimePackages]
+    .sort((left, right) => right.length - left.length)
+    .find((packageName) => filePath.includes(`/node_modules/${packageName}/`));
+}
+
 function requestServerModuleArtifact(
   artifact: BuiltServerModuleArtifact,
 ): BuiltServerModuleArtifact {
@@ -982,6 +1527,7 @@ async function prerenderStaticRoutes(options: {
   project: ResolvedAppRouterProject;
   routes: readonly AppRoute[];
   serverModules: Record<string, BuiltServerModuleArtifact>;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<Record<string, BuiltPrerenderedRoute>> {
   const clientScripts = new Map(
@@ -1002,37 +1548,48 @@ async function prerenderStaticRoutes(options: {
     ]),
   );
 
-  for (const route of options.routes) {
-    if (route.kind !== "page") {
-      continue;
-    }
+  const prerenderedEntries = await mapWithBuildConcurrency(
+    options.routes.filter((route): route is AppRoute & { kind: "page" } => route.kind === "page"),
+    async (route) => {
+      const routeFile = relative(options.project.projectRoot, route.file).split(sep).join("/");
+      const analysis = options.sourceAnalysis.byRouteFile.get(routeFile);
 
-    const source = await readFile(route.file, "utf8");
+      if (analysis === undefined || !analysis.hasPrerender) {
+        return [] as Array<[string, BuiltPrerenderedRoute]>;
+      }
 
-    if (!hasPrerenderExport(source)) {
-      continue;
-    }
+      const entries: Array<[string, BuiltPrerenderedRoute]> = [];
+      for (const pathname of await prerenderPathsForRoute(route, analysis, options.vitePlugins)) {
+        const response = await renderAppRequest({
+          appDir: options.appDir,
+          assetBaseUrl: options.assetBaseUrl,
+          clientScripts,
+          importPolicy,
+          request: new Request(`http://mreact.local${pathname}`),
+          serverModules: serverModuleMap,
+          vitePlugins: options.vitePlugins,
+        });
+        const headers: Record<string, string> = {};
 
-    for (const pathname of await prerenderPathsForRoute(route, source, options.vitePlugins)) {
-      const response = await renderAppRequest({
-        appDir: options.appDir,
-        assetBaseUrl: options.assetBaseUrl,
-        clientScripts,
-        importPolicy,
-        request: new Request(`http://mreact.local${pathname}`),
-        serverModules: serverModuleMap,
-        vitePlugins: options.vitePlugins,
-      });
-      const headers: Record<string, string> = {};
+        response.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        entries.push([
+          pathname,
+          {
+            headers,
+            html: await response.text(),
+            status: response.status,
+          },
+        ]);
+      }
+      return entries;
+    },
+  );
 
-      response.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
-      prerendered[pathname] = {
-        headers,
-        html: await response.text(),
-        status: response.status,
-      };
+  for (const entries of prerenderedEntries) {
+    for (const [pathname, route] of entries) {
+      prerendered[pathname] = route;
     }
   }
 
@@ -1041,21 +1598,21 @@ async function prerenderStaticRoutes(options: {
 
 async function prerenderPathsForRoute(
   route: AppRoute,
-  source: string,
+  analysis: BuildRouteSourceAnalysis,
   vitePlugins: readonly PluginOption[] | undefined,
 ): Promise<string[]> {
   if (route.segments.every((segment) => segment.kind === "static")) {
     return [route.path];
   }
 
-  if (!hasGenerateStaticParamsExport(source)) {
+  if (!analysis.hasGenerateStaticParams) {
     return [];
   }
 
   const module = await importAppRouterSourceModule<{
     generateStaticParams?: () => Iterable<StaticParams> | PromiseLike<Iterable<StaticParams>>;
   }>({
-    code: source,
+    code: analysis.source,
     label: `generate-static-params:${route.file}`,
     resolveDir: dirname(route.file),
     sourcefile: route.file,
@@ -1095,12 +1652,16 @@ function routePathFromParams(route: AppRoute, params: StaticParams): string {
 }
 
 async function buildServerModuleArtifacts(options: {
+  bundleCache: Map<string, Promise<RouterBundleOutput>>;
+  cacheDir?: string | undefined;
   clientRouteInferenceCache: ClientRouteInferenceCache;
   files: Record<string, string>;
   prebundleServerComponents: boolean;
   project: ResolvedAppRouterProject;
   projectRoot: string;
   routes: readonly AppRoute[];
+  sourceAnalysis: BuildSourceAnalysisScope;
+  serverTransformCache: ServerTransformCache;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<Record<string, BuiltServerModuleArtifact>> {
   const routeByFile = new Map(
@@ -1116,9 +1677,10 @@ async function buildServerModuleArtifacts(options: {
   } satisfies AppRouterImportPolicy;
   const artifacts: Record<string, BuiltServerModuleArtifact> = {};
 
-  for (const [file, source] of Object.entries(options.files)) {
+  for (const file of Object.keys(options.files)) {
     const absoluteFile = join(options.projectRoot, file);
     const route = routeByFile.get(file);
+    const analysis = options.sourceAnalysis.byFile.get(file);
 
     if (isMiddlewareFile(options.project.routesDir, absoluteFile)) {
       requestArtifactFiles.add(file);
@@ -1128,18 +1690,68 @@ async function buildServerModuleArtifacts(options: {
       requestArtifactFiles.add(file);
     }
 
-    if (route?.kind === "page" && hasLoaderExport(source)) {
+    if (route?.kind === "page" && analysis?.hasLoader === true) {
       loaderArtifactFiles.add(file);
     }
 
-    if (hasMetadataExport(source)) {
+    if (isServerComponentFile(file) && analysis?.hasMetadata === true) {
       metadataArtifactFiles.add(file);
     }
   }
 
+  const requestBatchEntries: RouteRequestModuleBatchEntry[] = [];
   for (const [file, source] of Object.entries(options.files)) {
     const absoluteFile = join(options.projectRoot, file);
     const route = routeByFile.get(file);
+
+    if (loaderArtifactFiles.has(file)) {
+      requestBatchEntries.push({
+        code: stripRouteLoaderOnlyExports(source, absoluteFile),
+        filename: absoluteFile,
+        key: routeRequestArtifactBatchKey(file, "loader"),
+        label: "Loader",
+      });
+    }
+
+    if (metadataArtifactFiles.has(file)) {
+      requestBatchEntries.push({
+        code: stripRouteMetadataOnlyExports(source, absoluteFile),
+        filename: absoluteFile,
+        key: routeRequestArtifactBatchKey(file, "metadata"),
+        label: "Metadata",
+      });
+    }
+
+    if (
+      requestArtifactFiles.has(file) &&
+      !isMiddlewareFile(options.project.routesDir, absoluteFile) &&
+      route?.kind !== "server" &&
+      route?.kind !== "metadata"
+    ) {
+      requestBatchEntries.push({
+        code: stripRouteRequestOnlyExports(source, absoluteFile),
+        filename: absoluteFile,
+        key: routeRequestArtifactBatchKey(file, "request"),
+        label: "Loader",
+      });
+    }
+  }
+
+  const requestBatchOutputs = requestBatchEntries.length >= 3
+    ? await bundleRouteRequestModuleBatchCode({
+        appDir: options.project.routesDir,
+        bundleCache: options.bundleCache,
+        cacheDir: options.cacheDir,
+        entries: requestBatchEntries,
+        importPolicy: requestModuleImportPolicy,
+        vitePlugins: options.vitePlugins,
+      })
+    : new Map<string, string>();
+
+  const artifactEntries = await mapWithBuildConcurrency(Object.entries(options.files), async ([file, source]) => {
+    const absoluteFile = join(options.projectRoot, file);
+    const route = routeByFile.get(file);
+    const routeAnalysis = options.sourceAnalysis.byRouteFile.get(file);
     const artifact: BuiltServerModuleArtifact = {};
 
     if (
@@ -1148,13 +1760,16 @@ async function buildServerModuleArtifacts(options: {
       metadataArtifactFiles.has(file)
     ) {
       if (loaderArtifactFiles.has(file)) {
-        const code = await bundleRouteLoaderModuleCode({
-          appDir: options.project.routesDir,
-          code: stripRouteLoaderOnlyExports(source),
-          filename: absoluteFile,
-          importPolicy: requestModuleImportPolicy,
-          vitePlugins: options.vitePlugins,
-        });
+        const code = requestBatchOutputs.get(routeRequestArtifactBatchKey(file, "loader")) ??
+          await bundleRouteLoaderModuleCode({
+            appDir: options.project.routesDir,
+            bundleCache: options.bundleCache,
+            cacheDir: options.cacheDir,
+            code: stripRouteLoaderOnlyExports(source, absoluteFile),
+            filename: absoluteFile,
+            importPolicy: requestModuleImportPolicy,
+            vitePlugins: options.vitePlugins,
+          });
         artifact.loader = {
           code,
           sourceHash: hashText(source),
@@ -1162,13 +1777,17 @@ async function buildServerModuleArtifacts(options: {
       }
 
       if (metadataArtifactFiles.has(file)) {
-        const code = await bundleRouteMetadataModuleCode({
-          appDir: options.project.routesDir,
-          code: stripRouteMetadataOnlyExports(source),
-          filename: absoluteFile,
-          importPolicy: requestModuleImportPolicy,
-          vitePlugins: options.vitePlugins,
-        });
+        const code = requestBatchOutputs.get(routeRequestArtifactBatchKey(file, "metadata")) ??
+          await bundleRouteRequestModuleCode({
+            appDir: options.project.routesDir,
+            bundleCache: options.bundleCache,
+            cacheDir: options.cacheDir,
+            code: stripRouteMetadataOnlyExports(source, absoluteFile),
+            filename: absoluteFile,
+            importPolicy: requestModuleImportPolicy,
+            label: "Metadata",
+            vitePlugins: options.vitePlugins,
+          });
         artifact.routeMetadata = {
           code,
           sourceHash: hashText(source),
@@ -1176,117 +1795,152 @@ async function buildServerModuleArtifacts(options: {
       }
 
       if (requestArtifactFiles.has(file)) {
+        const batchedRequestCode = requestBatchOutputs.get(
+          routeRequestArtifactBatchKey(file, "request"),
+        );
         artifact.request = {
-          code: await buildRequestModuleArtifactCode({
-            appDir: options.project.routesDir,
-            filename: absoluteFile,
-            importPolicy: requestModuleImportPolicy,
-            routeKind: route?.kind,
-            source,
-            vitePlugins: options.vitePlugins,
-          }),
+          code: batchedRequestCode ??
+            await buildRequestModuleArtifactCode({
+              appDir: options.project.routesDir,
+              bundleCache: options.bundleCache,
+              cacheDir: options.cacheDir,
+              filename: absoluteFile,
+              importPolicy: requestModuleImportPolicy,
+              routeKind: route?.kind,
+              source,
+              vitePlugins: options.vitePlugins,
+            }),
           sourceHash: hashText(source),
         };
       }
     }
 
     if (!isServerComponentFile(file)) {
-      if (Object.keys(artifact).length > 0) {
-        artifacts[file] = artifact;
-      }
-      continue;
+      return Object.keys(artifact).length > 0 ? ([file, artifact] as const) : undefined;
     }
 
-    const closureUsesAwait = shouldBuildRouteAsStream({
-      filename: file,
-      files: options.files,
-      projectRoot: options.projectRoot,
-      source,
-    });
+    const closureUsesAwait = routeAnalysis?.streamRoute ??
+      shouldBuildRouteAsStream({
+        filename: file,
+        files: options.files,
+        projectRoot: options.projectRoot,
+        source,
+      });
     const streamRoute = route !== undefined && closureUsesAwait;
     const serverOutputs =
       streamRoute || (route === undefined && closureUsesAwait)
         ? (["stream", "string"] as const)
         : (["string"] as const);
-    const code = route === undefined ? source : stripRouteBuildExports(source);
-    const clientInference = await inferClientRouteModule({
-      ...(route === undefined ? {} : { appDir: options.project.routesDir }),
-      cache: options.clientRouteInferenceCache,
-      code:
-        route === undefined
-          ? stripRouteClientOnlyExports(source)
-          : stripRouteClientSource({ code: source, filename: route.file }),
-      filename: join(options.projectRoot, file),
-      ...(route === undefined ? {} : { routePath: route.path }),
-      vitePlugins: options.vitePlugins,
-    });
-    const clientBoundaryImports = clientInference.clientBoundaryImports;
+    const code = routeAnalysis?.routeCode ??
+      (route === undefined ? source : stripRouteBuildExports(source, absoluteFile));
+    const clientInference = routeAnalysis === undefined
+      ? await inferClientRouteModule({
+          ...(route === undefined ? {} : { appDir: options.project.routesDir }),
+          cache: options.clientRouteInferenceCache,
+          code:
+            route === undefined
+              ? stripRouteClientOnlyExports(source, absoluteFile)
+              : stripRouteClientSource({ code: source, filename: route.file }),
+          filename: join(options.projectRoot, file),
+          ...(route === undefined ? {} : { routePath: route.path }),
+          vitePlugins: options.vitePlugins,
+        })
+      : undefined;
+    const clientBoundaryImports = routeAnalysis?.clientBoundaryImports ??
+      clientInference?.clientBoundaryImports ??
+      [];
 
-    for (const diagnostic of clientInference.diagnostics) {
+    for (const diagnostic of clientInference?.diagnostics ?? []) {
       console.warn(formatClientRouteInferenceDiagnostic(diagnostic));
     }
 
-    if (route?.kind === "page") {
+    if (routeAnalysis !== undefined) {
       artifact.analysis = builtRouteSourceAnalysisSummary({
-        clientBoundaryImports,
-        clientRoute: clientInference.client,
-        route,
-        routeCode: code,
-        source,
-        streamRoute,
+        analysis: routeAnalysis,
       });
     }
 
-    for (const serverOutput of serverOutputs) {
-      const output = transform({
-        code,
-        clientBoundaryImports,
-        dev: false,
-        filename: join(options.projectRoot, file),
-        serverEscape: nativeEscapeTransform,
-        serverOutput,
-        target: "server",
-      });
-      const fatalDiagnostics = output.diagnostics.filter(
-        (diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER",
-      );
+    const serverOutputArtifacts = await mapWithBuildConcurrency(
+      serverOutputs,
+      async (serverOutput) => {
+        const output = await transformServerRouteSource({
+          cache: options.serverTransformCache,
+          code,
+          clientBoundaryImports,
+          filename: join(options.projectRoot, file),
+          moduleContextCache: options.clientRouteInferenceCache,
+          serverOutput,
+        });
+        const fatalDiagnostics = output.diagnostics.filter(
+          (diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER",
+        );
+
+        if (fatalDiagnostics.length > 0) {
+          if (
+            serverOutput === "string" &&
+            streamRoute &&
+            route?.kind === "page" &&
+            fatalDiagnostics.every(
+              (diagnostic) => diagnostic.code === "MR_UNSUPPORTED_AWAIT_INNER_COMPONENT",
+            )
+          ) {
+            return undefined;
+          }
+
+          throw new Error(
+            fatalDiagnostics.map((diagnostic) => formatDiagnostic(file, diagnostic)).join("\n"),
+          );
+        }
 
-      if (fatalDiagnostics.length > 0) {
         if (
           serverOutput === "string" &&
           streamRoute &&
           route?.kind === "page" &&
-          fatalDiagnostics.every(
-            (diagnostic) => diagnostic.code === "MR_UNSUPPORTED_AWAIT_INNER_COMPONENT",
-          )
+          source.includes("<Await") &&
+          /\bLink\b/.test(source)
         ) {
-          continue;
+          // Native Link renders pre-rendered children as HTML. Keep direct
+          // Await renderers on the stream artifact so the string artifact
+          // cannot drop deferred Link content before the boundary resolves.
+          return undefined;
         }
 
-        throw new Error(
-          fatalDiagnostics.map((diagnostic) => formatDiagnostic(file, diagnostic)).join("\n"),
-        );
-      }
+        return [
+          serverOutput,
+          {
+            ...(options.prebundleServerComponents
+              ? {
+                  bundleCode: await buildServerComponentBundleArtifactCode({
+                    clientRouteInferenceCache: options.clientRouteInferenceCache,
+                    code: output.code,
+                    filename: absoluteFile,
+                    root: options.projectRoot,
+                    serverOutput,
+                    vitePlugins: options.vitePlugins,
+                  }),
+                }
+              : {}),
+            code: output.code,
+            metadata: output.metadata,
+            sourceHash: hashText(code),
+          },
+        ] as const;
+      },
+    );
 
-      artifact[serverOutput] = {
-        ...(options.prebundleServerComponents
-          ? {
-              bundleCode: await buildServerComponentBundleArtifactCode({
-                clientRouteInferenceCache: options.clientRouteInferenceCache,
-                code: output.code,
-                filename: absoluteFile,
-                serverOutput,
-                vitePlugins: options.vitePlugins,
-              }),
-            }
-          : {}),
-        code: output.code,
-        metadata: output.metadata,
-        sourceHash: hashText(code),
-      };
+    for (const entry of serverOutputArtifacts) {
+      if (entry !== undefined) {
+        artifact[entry[0]] = entry[1];
+      }
     }
 
-    artifacts[file] = artifact;
+    return [file, artifact] as const;
+  });
+
+  for (const entry of artifactEntries) {
+    if (entry !== undefined) {
+      artifacts[entry[0]] = entry[1];
+    }
   }
 
   return artifacts;
@@ -1296,6 +1950,7 @@ async function buildServerComponentBundleArtifactCode(options: {
   clientRouteInferenceCache: ClientRouteInferenceCache;
   code: string;
   filename: string;
+  root?: string | undefined;
   serverOutput: ServerOutputMode;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
@@ -1303,6 +1958,7 @@ async function buildServerComponentBundleArtifactCode(options: {
     code: options.code,
     label: `server-component:${options.filename}`,
     resolveDir: dirname(options.filename),
+    root: options.root,
     serverSourceTransform: {
       clientRouteInferenceCache: options.clientRouteInferenceCache,
       dev: false,
@@ -1314,27 +1970,63 @@ async function buildServerComponentBundleArtifactCode(options: {
   });
 }
 
-function builtRouteSourceAnalysisSummary(options: {
+async function transformServerRouteSource(options: {
+  cache: ServerTransformCache;
   clientBoundaryImports: readonly string[];
-  clientRoute: boolean;
-  route: AppRoute;
-  routeCode: string;
-  source: string;
-  streamRoute: boolean;
-}): BuiltRouteSourceAnalysisSummary {
-  const cachePolicy = routeCachePolicyFromSource(options.source);
+  code: string;
+  filename: string;
+  moduleContextCache: ClientRouteInferenceCache;
+  serverOutput: ServerOutputMode;
+}): Promise<ServerTransformOutput> {
+  const cacheKey = stableCacheKey({
+    clientBoundaryImports: options.clientBoundaryImports,
+    codeHash: hashText(options.code),
+    filename: resolve(options.filename),
+    serverOutput: options.serverOutput,
+    target: "server",
+  });
+  const cached = options.cache.get(cacheKey);
+
+  if (cached !== undefined) {
+    return await cached;
+  }
+
+  const transformed = Promise.resolve().then(async () => {
+    const moduleContext = await compilerModuleContextForSource({
+      cache: options.moduleContextCache,
+      code: options.code,
+      filename: options.filename,
+    });
 
+    return transformCompilerModuleContext({
+      code: options.code,
+      clientBoundaryImports: options.clientBoundaryImports,
+      dev: false,
+      filename: options.filename,
+      moduleContext,
+      serverEscape: nativeEscapeTransform,
+      serverOutput: options.serverOutput,
+      target: "server",
+    });
+  });
+  options.cache.set(cacheKey, transformed);
+  return await transformed;
+}
+
+function builtRouteSourceAnalysisSummary(options: {
+  analysis: BuildRouteSourceAnalysis;
+}): BuiltRouteSourceAnalysisSummary {
   return {
-    authIncludesClaims: authIncludesClaims(options.source),
-    ...(cachePolicy === undefined ? {} : { cachePolicy }),
-    clientBoundaryImports: options.clientBoundaryImports,
-    clientRoute: options.clientRoute,
-    hasLoader: hasLoaderExport(options.source),
-    routeCode: options.routeCode,
-    routePath: options.route.path,
-    sourceHash: hashText(options.source),
-    streamRoute: options.streamRoute,
-    usesRuntimeCacheControl: usesRuntimeCacheControl(options.source),
+    authIncludesClaims: options.analysis.authIncludesClaims,
+    ...(options.analysis.cachePolicy === undefined ? {} : { cachePolicy: options.analysis.cachePolicy }),
+    clientBoundaryImports: options.analysis.clientBoundaryImports,
+    clientRoute: options.analysis.clientRoute,
+    hasLoader: options.analysis.hasLoader,
+    routeCode: options.analysis.routeCode,
+    routePath: options.analysis.route.path,
+    sourceHash: options.analysis.sourceHash,
+    streamRoute: options.analysis.streamRoute,
+    usesRuntimeCacheControl: options.analysis.usesRuntimeCacheControl,
   };
 }
 
@@ -1345,7 +2037,10 @@ function shouldBuildRouteAsStream(options: {
   source: string;
 }): boolean {
   return (
-    isStreamRouteSource(options.source) ||
+    isStreamRouteSource(
+      options.source,
+      sourceFilenameForBuildAnalysis(options.projectRoot, options.filename),
+    ) ||
     routeClosureMayUseAwaitBoundary({
       filename: options.filename,
       files: options.files,
@@ -1355,6 +2050,10 @@ function shouldBuildRouteAsStream(options: {
   );
 }
 
+function sourceFilenameForBuildAnalysis(projectRoot: string, filename: string): string {
+  return filename.startsWith("/") ? filename : join(projectRoot, filename);
+}
+
 function resolveBuildLocalSourceImport(
   files: Record<string, string>,
   importer: string,
@@ -1379,12 +2078,18 @@ function usesRuntimeCacheControl(code: string): boolean {
   return /\bcacheControl\s*\(/.test(code);
 }
 
+function routeRequestArtifactBatchKey(file: string, kind: "loader" | "metadata" | "request"): string {
+  return `${kind}:${file}`;
+}
+
 function authIncludesClaims(code: string): boolean {
   return /\bexport\s+const\s+auth\s*=\s*["']include-claims["']\s*;?/.test(code);
 }
 
 async function buildRequestModuleArtifactCode(options: {
   appDir: string;
+  bundleCache: Map<string, Promise<RouterBundleOutput>>;
+  cacheDir?: string | undefined;
   filename: string;
   importPolicy: AppRouterImportPolicy;
   routeKind?: AppRoute["kind"] | undefined;
@@ -1401,53 +2106,161 @@ async function buildRequestModuleArtifactCode(options: {
     });
   }
 
-  if (options.routeKind === "server" || options.routeKind === "metadata") {
-    return await bundleAppRouterSourceModule({
-      code: options.source,
-      label: `server-route:${options.filename}`,
-      resolveDir: dirname(options.filename),
-      sourcefile: options.filename,
-      vitePlugins: options.vitePlugins,
-    });
-  }
+  if (options.routeKind === "server" || options.routeKind === "metadata") {
+    return await bundleAppRouterSourceModule({
+      code: options.source,
+      label: `server-route:${options.filename}`,
+      plugins: [fileImportMetaUrlPlugin()],
+      resolveDir: dirname(options.filename),
+      root: options.importPolicy.projectRoot,
+      sourcefile: options.filename,
+      vitePlugins: options.vitePlugins,
+    });
+  }
+
+    return await bundleRouteLoaderModuleCode({
+      appDir: options.appDir,
+      bundleCache: options.bundleCache,
+      cacheDir: options.cacheDir,
+      code: stripRouteRequestOnlyExports(options.source, options.filename),
+      filename: options.filename,
+      importPolicy: options.importPolicy,
+      vitePlugins: options.vitePlugins,
+    });
+}
+
+async function bundleRouteLoaderModuleCode(options: {
+  appDir: string;
+  bundleCache?: Map<string, Promise<RouterBundleOutput>> | undefined;
+  cacheDir?: string | undefined;
+  code: string;
+  filename: string;
+  importPolicy?: AppRouterImportPolicy | undefined;
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<string> {
+  return await bundleRouteRequestModuleCode({
+    ...options,
+    label: "Loader",
+  });
+}
+
+async function bundleRouteRequestModuleBatchCode(options: {
+  appDir: string;
+  bundleCache?: Map<string, Promise<RouterBundleOutput>> | undefined;
+  cacheDir?: string | undefined;
+  entries: readonly RouteRequestModuleBatchEntry[];
+  importPolicy?: AppRouterImportPolicy | undefined;
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<Map<string, string>> {
+  if (options.entries.length === 0) {
+    return new Map();
+  }
+
+  if (options.entries.length === 1) {
+    const entry = options.entries[0];
+    if (entry === undefined) {
+      return new Map();
+    }
+
+    return new Map([
+      [
+        entry.key,
+        await bundleRouteRequestModuleCode({
+          appDir: options.appDir,
+          bundleCache: options.bundleCache,
+          cacheDir: options.cacheDir,
+          code: entry.code,
+          filename: entry.filename,
+          importPolicy: options.importPolicy,
+          label: entry.label,
+          vitePlugins: options.vitePlugins,
+        }),
+      ],
+    ]);
+  }
+
+  const namesByKey = new Map(
+    options.entries.map((entry, index) => [
+      entry.key,
+      `request-${index}-${hashText(entry.key).slice(0, 8)}`,
+    ]),
+  );
+  const output = await bundleRouterModules({
+    cacheDir: options.cacheDir,
+    chunkFileNames: "request/chunks/[name].[hash].js",
+    entries: options.entries.map((entry) => ({
+      code: entry.code,
+      filename: entry.filename,
+      name: namesByKey.get(entry.key) ?? hashText(entry.key).slice(0, 8),
+    })),
+    entryFileNames: "request/[name].js",
+    platform: "node",
+    plugins: [
+      fileImportMetaUrlPlugin(),
+      createAppRouterImportPolicyPlugin({
+        appDir: options.appDir,
+        importPolicy: options.importPolicy,
+        label: "Request artifact",
+      }),
+    ],
+    root: options.importPolicy?.projectRoot ?? dirname(options.entries[0]?.filename ?? options.appDir),
+    vitePlugins: options.vitePlugins,
+  });
+
+  if (output.chunks.some((chunk) => !chunk.isEntry)) {
+    const fallbackEntries = await mapWithBuildConcurrency(options.entries, async (entry) => [
+      entry.key,
+      await bundleRouteRequestModuleCode({
+        appDir: options.appDir,
+        bundleCache: options.bundleCache,
+        cacheDir: options.cacheDir,
+        code: entry.code,
+        filename: entry.filename,
+        importPolicy: options.importPolicy,
+        label: entry.label,
+        vitePlugins: options.vitePlugins,
+      }),
+    ] as const);
+    return new Map(fallbackEntries);
+  }
+
+  const chunksByName = new Map(output.chunks.map((chunk) => [chunk.name, chunk]));
+  return new Map(
+    options.entries.map((entry) => {
+      const name = namesByKey.get(entry.key);
+      const chunk = name === undefined ? undefined : chunksByName.get(name);
 
-  return await bundleRouteLoaderModuleCode({
-    appDir: options.appDir,
-    code: stripRouteRequestOnlyExports(options.source),
-    filename: options.filename,
-    importPolicy: options.importPolicy,
-    vitePlugins: options.vitePlugins,
-  });
-}
+      if (chunk === undefined) {
+        throw new Error(`Failed to compile request artifact for ${entry.filename}.`);
+      }
 
-async function bundleRouteLoaderModuleCode(options: {
-  appDir: string;
-  code: string;
-  filename: string;
-  importPolicy?: AppRouterImportPolicy | undefined;
-  vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<string> {
-  return await bundleRouteRequestModuleCode({
-    ...options,
-    label: "Loader",
-  });
+      return [entry.key, chunk.code] as const;
+    }),
+  );
 }
 
-async function bundleRouteMetadataModuleCode(options: {
+export async function __bundleRouteRequestModuleBatchForTests(options: {
   appDir: string;
-  code: string;
-  filename: string;
+  cacheDir?: string | undefined;
+  entries: readonly RouteRequestModuleBatchEntry[];
   importPolicy?: AppRouterImportPolicy | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<string> {
-  return await bundleRouteRequestModuleCode({
-    ...options,
-    label: "Metadata",
-  });
+}): Promise<Record<string, string>> {
+  return Object.fromEntries(
+    await bundleRouteRequestModuleBatchCode({
+      appDir: options.appDir,
+      cacheDir: options.cacheDir,
+      entries: options.entries,
+      importPolicy: options.importPolicy,
+      vitePlugins: options.vitePlugins,
+    }),
+  );
 }
 
 async function bundleRouteRequestModuleCode(options: {
   appDir: string;
+  bundleCache?: Map<string, Promise<RouterBundleOutput>> | undefined;
+  cacheDir?: string | undefined;
   code: string;
   filename: string;
   importPolicy?: AppRouterImportPolicy | undefined;
@@ -1455,11 +2268,16 @@ async function bundleRouteRequestModuleCode(options: {
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const output = await bundleRouterModule({
+    cache: options.bundleCache,
+    cacheDir: options.cacheDir,
+    cacheKey: routeRequestBundleCacheKey(options),
     code: options.code,
     filename: options.filename,
     platform: "node",
+    root: options.importPolicy?.projectRoot,
     vitePlugins: options.vitePlugins,
     plugins: [
+      fileImportMetaUrlPlugin(),
       createAppRouterImportPolicyPlugin({
         appDir: options.appDir,
         importPolicy: options.importPolicy,
@@ -1476,6 +2294,42 @@ async function bundleRouteRequestModuleCode(options: {
   return code;
 }
 
+function routeRequestBundleCacheKey(options: {
+  appDir: string;
+  code: string;
+  filename: string;
+  importPolicy?: AppRouterImportPolicy | undefined;
+  label: "Loader" | "Metadata";
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): string {
+  return stableCacheKey({
+    appDir: resolve(options.appDir),
+    codeHash: hashText(options.code),
+    filename: resolve(options.filename),
+    importPolicy:
+      options.importPolicy === undefined
+        ? undefined
+        : {
+            allowedPackages: [...(options.importPolicy.allowedPackages ?? [])].sort(),
+            allowedSourceDirs: (options.importPolicy.allowedSourceDirs ?? [])
+              .map((dir) => resolve(dir))
+              .sort(),
+            projectRoot:
+              options.importPolicy.projectRoot === undefined
+                ? undefined
+                : resolve(options.importPolicy.projectRoot),
+          },
+    label: options.label,
+    platform: "node",
+    target: "es2022",
+    vitePlugins: vitePluginsCacheKey(options.vitePlugins),
+  });
+}
+
+function stableCacheKey(value: unknown): string {
+  return JSON.stringify(value);
+}
+
 function isMiddlewareFile(appDir: string, file: string): boolean {
   return file === join(appDir, "middleware.ts") || file === join(appDir, "middleware.mreact.ts");
 }
@@ -1510,7 +2364,31 @@ interface CloudflareRouteModulesOutput {
   registryFile: string;
 }
 
+interface CloudflareRequiredRoute {
+  route: AppRoute;
+  routeFile: string;
+  routeId: string;
+}
+
+interface CloudflareBatchedRouteModule {
+  code: string;
+  fileName: string;
+}
+
+interface CloudflareBatchedRouteModules {
+  chunks: readonly RouterBundleChunkOutput[];
+  entries: ReadonlyMap<string, CloudflareBatchedRouteModule>;
+}
+
+interface RouteRequestModuleBatchEntry {
+  code: string;
+  filename: string;
+  key: string;
+  label: "Loader" | "Metadata";
+}
+
 async function writeCloudflareRouteModules(options: {
+  cacheDir?: string | undefined;
   cloudflareDir: string;
   files: Record<string, string>;
   prerenderedRoutes: Record<string, BuiltPrerenderedRoute>;
@@ -1518,32 +2396,66 @@ async function writeCloudflareRouteModules(options: {
   routesDir: string;
   routes: readonly AppRoute[];
   serverModules: Record<string, BuiltServerModuleArtifact>;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<CloudflareRouteModulesOutput> {
   const routesDir = join(options.cloudflareDir, "routes");
-  const requiredRoutes = options.routes.filter((route) =>
-    cloudflareRouteRequiresGeneratedModule(route, options.prerenderedRoutes),
+  const requiredRoutes = await Promise.all(
+    options.routes
+      .filter((route) => cloudflareRouteRequiresGeneratedModule(route, options.prerenderedRoutes))
+      .flatMap((route): CloudflareRequiredRoute[] => {
+        const routeFile = relative(options.projectRoot, route.file).replaceAll(sep, "/");
+        const analysis = options.sourceAnalysis.byFile.get(routeFile);
+
+        return analysis === undefined
+          ? []
+          : [{
+              route,
+              routeFile,
+              routeId: routeIdForPath(route.path),
+            }];
+      }),
   );
-  const registryEntries: string[] = [];
 
   await mkdir(routesDir, { recursive: true });
 
-  for (const route of requiredRoutes) {
-    const routeFile = relative(options.projectRoot, route.file).replaceAll(sep, "/");
-    const source = await readFile(route.file, "utf8");
-    const routeId = routeIdForPath(route.path);
+  const serverRouteModules = await buildCloudflareServerRouteModuleBatch({
+    cacheDir: options.cacheDir,
+    routes: requiredRoutes
+      .filter(({ route }) => route.kind === "server" || route.kind === "metadata")
+      .map(({ route, routeId }) => ({ filename: route.file, routeId })),
+    root: options.projectRoot,
+    vitePlugins: options.vitePlugins,
+  });
+  const loaderRouteModules = await buildCloudflareRouteLoaderModuleBatch({
+    cacheDir: options.cacheDir,
+    routes: requiredRoutes
+      .filter(({ route, routeFile }) =>
+        route.kind === "page" && options.sourceAnalysis.byRouteFile.get(routeFile)?.hasLoader === true
+      )
+      .map(({ route, routeId }) => ({ filename: route.file, routeId })),
+    root: options.projectRoot,
+    vitePlugins: options.vitePlugins,
+  });
+
+  await Promise.all([
+    writeCloudflareBatchedRouteModuleChunks(options.cloudflareDir, serverRouteModules),
+    writeCloudflareBatchedRouteModuleChunks(options.cloudflareDir, loaderRouteModules),
+  ]);
+
+  const registryEntries = await mapWithBuildConcurrency(requiredRoutes, async ({ route, routeFile, routeId }) => {
     const routeModuleFile = `routes/${routeId}.mjs`;
     let routeModuleExports: string[];
 
     if (route.kind === "server" || route.kind === "metadata") {
       try {
-        const routeOutput = await buildCloudflareServerRouteModule({
-          filename: route.file,
-          vitePlugins: options.vitePlugins,
-        });
-        const serverRouteFile = `routes/${routeId}.${hashText(routeOutput).slice(0, 8)}.server.mjs`;
+        const serverRouteModule = serverRouteModules.entries.get(routeId);
+
+        if (serverRouteModule === undefined) {
+          throw new Error(`Missing bundled Cloudflare ${route.kind} route module.`);
+        }
 
-        await writeFile(join(options.cloudflareDir, serverRouteFile), routeOutput);
+        const serverRouteFile = serverRouteModule.fileName;
         const serverRouteImport = `./${serverRouteFile.split("/").pop() ?? serverRouteFile}`;
         routeModuleExports = [
           `export * from ${JSON.stringify(serverRouteImport)};`,
@@ -1558,20 +2470,12 @@ async function writeCloudflareRouteModules(options: {
       }
 
       await writeFile(join(options.cloudflareDir, routeModuleFile), `${routeModuleExports.join("\n")}\n`);
-      registryEntries.push(
-        `${JSON.stringify(routeFile)}: () => import(${JSON.stringify(`./${routeModuleFile}`)})`,
-      );
-      continue;
+      return `${JSON.stringify(routeFile)}: () => import(${JSON.stringify(`./${routeModuleFile}`)})`;
     }
 
     const serverOutput =
       options.serverModules[routeFile]?.analysis?.streamRoute === true ||
-      shouldBuildRouteAsStream({
-        filename: routeFile,
-        files: options.files,
-        projectRoot: options.projectRoot,
-        source,
-      })
+      options.sourceAnalysis.byRouteFile.get(routeFile)?.streamRoute === true
         ? "stream"
         : "string";
 
@@ -1579,17 +2483,21 @@ async function writeCloudflareRouteModules(options: {
       const componentOutput =
         serverOutput === "stream"
           ? await buildCloudflareStreamRouteComponentModule({
+              cacheDir: options.cacheDir,
               filename: route.file,
               projectRoot: options.projectRoot,
               routesDir: options.routesDir,
               serverModules: options.serverModules,
+              sourceAnalysis: options.sourceAnalysis,
               vitePlugins: options.vitePlugins,
             })
           : await buildCloudflareStringRouteComponentModule({
+              cacheDir: options.cacheDir,
               filename: route.file,
               projectRoot: options.projectRoot,
               routesDir: options.routesDir,
               serverModules: options.serverModules,
+              sourceAnalysis: options.sourceAnalysis,
               vitePlugins: options.vitePlugins,
             });
       const componentFile = `routes/${routeId}.${hashText(componentOutput).slice(0, 8)}.component.mjs`;
@@ -1606,16 +2514,15 @@ async function writeCloudflareRouteModules(options: {
       );
     }
 
-    if (hasLoaderExport(source)) {
+    if (options.sourceAnalysis.byRouteFile.get(routeFile)?.hasLoader === true) {
       try {
-        const loaderOutput = await buildCloudflareRouteLoaderModule({
-          filename: route.file,
-          projectRoot: options.projectRoot,
-          vitePlugins: options.vitePlugins,
-        });
-        const loaderFile = `routes/${routeId}.${hashText(loaderOutput).slice(0, 8)}.loader.mjs`;
+        const loaderModule = loaderRouteModules.entries.get(routeId);
+
+        if (loaderModule === undefined) {
+          throw new Error("Missing bundled Cloudflare loader module.");
+        }
 
-        await writeFile(join(options.cloudflareDir, loaderFile), loaderOutput);
+        const loaderFile = loaderModule.fileName;
         const loaderImport = `./${loaderFile.split("/").pop() ?? loaderFile}`;
         routeModuleExports.push(`export { loader } from ${JSON.stringify(loaderImport)};`);
       } catch (error) {
@@ -1626,10 +2533,8 @@ async function writeCloudflareRouteModules(options: {
     }
 
     await writeFile(join(options.cloudflareDir, routeModuleFile), `${routeModuleExports.join("\n")}\n`);
-    registryEntries.push(
-      `${JSON.stringify(routeFile)}: () => import(${JSON.stringify(`./${routeModuleFile}`)})`,
-    );
-  }
+    return `${JSON.stringify(routeFile)}: () => import(${JSON.stringify(`./${routeModuleFile}`)})`;
+  });
 
   const registrySource = [
     `export const routeModules = {`,
@@ -1651,14 +2556,19 @@ interface CloudflareShellFile {
 }
 
 async function buildCloudflareServerComponentModule(options: {
+  cacheDir?: string | undefined;
   filename: string;
   projectRoot: string;
   serverOutput: ServerOutputMode;
   serverModules: Record<string, BuiltServerModuleArtifact>;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const metadataModule = await buildCloudflareRouteMetadataExportModule({
+    cacheDir: options.cacheDir,
     filename: options.filename,
+    hasMetadata: buildSourceAnalysisForFile(options.sourceAnalysis, options.projectRoot, options.filename)?.hasMetadata,
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
   const entry = `import * as routeModule from ${JSON.stringify(options.filename)};
@@ -1674,6 +2584,7 @@ export const slots = routeModule.slots;`;
   return bundleCloudflareVirtualModule({
     entry,
     filename: `${options.filename}.mreact-cloudflare-component.js`,
+    cacheDir: options.cacheDir,
     modules: metadataModule === undefined
       ? new Map()
       : new Map([["mreact:metadata", metadataModule]]),
@@ -1687,43 +2598,52 @@ export const slots = routeModule.slots;`;
       cloudflareWorkspaceRuntimePlugin(),
     ],
     resolveDir: dirname(options.filename),
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
 }
 
 async function buildCloudflareStringRouteComponentModule(options: {
+  cacheDir?: string | undefined;
   filename: string;
   projectRoot: string;
   routesDir: string;
   serverModules: Record<string, BuiltServerModuleArtifact>;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const shellFiles = await cloudflareShellFilesForPage(options.routesDir, options.filename);
 
   if (shellFiles.length === 0) {
     return buildCloudflareServerComponentModule({
+      cacheDir: options.cacheDir,
       filename: options.filename,
       projectRoot: options.projectRoot,
       serverModules: options.serverModules,
       serverOutput: "string",
+      sourceAnalysis: options.sourceAnalysis,
       vitePlugins: options.vitePlugins,
     });
   }
 
   const pageModule = await buildCloudflareComponentExportModule({
+    cacheDir: options.cacheDir,
     filename: options.filename,
     projectRoot: options.projectRoot,
     serverModules: options.serverModules,
     serverOutput: "string",
+    sourceAnalysis: options.sourceAnalysis,
     vitePlugins: options.vitePlugins,
   });
   const shellModules = await Promise.all(
     shellFiles.map((shell) =>
       buildCloudflareComponentExportModule({
+        cacheDir: options.cacheDir,
         filename: shell.file,
         projectRoot: options.projectRoot,
         serverModules: options.serverModules,
         serverOutput: "string",
+        sourceAnalysis: options.sourceAnalysis,
         vitePlugins: options.vitePlugins,
       }),
     ),
@@ -1785,6 +2705,7 @@ ${cloudflareShellRuntimeSource()}`;
 
   return bundleCloudflareVirtualModule({
     entry,
+    cacheDir: options.cacheDir,
     filename: `${options.filename}.mreact-cloudflare-string-route.js`,
     modules: new Map([
       ["mreact:page", pageModule],
@@ -1792,32 +2713,39 @@ ${cloudflareShellRuntimeSource()}`;
     ]),
     plugins: [cloudflareWorkspaceRuntimePlugin()],
     resolveDir: dirname(options.filename),
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
 }
 
 async function buildCloudflareStreamRouteComponentModule(options: {
+  cacheDir?: string | undefined;
   filename: string;
   projectRoot: string;
   routesDir: string;
   serverModules: Record<string, BuiltServerModuleArtifact>;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const pageModule = await buildCloudflareComponentExportModule({
+    cacheDir: options.cacheDir,
     filename: options.filename,
     projectRoot: options.projectRoot,
     serverModules: options.serverModules,
     serverOutput: "stream",
+    sourceAnalysis: options.sourceAnalysis,
     vitePlugins: options.vitePlugins,
   });
   const shellFiles = await cloudflareShellFilesForPage(options.routesDir, options.filename);
   const shellModules = await Promise.all(
     shellFiles.map((shell) =>
       buildCloudflareComponentExportModule({
+        cacheDir: options.cacheDir,
         filename: shell.file,
         projectRoot: options.projectRoot,
         serverModules: options.serverModules,
         serverOutput: "string",
+        sourceAnalysis: options.sourceAnalysis,
         vitePlugins: options.vitePlugins,
       }),
     ),
@@ -1895,6 +2823,7 @@ ${cloudflareShellRuntimeSource()}`;
 
   return bundleCloudflareVirtualModule({
     entry,
+    cacheDir: options.cacheDir,
     filename: `${options.filename}.mreact-cloudflare-stream-route.js`,
     modules: new Map([
       ["mreact:page", pageModule],
@@ -1902,6 +2831,7 @@ ${cloudflareShellRuntimeSource()}`;
     ]),
     plugins: [cloudflareWorkspaceRuntimePlugin()],
     resolveDir: dirname(options.filename),
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
 }
@@ -2155,14 +3085,19 @@ function escapeHtml(value) {
 }
 
 async function buildCloudflareComponentExportModule(options: {
+  cacheDir?: string | undefined;
   filename: string;
   projectRoot: string;
   serverModules: Record<string, BuiltServerModuleArtifact>;
   serverOutput: ServerOutputMode;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const metadataModule = await buildCloudflareRouteMetadataExportModule({
+    cacheDir: options.cacheDir,
     filename: options.filename,
+    hasMetadata: buildSourceAnalysisForFile(options.sourceAnalysis, options.projectRoot, options.filename)?.hasMetadata,
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
   const entry = `import * as routeModule from ${JSON.stringify(options.filename)};
@@ -2177,6 +3112,7 @@ export const slots = routeModule.slots;`;
 
   return bundleCloudflareVirtualModule({
     entry,
+    cacheDir: options.cacheDir,
     filename: `${options.filename}.mreact-cloudflare-${options.serverOutput}-component.js`,
     modules: metadataModule === undefined
       ? new Map()
@@ -2191,33 +3127,142 @@ export const slots = routeModule.slots;`;
       cloudflareWorkspaceRuntimePlugin(),
     ],
     resolveDir: dirname(options.filename),
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
 }
 
-async function buildCloudflareRouteLoaderModule(options: {
-  filename: string;
+async function writeCloudflareBatchedRouteModuleChunks(
+  cloudflareDir: string,
+  modules: CloudflareBatchedRouteModules,
+): Promise<void> {
+  if (modules.chunks.some((chunk) => chunk.fileName.startsWith("routes/chunks/"))) {
+    await mkdir(join(cloudflareDir, "routes", "chunks"), { recursive: true });
+  }
+
+  await Promise.all(
+    modules.chunks.map((chunk) => writeFile(join(cloudflareDir, chunk.fileName), chunk.code)),
+  );
+}
+
+async function buildCloudflareRouteLoaderModuleBatch(options: {
+  cacheDir?: string | undefined;
+  routes: readonly { filename: string; routeId: string }[];
+  root: string;
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<CloudflareBatchedRouteModules> {
+  return await bundleCloudflareModuleBatch({
+    cacheDir: options.cacheDir,
+    entries: options.routes.map((route) => ({
+      code: cloudflareRouteLoaderModuleEntry(route.filename),
+      filename: `${route.filename}.mreact-cloudflare-loader.js`,
+      name: `${route.routeId}.loader`,
+      routeId: route.routeId,
+    })),
+    root: options.root,
+    vitePlugins: options.vitePlugins,
+  });
+}
+
+export async function __buildCloudflareRouteLoaderModuleBatchForTests(options: {
+  cacheDir?: string | undefined;
   projectRoot: string;
+  routes: readonly { filename: string; routeId: string }[];
   vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<string> {
-  const entry = `export { loader } from ${JSON.stringify(options.filename)};`;
+}): Promise<Record<string, string>> {
+  const output = await buildCloudflareRouteLoaderModuleBatch({
+    cacheDir: options.cacheDir,
+    root: options.projectRoot,
+    routes: options.routes,
+    vitePlugins: options.vitePlugins,
+  });
 
-  return bundleCloudflareModule({
-    entry,
-    filename: `${options.filename}.mreact-cloudflare-loader.js`,
+  return Object.fromEntries(
+    options.routes.map((route) => [route.routeId, output.entries.get(route.routeId)?.code ?? ""]),
+  );
+}
+
+async function buildCloudflareServerRouteModuleBatch(options: {
+  cacheDir?: string | undefined;
+  routes: readonly { filename: string; routeId: string }[];
+  root: string;
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<CloudflareBatchedRouteModules> {
+  return await bundleCloudflareModuleBatch({
+    cacheDir: options.cacheDir,
+    entries: options.routes.map((route) => ({
+      code: cloudflareServerRouteModuleEntry(route.filename),
+      filename: `${route.filename}.mreact-cloudflare-server-route.js`,
+      name: `${route.routeId}.server`,
+      routeId: route.routeId,
+    })),
+    root: options.root,
+    vitePlugins: options.vitePlugins,
+  });
+}
+
+async function bundleCloudflareModuleBatch(options: {
+  cacheDir?: string | undefined;
+  entries: readonly {
+    code: string;
+    filename: string;
+    name: string;
+    routeId: string;
+  }[];
+  root: string;
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<CloudflareBatchedRouteModules> {
+  if (options.entries.length === 0) {
+    return { chunks: [], entries: new Map() };
+  }
+
+  const output = await bundleRouterModules({
+    cacheDir: options.cacheDir,
+    chunkFileNames: "routes/chunks/[name].[hash].mjs",
+    entries: options.entries,
+    entryFileNames: "routes/[name].[hash].mjs",
+    minify: true,
+    platform: "node",
     plugins: [cloudflareWorkspaceRuntimePlugin()],
-    resolveDir: dirname(options.filename),
+    root: options.root,
+    target: "es2022",
     vitePlugins: options.vitePlugins,
   });
+  const entriesByName = new Map(options.entries.map((entry) => [entry.name, entry]));
+  const entries = new Map<string, CloudflareBatchedRouteModule>();
+
+  for (const chunk of output.chunks) {
+    if (!chunk.isEntry) {
+      continue;
+    }
+
+    const entry = entriesByName.get(chunk.name);
+
+    if (entry === undefined) {
+      continue;
+    }
+
+    entries.set(entry.routeId, {
+      code: chunk.code,
+      fileName: chunk.fileName,
+    });
+  }
+
+  return { chunks: output.chunks, entries };
+}
+
+function cloudflareRouteLoaderModuleEntry(filename: string): string {
+  return `export { loader } from ${JSON.stringify(filename)};`;
 }
 
 async function buildCloudflareRouteMetadataExportModule(options: {
+  cacheDir?: string | undefined;
   filename: string;
+  hasMetadata?: boolean | undefined;
+  root?: string | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string | undefined> {
-  const source = await readFile(options.filename, "utf8");
-
-  if (!hasMetadataExport(source)) {
+  if (options.hasMetadata !== true) {
     return undefined;
   }
 
@@ -2227,18 +3272,17 @@ export const metadata = routeMetadataModule.metadata;`;
 
   return bundleCloudflareModule({
     entry,
+    cacheDir: options.cacheDir,
     filename: `${options.filename}.mreact-cloudflare-metadata.js`,
     plugins: [cloudflareWorkspaceRuntimePlugin()],
     resolveDir: dirname(options.filename),
+    root: options.root,
     vitePlugins: options.vitePlugins,
   });
 }
 
-async function buildCloudflareServerRouteModule(options: {
-  filename: string;
-  vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<string> {
-  const entry = `import * as routeModule from ${JSON.stringify(options.filename)};
+function cloudflareServerRouteModuleEntry(filename: string): string {
+  return `import * as routeModule from ${JSON.stringify(filename)};
 
 export const GET = routeModule.GET;
 export const HEAD = routeModule.HEAD;
@@ -2250,30 +3294,26 @@ export const OPTIONS = routeModule.OPTIONS;
 export const ALL = routeModule.ALL;
 const defaultHandler = routeModule.default;
 export default defaultHandler;`;
-
-  return bundleCloudflareModule({
-    entry,
-    filename: `${options.filename}.mreact-cloudflare-server-route.js`,
-    plugins: [cloudflareWorkspaceRuntimePlugin()],
-    resolveDir: dirname(options.filename),
-    vitePlugins: options.vitePlugins,
-  });
 }
 
 async function bundleCloudflareModule(options: {
+  cacheDir?: string | undefined;
   entry: string;
   filename: string;
   plugins: RouterCompatPlugin[];
   resolveDir: string;
+  root?: string | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   const output = await bundleRouterModule({
+    cacheDir: options.cacheDir,
     code: options.entry,
     filename: options.filename,
     minify: true,
-    platform: "browser",
+    platform: "node",
     preserveExports: true,
     plugins: options.plugins,
+    root: options.root,
     target: "es2022",
     vitePlugins: options.vitePlugins,
   });
@@ -2287,14 +3327,17 @@ async function bundleCloudflareModule(options: {
 }
 
 async function bundleCloudflareVirtualModule(options: {
+  cacheDir?: string | undefined;
   entry: string;
   filename: string;
   modules: ReadonlyMap<string, string>;
   plugins: RouterCompatPlugin[];
   resolveDir: string;
+  root?: string | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<string> {
   return bundleCloudflareModule({
+    cacheDir: options.cacheDir,
     entry: options.entry,
     filename: options.filename,
     plugins: [
@@ -2323,6 +3366,7 @@ async function bundleCloudflareVirtualModule(options: {
       ...options.plugins,
     ],
     resolveDir: options.resolveDir,
+    root: options.root,
     vitePlugins: options.vitePlugins,
   });
 }
@@ -2371,7 +3415,9 @@ function cloudflareServerSourceTransformPlugin(options: {
         }
 
         const source = await readFile(args.path, "utf8");
-        const serverSource = isServerComponentFile(args.path) ? stripRouteBuildExports(source) : source;
+        const serverSource = isServerComponentFile(args.path)
+          ? stripRouteBuildExports(source, args.path)
+          : source;
         const sourceHash = hashText(serverSource);
         const routeFile = relative(options.projectRoot, args.path).replaceAll(sep, "/");
         const artifact = options.serverModules[routeFile]?.[options.serverOutput];
@@ -2616,11 +3662,13 @@ function viteManifestFromClientRoutes(routes: ClientRouteManifestEntry[]): Recor
 async function writeClientRouteBundles(options: {
   appDir: string;
   assetBaseUrl?: string | undefined;
+  cacheDir?: string | undefined;
   clientDir: string;
   clientConsolePureFunctions?: readonly string[] | undefined;
   clientRouteInferenceCache: ClientRouteInferenceCache;
   projectRoot: string;
   routes: readonly AppRoute[];
+  sourceAnalysis: BuildSourceAnalysisScope;
   sourceMapDir: string;
   sourceMaps: AppRouterClientSourceMapMode;
   vitePlugins?: readonly PluginOption[] | undefined;
@@ -2633,6 +3681,18 @@ async function writeClientRouteBundles(options: {
   };
   type PreparedClientManifestEntry = { manifest: ClientRouteManifestEntry };
   type PreparedRouteEntry = PreparedClientRouteEntry | PreparedClientManifestEntry;
+  const pageRoutes = options.routes.filter(
+    (route): route is AppRoute & { kind: "page" } => route.kind === "page",
+  );
+  const routeCssAssets = await writeRouteCssAssetBatches({
+    appDir: options.appDir,
+    cacheDir: options.cacheDir,
+    clientDir: options.clientDir,
+    pageRoutes,
+    projectRoot: options.projectRoot,
+    sourceAnalysis: options.sourceAnalysis,
+    vitePlugins: options.vitePlugins,
+  });
   const entries: PreparedRouteEntry[] = await Promise.all(
     options.routes.map(async (route) => {
       if (route.kind !== "page") {
@@ -2641,21 +3701,26 @@ async function writeClientRouteBundles(options: {
         };
       }
 
-      const css = await writeRouteCssAssets({
-        appDir: options.appDir,
-        clientDir: options.clientDir,
-        pageFile: route.file,
-        projectRoot: options.projectRoot,
-        routeId: routeIdForPath(route.path),
-        vitePlugins: options.vitePlugins,
-      });
-      const source = await readFile(route.file, "utf8");
+      const css = routeCssAssets.get(route.file) ?? [];
+      const source = buildSourceAnalysisForFile(
+        options.sourceAnalysis,
+        options.projectRoot,
+        route.file,
+      )?.source;
+
+      if (source === undefined) {
+        return {
+          manifest: { path: route.path, kind: route.kind, client: false },
+        };
+      }
+
       const clientSource = stripRouteClientSource({ code: source, filename: route.file });
       const references = await collectClientRouteReferences({
         appDir: options.appDir,
         cache: options.clientRouteInferenceCache,
         code: clientSource,
         filename: route.file,
+        routePath: route.path,
         vitePlugins: options.vitePlugins,
       });
       const navigation = await resolveNavigationRuntime({
@@ -2663,6 +3728,7 @@ async function writeClientRouteBundles(options: {
         code: source,
         filename: route.file,
         references,
+        vitePlugins: options.vitePlugins,
       });
 
       for (const diagnostic of references.diagnostics) {
@@ -2691,6 +3757,7 @@ async function writeClientRouteBundles(options: {
           clientReferenceImports: references.clientReferenceImports,
           clientReferenceManifest: references.clientReferenceManifest,
           clientNavigation: detectClientNavigationHint(source),
+          cacheDir: options.cacheDir,
           dropConsoleFunctions: options.clientConsolePureFunctions,
           filename: route.file,
           minify: true,
@@ -2714,6 +3781,7 @@ async function writeClientRouteBundles(options: {
   try {
     output = await buildClientRouteBatchOutput({
       assetBaseUrl: options.assetBaseUrl,
+      cacheDir: options.cacheDir,
       dropConsoleFunctions: options.clientConsolePureFunctions,
       minify: true,
       projectRoot: options.projectRoot,
@@ -2802,20 +3870,75 @@ async function writeClientRouteBundles(options: {
   });
 }
 
-async function writeRouteCssAssets(options: {
+async function writeRouteCssAssetBatches(options: {
   appDir: string;
+  cacheDir?: string | undefined;
   clientDir: string;
-  pageFile: string;
+  pageRoutes: readonly (AppRoute & { kind: "page" })[];
   projectRoot: string;
-  routeId: string;
+  sourceAnalysis: BuildSourceAnalysisScope;
   vitePlugins?: readonly PluginOption[] | undefined;
-}): Promise<string[]> {
-  const cssFiles = await collectRouteCssFiles({
-    appDir: options.appDir,
-    pageFile: options.pageFile,
-    projectRoot: options.projectRoot,
+}): Promise<Map<string, string[]>> {
+  const cssInputs = await mapWithBuildConcurrency(options.pageRoutes, async (route) => {
+    const cssFiles = await collectRouteCssFilesFromSources({
+      appDir: options.appDir,
+      pageFile: route.file,
+      projectRoot: options.projectRoot,
+      readSource: (file) => buildSourceAnalysisForFile(options.sourceAnalysis, options.projectRoot, file)?.source,
+    });
+
+    return { cssFiles, route };
   });
+  const groups = new Map<string, { cssFiles: string[]; routeIds: string[]; routeFiles: string[] }>();
+
+  for (const { cssFiles, route } of cssInputs) {
+    if (cssFiles.length === 0) {
+      continue;
+    }
+
+    const key = cssFiles.join("\0");
+    const group = groups.get(key) ?? { cssFiles, routeFiles: [], routeIds: [] };
+    group.routeFiles.push(route.file);
+    group.routeIds.push(routeIdForPath(route.path));
+    groups.set(key, group);
+  }
 
+  const writtenGroups = await mapWithBuildConcurrency([...groups.entries()], async ([key, group]) => [
+    key,
+    await writeRouteCssAssetsForFiles({
+      cacheDir: options.cacheDir,
+      clientDir: options.clientDir,
+      cssFiles: group.cssFiles,
+      pageFile: group.routeFiles[0] ?? options.appDir,
+      projectRoot: options.projectRoot,
+      routeIds: group.routeIds,
+      vitePlugins: options.vitePlugins,
+    }),
+  ] as const);
+  const cssByGroup = new Map(writtenGroups);
+  const cssByRoute = new Map<string, string[]>();
+
+  for (const [key, group] of groups) {
+    const css = cssByGroup.get(key) ?? [];
+
+    for (const routeFile of group.routeFiles) {
+      cssByRoute.set(routeFile, css);
+    }
+  }
+
+  return cssByRoute;
+}
+
+async function writeRouteCssAssetsForFiles(options: {
+  cacheDir?: string | undefined;
+  clientDir: string;
+  cssFiles: readonly string[];
+  pageFile: string;
+  projectRoot: string;
+  routeIds: readonly string[];
+  vitePlugins?: readonly PluginOption[] | undefined;
+}): Promise<string[]> {
+  const cssFiles = [...options.cssFiles];
   if (cssFiles.length === 0) {
     return [];
   }
@@ -2825,22 +3948,27 @@ async function writeRouteCssAssets(options: {
     "export default undefined;",
   ].join("\n");
   const output = await bundleRouterModule({
+    cacheDir: options.cacheDir,
     code,
     filename: options.pageFile,
     minify: true,
     platform: "browser",
+    root: options.projectRoot,
     vitePlugins: options.vitePlugins,
   });
   const cssAssets = (output.assets ?? []).filter((asset) => asset.fileName.endsWith(".css"));
   const written: string[] = [];
+  const routeStem = options.routeIds.length === 1
+    ? (options.routeIds[0] ?? "index")
+    : `shared.${hashText(cssFiles.join("\0")).slice(0, 8)}`;
 
-  for (const asset of cssAssets) {
+  for (const [index, asset] of cssAssets.entries()) {
     const source =
       typeof asset.source === "string"
         ? asset.source
         : Buffer.from(asset.source).toString("utf8");
     const hash = createHash("sha256").update(source).digest("hex").slice(0, 8);
-    const cssFile = `assets/routes/${options.routeId}.${hash}.css`;
+    const cssFile = `assets/routes/${routeStem}${cssAssets.length === 1 ? "" : `.${index}`}.${hash}.css`;
 
     await mkdir(dirname(join(options.clientDir, cssFile)), { recursive: true });
     await writeFile(join(options.clientDir, cssFile), source);
@@ -2945,7 +4073,15 @@ export async function packageAwsLambdaArtifact(
     fromDir: dirname(options.fromDir),
     outDir: options.outDir,
   });
-  await writeFile(join(options.outDir, "mreact-handler.mjs"), awsLambdaHandlerSource(".mreact"));
+  if (options.handlerEntry === undefined) {
+    await writeFile(join(options.outDir, "mreact-handler.mjs"), awsLambdaHandlerSource(".mreact"));
+  } else {
+    await writeAwsLambdaCustomHandlerArtifact({
+      entry: options.handlerEntry,
+      projectRoot: dirname(options.fromDir),
+      outDir: options.outDir,
+    });
+  }
 
   if (options.skipRuntimeDependencyCheck !== true) {
     await assertAwsLambdaRuntimeDependencies(options.outDir);
@@ -2968,6 +4104,44 @@ export async function packageAwsLambdaArtifact(
   return manifest;
 }
 
+async function writeAwsLambdaCustomHandlerArtifact(options: {
+  entry: string;
+  outDir: string;
+  projectRoot: string;
+}): Promise<void> {
+  const entry = resolve(options.entry);
+  const output = await bundleRouterModule({
+    code: await readFile(entry, "utf8"),
+    filename: entry,
+    outfile: "mreact-handler.mjs",
+    platform: "node",
+    plugins: [externalizePackageImportsPlugin()],
+    preserveExports: true,
+    root: options.projectRoot,
+    target: "node24",
+  });
+
+  await writeFile(join(options.outDir, "mreact-handler.mjs"), output.code);
+}
+
+function externalizePackageImportsPlugin(): RouterCompatPlugin {
+  return {
+    name: "mreact-router-externalize-package-imports",
+    setup(buildApi) {
+      buildApi.onResolve({ filter: /^(?:node:|[A-Za-z@])/ }, (args) =>
+        isBarePackageImport(args.path) ? { external: true, path: args.path } : undefined,
+      );
+    },
+  };
+}
+
+function isBarePackageImport(specifier: string): boolean {
+  return (
+    specifier.startsWith("node:") ||
+    (!specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.includes("\\"))
+  );
+}
+
 async function assertAwsLambdaRuntimeDependencies(outDir: string): Promise<void> {
   try {
     const info = await stat(join(outDir, "node_modules", "@reckona", "mreact-router", "package.json"));
@@ -3146,31 +4320,34 @@ export const handler = await createPreloadedAwsLambdaRequestHandler({
 }
 
 async function validateProductionRoutes(options: {
+  clientRouteInferenceCache: ClientRouteInferenceCache;
   files: Record<string, string>;
+  project: ResolvedAppRouterProject;
   projectRoot: string;
   routes: readonly AppRoute[];
+  sourceAnalysis: BuildSourceAnalysisScope;
+  serverTransformCache: ServerTransformCache;
+  vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<void> {
   for (const route of options.routes) {
     if (route.kind !== "page") {
       continue;
     }
 
-    const source = await readFile(route.file, "utf8");
     const filename = relative(options.projectRoot, route.file);
-    const output = transform({
-      code: stripRouteBuildExports(source),
-      dev: false,
+    const analysis = options.sourceAnalysis.byRouteFile.get(filename.split(sep).join("/"));
+
+    if (analysis === undefined) {
+      continue;
+    }
+
+    const output = await transformServerRouteSource({
+      cache: options.serverTransformCache,
+      code: analysis.routeCode,
+      clientBoundaryImports: analysis.clientBoundaryImports,
       filename: route.file,
-      serverEscape: nativeEscapeTransform,
-      serverOutput: shouldBuildRouteAsStream({
-        filename,
-        files: options.files,
-        projectRoot: options.projectRoot,
-        source,
-      })
-        ? "stream"
-        : "string",
-      target: "server",
+      moduleContextCache: options.clientRouteInferenceCache,
+      serverOutput: analysis.streamRoute ? "stream" : "string",
     });
     const fatalDiagnostics = output.diagnostics.filter(
       (diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER",
@@ -3192,18 +4369,26 @@ async function collectBuildFiles(
   const files: Record<string, string> = {};
 
   for (const directory of allowedSourceDirs) {
-    for (const file of await collectFiles(directory)) {
+    const sourceFiles = (await collectFiles(directory)).flatMap((file) => {
       if (isAppFileConventionAsset(file, appDir)) {
-        continue;
+        return [];
       }
 
       const relativeFile = relative(projectRoot, file);
 
       if (relativeFile === "" || relativeFile.startsWith("..") || relativeFile.startsWith(sep)) {
-        continue;
+        return [];
       }
 
-      files[relativeFile] = await readFile(file, "utf8");
+      return [{ file, relativeFile }];
+    });
+    const fileContents = await mapWithBuildConcurrency(sourceFiles, async ({ file, relativeFile }) => [
+      relativeFile,
+      await readFile(file, "utf8"),
+    ] as const);
+
+    for (const [relativeFile, source] of fileContents) {
+      files[relativeFile] = source;
     }
   }
 
@@ -3221,22 +4406,21 @@ function isAppFileConventionAsset(file: string, appDir: string): boolean {
 
 async function collectFiles(directory: string): Promise<string[]> {
   const entries = await readdir(directory, { withFileTypes: true });
-  const files: string[] = [];
-
-  for (const entry of entries) {
+  const nestedFiles = await mapWithBuildConcurrency(entries, async (entry) => {
     const path = join(directory, entry.name);
 
     if (entry.isDirectory()) {
-      files.push(...(await collectFiles(path)));
-      continue;
+      return await collectFiles(path);
     }
 
     if (entry.isFile()) {
-      files.push(path);
+      return [path];
     }
-  }
 
-  return files;
+    return [];
+  });
+
+  return nestedFiles.flat();
 }
 
 function hashText(text: string): string {