@reckona/mreact-router 0.0.174 → 0.0.176

package/src/serve.ts

@@ -1,19 +1,29 @@
-import { createServer, type Server } from "node:http";
-import { createHash } from "node:crypto";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, normalize, sep } from "node:path";
-import type {
-  BuiltPrerenderedRoute,
-  BuiltServerManifest,
-  BuiltServerModuleArtifact,
-} from "./build.js";
+import type { Server } from "node:http";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { BuiltPrerenderedRoute } from "./build.js";
 import type { AppRouterCache } from "./cache.js";
-import type { ClientRouteManifestEntry } from "./client-route-inference.js";
 import {
-  createRouteMatcher,
+  builtClientAssetPathname,
+  clearBuiltPublicAssetCacheForTest,
+  getBuiltPublicAssetCacheSizeForTest,
+  readBuiltClientAsset,
+  readBuiltPublicAsset,
+} from "./built-assets.js";
+import {
+  materializeBuiltRuntime,
+  mergeBuiltRuntimeImportPolicy,
+  readBuiltImportPolicyText,
+  type BuiltRuntime,
+} from "./built-runtime.js";
+import {
+  allBuiltServerModuleFiles,
+  loadBuiltServerModuleArtifacts,
+  loadBuiltServerModuleArtifactsForRequest,
+} from "./built-server-module-artifacts.js";
+import {
   type AppRoute,
   type MatchedRoute,
-  type RouteMatcher,
 } from "./routes.js";
 import type { AppRouterServerActionOptions } from "./actions.js";
 import type { AppRouterImportPolicy } from "./import-policy.js";
@@ -21,75 +31,27 @@ import {
   preloadBuiltRequestModules,
   renderAppRequest,
   resolveAppRouterMiddleware,
+  type AppRouterServerRenderArtifactLoader,
   type AppRouterRenderPreload,
   type AppRouterResponseHook,
-  type RenderAppRequestOptions,
+  type RenderAppRequestRuntimeOptions,
 } from "./render.js";
 import type { RouterInstrumentation } from "./trace.js";
 import {
   bytesResponse,
   htmlResponse,
-  nodeRequestToWebRequest,
-  rawNodeRequestUrl,
-  sendResponse,
 } from "./http.js";
 import {
   emitRouterLog,
   logDurationMs,
-  logError,
   logNow,
-  nodeRequestPath,
-  requestLogFields,
   type AppRouterLogger,
 } from "./logger.js";
+import { startNodeRequestServer } from "./node-server.js";
 import { builtAppRuntimePreloadPlan } from "./preload-policy.js";
-import { routeShellCandidates } from "./route-shells.js";
 import { normalizeRoutePath } from "./route-path.js";
 import type { HttpUpgradeHandler } from "./upgrade.js";
 
-interface BuiltRuntime {
-  appDir: string;
-  allowedSourceDirs: readonly string[];
-  assetBaseUrl?: string | undefined;
-  clientAssetPaths: ReadonlySet<string>;
-  clientScripts: ReadonlyMap<string, string>;
-  clientStylesByFile: ReadonlyMap<string, readonly string[]>;
-  clientStyles: ReadonlyMap<string, readonly string[]>;
-  generatedImportPolicy?: AppRouterImportPolicy | undefined;
-  hasMiddleware: boolean;
-  navigationScripts: ReadonlyMap<string, string>;
-  projectRoot: string;
-  publicAssetBaseUrl?: string | undefined;
-  prerenderableRoutes: ReadonlySet<string>;
-  prerenderLocks: Map<string, Promise<Response>>;
-  prerenderedRoutes: Map<string, BuiltPrerenderedRoute>;
-  routeMatcher: RouteMatcher;
-  routes: readonly AppRoute[];
-  serverActionReferencesByFile: ReadonlyMap<
-    string,
-    readonly {
-      end: number;
-      expression: string;
-      expressionEnd: number;
-      expressionStart: number;
-      moduleId: string;
-      exportName: string;
-      inferred: boolean;
-      sourceHash: string;
-      start: number;
-    }[]
-  >;
-  serverActionManifest?: readonly { moduleId: string; exportName: string; inferred?: boolean }[] | undefined;
-  serverModuleArtifactLoads: Map<string, Promise<void>>;
-  serverModuleClosureFiles: Map<string, readonly string[]>;
-  serverModuleFiles: ReadonlyMap<string, string>;
-  serverModuleRenderFiles: ReadonlyMap<string, string>;
-  serverModuleRequestFiles: ReadonlyMap<string, string>;
-  serverModules: Map<string, BuiltServerModuleArtifact>;
-  serverModuleCacheVersion: string;
-  serverSourceFiles: ReadonlyMap<string, string>;
-}
-
 interface BuiltRuntimeCacheEntry {
   clientManifestText: string;
   importPolicyText: string | undefined;
@@ -98,12 +60,8 @@ interface BuiltRuntimeCacheEntry {
 }
 
 const builtRuntimeCache = new Map<string, BuiltRuntimeCacheEntry>();
-const builtPublicAssetCache = new Map<string, BuiltPublicAsset>();
-
-interface BuiltPublicAsset {
-  bytes: Uint8Array;
-  headers: HeadersInit;
-}
+const builtRuntimeReadInflight = new Map<string, Promise<BuiltRuntime>>();
+let builtRuntimeMaterializeCountForTest = 0;
 
 /**
  * Strategy for the final response body shape sent to the HTTP layer.
@@ -615,30 +573,18 @@ export async function startServer(
     importPolicy: options.importPolicy,
     outDir: options.outDir,
   });
-  const server = createServer(async (incoming, outgoing) => {
-    const startedAt = logNow();
-    const fallbackRequestFields = {
-      method: incoming.method ?? "GET",
-      path: nodeRequestPath(incoming.url),
-      runtime: "node" as const,
-    };
-
-    try {
-      const fallbackHost = `${options.hostname ?? "127.0.0.1"}:${options.port}`;
-      const host = resolveRequestHost({
-        allowedHosts: options.allowedHosts,
-        fallbackHost,
-        hostPolicy: options.hostPolicy,
-        rawHost: incoming.headers.host,
-      });
-      const origin = `http://${host}`;
-      const request = nodeRequestToWebRequest(incoming, origin);
-      const logFields = requestLogFields(request, "node");
-      emitRouterLog(options.logger, "info", {
-        ...logFields,
-        type: "router:request:start",
-      });
-      const response = await runtime.render(request, {
+
+  return await startNodeRequestServer({
+    allowedHosts: options.allowedHosts,
+    errorHandler: options.errorHandler,
+    hostname: options.hostname,
+    hostPolicy: options.hostPolicy,
+    logger: options.logger,
+    onUpgrade: options.onUpgrade,
+    port: options.port,
+    resolveHost: resolveRequestHost,
+    render: (request) =>
+      runtime.render(request, {
         instrumentation: options.instrumentation,
         logger: options.logger,
         onResponse: options.onResponse,
@@ -646,217 +592,28 @@ export async function startServer(
         routeCache: options.routeCache,
         serverActions: options.serverActions,
         ...(options.sinkStrategy === undefined ? {} : { sinkStrategy: options.sinkStrategy }),
-      });
-      emitRouterLog(options.logger, "info", {
-        ...logFields,
-        durationMs: logDurationMs(startedAt),
-        status: response.status,
-        type: "router:request:end",
-      });
-
-      await sendResponse(outgoing, response);
-    } catch (error) {
-      // Log the full stack to stderr for operator visibility; never
-      // place it in the response body where attackers can scrape it
-      // (Issue 071). The errorHandler hook lets embedders customize
-      // the public response shape while still benefiting from the
-      // server-side log.
-      emitRouterLog(options.logger, "error", {
-        ...fallbackRequestFields,
-        durationMs: logDurationMs(startedAt),
-        error: logError(error),
-        type: "router:request:error",
-      });
-      if (options.logger === undefined) {
-        console.error("[mreact] startServer request failed:", error);
-      }
-      const payload = options.errorHandler
-        ? options.errorHandler(error)
-        : { body: "Internal Server Error", status: 500 };
-      outgoing.statusCode = payload.status;
-      outgoing.setHeader(
-        "content-type",
-        payload.headers?.["content-type"] ?? "text/plain; charset=utf-8",
-      );
-      for (const [name, value] of Object.entries(payload.headers ?? {})) {
-        if (name.toLowerCase() === "content-type") continue;
-        outgoing.setHeader(name, value);
-      }
-      outgoing.end(payload.body);
-    }
+      }),
   });
-
-  if (options.onUpgrade !== undefined) {
-    server.on("upgrade", options.onUpgrade);
-  }
-
-  await new Promise<void>((resolve) =>
-    server.listen(options.port, options.hostname ?? "127.0.0.1", resolve),
-  );
-  const address = server.address();
-  const port = typeof address === "object" && address !== null ? address.port : options.port;
-
-  return {
-    server,
-    url: `http://${options.hostname ?? "127.0.0.1"}:${port}`,
-    close: () =>
-      new Promise<void>((resolve, reject) =>
-        server.close((error) => (error ? reject(error) : resolve())),
-      ),
-  };
-}
-
-async function readBuiltClientAsset(
-  outDir: string,
-  pathname: string,
-  allowedPaths: ReadonlySet<string>,
-): Promise<Response> {
-  const clientPrefix = "/_mreact/client/";
-  const normalized = safeBuiltClientAssetPath(pathname.slice(clientPrefix.length));
-
-  if (normalized === undefined || !allowedPaths.has(normalized)) {
-    return new Response("Not Found", { status: 404 });
-  }
-
-  try {
-    const code = await readFile(join(outDir, "client", normalized), "utf8");
-
-    return new Response(code, {
-      headers: clientAssetHeaders(normalized),
-    });
-  } catch {
-    return new Response("Not Found", { status: 404 });
-  }
 }
 
-function builtClientAssetPathname(request: Request, url: URL): string | undefined {
-  const rawUrl = rawNodeRequestUrl(request);
-  const rawPathname = rawUrl?.split(/[?#]/, 1)[0];
-  const pathname = rawPathname === undefined || rawPathname === "" ? url.pathname : rawPathname;
-  const normalizedPathname = pathname.startsWith("/") ? pathname : `/${pathname}`;
-
-  return normalizedPathname.startsWith("/_mreact/client/") ? normalizedPathname : undefined;
-}
-
-function safeBuiltClientAssetPath(relativePath: string): string | undefined {
-  let decoded: string;
-
-  try {
-    decoded = decodeURIComponent(relativePath);
-  } catch {
-    return undefined;
-  }
-
-  if (decoded.includes("\\") || decoded.includes("\0")) {
-    return undefined;
-  }
-
-  if (decoded.split("/").some((segment) => segment === "..")) {
-    return undefined;
-  }
-
-  const normalized = normalize(decoded);
-
-  if (isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${sep}`)) {
-    return undefined;
-  }
-
-  return normalized;
-}
-
-function builtClientAssetPaths(manifest: {
-  assets?: readonly string[] | undefined;
-  routes: readonly ClientRouteManifestEntry[];
-}): ReadonlySet<string> {
-  const paths = new Set<string>(["manifest.json"]);
-
-  for (const route of manifest.routes) {
-    for (const asset of [
-      route.script,
-      route.sourceMap,
-      route.navigationScript,
-      ...(route.css ?? []),
-      ...(route.imports ?? []),
-    ]) {
-      const path = safeClientManifestAssetPath(asset);
-
-      if (path !== undefined) {
-        paths.add(path);
-      }
-    }
-  }
-
-  for (const asset of manifest.assets ?? []) {
-    const path = safeClientManifestAssetPath(asset);
-
-    if (path !== undefined) {
-      paths.add(path);
-    }
-  }
-
-  return paths;
-}
-
-function safeClientManifestAssetPath(asset: string | undefined): string | undefined {
-  if (asset === undefined || asset === "" || asset.startsWith("/") || asset.includes("\\")) {
-    return undefined;
-  }
-
-  const segments = asset.split("/");
+export const __readBuiltPublicAssetForTest = readBuiltPublicAsset;
 
-  return segments.some((segment) => segment === "" || segment === "." || segment === "..")
-    ? undefined
-    : segments.join("/");
+export function __clearBuiltRuntimeCacheForTest(): void {
+  builtRuntimeCache.clear();
+  builtRuntimeReadInflight.clear();
+  builtRuntimeMaterializeCountForTest = 0;
 }
 
-async function readBuiltPublicAsset(
-  outDir: string,
-  pathname: string,
-): Promise<Response | undefined> {
-  const relativePath = pathname.startsWith("/") ? pathname.slice(1) : pathname;
-
-  if (relativePath === "") {
-    return undefined;
-  }
-
-  const normalized = normalize(relativePath);
-
-  if (isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
-    return undefined;
-  }
-
-  try {
-    const cacheKey = `${outDir}\0${normalized}`;
-    const cached = builtPublicAssetCache.get(cacheKey);
-
-    if (cached !== undefined) {
-      return bytesResponse(cached.bytes, {
-        headers: cached.headers,
-      });
-    }
-
-    const bytes = await readFile(join(outDir, "client", "public", normalized));
-    const headers = publicAssetHeaders(normalized);
-
-    builtPublicAssetCache.set(cacheKey, {
-      bytes,
-      headers,
-    });
-
-    return bytesResponse(bytes, { headers });
-  } catch {
-    return undefined;
-  }
+export function __getBuiltRuntimeMaterializeCountForTest(): number {
+  return builtRuntimeMaterializeCountForTest;
 }
 
-export const __readBuiltPublicAssetForTest = readBuiltPublicAsset;
-
 export function __clearBuiltPublicAssetCacheForTest(): void {
-  builtPublicAssetCache.clear();
+  clearBuiltPublicAssetCacheForTest();
 }
 
 export function __getBuiltPublicAssetCacheSizeForTest(): number {
-  return builtPublicAssetCache.size;
+  return getBuiltPublicAssetCacheSizeForTest();
 }
 
 async function readBuiltRuntime(options: {
@@ -873,6 +630,44 @@ async function readBuiltRuntime(options: {
     return cached.runtime;
   }
 
+  if (cached === undefined) {
+    const inflight = builtRuntimeReadInflight.get(cacheKey);
+    if (inflight !== undefined) {
+      return inflight;
+    }
+
+    const runtime = readBuiltRuntimeUncached({
+      cacheKey,
+      cached,
+      outDir,
+      runtimeDir,
+    });
+    builtRuntimeReadInflight.set(cacheKey, runtime);
+    void runtime
+      .finally(() => {
+        if (builtRuntimeReadInflight.get(cacheKey) === runtime) {
+          builtRuntimeReadInflight.delete(cacheKey);
+        }
+      })
+      .catch(() => {});
+    return runtime;
+  }
+
+  return readBuiltRuntimeUncached({
+    cacheKey,
+    cached,
+    outDir,
+    runtimeDir,
+  });
+}
+
+async function readBuiltRuntimeUncached(options: {
+  cached: BuiltRuntimeCacheEntry | undefined;
+  cacheKey: string;
+  outDir: string;
+  runtimeDir: string;
+}): Promise<BuiltRuntime> {
+  const { cacheKey, cached, outDir, runtimeDir } = options;
   const serverManifestPath = join(outDir, "server", "manifest.json");
   const clientManifestPath = join(outDir, "client", "manifest.json");
   const importPolicyPath = join(outDir, "server", "import-policy.json");
@@ -896,6 +691,9 @@ async function readBuiltRuntime(options: {
     clientManifestPath,
     importPolicyText,
     importPolicyPath,
+    onMaterialize() {
+      builtRuntimeMaterializeCountForTest += 1;
+    },
     outDir,
     runtimeDir,
     serverManifestText,
@@ -908,209 +706,13 @@ async function readBuiltRuntime(options: {
     runtime,
     serverManifestText,
   });
-
-  return runtime;
-}
-
-async function materializeBuiltRuntime(options: {
-  clientManifestText: string;
-  clientManifestPath: string;
-  importPolicyPath: string;
-  importPolicyText: string | undefined;
-  outDir: string;
-  runtimeDir: string;
-  serverManifestText: string;
-  serverManifestPath: string;
-}): Promise<BuiltRuntime> {
-  const serverManifest = parseBuiltJsonArtifact<BuiltServerManifest>(
-    options.serverManifestText,
-    options.serverManifestPath,
-    "built app server manifest",
-  );
-  const clientManifest = parseBuiltJsonArtifact<{
-    assets?: readonly string[];
-    routes: ClientRouteManifestEntry[];
-    styles?: Array<{ css?: readonly string[]; file: string }>;
-  }>(options.clientManifestText, options.clientManifestPath, "built app client manifest");
-  const appDir = await materializeBuiltServerApp(options.runtimeDir, serverManifest);
-  const projectRoot = appDir;
-  const routesDir = join(projectRoot, serverManifest.routesDir ?? "");
-  const routes = serverManifest.routes.map((route) => ({
-    ...route,
-    file: join(projectRoot, route.file),
-  }));
-  const prerenderedRoutes = new Map(Object.entries(serverManifest.prerenderedRoutes ?? {}));
-  const prerenderableRoutes = new Set(prerenderedRoutes.keys());
-  const prerenderLocks = new Map<string, Promise<Response>>();
-  const serverModules = new Map<string, BuiltServerModuleArtifact>(
-    Object.entries(serverManifest.serverModules ?? {}).map(([file, artifact]) => [
-      join(appDir, file),
-      artifact,
-    ]),
-  );
-  const serverModuleFiles = new Map(
-    Object.entries(serverManifest.serverModuleFiles ?? {}).map(([file, artifactFile]) => [
-      join(appDir, file),
-      join(options.outDir, "server", safeManifestFilePath(artifactFile)),
-    ]),
-  );
-  const serverModuleRequestFiles = new Map(
-    Object.entries(serverManifest.serverModuleRequestFiles ?? {}).map(([file, artifactFile]) => [
-      join(appDir, file),
-      join(options.outDir, "server", safeManifestFilePath(artifactFile)),
-    ]),
-  );
-  const serverModuleRenderFiles = new Map(
-    Object.entries(serverManifest.serverModuleRenderFiles ?? {}).map(([file, artifactFile]) => [
-      join(appDir, file),
-      join(options.outDir, "server", safeManifestFilePath(artifactFile)),
-    ]),
-  );
-  const serverSourceFiles = new Map(
-    Object.entries(serverManifest.files).map(([file, source]) => [join(appDir, file), source]),
-  );
-  const serverActionReferencesByFile = new Map(
-    Object.entries(serverManifest.routeServerActionReferences ?? {}).map(([file, references]) => [
-      join(appDir, file),
-      references,
-    ]),
-  );
-  const routeMatcher = createRouteMatcher(routes, serverManifest.routeMatcher);
-  const clientScripts = new Map(
-    clientManifest.routes.flatMap((route) =>
-      route.client && route.script !== undefined ? [[route.path, route.script]] : [],
-    ),
-  );
-  const clientStyles = new Map(
-    clientManifest.routes.flatMap((route) =>
-      route.css !== undefined && route.css.length > 0 ? [[route.path, route.css]] : [],
-    ),
-  );
-  const clientStylesByFile = new Map(
-    (clientManifest.styles ?? []).flatMap((style) =>
-      style.css !== undefined && style.css.length > 0
-        ? [[join(routesDir, style.file), style.css] as const]
-        : [],
-    ),
-  );
-  const navigationScripts = new Map(
-    clientManifest.routes.flatMap((route) =>
-      route.navigation === true && route.navigationScript !== undefined
-        ? [[route.path, route.navigationScript]]
-        : [],
-    ),
-  );
-  const hasMiddleware =
-    serverSourceFiles.has(join(routesDir, "middleware.ts")) ||
-    serverSourceFiles.has(join(routesDir, "middleware.mreact.ts"));
-  const serverModuleCacheVersion = createHash("sha256")
-    .update(options.serverManifestText)
-    .update("\0")
-    .update(options.clientManifestText)
-    .digest("hex")
-    .slice(0, 16);
-
-  const allowedSourceDirs = (serverManifest.allowedSourceDirs ?? [""]).map((directory) =>
-    join(projectRoot, directory),
-  );
-  const generatedImportPolicy = builtGeneratedImportPolicy(
-    options.importPolicyText,
-    options.importPolicyPath,
-  );
-
-  return {
-    appDir: routesDir,
-    allowedSourceDirs,
-    ...(serverManifest.assetBaseUrl === undefined
-      ? {}
-      : { assetBaseUrl: serverManifest.assetBaseUrl }),
-    clientAssetPaths: builtClientAssetPaths(clientManifest),
-    clientScripts,
-    clientStylesByFile,
-    clientStyles,
-    ...(generatedImportPolicy === undefined ? {} : { generatedImportPolicy }),
-    hasMiddleware,
-    navigationScripts,
-    projectRoot,
-    ...(serverManifest.publicAssetBaseUrl === undefined
-      ? {}
-      : { publicAssetBaseUrl: serverManifest.publicAssetBaseUrl }),
-    prerenderableRoutes,
-    prerenderLocks,
-    prerenderedRoutes,
-    routeMatcher,
-    routes,
-    serverActionReferencesByFile,
-    ...(serverManifest.serverActionManifest === undefined
-      ? {}
-      : { serverActionManifest: serverManifest.serverActionManifest }),
-    serverModuleArtifactLoads: new Map(),
-    serverModuleClosureFiles: new Map(),
-    serverModuleFiles,
-    serverModuleRenderFiles,
-    serverModuleRequestFiles,
-    serverModules,
-    serverModuleCacheVersion,
-    serverSourceFiles,
-  };
-}
-
-async function readBuiltImportPolicyText(outDir: string): Promise<string | undefined> {
-  const policyPath = join(outDir, "server", "import-policy.json");
-
-  try {
-    return await readFile(policyPath, "utf8");
-  } catch (error) {
-    if (isMissingFileError(error)) {
-      return undefined;
+  runtime.catch(() => {
+    if (builtRuntimeCache.get(cacheKey)?.runtime === runtime) {
+      builtRuntimeCache.delete(cacheKey);
     }
+  });
 
-    throw builtArtifactReadError("built app import policy", policyPath, error);
-  }
-}
-
-function builtGeneratedImportPolicy(
-  importPolicyText: string | undefined,
-  importPolicyPath: string,
-): AppRouterImportPolicy | undefined {
-  if (importPolicyText === undefined) {
-    return undefined;
-  }
-
-  const artifact = parseBuiltJsonArtifact<{
-    runtimePackages?: unknown;
-  }>(importPolicyText, importPolicyPath, "built app import policy");
-  const runtimePackages = Array.isArray(artifact.runtimePackages)
-    ? artifact.runtimePackages.filter((name): name is string => typeof name === "string")
-    : [];
-
-  return runtimePackages.length === 0 ? undefined : { allowedPackages: runtimePackages };
-}
-
-function mergeBuiltRuntimeImportPolicy(
-  runtime: BuiltRuntime,
-  importPolicy: AppRouterImportPolicy | undefined,
-): AppRouterImportPolicy | undefined {
-  const generatedImportPolicy = runtime.generatedImportPolicy;
-
-  if (generatedImportPolicy === undefined) {
-    return importPolicy;
-  }
-
-  const allowedPackages = [
-    ...new Set([
-      ...(generatedImportPolicy.allowedPackages ?? []),
-      ...(importPolicy?.allowedPackages ?? []),
-    ]),
-  ];
-
-  return {
-    ...(allowedPackages.length === 0 ? {} : { allowedPackages }),
-    ...(importPolicy?.allowedSourceDirs === undefined
-      ? {}
-      : { allowedSourceDirs: importPolicy.allowedSourceDirs }),
-    ...(importPolicy?.projectRoot === undefined ? {} : { projectRoot: importPolicy.projectRoot }),
-  };
+  return runtime;
 }
 
 function isMissingFileError(error: unknown): boolean {
@@ -1137,300 +739,6 @@ function builtArtifactReadError(label: string, artifactPath: string, error: unkn
   return new Error(`${prefix} ${label}: ${artifactPath}${detail}`, { cause: error });
 }
 
-function parseBuiltJsonArtifact<T>(text: string, artifactPath: string, label: string): T {
-  try {
-    return JSON.parse(text) as T;
-  } catch (error) {
-    const detail = error instanceof Error && error.message !== "" ? `: ${error.message}` : "";
-
-    throw new Error(`Invalid ${label}: ${artifactPath}${detail}`, { cause: error });
-  }
-}
-
-async function loadBuiltServerModuleArtifacts(
-  runtime: BuiltRuntime,
-  files: Iterable<string>,
-  kind: BuiltServerModuleArtifactKind = "all",
-): Promise<void> {
-  for (const file of files) {
-    await loadBuiltServerModuleArtifact(runtime, file, kind);
-  }
-}
-
-type BuiltServerModuleArtifactKind = "all" | "render" | "request";
-
-async function loadBuiltServerModuleArtifact(
-  runtime: BuiltRuntime,
-  file: string,
-  kind: BuiltServerModuleArtifactKind = "all",
-): Promise<void> {
-  if (kind === "all") {
-    await loadBuiltServerModuleArtifact(runtime, file, "request");
-    await loadBuiltServerModuleArtifact(runtime, file, "render");
-    return;
-  }
-
-  const artifactPath =
-    kind === "request"
-      ? runtime.serverModuleRequestFiles.get(file) ?? runtime.serverModuleFiles.get(file)
-      : runtime.serverModuleRenderFiles.get(file) ?? runtime.serverModuleFiles.get(file);
-
-  if (artifactPath === undefined) {
-    return;
-  }
-
-  const cached = runtime.serverModuleArtifactLoads.get(`${kind}\0${file}`);
-
-  if (cached !== undefined) {
-    await cached;
-    return;
-  }
-
-  const loaded = readFile(artifactPath, "utf8")
-    .then((text) => {
-      const existing = runtime.serverModules.get(file) ?? {};
-      runtime.serverModules.set(
-        file,
-        mergeBuiltServerModuleArtifacts(
-          existing,
-          hydrateBuiltServerModuleArtifact(
-            parseBuiltJsonArtifact<BuiltServerModuleArtifact>(
-              text,
-              artifactPath,
-              `built server module artifact for ${file}`,
-            ),
-            builtServerDirForArtifactPath(artifactPath),
-          ),
-        ),
-      );
-    })
-    .catch((error) => {
-      runtime.serverModuleArtifactLoads.delete(`${kind}\0${file}`);
-      if (isMissingFileError(error)) {
-        throw builtArtifactReadError(`built server module artifact for ${file}`, artifactPath, error);
-      }
-      throw error;
-    });
-  runtime.serverModuleArtifactLoads.set(`${kind}\0${file}`, loaded);
-
-  await loaded;
-}
-
-function allBuiltServerModuleFiles(runtime: BuiltRuntime): Iterable<string> {
-  return new Set([
-    ...runtime.serverModuleFiles.keys(),
-    ...runtime.serverModuleRequestFiles.keys(),
-    ...runtime.serverModuleRenderFiles.keys(),
-  ]);
-}
-
-function builtServerDirForArtifactPath(artifactPath: string): string {
-  const marker = `${sep}server-modules${sep}`;
-  const index = artifactPath.lastIndexOf(marker);
-
-  return index === -1 ? dirname(dirname(artifactPath)) : artifactPath.slice(0, index);
-}
-
-function hydrateBuiltServerModuleArtifact(
-  artifact: BuiltServerModuleArtifact,
-  serverDir: string,
-): BuiltServerModuleArtifact {
-  return {
-    ...(artifact.analysis === undefined ? {} : { analysis: artifact.analysis }),
-    ...(artifact.loader === undefined
-      ? {}
-      : { loader: hydrateBuiltServerModuleOutput(artifact.loader, serverDir) }),
-    ...(artifact.routeMetadata === undefined
-      ? {}
-      : { routeMetadata: hydrateBuiltServerModuleOutput(artifact.routeMetadata, serverDir) }),
-    ...(artifact.request === undefined
-      ? {}
-      : { request: hydrateBuiltServerModuleOutput(artifact.request, serverDir) }),
-    ...(artifact.stream === undefined
-      ? {}
-      : { stream: hydrateBuiltServerModuleOutput(artifact.stream, serverDir) }),
-    ...(artifact.string === undefined
-      ? {}
-      : { string: hydrateBuiltServerModuleOutput(artifact.string, serverDir) }),
-  };
-}
-
-function hydrateBuiltServerModuleOutput<T extends { moduleFile?: string | undefined }>(
-  output: T,
-  serverDir: string,
-): T {
-  if (output.moduleFile === undefined || isAbsolute(output.moduleFile)) {
-    return output;
-  }
-
-  return {
-    ...output,
-    moduleFile: join(serverDir, safeManifestFilePath(output.moduleFile)),
-  };
-}
-
-function mergeBuiltServerModuleArtifacts(
-  existing: BuiltServerModuleArtifact,
-  loaded: BuiltServerModuleArtifact,
-): BuiltServerModuleArtifact {
-  return {
-    ...existing,
-    ...loaded,
-  };
-}
-
-async function loadBuiltServerModuleArtifactsForRequest(
-  runtime: BuiltRuntime,
-  routeFile: string | undefined,
-  options: {
-    includeRender?: boolean | undefined;
-    includeShells?: boolean | undefined;
-  } = {},
-): Promise<void> {
-  const roots = [
-    join(runtime.appDir, "middleware.ts"),
-    join(runtime.appDir, "middleware.mreact.ts"),
-    ...(routeFile === undefined
-      ? []
-      : [
-          routeFile,
-          ...(options.includeShells === false ? [] : shellFilesForRoute(runtime, routeFile)),
-        ]),
-  ];
-  const seen = new Set<string>();
-
-  for (const file of roots) {
-    await loadBuiltServerModuleArtifactClosure(runtime, file, seen, "request");
-  }
-
-  if (options.includeRender === true) {
-    seen.clear();
-    for (const file of roots) {
-      await loadBuiltServerModuleArtifactClosure(runtime, file, seen, "render");
-    }
-  }
-}
-
-async function loadBuiltServerModuleArtifactClosure(
-  runtime: BuiltRuntime,
-  file: string,
-  seen: Set<string>,
-  kind: BuiltServerModuleArtifactKind,
-): Promise<void> {
-  for (const closureFile of builtServerModuleClosureFiles(runtime, file)) {
-    if (seen.has(closureFile)) {
-      continue;
-    }
-    seen.add(closureFile);
-    await loadBuiltServerModuleArtifact(runtime, closureFile, kind);
-  }
-}
-
-function builtServerModuleClosureFiles(
-  runtime: BuiltRuntime,
-  file: string,
-): readonly string[] {
-  const cached = runtime.serverModuleClosureFiles.get(file);
-  if (cached !== undefined) {
-    return cached;
-  }
-
-  const closure: string[] = [];
-  collectBuiltServerModuleClosureFiles(runtime, file, new Set(), closure);
-  runtime.serverModuleClosureFiles.set(file, closure);
-  return closure;
-}
-
-function collectBuiltServerModuleClosureFiles(
-  runtime: BuiltRuntime,
-  file: string,
-  seen: Set<string>,
-  closure: string[],
-): void {
-  if (seen.has(file)) {
-    return;
-  }
-  seen.add(file);
-  closure.push(file);
-
-  const source = runtime.serverSourceFiles.get(file);
-  if (source === undefined) {
-    return;
-  }
-
-  for (const specifier of localServerModuleSpecifiers(source)) {
-    const resolved = resolveBuiltLocalServerSourceImport(runtime, file, specifier);
-    if (resolved !== undefined) {
-      collectBuiltServerModuleClosureFiles(runtime, resolved, seen, closure);
-    }
-  }
-}
-
-const localServerModuleImportPattern =
-  /\b(?:import|export)\s+(?:type\s+)?(?:[^"']*?\s+from\s*)?["'](?<source>\.{1,2}\/[^"']+)["']/g;
-
-function localServerModuleSpecifiers(code: string): string[] {
-  const specifiers = new Set<string>();
-  localServerModuleImportPattern.lastIndex = 0;
-
-  for (const match of code.matchAll(localServerModuleImportPattern)) {
-    const source = match.groups?.source;
-
-    if (source !== undefined) {
-      specifiers.add(source);
-    }
-  }
-
-  return Array.from(specifiers);
-}
-
-function resolveBuiltLocalServerSourceImport(
-  runtime: BuiltRuntime,
-  fromFile: string,
-  specifier: string,
-): string | undefined {
-  const base = join(dirname(fromFile), specifier);
-
-  for (const candidate of localServerSourceImportCandidates(base)) {
-    if (runtime.serverSourceFiles.has(candidate)) {
-      return candidate;
-    }
-  }
-
-  return undefined;
-}
-
-function localServerSourceImportCandidates(base: string): string[] {
-  const candidates = [base];
-
-  if (base.endsWith(".js")) {
-    const withoutJs = base.slice(0, -".js".length);
-    candidates.push(`${withoutJs}.ts`, `${withoutJs}.tsx`, `${withoutJs}.mreact.tsx`);
-  } else if (base.endsWith(".jsx")) {
-    const withoutJsx = base.slice(0, -".jsx".length);
-    candidates.push(`${withoutJsx}.tsx`, `${withoutJsx}.mreact.tsx`);
-  } else if (base.endsWith(".mreact")) {
-    candidates.push(`${base}.tsx`);
-  } else {
-    candidates.push(
-      `${base}.ts`,
-      `${base}.tsx`,
-      `${base}.mreact.tsx`,
-      join(base, "index.ts"),
-      join(base, "index.tsx"),
-      join(base, "index.mreact.tsx"),
-    );
-  }
-
-  return candidates;
-}
-
-function shellFilesForRoute(runtime: BuiltRuntime, routeFile: string): string[] {
-  return routeShellCandidates(runtime.appDir, routeFile)
-    .map((candidate) => candidate.file)
-    .filter((file) => runtime.serverSourceFiles.has(file));
-}
-
 async function readPrerenderedRoute(
   runtime: BuiltRuntime,
   path: string,
@@ -1468,10 +776,15 @@ function builtRenderAppRequestOptions(
     requestUrl?: URL | undefined;
     runtime: BuiltRuntime;
   },
-): RenderAppRequestOptions {
-  const renderOptions: RenderAppRequestOptions & {
-    __mreactLoadServerRenderArtifacts?: ((routeFile: string) => Promise<void>) | undefined;
-  } = {
+): RenderAppRequestRuntimeOptions {
+  const serverRenderArtifactLoader: AppRouterServerRenderArtifactLoader = {
+    async load(routeFile: string) {
+      await loadBuiltServerModuleArtifactsForRequest(options.runtime, routeFile, {
+        includeRender: true,
+      });
+    },
+  };
+  const renderOptions: RenderAppRequestRuntimeOptions = {
     appDir: options.runtime.appDir,
     assetBaseUrl: options.runtime.assetBaseUrl,
     clientScripts: options.runtime.clientScripts,
@@ -1491,11 +804,7 @@ function builtRenderAppRequestOptions(
     routeMatcher: options.runtime.routeMatcher,
     requestUrl: options.requestUrl,
     routes: options.runtime.routes,
-    __mreactLoadServerRenderArtifacts: async (routeFile: string) => {
-      await loadBuiltServerModuleArtifactsForRequest(options.runtime, routeFile, {
-        includeRender: true,
-      });
-    },
+    serverRenderArtifactLoader,
     serverModules: options.runtime.serverModules,
     serverModuleCacheVersion: options.runtime.serverModuleCacheVersion,
     serverSourceFiles: options.runtime.serverSourceFiles,
@@ -1626,70 +935,3 @@ async function cloneResponse(response: Response): Promise<Response> {
     status: response.status,
   });
 }
-
-async function materializeBuiltServerApp(
-  runtimeDir: string,
-  manifest: BuiltServerManifest,
-): Promise<string> {
-  const appDir = join(runtimeDir, "app");
-
-  await rm(appDir, { force: true, recursive: true });
-  await Promise.all(
-    Object.entries(manifest.files).map(async ([file, code]) => {
-      const outputFile = join(appDir, safeManifestFilePath(file));
-
-      await mkdir(dirname(outputFile), { recursive: true });
-      await writeFile(outputFile, code);
-    }),
-  );
-
-  return appDir;
-}
-
-function safeManifestFilePath(pathname: string): string {
-  const normalized = normalize(pathname);
-
-  if (isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
-    throw new Error(`Invalid built app manifest file path: ${pathname}`);
-  }
-
-  return normalized;
-}
-
-function clientAssetHeaders(pathname: string): HeadersInit {
-  if (pathname === "manifest.json") {
-    return {
-      "cache-control": "no-cache",
-      "content-type": "application/json; charset=utf-8",
-    };
-  }
-
-  return {
-    "cache-control": "public, max-age=31536000, immutable",
-    "content-type": pathname.endsWith(".css")
-      ? "text/css; charset=utf-8"
-      : "text/javascript; charset=utf-8",
-  };
-}
-
-function publicAssetHeaders(pathname: string): HeadersInit {
-  return {
-    "cache-control": "public, max-age=3600",
-    "content-type": publicAssetContentType(pathname),
-  };
-}
-
-function publicAssetContentType(pathname: string): string {
-  if (pathname.endsWith(".css")) return "text/css; charset=utf-8";
-  if (pathname.endsWith(".html")) return "text/html; charset=utf-8";
-  if (pathname.endsWith(".js")) return "text/javascript; charset=utf-8";
-  if (pathname.endsWith(".json")) return "application/json; charset=utf-8";
-  if (pathname.endsWith(".svg")) return "image/svg+xml";
-  if (pathname.endsWith(".png")) return "image/png";
-  if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) return "image/jpeg";
-  if (pathname.endsWith(".webp")) return "image/webp";
-  if (pathname.endsWith(".ico")) return "image/x-icon";
-  if (pathname.endsWith(".txt")) return "text/plain; charset=utf-8";
-
-  return "application/octet-stream";
-}