@reckona/mreact-router 0.0.96 → 0.0.98

package/dist/build.js

@@ -1,12 +1,14 @@
 import { createHash } from "node:crypto";
 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, formatDiagnostic, hasModuleDirective, transform, } from "@reckona/mreact-compiler";
 import { transformCompilerModuleContext } from "@reckona/mreact-compiler/internal";
 import { compilerModuleContextForSource, collectClientRouteReferences, createClientRouteInferenceCache, detectClientNavigationHint, formatClientRouteInferenceDiagnostic, inferClientRouteModule, resolveNavigationRuntime, } from "./client-route-inference.js";
 import { buildClientRouteBatchOutput, buildNavigationRuntimeBundle, clientScriptForPath, routeIdForPath, } 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 { appFileConventionForRootFilename, } from "./file-conventions.js";
 import { resolveAppRouterProjectOptions, resolveBuildTargets, } from "./config.js";
@@ -14,110 +16,250 @@ import { routeCachePolicyFromSource } from "./cache.js";
 import { bundleMiddlewareModuleCode, renderAppRequest } from "./render.js";
 import { createAppRouterImportPolicyPlugin } from "./import-policy.js";
 import { hasGenerateStaticParamsExport, hasLoaderExport, hasPrerenderExport, isStreamRouteSource, routeClosureMayUseAwaitBoundary, stripRouteBuildExports, stripRouteClientOnlyExports, stripRouteClientSource, stripRouteLoaderOnlyExports, stripRouteMetadataOnlyExports, stripRouteRequestOnlyExports, } from "./route-source.js";
-import { bundleRouterModule, } from "./bundle-pipeline.js";
-import { collectRouteCssFiles } from "./route-styles.js";
+import { bundleRouterModule, bundleRouterModules, } from "./bundle-pipeline.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";
 const nativeEscapeTransform = {
     batchImportName: "escapeHtmlBatch",
     batchImportSource: "@reckona/mreact-router/native-escape",
 };
+const defaultBuildConcurrency = Math.max(1, Math.min(2, availableParallelism()));
+const serverArtifactFilesystemConcurrency = 2;
 export async function buildApp(options) {
+    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 = new Map();
     const serverDir = join(options.outDir, "server");
     const clientDir = join(options.outDir, "client");
     const cloudflareDir = join(options.outDir, "cloudflare");
-    await validateProductionRoutes({ files, projectRoot: project.projectRoot, routes });
-    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();
-    const serverActionManifest = await collectBuildServerActionManifest({
-        files,
-        projectRoot: project.projectRoot,
-        routes,
-        routesDir: project.routesDir,
-    });
+    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,
+        }));
+    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,
+        }));
+    }
+    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 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
         ? clientRoutes
         : clientRoutes.map((route) => route.navigation === true && !route.client
             ? { ...route, navigationScript: navigationRuntimeScript }
             : route);
-    const prerenderedRoutes = await prerenderStaticRoutes({
-        appDir: project.routesDir,
-        assetBaseUrl: project.assetBaseUrl,
-        clientRoutes: clientManifestRoutes,
-        project,
-        routes,
-        serverModules,
-        vitePlugins,
-    });
-    let cloudflareRouteModules;
-    if (shouldBuildCloudflare) {
-        cloudflareRouteModules = await writeCloudflareRouteModules({
-            cloudflareDir,
-            files,
-            prerenderedRoutes,
-            projectRoot: project.projectRoot,
-            routesDir: project.routesDir,
+    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;
+    if (shouldBuildCloudflare) {
+        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([...serverActionManifest.routeReferences.entries()].sort(([left], [right]) => left.localeCompare(right)));
     const serverManifest = {
@@ -151,82 +293,263 @@ export async function buildApp(options) {
         ...(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);
-    }
-    if (shouldBuildCloudflare) {
-        await writeCloudflareWorkerArtifact({
-            cloudflareDir,
-            clientManifest,
-            modulesFile: cloudflareRouteModules?.registryFile ?? "route-modules.mjs",
-            serverManifest,
+    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 (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 writeServerModuleArtifactFiles(serverDir, serverModules) {
+async function timeBuildPhase(sink, phase, run) {
+    const startedAt = performance.now();
+    try {
+        return await run();
+    }
+    finally {
+        sink({
+            ms: roundBuildPhaseMs(performance.now() - startedAt),
+            phase,
+        });
+    }
+}
+function roundBuildPhaseMs(value) {
+    return Math.round(value * 100) / 100;
+}
+async function mapWithBuildConcurrency(items, map, concurrency = defaultBuildConcurrency) {
+    if (items.length === 0) {
+        return [];
+    }
+    const workerCount = Math.max(1, Math.min(concurrency, items.length));
+    const results = [];
+    results.length = items.length;
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            results[index] = await map(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        await runWorker();
+    }));
+    return results;
+}
+export async function __mapWithBuildConcurrencyForTests(items, map, concurrency) {
+    return await mapWithBuildConcurrency(items, map, concurrency);
+}
+async function analyzeBuildRouteSources(options) {
+    const byFile = new Map();
+    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.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,
+                }),
+            },
+        ];
+    });
+    const byRouteFile = new Map();
+    for (const entry of routeAnalyses) {
+        if (entry !== undefined) {
+            byRouteFile.set(entry[0], entry[1]);
+        }
+    }
+    return { byFile, byRouteFile };
+}
+function analyzeBuildSource(source, filename) {
+    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, projectRoot, file) {
+    return sourceAnalysis.byFile.get(relative(projectRoot, file).split(sep).join("/"));
+}
+async function buildPublicAssetManifest(project, clientDir) {
+    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, serverModules, portableRuntimePackages = []) {
     const files = {};
     const renderFiles = {};
     const requestFiles = {};
     const modulesDir = join(serverDir, "server-modules");
-    for (const [file, artifact] of Object.entries(serverModules)) {
-        const externalized = await externalizeServerModuleArtifactCode(serverDir, artifact);
+    const artifactEntries = Object.entries(serverModules);
+    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(artifactEntries, async ([file, artifact]) => {
+        const externalized = await externalizeServerModuleArtifactCode(serverDir, artifact, portableRuntimePackages);
         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;
-            continue;
+            return { file, renderArtifactFile, requestArtifactFile };
         }
         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;
+        return { artifactFile, file };
+    }, serverArtifactFilesystemConcurrency);
+    for (const artifact of writtenArtifacts) {
+        if ("requestArtifactFile" in artifact) {
+            requestFiles[artifact.file] = artifact.requestArtifactFile;
+            renderFiles[artifact.file] = artifact.renderArtifactFile;
+            continue;
+        }
+        files[artifact.file] = artifact.artifactFile;
     }
     return { files, renderFiles, requestFiles };
 }
-async function externalizeServerModuleArtifactCode(serverDir, artifact) {
+export async function __writeServerModuleArtifactFilesForTests(serverDir, serverModules) {
+    return await writeServerModuleArtifactFiles(serverDir, serverModules);
+}
+async function externalizeServerModuleArtifactCode(serverDir, artifact, portableRuntimePackages) {
     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
             ? {}
             : {
-                routeMetadata: await externalizeServerModuleOutputCode(serverDir, artifact.routeMetadata, "code"),
+                routeMetadata: await externalizeServerModuleOutputCode(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),
+            }),
     };
 }
-async function externalizeServerModuleOutputCode(serverDir, output, kind) {
-    const moduleCode = kind === "bundle" ? output.bundleCode : output.code;
+async function externalizeServerModuleOutputCode(serverDir, output, kind, portableRuntimePackages) {
+    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 {
         code: kind === "code" ? "" : output.code,
@@ -235,6 +558,27 @@ async function externalizeServerModuleOutputCode(serverDir, output, kind) {
         sourceHash: output.sourceHash,
     };
 }
+function rewritePortableRuntimePackageImports(code, runtimePackages) {
+    if (runtimePackages.length === 0 || !code.includes("file://")) {
+        return code;
+    }
+    return code.replace(/\b(from\s+|import\s*)["'](?<specifier>file:\/\/[^"']+)["']/gu, (match, prefix, specifier) => {
+        const packageName = specifier === undefined ? undefined : runtimePackageForFileUrl(specifier, runtimePackages);
+        return packageName === undefined ? match : `${prefix}"${packageName}"`;
+    });
+}
+function runtimePackageForFileUrl(specifier, runtimePackages) {
+    let filePath;
+    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) {
     return {
         ...(artifact.analysis === undefined ? {} : { analysis: artifact.analysis }),
@@ -604,15 +948,14 @@ async function prerenderStaticRoutes(options) {
         join(options.project.projectRoot, file),
         artifact,
     ]));
-    for (const route of options.routes) {
-        if (route.kind !== "page") {
-            continue;
-        }
-        const source = await readFile(route.file, "utf8");
-        if (!hasPrerenderExport(source)) {
-            continue;
+    const prerenderedEntries = await mapWithBuildConcurrency(options.routes.filter((route) => route.kind === "page"), async (route) => {
+        const routeFile = relative(options.project.projectRoot, route.file).split(sep).join("/");
+        const analysis = options.sourceAnalysis.byRouteFile.get(routeFile);
+        if (analysis === undefined || !analysis.hasPrerender) {
+            return [];
         }
-        for (const pathname of await prerenderPathsForRoute(route, source, options.vitePlugins)) {
+        const entries = [];
+        for (const pathname of await prerenderPathsForRoute(route, analysis, options.vitePlugins)) {
             const response = await renderAppRequest({
                 appDir: options.appDir,
                 assetBaseUrl: options.assetBaseUrl,
@@ -626,24 +969,33 @@ async function prerenderStaticRoutes(options) {
             response.headers.forEach((value, key) => {
                 headers[key] = value;
             });
-            prerendered[pathname] = {
-                headers,
-                html: await response.text(),
-                status: response.status,
-            };
+            entries.push([
+                pathname,
+                {
+                    headers,
+                    html: await response.text(),
+                    status: response.status,
+                },
+            ]);
+        }
+        return entries;
+    });
+    for (const entries of prerenderedEntries) {
+        for (const [pathname, route] of entries) {
+            prerendered[pathname] = route;
         }
     }
     return prerendered;
 }
-async function prerenderPathsForRoute(route, source, vitePlugins) {
+async function prerenderPathsForRoute(route, analysis, vitePlugins) {
     if (route.segments.every((segment) => segment.kind === "static")) {
         return [route.path];
     }
-    if (!hasGenerateStaticParamsExport(source)) {
+    if (!analysis.hasGenerateStaticParams) {
         return [];
     }
     const module = await importAppRouterSourceModule({
-        code: source,
+        code: analysis.source,
         label: `generate-static-params:${route.file}`,
         resolveDir: dirname(route.file),
         sourcefile: route.file,
@@ -683,119 +1035,171 @@ async function buildServerModuleArtifacts(options) {
         projectRoot: options.project.projectRoot,
     };
     const artifacts = {};
-    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);
         }
         if (route?.kind === "server" || route?.kind === "metadata") {
             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 = [];
     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();
+    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 = {};
         if (requestArtifactFiles.has(file) ||
             loaderArtifactFiles.has(file) ||
             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),
                 };
             }
             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),
                 };
             }
             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] : 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"]
             : ["string"];
-        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;
-        for (const diagnostic of clientInference.diagnostics) {
+        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 ?? []) {
             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({
+        const serverOutputArtifacts = await mapWithBuildConcurrency(serverOutputs, async (serverOutput) => {
+            const output = await transformServerRouteSource({
+                cache: options.serverTransformCache,
                 code,
                 clientBoundaryImports,
-                dev: false,
                 filename: join(options.projectRoot, file),
-                serverEscape: nativeEscapeTransform,
+                moduleContextCache: options.clientRouteInferenceCache,
                 serverOutput,
-                target: "server",
             });
             const fatalDiagnostics = output.diagnostics.filter((diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER");
             if (fatalDiagnostics.length > 0) {
@@ -803,28 +1207,52 @@ async function buildServerModuleArtifacts(options) {
                     streamRoute &&
                     route?.kind === "page" &&
                     fatalDiagnostics.every((diagnostic) => diagnostic.code === "MR_UNSUPPORTED_AWAIT_INNER_COMPONENT")) {
-                    continue;
+                    return undefined;
                 }
                 throw new Error(fatalDiagnostics.map((diagnostic) => formatDiagnostic(file, diagnostic)).join("\n"));
             }
-            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),
-            };
+            if (serverOutput === "string" &&
+                streamRoute &&
+                route?.kind === "page" &&
+                source.includes("<Await") &&
+                /\bLink\b/.test(source)) {
+                // 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;
+            }
+            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),
+                },
+            ];
+        });
+        for (const entry of serverOutputArtifacts) {
+            if (entry !== undefined) {
+                artifact[entry[0]] = entry[1];
+            }
+        }
+        return [file, artifact];
+    });
+    for (const entry of artifactEntries) {
+        if (entry !== undefined) {
+            artifacts[entry[0]] = entry[1];
         }
-        artifacts[file] = artifact;
     }
     return artifacts;
 }
@@ -833,6 +1261,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,
@@ -843,23 +1272,54 @@ async function buildServerComponentBundleArtifactCode(options) {
         vitePlugins: options.vitePlugins,
     });
 }
+async function transformServerRouteSource(options) {
+    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) {
-    const cachePolicy = routeCachePolicyFromSource(options.source);
     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,
     };
 }
 function shouldBuildRouteAsStream(options) {
-    return (isStreamRouteSource(options.source) ||
+    return (isStreamRouteSource(options.source, sourceFilenameForBuildAnalysis(options.projectRoot, options.filename)) ||
         routeClosureMayUseAwaitBoundary({
             filename: options.filename,
             files: options.files,
@@ -867,6 +1327,9 @@ function shouldBuildRouteAsStream(options) {
             source: options.source,
         }));
 }
+function sourceFilenameForBuildAnalysis(projectRoot, filename) {
+    return filename.startsWith("/") ? filename : join(projectRoot, filename);
+}
 function resolveBuildLocalSourceImport(files, importer, specifier) {
     if (!specifier.startsWith(".")) {
         return undefined;
@@ -882,6 +1345,9 @@ function resolveBuildLocalSourceImport(files, importer, specifier) {
 function usesRuntimeCacheControl(code) {
     return /\bcacheControl\s*\(/.test(code);
 }
+function routeRequestArtifactBatchKey(file, kind) {
+    return `${kind}:${file}`;
+}
 function authIncludesClaims(code) {
     return /\bexport\s+const\s+auth\s*=\s*["']include-claims["']\s*;?/.test(code);
 }
@@ -899,14 +1365,18 @@ async function buildRequestModuleArtifactCode(options) {
         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,
-        code: stripRouteRequestOnlyExports(options.source),
+        bundleCache: options.bundleCache,
+        cacheDir: options.cacheDir,
+        code: stripRouteRequestOnlyExports(options.source, options.filename),
         filename: options.filename,
         importPolicy: options.importPolicy,
         vitePlugins: options.vitePlugins,
@@ -918,19 +1388,103 @@ async function bundleRouteLoaderModuleCode(options) {
         label: "Loader",
     });
 }
-async function bundleRouteMetadataModuleCode(options) {
-    return await bundleRouteRequestModuleCode({
-        ...options,
-        label: "Metadata",
+async function bundleRouteRequestModuleBatchCode(options) {
+    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,
+            }),
+        ]);
+        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);
+        if (chunk === undefined) {
+            throw new Error(`Failed to compile request artifact for ${entry.filename}.`);
+        }
+        return [entry.key, chunk.code];
+    }));
+}
+export async function __bundleRouteRequestModuleBatchForTests(options) {
+    return Object.fromEntries(await bundleRouteRequestModuleBatchCode({
+        appDir: options.appDir,
+        cacheDir: options.cacheDir,
+        entries: options.entries,
+        importPolicy: options.importPolicy,
+        vitePlugins: options.vitePlugins,
+    }));
 }
 async function bundleRouteRequestModuleCode(options) {
     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,
@@ -944,6 +1498,31 @@ async function bundleRouteRequestModuleCode(options) {
     }
     return code;
 }
+function routeRequestBundleCacheKey(options) {
+    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) {
+    return JSON.stringify(value);
+}
 function isMiddlewareFile(appDir, file) {
     return file === join(appDir, "middleware.ts") || file === join(appDir, "middleware.mreact.ts");
 }
@@ -968,23 +1547,50 @@ async function readDeclaredProjectPackages(projectRoot) {
 }
 async function writeCloudflareRouteModules(options) {
     const routesDir = join(options.cloudflareDir, "routes");
-    const requiredRoutes = options.routes.filter((route) => cloudflareRouteRequiresGeneratedModule(route, options.prerenderedRoutes));
-    const registryEntries = [];
-    await mkdir(routesDir, { recursive: true });
-    for (const route of requiredRoutes) {
+    const requiredRoutes = await Promise.all(options.routes
+        .filter((route) => cloudflareRouteRequiresGeneratedModule(route, options.prerenderedRoutes))
+        .flatMap((route) => {
         const routeFile = relative(options.projectRoot, route.file).replaceAll(sep, "/");
-        const source = await readFile(route.file, "utf8");
-        const routeId = routeIdForPath(route.path);
+        const analysis = options.sourceAnalysis.byFile.get(routeFile);
+        return analysis === undefined
+            ? []
+            : [{
+                    route,
+                    routeFile,
+                    routeId: routeIdForPath(route.path),
+                }];
+    }));
+    await mkdir(routesDir, { recursive: true });
+    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;
         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`;
-                await writeFile(join(options.cloudflareDir, serverRouteFile), routeOutput);
+                const serverRouteModule = serverRouteModules.entries.get(routeId);
+                if (serverRouteModule === undefined) {
+                    throw new Error(`Missing bundled Cloudflare ${route.kind} route module.`);
+                }
+                const serverRouteFile = serverRouteModule.fileName;
                 const serverRouteImport = `./${serverRouteFile.split("/").pop() ?? serverRouteFile}`;
                 routeModuleExports = [
                     `export * from ${JSON.stringify(serverRouteImport)};`,
@@ -997,32 +1603,30 @@ async function writeCloudflareRouteModules(options) {
                 throw new Error(`Failed to build Cloudflare ${route.kind} route module for ${routeFile}: ${errorMessage(error)}`);
             }
             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";
         try {
             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`;
@@ -1035,15 +1639,13 @@ async function writeCloudflareRouteModules(options) {
         catch (error) {
             throw new Error(`Failed to build Cloudflare route module for ${routeFile}: ${errorMessage(error)}`);
         }
-        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`;
-                await writeFile(join(options.cloudflareDir, loaderFile), loaderOutput);
+                const loaderModule = loaderRouteModules.entries.get(routeId);
+                if (loaderModule === undefined) {
+                    throw new Error("Missing bundled Cloudflare loader module.");
+                }
+                const loaderFile = loaderModule.fileName;
                 const loaderImport = `./${loaderFile.split("/").pop() ?? loaderFile}`;
                 routeModuleExports.push(`export { loader } from ${JSON.stringify(loaderImport)};`);
             }
@@ -1052,8 +1654,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 = {`,
         ...registryEntries.map((entry) => `  ${entry},`),
@@ -1066,7 +1668,10 @@ async function writeCloudflareRouteModules(options) {
 }
 async function buildCloudflareServerComponentModule(options) {
     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)};
@@ -1081,6 +1686,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]]),
@@ -1094,6 +1700,7 @@ export const slots = routeModule.slots;`;
             cloudflareWorkspaceRuntimePlugin(),
         ],
         resolveDir: dirname(options.filename),
+        root: options.projectRoot,
         vitePlugins: options.vitePlugins,
     });
 }
@@ -1101,25 +1708,31 @@ async function buildCloudflareStringRouteComponentModule(options) {
     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,
     })));
     const shellImports = shellFiles.map((_, index) => `import * as shell${index} from "mreact:shell-${index}";`);
@@ -1175,6 +1788,7 @@ async function renderRouteSlots(slots, props) {
 ${cloudflareShellRuntimeSource()}`;
     return bundleCloudflareVirtualModule({
         entry,
+        cacheDir: options.cacheDir,
         filename: `${options.filename}.mreact-cloudflare-string-route.js`,
         modules: new Map([
             ["mreact:page", pageModule],
@@ -1182,23 +1796,28 @@ ${cloudflareShellRuntimeSource()}`;
         ]),
         plugins: [cloudflareWorkspaceRuntimePlugin()],
         resolveDir: dirname(options.filename),
+        root: options.projectRoot,
         vitePlugins: options.vitePlugins,
     });
 }
 async function buildCloudflareStreamRouteComponentModule(options) {
     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,
     })));
     const shellImports = shellFiles.map((_, index) => `import * as shell${index} from "mreact:shell-${index}";`);
@@ -1270,6 +1889,7 @@ async function renderRouteSlots(slots, props) {
 ${cloudflareShellRuntimeSource()}`;
     return bundleCloudflareVirtualModule({
         entry,
+        cacheDir: options.cacheDir,
         filename: `${options.filename}.mreact-cloudflare-stream-route.js`,
         modules: new Map([
             ["mreact:page", pageModule],
@@ -1277,6 +1897,7 @@ ${cloudflareShellRuntimeSource()}`;
         ]),
         plugins: [cloudflareWorkspaceRuntimePlugin()],
         resolveDir: dirname(options.filename),
+        root: options.projectRoot,
         vitePlugins: options.vitePlugins,
     });
 }
@@ -1529,7 +2150,10 @@ function escapeHtml(value) {
 }
 async function buildCloudflareComponentExportModule(options) {
     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)};
@@ -1543,6 +2167,7 @@ export const metadata = metadataModule.metadata;
 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()
@@ -1557,22 +2182,89 @@ export const slots = routeModule.slots;`;
             cloudflareWorkspaceRuntimePlugin(),
         ],
         resolveDir: dirname(options.filename),
+        root: options.projectRoot,
         vitePlugins: options.vitePlugins,
     });
 }
-async function buildCloudflareRouteLoaderModule(options) {
-    const entry = `export { loader } from ${JSON.stringify(options.filename)};`;
-    return bundleCloudflareModule({
-        entry,
-        filename: `${options.filename}.mreact-cloudflare-loader.js`,
+async function writeCloudflareBatchedRouteModuleChunks(cloudflareDir, modules) {
+    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) {
+    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) {
+    const output = await buildCloudflareRouteLoaderModuleBatch({
+        cacheDir: options.cacheDir,
+        root: options.projectRoot,
+        routes: options.routes,
+        vitePlugins: options.vitePlugins,
+    });
+    return Object.fromEntries(options.routes.map((route) => [route.routeId, output.entries.get(route.routeId)?.code ?? ""]));
+}
+async function buildCloudflareServerRouteModuleBatch(options) {
+    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) {
+    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();
+    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) {
+    return `export { loader } from ${JSON.stringify(filename)};`;
 }
 async function buildCloudflareRouteMetadataExportModule(options) {
-    const source = await readFile(options.filename, "utf8");
-    if (!hasMetadataExport(source)) {
+    if (options.hasMetadata !== true) {
         return undefined;
     }
     const entry = `import * as routeMetadataModule from ${JSON.stringify(options.filename)};
@@ -1580,14 +2272,16 @@ export const generateMetadata = routeMetadataModule.generateMetadata;
 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) {
-    const entry = `import * as routeModule from ${JSON.stringify(options.filename)};
+function cloudflareServerRouteModuleEntry(filename) {
+    return `import * as routeModule from ${JSON.stringify(filename)};
 
 export const GET = routeModule.GET;
 export const HEAD = routeModule.HEAD;
@@ -1599,22 +2293,17 @@ 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) {
     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,
     });
@@ -1626,6 +2315,7 @@ async function bundleCloudflareModule(options) {
 }
 async function bundleCloudflareVirtualModule(options) {
     return bundleCloudflareModule({
+        cacheDir: options.cacheDir,
         entry: options.entry,
         filename: options.filename,
         plugins: [
@@ -1652,6 +2342,7 @@ async function bundleCloudflareVirtualModule(options) {
             ...options.plugins,
         ],
         resolveDir: options.resolveDir,
+        root: options.root,
         vitePlugins: options.vitePlugins,
     });
 }
@@ -1686,7 +2377,9 @@ function cloudflareServerSourceTransformPlugin(options) {
                     return undefined;
                 }
                 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];
@@ -1872,27 +2565,36 @@ function viteManifestFromClientRoutes(routes) {
     return manifest;
 }
 async function writeClientRouteBundles(options) {
+    const pageRoutes = options.routes.filter((route) => 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 = await Promise.all(options.routes.map(async (route) => {
         if (route.kind !== "page") {
             return {
                 manifest: { path: route.path, kind: route.kind, client: false },
             };
         }
-        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({
@@ -1900,6 +2602,7 @@ async function writeClientRouteBundles(options) {
             code: source,
             filename: route.file,
             references,
+            vitePlugins: options.vitePlugins,
         });
         for (const diagnostic of references.diagnostics) {
             console.warn(formatClientRouteInferenceDiagnostic(diagnostic));
@@ -1925,6 +2628,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,
@@ -1942,6 +2646,7 @@ async function writeClientRouteBundles(options) {
     try {
         output = await buildClientRouteBatchOutput({
             assetBaseUrl: options.assetBaseUrl,
+            cacheDir: options.cacheDir,
             dropConsoleFunctions: options.clientConsolePureFunctions,
             minify: true,
             projectRoot: options.projectRoot,
@@ -2012,12 +2717,51 @@ async function writeClientRouteBundles(options) {
         };
     });
 }
-async function writeRouteCssAssets(options) {
-    const cssFiles = await collectRouteCssFiles({
-        appDir: options.appDir,
-        pageFile: options.pageFile,
-        projectRoot: options.projectRoot,
+async function writeRouteCssAssetBatches(options) {
+    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();
+    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,
+        }),
+    ]);
+    const cssByGroup = new Map(writtenGroups);
+    const cssByRoute = new Map();
+    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) {
+    const cssFiles = [...options.cssFiles];
     if (cssFiles.length === 0) {
         return [];
     }
@@ -2026,20 +2770,25 @@ 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 = [];
-    for (const asset of cssAssets) {
+    const routeStem = options.routeIds.length === 1
+        ? (options.routeIds[0] ?? "index")
+        : `shared.${hashText(cssFiles.join("\0")).slice(0, 8)}`;
+    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);
         written.push(cssFile);
@@ -2110,7 +2859,16 @@ export async function packageAwsLambdaArtifact(options) {
         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);
     }
@@ -2125,6 +2883,32 @@ export async function packageAwsLambdaArtifact(options) {
     await writeFile(join(options.outDir, "mreact-lambda-artifact.json"), JSON.stringify(manifest, null, 2));
     return manifest;
 }
+async function writeAwsLambdaCustomHandlerArtifact(options) {
+    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() {
+    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) {
+    return (specifier.startsWith("node:") ||
+        (!specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.includes("\\")));
+}
 async function assertAwsLambdaRuntimeDependencies(outDir) {
     try {
         const info = await stat(join(outDir, "node_modules", "@reckona", "mreact-router", "package.json"));
@@ -2266,22 +3050,18 @@ async function validateProductionRoutes(options) {
         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");
         if (fatalDiagnostics.length > 0) {
@@ -2292,15 +3072,22 @@ async function validateProductionRoutes(options) {
 async function collectBuildFiles(projectRoot, allowedSourceDirs, appDir) {
     const files = {};
     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"),
+        ]);
+        for (const [relativeFile, source] of fileContents) {
+            files[relativeFile] = source;
         }
     }
     return files;
@@ -2314,18 +3101,17 @@ function isAppFileConventionAsset(file, appDir) {
 }
 async function collectFiles(directory) {
     const entries = await readdir(directory, { withFileTypes: true });
-    const files = [];
-    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) {
     return createHash("sha256").update(text).digest("hex").slice(0, 16);