@reckona/mreact-router 0.0.175 → 0.0.177

package/dist/serve.js

@@ -1,16 +1,18 @@
-import { createServer } 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 { createRouteMatcher, } from "./routes.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { builtClientAssetPathname, clearBuiltPublicAssetCacheForTest, getBuiltPublicAssetCacheSizeForTest, readBuiltClientAsset, readBuiltPublicAsset, } from "./built-assets.js";
+import { materializeBuiltRuntime, mergeBuiltRuntimeImportPolicy, readBuiltImportPolicyText, } from "./built-runtime.js";
+import { allBuiltServerModuleFiles, loadBuiltServerModuleArtifacts, loadBuiltServerModuleArtifactsForRequest, } from "./built-server-module-artifacts.js";
+import {} from "./routes.js";
 import { preloadBuiltRequestModules, renderAppRequest, resolveAppRouterMiddleware, } from "./render.js";
-import { bytesResponse, htmlResponse, nodeRequestToWebRequest, rawNodeRequestUrl, sendResponse, } from "./http.js";
-import { emitRouterLog, logDurationMs, logError, logNow, nodeRequestPath, requestLogFields, } from "./logger.js";
+import { bytesResponse, htmlResponse, } from "./http.js";
+import { emitRouterLog, logDurationMs, logNow, } 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";
 const builtRuntimeCache = new Map();
-const builtPublicAssetCache = new Map();
+const builtRuntimeReadInflight = new Map();
+let builtRuntimeMaterializeCountForTest = 0;
 let warnedImplicitHostTrust = false;
 export function resolveRequestHost(options) {
     const raw = options.rawHost;
@@ -284,196 +286,40 @@ export async function startServer(options) {
         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",
-        };
-        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, {
-                instrumentation: options.instrumentation,
-                logger: options.logger,
-                onResponse: options.onResponse,
-                prerenderStore: options.prerenderStore,
-                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);
-        }
+    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,
+            prerenderStore: options.prerenderStore,
+            routeCache: options.routeCache,
+            serverActions: options.serverActions,
+            ...(options.sinkStrategy === undefined ? {} : { sinkStrategy: options.sinkStrategy }),
+        }),
     });
-    if (options.onUpgrade !== undefined) {
-        server.on("upgrade", options.onUpgrade);
-    }
-    await new Promise((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((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))),
-    };
-}
-async function readBuiltClientAsset(outDir, pathname, allowedPaths) {
-    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, url) {
-    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) {
-    let decoded;
-    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) {
-    const paths = new Set(["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;
+export const __readBuiltPublicAssetForTest = readBuiltPublicAsset;
+export function __clearBuiltRuntimeCacheForTest() {
+    builtRuntimeCache.clear();
+    builtRuntimeReadInflight.clear();
+    builtRuntimeMaterializeCountForTest = 0;
 }
-function safeClientManifestAssetPath(asset) {
-    if (asset === undefined || asset === "" || asset.startsWith("/") || asset.includes("\\")) {
-        return undefined;
-    }
-    const segments = asset.split("/");
-    return segments.some((segment) => segment === "" || segment === "." || segment === "..")
-        ? undefined
-        : segments.join("/");
+export function __getBuiltRuntimeMaterializeCountForTest() {
+    return builtRuntimeMaterializeCountForTest;
 }
-async function readBuiltPublicAsset(outDir, pathname) {
-    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 const __readBuiltPublicAssetForTest = readBuiltPublicAsset;
 export function __clearBuiltPublicAssetCacheForTest() {
-    builtPublicAssetCache.clear();
+    clearBuiltPublicAssetCacheForTest();
 }
 export function __getBuiltPublicAssetCacheSizeForTest() {
-    return builtPublicAssetCache.size;
+    return getBuiltPublicAssetCacheSizeForTest();
 }
 async function readBuiltRuntime(options) {
     const outDir = options.outDir;
@@ -483,6 +329,36 @@ async function readBuiltRuntime(options) {
     if (options.immutable === true && cached !== undefined) {
         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) {
+    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");
@@ -502,6 +378,9 @@ async function readBuiltRuntime(options) {
         clientManifestPath,
         importPolicyText,
         importPolicyPath,
+        onMaterialize() {
+            builtRuntimeMaterializeCountForTest += 1;
+        },
         outDir,
         runtimeDir,
         serverManifestText,
@@ -513,137 +392,12 @@ async function readBuiltRuntime(options) {
         runtime,
         serverManifestText,
     });
-    return runtime;
-}
-async function materializeBuiltRuntime(options) {
-    const serverManifest = parseBuiltJsonArtifact(options.serverManifestText, options.serverManifestPath, "built app server manifest");
-    const clientManifest = parseBuiltJsonArtifact(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();
-    const serverModules = new Map(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]]
-        : []));
-    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) {
-    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, importPolicyPath) {
-    if (importPolicyText === undefined) {
-        return undefined;
-    }
-    const artifact = parseBuiltJsonArtifact(importPolicyText, importPolicyPath, "built app import policy");
-    const runtimePackages = Array.isArray(artifact.runtimePackages)
-        ? artifact.runtimePackages.filter((name) => typeof name === "string")
-        : [];
-    return runtimePackages.length === 0 ? undefined : { allowedPackages: runtimePackages };
-}
-function mergeBuiltRuntimeImportPolicy(runtime, importPolicy) {
-    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) {
     return (typeof error === "object" &&
@@ -664,201 +418,6 @@ function builtArtifactReadError(label, artifactPath, error) {
     const detail = error instanceof Error && error.message !== "" ? `: ${error.message}` : "";
     return new Error(`${prefix} ${label}: ${artifactPath}${detail}`, { cause: error });
 }
-function parseBuiltJsonArtifact(text, artifactPath, label) {
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        const detail = error instanceof Error && error.message !== "" ? `: ${error.message}` : "";
-        throw new Error(`Invalid ${label}: ${artifactPath}${detail}`, { cause: error });
-    }
-}
-async function loadBuiltServerModuleArtifacts(runtime, files, kind = "all") {
-    for (const file of files) {
-        await loadBuiltServerModuleArtifact(runtime, file, kind);
-    }
-}
-async function loadBuiltServerModuleArtifact(runtime, file, kind = "all") {
-    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(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) {
-    return new Set([
-        ...runtime.serverModuleFiles.keys(),
-        ...runtime.serverModuleRequestFiles.keys(),
-        ...runtime.serverModuleRenderFiles.keys(),
-    ]);
-}
-function builtServerDirForArtifactPath(artifactPath) {
-    const marker = `${sep}server-modules${sep}`;
-    const index = artifactPath.lastIndexOf(marker);
-    return index === -1 ? dirname(dirname(artifactPath)) : artifactPath.slice(0, index);
-}
-function hydrateBuiltServerModuleArtifact(artifact, serverDir) {
-    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(output, serverDir) {
-    if (output.moduleFile === undefined || isAbsolute(output.moduleFile)) {
-        return output;
-    }
-    return {
-        ...output,
-        moduleFile: join(serverDir, safeManifestFilePath(output.moduleFile)),
-    };
-}
-function mergeBuiltServerModuleArtifacts(existing, loaded) {
-    return {
-        ...existing,
-        ...loaded,
-    };
-}
-async function loadBuiltServerModuleArtifactsForRequest(runtime, routeFile, options = {}) {
-    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();
-    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, file, seen, kind) {
-    for (const closureFile of builtServerModuleClosureFiles(runtime, file)) {
-        if (seen.has(closureFile)) {
-            continue;
-        }
-        seen.add(closureFile);
-        await loadBuiltServerModuleArtifact(runtime, closureFile, kind);
-    }
-}
-function builtServerModuleClosureFiles(runtime, file) {
-    const cached = runtime.serverModuleClosureFiles.get(file);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const closure = [];
-    collectBuiltServerModuleClosureFiles(runtime, file, new Set(), closure);
-    runtime.serverModuleClosureFiles.set(file, closure);
-    return closure;
-}
-function collectBuiltServerModuleClosureFiles(runtime, file, seen, closure) {
-    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) {
-    const specifiers = new Set();
-    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, fromFile, specifier) {
-    const base = join(dirname(fromFile), specifier);
-    for (const candidate of localServerSourceImportCandidates(base)) {
-        if (runtime.serverSourceFiles.has(candidate)) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-function localServerSourceImportCandidates(base) {
-    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, routeFile) {
-    return routeShellCandidates(runtime.appDir, routeFile)
-        .map((candidate) => candidate.file)
-        .filter((file) => runtime.serverSourceFiles.has(file));
-}
 async function readPrerenderedRoute(runtime, path, store) {
     const stored = await store?.get(path);
     if (stored !== undefined) {
@@ -875,6 +434,13 @@ function renderBuiltDynamicResponse(options) {
     return renderAppRequest(builtRenderAppRequestOptions(options));
 }
 function builtRenderAppRequestOptions(options) {
+    const serverRenderArtifactLoader = {
+        async load(routeFile) {
+            await loadBuiltServerModuleArtifactsForRequest(options.runtime, routeFile, {
+                includeRender: true,
+            });
+        },
+    };
     const renderOptions = {
         appDir: options.runtime.appDir,
         assetBaseUrl: options.runtime.assetBaseUrl,
@@ -895,11 +461,7 @@ function builtRenderAppRequestOptions(options) {
         routeMatcher: options.runtime.routeMatcher,
         requestUrl: options.requestUrl,
         routes: options.runtime.routes,
-        __mreactLoadServerRenderArtifacts: async (routeFile) => {
-            await loadBuiltServerModuleArtifactsForRequest(options.runtime, routeFile, {
-                includeRender: true,
-            });
-        },
+        serverRenderArtifactLoader,
         serverModules: options.runtime.serverModules,
         serverModuleCacheVersion: options.runtime.serverModuleCacheVersion,
         serverSourceFiles: options.runtime.serverSourceFiles,
@@ -986,64 +548,4 @@ async function cloneResponse(response) {
         status: response.status,
     });
 }
-async function materializeBuiltServerApp(runtimeDir, manifest) {
-    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) {
-    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) {
-    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) {
-    return {
-        "cache-control": "public, max-age=3600",
-        "content-type": publicAssetContentType(pathname),
-    };
-}
-function publicAssetContentType(pathname) {
-    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";
-}
 //# sourceMappingURL=serve.js.map