@anaemia/core 0.3.7 → 0.5.0

package/src/runtime/entry-server.tsx

@@ -1,14 +1,7 @@
-import { Hono } from "hono";
-import { serve } from "@hono/node-server";
-import type { Context } from "hono";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { compress } from "hono/compress";
-import { renderToStringAsync, generateHydrationScript } from "solid-js/web";
-import { Router } from "@solidjs/router";
-import { ssrStorage, serverFunctionsRegistry } from "./context.js";
-import fs from "node:fs";
-import path from "path";
-import type { StatusCode, RedirectStatusCode } from "hono/utils/http-status";
+import { createServerApp } from "./server/app.js";
+import { serveServer } from "./server/boot.js";
+import { createRuntimeEnv } from "./server/env.js";
+import { createManifestStore } from "./server/manifest.js";
 
 // @ts-expect-error - resolved by Rspack
 import App from "anaemia-user-app";
@@ -19,371 +12,24 @@ import { preloadActiveClientRoute, serverLoaderRegistry, serverGuardRegistry } f
 // @ts-expect-error - resolved by Rspack
 import { registerServerRoutes } from "__anaemia_server_routes__";
 
-const port = Number(process.env.PORT) || 3000;
-const isDev = process.env.NODE_ENV !== "production";
-
-const devPort = Number(process.env.RSPACK_DEV_PORT) || 4445;
-const devServerUrl = `http://localhost:${devPort}`;
-
-interface ChunkAssets {
-  js?: string[];
-  css?: string[];
-}
-
-interface RouteManifest {
-  routes: Array<{ urlPattern: string; chunkName: string; params: string[] }>;
-  chunks: Record<string, ChunkAssets>;
-  errors?: Record<string, string>;
-}
-
-type SortedRoute = { urlPattern: string; chunkName: string; params: string[] };
-let sortedRoutes: SortedRoute[] | null = null;
-
-const ENTRY_TAG_REGEX = /(<([a-zA-Z0-9-]+)[^>]*anaemia-entry[^>]*>)(.*?)(<\/\2>)/is;
-
-const app = new Hono();
-
-app.use("*", compress());
-
-app.use("*", async (c, next) => {
-  const store = new Map<string, unknown>();
-  store.set("honoContext", c);
-  return await ssrStorage.run(store, next);
-});
-
-if (isDev) {
-  const devAssetProxy = async (c: Context) => {
-    const targetUrl = `${devServerUrl}${c.req.path}`;
-    try {
-      const response = await fetch(targetUrl);
-      if (!response.ok) return c.text("asset not found in Rspack memory", 404);
-
-      const contentType = response.headers.get("content-type");
-      if (contentType) c.header("content-type", contentType);
-
-      c.header("Cache-Control", "no-cache, no-store, must-revalidate");
-      c.header("Pragma", "no-cache");
-      c.header("Expires", "0");
-
-      return c.body(await response.arrayBuffer());
-    } catch {
-      return c.text("failed to connect to Rspack dev server asset bridge", 500);
-    }
-  };
-
-  app.get("/assets/*", devAssetProxy);
-} else {
-  app.use("/assets/*", async (c, next) => {
-    await next();
-    if (c.res.ok) c.res.headers.set("Cache-Control", "public, max-age=31536000, immutable");
-  });
-
-  app.use(
-    "/assets/*",
-    serveStatic({
-      root: path.resolve(process.cwd(), "./dist/client"),
-    })
-  );
-}
-
-app.post("/_rpc", async (c) => {
-  const functionId = c.req.query("id");
-  if (!functionId || !serverFunctionsRegistry.has(functionId)) {
-    return c.json({ error: "RPC function not found" }, 404);
-  }
-
-  const contentLength = Number(c.req.header("content-length") ?? 0);
-  if (contentLength > 512_000) {
-    return c.json({ error: "Payload too large" }, 413);
-  }
-
-  let argumentsArray: unknown[];
-  try {
-    const body = await c.req.json();
-    if (!Array.isArray(body)) throw new Error("Expected array");
-    argumentsArray = body;
-  } catch {
-    return c.json({ error: "Invalid request body" }, 400);
-  }
-
-  try {
-    const result = await serverFunctionsRegistry.get(functionId)!(...argumentsArray);
-    return c.json(result);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Internal server error";
-    return c.json({ error: message }, 500);
-  }
-});
-
-app.use(async (c, next) => {
-  const p = c.req.path;
-  if (isDev && p.includes(".hot-update.")) {
-    const targetUrl = `${devServerUrl}${p}`;
-    try {
-      const response = await fetch(targetUrl);
-      if (!response.ok) return c.text("hot update not found", 404);
-
-      const contentType = response.headers.get("content-type");
-      if (contentType) c.header("content-type", contentType);
-
-      c.header("Cache-Control", "no-cache, no-store, must-revalidate");
-
-      return c.body(await response.arrayBuffer());
-    } catch {
-      return c.text("failed to fetch hot update", 500);
-    }
-  }
-  await next();
-});
-
-registerServerRoutes(app);
-
-let memoizedHtmlTemplate = "";
-let memoizedManifest: RouteManifest | null = null;
-
-const templatePath = path.resolve(process.cwd(), "./dist/client/index.html");
-const manifestPath = path.resolve(process.cwd(), "./dist/route-manifest.json");
-
-const loadManifestAndTemplate = async () => {
-  if (isDev) {
-    try {
-      memoizedHtmlTemplate = await fetch(`${devServerUrl}/index.html`).then((r) => {
-        if (!r.ok) throw new Error(`index.html fetch failed: ${r.status}`);
-        return r.text();
-      });
-    } catch (err) {
-      console.error("[anaemia engine sync error - HTML fetch failed]:", err);
-      memoizedHtmlTemplate = "";
-    }
-
-    try {
-      if (fs.existsSync(manifestPath)) {
-        memoizedManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-      } else {
-        memoizedManifest = { routes: [], chunks: {}, errors: {} };
-      }
-    } catch (err) {
-      console.error("[anaemia engine sync error - manifest read failed]:", err);
-      memoizedManifest = { routes: [], chunks: {}, errors: {} };
-    }
-  } else {
-    try {
-      if (fs.existsSync(templatePath)) memoizedHtmlTemplate = fs.readFileSync(templatePath, "utf-8");
-      if (fs.existsSync(manifestPath)) memoizedManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-    } catch {
-      console.warn("build assets not fully initialized during bootstrapping cycle.");
-    }
-  }
-
-  sortedRoutes = null;
-};
-
-const normalizeAssetUrl = (url: unknown): string => {
-  if (!url || typeof url !== "string") return "";
-  if (url.startsWith("http://") || url.startsWith("https://")) return url;
-  return url.startsWith("/") ? url : `/${url}`;
-};
-
-type RouteMatch = {
-  activeChunk: string;
-  targetPattern: string;
-  statusCode: StatusCode;
-  params: Record<string, string>;
-};
-
-type GuardFn = (ctx: { params: Record<string, string>; request: Request; url: string }) => void | undefined | { redirect: string; status?: 301 | 302 | 307 | 308 } | { status: number; body?: string } | Promise<void | undefined | { redirect: string; status?: number } | { status: number; body?: string }>;
-
-async function runGuards(pattern: string, ctx: { params: Record<string, string>; request: Request; url: string }) {
-  const chain: (() => Promise<GuardFn[]>)[] = serverGuardRegistry.get(pattern) ?? [];
-  for (const loadGuards of chain) {
-    const guards: GuardFn[] = await loadGuards();
-    for (const guard of guards) {
-      const result = await guard(ctx);
-      if (result && ("redirect" in result || "status" in result)) return result;
-    }
-  }
-  return null;
-}
-
-function matchRoute(manifest: RouteManifest, reqPath: string): RouteMatch {
-  if (!sortedRoutes) {
-    sortedRoutes = [...manifest.routes].sort((a, b) => {
-      const score = (pattern: string) => {
-        const segments = pattern.split("/").filter(Boolean);
-        return segments.reduce((acc, s) => {
-          if (s.startsWith(":")) return acc - 1;
-          if (s === "*" || s.startsWith("*")) return acc - 2;
-          return acc;
-        }, segments.length * 10);
-      };
-      return score(b.urlPattern) - score(a.urlPattern);
-    });
-  }
-
-  for (const route of sortedRoutes) {
-    const regexStr = route.urlPattern.replace(/:([a-zA-Z0-9_-]+)/g, "(?<$1>[^/]+)").replace(/\*([a-zA-Z0-9_-]*)/g, "(?<catchall>.*)");
-
-    const match = new RegExp(`^${regexStr}$`).exec(reqPath);
-    if (match) {
-      return {
-        activeChunk: route.chunkName,
-        targetPattern: route.urlPattern,
-        statusCode: 200,
-        params: match.groups ? { ...match.groups } : {},
-      };
-    }
-  }
-
-  return {
-    activeChunk: "route-404",
-    targetPattern: manifest.errors?.["404"] || "",
-    statusCode: 404,
-    params: {},
-  };
-}
-
-app.get("*", async (c) => {
-  if (isDev) await loadManifestAndTemplate();
-
-  let template = memoizedHtmlTemplate;
-  let manifest = memoizedManifest;
-
-  if (!template || !manifest) {
-    return c.text("anaemia engine error: build assets are missing", 500);
-  }
-
-  const reqPath = c.req.path;
-  const { activeChunk, targetPattern, statusCode: matchedStatus, params } = matchRoute(manifest, reqPath);
-  let statusCode: StatusCode = matchedStatus;
-  const loaderArgs = { params, request: c.req.raw };
-
-  const store = ssrStorage.getStore() || new Map<string, unknown>();
-  let htmlPayload;
-
-  if (targetPattern) {
-    try {
-      const guardResult = await runGuards(targetPattern, { params, request: c.req.raw, url: reqPath });
-      if (guardResult) {
-        if ("redirect" in guardResult) return c.redirect(guardResult.redirect, (guardResult.status ?? 302) as RedirectStatusCode);
-        if ("status" in guardResult) statusCode = guardResult.status as StatusCode;
-      }
-    } catch (err) {
-      console.error("[anaemia] guard threw unexpectedly:", err);
-      return c.text("Internal Server Error", 500);
-    }
-  }
-
-  try {
-    htmlPayload = await ssrStorage.run(store, async () => {
-      if (targetPattern) {
-        const executableLoader = serverLoaderRegistry.get(targetPattern);
-        if (executableLoader) {
-          const initialLoaderData = await executableLoader(loaderArgs);
-          store.set("__LOADER_DATA__", initialLoaderData);
-        }
-      }
-
-      await preloadActiveClientRoute(reqPath);
-
-      return await renderToStringAsync(() => (
-        <Router url={reqPath}>
-          <App />
-        </Router>
-      ));
-    });
-  } catch (err) {
-    statusCode = 500;
-    console.error("[anaemia framework] runtime execution crash handled:", err);
-
-    const error500Pattern = manifest.errors?.["500"];
-    const error500Loader = error500Pattern ? serverLoaderRegistry.get(error500Pattern) : null;
-
-    if (error500Loader) {
-      const message = err instanceof Error ? err.message : String(err);
-      const stack = err instanceof Error ? err.stack : undefined;
-      const runtimeContextPayload = { message, stack: isDev ? stack : undefined };
-      store.set("__LOADER_DATA__", runtimeContextPayload);
-
-      try {
-        htmlPayload = await ssrStorage.run(store, async () => {
-          return await renderToStringAsync(() => (
-            <Router url={error500Pattern}>
-              <App />
-            </Router>
-          ));
-        });
-      } catch {
-        htmlPayload = `<h1>500 Internal Server Error</h1>`;
-      }
-    } else {
-      const stack = err instanceof Error ? err.stack : String(err);
-      htmlPayload = `<h1>500 Internal Server Error</h1><pre>${isDev ? stack : ""}</pre>`;
-    }
-  }
-
-  let assetScripts = "";
-  let assetStyles = "";
-
-  if (manifest.chunks) {
-    const processChunkAssets = (chunk: ChunkAssets | undefined) => {
-      if (!chunk) return;
-      if (chunk.js) {
-        const jsSpecs = Array.isArray(chunk.js) ? chunk.js : [chunk.js];
-        jsSpecs.forEach((jsFile: string) => {
-          assetScripts += `<script type="module" src="${normalizeAssetUrl(jsFile)}"></script>\n`;
-        });
-      }
-      if (chunk.css) {
-        const cssSpecs = Array.isArray(chunk.css) ? chunk.css : [chunk.css];
-        cssSpecs.forEach((cssFile: string) => {
-          assetStyles += `<link rel="stylesheet" href="${normalizeAssetUrl(cssFile)}">\n`;
-        });
-      }
-    };
-
-    processChunkAssets(manifest.chunks["client"]);
-    if (manifest.chunks["commons"]) processChunkAssets(manifest.chunks["commons"]);
-    if (manifest.chunks["vendors"]) processChunkAssets(manifest.chunks["vendors"]);
-    if (activeChunk && activeChunk !== "client") processChunkAssets(manifest.chunks[activeChunk]);
-  }
-
-  const hydrationScript = generateHydrationScript();
-  const rawStorePayload = Object.fromEntries(store);
-
-  const finalHydrationStatePayload = {
-    __LOADER_DATA__: rawStorePayload.__LOADER_DATA__ || {},
-    __SERVER_FUNCTION_DATA__: rawStorePayload.__SERVER_FUNCTION_DATA__ || {},
-  };
-
-  const serializedData = JSON.stringify(finalHydrationStatePayload).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\//g, "\\u002f");
-
-  const dataScript = `<script id="__ANAEMIA_DATA__" type="application/json">${serializedData}</script>\n`;
-
-  const devNoCacheTag = isDev ? `<meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate">\n<meta http-equiv="Pragma" content="no-cache">\n<meta http-equiv="Expires" content="0">\n` : "";
-
-  const combinedHeadInjections = `${devNoCacheTag}${assetStyles}${dataScript}${hydrationScript}`;
-  const sanitizedPayload = htmlPayload.trim();
-
-  let completeHtmlOutput = ENTRY_TAG_REGEX.test(template) ? template.replace(ENTRY_TAG_REGEX, (_, open, _tag, _inner, close) => `${open}${sanitizedPayload}${close}`) : template.replace("</body>", () => `<div anaemia-entry>${sanitizedPayload}</div></body>`);
-
-  completeHtmlOutput = completeHtmlOutput.replace("<head>", `<head>${combinedHeadInjections}`);
-  completeHtmlOutput = completeHtmlOutput.replace("</body>", `${assetScripts}</body>`);
-
-  if (isDev) {
-    c.header("Cache-Control", "no-cache, no-store, must-revalidate");
-    c.header("Pragma", "no-cache");
-    c.header("Expires", "0");
-  }
-
-  c.status(statusCode);
-  return c.html(completeHtmlOutput);
+const env = createRuntimeEnv();
+const manifestStore = createManifestStore(env);
+
+const app = createServerApp({
+  App,
+  env,
+  preloadActiveClientRoute,
+  serverLoaderRegistry,
+  serverGuardRegistry,
+  registerServerRoutes,
+  getManifestSnapshot: manifestStore.getSnapshot,
+  loadManifestAndTemplate: manifestStore.load,
 });
 
-loadManifestAndTemplate()
+manifestStore
+  .load()
   .then(() => {
-    serve({ fetch: app.fetch, port }, (info) => {
-      console.log(`[anaemia framework] server live at http://localhost:${info.port}`);
-    });
+    serveServer(app, env);
   })
   .catch((err) => {
     console.error("[anaemia] failed to initialize:", err);

package/src/runtime/resources.ts

@@ -1,5 +1,6 @@
 import { createResource, type ResourceOptions, type ResourceReturn } from "solid-js";
 import { isServer } from "solid-js/web";
+import { SERVER_FUNCTION_DATA_KEY } from "./shared/constants.js";
 
 interface ServerStorage {
   getStore?: () => Map<string, unknown> | undefined;
@@ -18,14 +19,14 @@ export function createServerResource<Source, Return>(
     readHydrationCache?: (s: Source) => Return | undefined;
     id?: string;
   },
-  options?: ResourceOptions<Return, Source>
+  options?: ResourceOptions<Return, Source>,
 ): ResourceReturn<Return, unknown> {
   if (isServer) {
     let ssrInitialValue: Return | undefined = undefined;
     const store = (globalThis as unknown as AnaemiaGlobal).__ANAEMIA_SERVER_STORAGE__?.getStore?.();
 
     if (store && serverFn.id) {
-      const fnData = store.get("__SERVER_FUNCTION_DATA__") as ServerFunctionData | undefined;
+      const fnData = store.get(SERVER_FUNCTION_DATA_KEY) as ServerFunctionData | undefined;
       const fnCache = fnData?.[serverFn.id];
       if (fnCache) {
         const sourceValue = source();

package/src/runtime/route-data.ts

@@ -4,6 +4,7 @@ import { useParams, useLocation, type Params } from "@solidjs/router";
 import type { Location } from "@solidjs/router";
 import { ssrStorage } from "./context.js";
 import { createRouteRequest } from "./route-request.js";
+import { ANAEMIA_DATA_SCRIPT_ID, LOADER_DATA_KEY } from "./shared/constants.js";
 
 type LoaderArgs<TParams extends Params> = {
   params: TParams;
@@ -25,19 +26,19 @@ const RouteDataContext = createContext<RouteDataContextValue>();
 let hasReadClientHydrationData = false;
 
 interface AnaemiaHydrationData {
-  __LOADER_DATA__?: unknown;
+  [LOADER_DATA_KEY]?: unknown;
 }
 
 function readSSRData(): unknown {
   if (isServer) {
-    return ssrStorage.getStore()?.get("__LOADER_DATA__");
+    return ssrStorage.getStore()?.get(LOADER_DATA_KEY);
   }
   if (hasReadClientHydrationData) return undefined;
   hasReadClientHydrationData = true;
-  const el = document.getElementById("__ANAEMIA_DATA__");
+  const el = document.getElementById(ANAEMIA_DATA_SCRIPT_ID);
   if (!el?.textContent) return undefined;
   try {
-    return (JSON.parse(el.textContent) as AnaemiaHydrationData).__LOADER_DATA__;
+    return (JSON.parse(el.textContent) as AnaemiaHydrationData)[LOADER_DATA_KEY];
   } catch {
     return undefined;
   }
@@ -61,7 +62,7 @@ export function RouteDataController<TParams extends Params = Params>(props: Rout
     {
       initialValue: ssrData,
       ssrLoadFrom: "initial",
-    }
+    },
   );
 
   return createComponent(RouteDataContext.Provider, {

package/src/runtime/route-request.ts

@@ -1,13 +1,14 @@
 import { isServer } from "solid-js/web";
 import type { Context } from "hono";
 import { ssrStorage } from "./context.js";
+import { HONO_CONTEXT_KEY } from "./shared/constants.js";
 
 export function createRouteRequest(pathname: string): Request {
   if (isServer) {
-    const honoContext = ssrStorage.getStore()?.get("honoContext") as Context | undefined;
-    const request = honoContext?.req?.raw;
+    const honoContext = ssrStorage.getStore()?.get(HONO_CONTEXT_KEY) as Context | undefined;
+    const request = honoContext?.req.raw;
     if (request) return request;
     return new Request(new URL(pathname, "http://localhost").toString());
   }
   return new Request(new URL(pathname, window.location.origin).toString());
-}
+}

package/src/runtime/rpc-client.ts

@@ -1,4 +1,5 @@
 import { isServer } from "solid-js/web";
+import { ANAEMIA_DATA_SCRIPT_ID, RPC_PATH, SERVER_FUNCTION_DATA_KEY } from "./shared/constants.js";
 
 interface CacheMatch {
   matchingKey: string;
@@ -10,7 +11,7 @@ interface ServerFunctionCache {
 }
 
 interface AnaemiaClientCache {
-  __SERVER_FUNCTION_DATA__?: ServerFunctionCache;
+  [SERVER_FUNCTION_DATA_KEY]?: ServerFunctionCache;
 }
 
 interface AnaemiaServerStorage {
@@ -25,7 +26,7 @@ let _clientCache: AnaemiaClientCache | null = null;
 
 function ensureCacheInitialized() {
   if (isServer || _clientCache) return;
-  const script = document.getElementById("__ANAEMIA_DATA__");
+  const script = document.getElementById(ANAEMIA_DATA_SCRIPT_ID);
   try {
     _clientCache = JSON.parse(script?.textContent || "{}") as AnaemiaClientCache;
   } catch {
@@ -34,8 +35,8 @@ function ensureCacheInitialized() {
 }
 
 function findLooseCacheMatch(
-  serverFunctionData: Record<string, unknown>,
-  targetArg: string
+  serverFunctionData: Record<string, unknown> | null | undefined,
+  targetArg: string,
 ): CacheMatch | undefined {
   if (!serverFunctionData) return undefined;
   const strictKey = JSON.stringify([targetArg]);
@@ -56,17 +57,17 @@ export function $$executeClientRpc(hashId: string) {
     if (isServer) {
       const store = getServerStore();
       if (store) {
-        const functionCache = store.get("__SERVER_FUNCTION_DATA__") as ServerFunctionCache | undefined;
+        const functionCache = store.get(SERVER_FUNCTION_DATA_KEY) as ServerFunctionCache | undefined;
         if (functionCache?.[hashId]) {
           const match = findLooseCacheMatch(functionCache[hashId], args[0] as string);
           if (match) return match.data;
         }
       }
-      return undefined;
+      return;
     }
 
     ensureCacheInitialized();
-    const serverFunctionData = _clientCache?.__SERVER_FUNCTION_DATA__?.[hashId];
+    const serverFunctionData = _clientCache?.[SERVER_FUNCTION_DATA_KEY]?.[hashId];
     const match = findLooseCacheMatch(serverFunctionData ?? {}, args[0] as string);
     if (match) {
       const { matchingKey, data } = match;
@@ -74,13 +75,13 @@ export function $$executeClientRpc(hashId: string) {
       return data;
     }
 
-    const response = await fetch(`/_rpc?id=${hashId}`, {
+    const response = await fetch(`${RPC_PATH}?id=${hashId}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(args),
     });
     if (!response.ok) throw new Error(`[anaemia] RPC execution failed: ${response.status}`);
-    return await response.json() as unknown;
+    return (await response.json()) as unknown;
   };
 
   asyncRpcCall.id = hashId;
@@ -88,20 +89,20 @@ export function $$executeClientRpc(hashId: string) {
     if (isServer) {
       const store = getServerStore();
       if (store) {
-        const functionCache = store.get("__SERVER_FUNCTION_DATA__") as ServerFunctionCache | undefined;
+        const functionCache = store.get(SERVER_FUNCTION_DATA_KEY) as ServerFunctionCache | undefined;
         if (functionCache?.[hashId]) {
           const match = findLooseCacheMatch(functionCache[hashId], args[0] as string);
           if (match) return match.data;
         }
       }
-      return undefined;
+      return;
     }
 
     ensureCacheInitialized();
-    const serverFunctionData = _clientCache?.__SERVER_FUNCTION_DATA__?.[hashId];
+    const serverFunctionData = _clientCache?.[SERVER_FUNCTION_DATA_KEY]?.[hashId];
     const match = findLooseCacheMatch(serverFunctionData ?? {}, args[0] as string);
     return match ? match.data : undefined;
   };
 
   return asyncRpcCall;
-}
+}

package/src/runtime/server/app.ts

@@ -0,0 +1,44 @@
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import type { Component } from "solid-js";
+import { ssrStorage } from "../context.js";
+import { HONO_CONTEXT_KEY } from "../shared/constants.js";
+import { registerAssetRoutes } from "./assets.js";
+import { registerRpcRoute } from "./rpc.js";
+import { createRenderRequestHandler } from "./render-request.jsx";
+import type { RuntimeEnv } from "./types.js";
+import type { GuardFn } from "./guards.js";
+import type { ManifestSnapshot } from "./manifest.js";
+
+type ServerLoader = (args: { params: Record<string, string>; request: Request }) => unknown | Promise<unknown>;
+
+type CreateServerAppOptions = {
+  App: Component;
+  env: RuntimeEnv;
+  preloadActiveClientRoute: (path: string) => unknown | Promise<unknown>;
+  serverLoaderRegistry: Map<string, ServerLoader>;
+  serverGuardRegistry: Map<string, (() => Promise<GuardFn[]>)[]>;
+  registerServerRoutes: (app: Hono) => void;
+  getManifestSnapshot: () => ManifestSnapshot;
+  loadManifestAndTemplate: () => Promise<void>;
+};
+
+export function createServerApp(options: CreateServerAppOptions) {
+  const app = new Hono();
+
+  app.use("*", compress());
+
+  app.use("*", async (c, next) => {
+    const store = new Map<string, unknown>();
+    store.set(HONO_CONTEXT_KEY, c);
+    return await ssrStorage.run(store, next);
+  });
+
+  registerAssetRoutes(app, options.env);
+  registerRpcRoute(app);
+  options.registerServerRoutes(app);
+
+  app.get("*", createRenderRequestHandler(options));
+
+  return app;
+}