@anaemia/core 0.4.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anaemia/core",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,7 +28,10 @@
       "types": "./dist/plugins/index.d.ts",
       "import": "./dist/plugins/index.js"
     },
-    "./client": "./anaemia.d.ts",
+    "./client": {
+      "types": "./anaemia.d.ts",
+      "default": "./anaemia.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "dependencies": {

package/src/runtime/context.ts

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { SERVER_FUNCTION_DATA_KEY } from "./shared/constants.js";
 
 type AnyFn = (...args: unknown[]) => unknown;
 
@@ -14,13 +15,10 @@ export function runOnServer<T extends AnyFn>(backendFn: T, id?: string): T & { i
     const result = await backendFn(...args);
     const store = ssrStorage.getStore();
     if (store && hashId) {
-      if (!store.has("__SERVER_FUNCTION_DATA__")) {
-        store.set("__SERVER_FUNCTION_DATA__", {});
+      if (!store.has(SERVER_FUNCTION_DATA_KEY)) {
+        store.set(SERVER_FUNCTION_DATA_KEY, {});
       }
-      const functionCache = store.get("__SERVER_FUNCTION_DATA__") as Record<
-        string,
-        Record<string, unknown> | undefined
-      >;
+      const functionCache = store.get(SERVER_FUNCTION_DATA_KEY) as Record<string, Record<string, unknown> | undefined>;
       if (!functionCache[hashId]) {
         functionCache[hashId] = {};
       }

package/src/runtime/entry-client.tsx

@@ -1,10 +1,11 @@
 import { hydrate, render } from "solid-js/web";
 import { Router } from "@solidjs/router";
+import { ENTRY_SELECTOR } from "./shared/constants.js";
 
 // @ts-expect-error - resolved by Rspack
 import App, { preloadActiveClientRoute } from "anaemia-user-app";
 
-const mountTarget = document.querySelector("[anaemia-entry]") as HTMLElement | null;
+const mountTarget = document.querySelector(ENTRY_SELECTOR) as HTMLElement | null;
 
 if (!mountTarget) {
   throw new Error("[anaemia] missing mount target");

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 "node: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,395 +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();
-
-  const template = memoizedHtmlTemplate;
-  const 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 = "";
-
-  const processChunkAssets = (chunk: ChunkAssets | undefined) => {
-    if (!chunk) return;
-    if (chunk.js) {
-      const jsSpecs = Array.isArray(chunk.js) ? chunk.js : [chunk.js];
-
-      for (const jsFile of jsSpecs) {
-        assetScripts += `<script type="module" src="${normalizeAssetUrl(jsFile)}"></script>\n`;
-      }
-    }
-    if (chunk.css) {
-      const cssSpecs = Array.isArray(chunk.css) ? chunk.css : [chunk.css];
-
-      for (const cssFile of cssSpecs) {
-        assetStyles += `<link rel="stylesheet" href="${normalizeAssetUrl(cssFile)}">\n`;
-      }
-    }
-  };
-
-  processChunkAssets(manifest.chunks["client"]);
-  processChunkAssets(manifest.chunks["commons"]);
-  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;
@@ -25,7 +26,7 @@ export function createServerResource<Source, Return>(
     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;
   }

package/src/runtime/route-request.ts

@@ -1,10 +1,11 @@
 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 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());

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 {
@@ -56,7 +57,7 @@ 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;
@@ -66,7 +67,7 @@ export function $$executeClientRpc(hashId: string) {
     }
 
     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,7 +75,7 @@ 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),
@@ -88,7 +89,7 @@ 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;
@@ -98,7 +99,7 @@ export function $$executeClientRpc(hashId: string) {
     }
 
     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;
   };

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;
+}