@anaemia/core 0.4.0 → 0.5.0

package/src/runtime/server/assets.ts

@@ -0,0 +1,69 @@
+import type { Context, Hono } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import type { RuntimeEnv } from "./types.js";
+
+function setNoCacheHeaders(c: Context) {
+  c.header("Cache-Control", "no-cache, no-store, must-revalidate");
+  c.header("Pragma", "no-cache");
+  c.header("Expires", "0");
+}
+
+async function proxyDevAsset(c: Context, targetUrl: string, notFoundMessage: string, failureMessage: string) {
+  try {
+    const response = await fetch(targetUrl);
+    if (!response.ok) return c.text(notFoundMessage, 404);
+
+    const contentType = response.headers.get("content-type");
+    if (contentType) c.header("content-type", contentType);
+
+    setNoCacheHeaders(c);
+
+    return c.body(await response.arrayBuffer());
+  } catch {
+    return c.text(failureMessage, 500);
+  }
+}
+
+export function registerAssetRoutes(app: Hono, env: RuntimeEnv) {
+  if (env.isDev) {
+    app.get("/assets/*", (c) =>
+      proxyDevAsset(
+        c,
+        `${env.devServerUrl}${c.req.path}`,
+        "asset not found in Rspack memory",
+        "failed to connect to Rspack dev server asset bridge",
+      ),
+    );
+  } 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: env.clientDistPath,
+      }),
+    );
+  }
+
+  app.use(async (c, next) => {
+    const requestPath = c.req.path;
+    if (env.isDev && requestPath.includes(".hot-update.")) {
+      return proxyDevAsset(
+        c,
+        `${env.devServerUrl}${requestPath}`,
+        "hot update not found",
+        "failed to fetch hot update",
+      );
+    }
+
+    await next();
+  });
+}
+
+export function setDevResponseCacheHeaders(c: Context, env: RuntimeEnv) {
+  if (!env.isDev) return;
+  setNoCacheHeaders(c);
+}

package/src/runtime/server/boot.ts

@@ -0,0 +1,9 @@
+import { serve } from "@hono/node-server";
+import type { Hono } from "hono";
+import type { RuntimeEnv } from "./types.js";
+
+export function serveServer(app: Hono, env: RuntimeEnv) {
+  serve({ fetch: app.fetch, port: env.port }, (info) => {
+    console.log(`[anaemia framework] server live at http://localhost:${info.port}`);
+  });
+}

package/src/runtime/server/env.ts

@@ -0,0 +1,17 @@
+import path from "node:path";
+import type { RuntimeEnv } from "./types.js";
+
+export function createRuntimeEnv(processEnv: NodeJS.ProcessEnv = process.env): RuntimeEnv {
+  const port = Number(processEnv.PORT) || 3000;
+  const isDev = processEnv.NODE_ENV !== "production";
+  const devPort = Number(processEnv.RSPACK_DEV_PORT) || 4445;
+
+  return {
+    port,
+    isDev,
+    devServerUrl: `http://localhost:${devPort}`,
+    templatePath: path.resolve(process.cwd(), "./dist/client/index.html"),
+    manifestPath: path.resolve(process.cwd(), "./dist/route-manifest.json"),
+    clientDistPath: path.resolve(process.cwd(), "./dist/client"),
+  };
+}

package/src/runtime/server/guards.ts

@@ -0,0 +1,26 @@
+export 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 }>;
+
+export async function runGuards(
+  serverGuardRegistry: Map<string, (() => Promise<GuardFn[]>)[]>,
+  pattern: string,
+  ctx: { params: Record<string, string>; request: Request; url: string },
+) {
+  const chain = serverGuardRegistry.get(pattern) ?? [];
+  for (const loadGuards of chain) {
+    const guards = await loadGuards();
+    for (const guard of guards) {
+      const result = await guard(ctx);
+      if (result && ("redirect" in result || "status" in result)) return result;
+    }
+  }
+  return null;
+}

package/src/runtime/server/html.ts

@@ -0,0 +1,84 @@
+import { ENTRY_ATTRIBUTE } from "../shared/constants.js";
+import type { ChunkAssets, RouteManifest } from "./types.js";
+
+const ENTRY_TAG_REGEX = /(<([a-zA-Z0-9-]+)[^>]*anaemia-entry[^>]*>)(.*?)(<\/\2>)/is;
+
+function normalizeAssetUrl(url: unknown): string {
+  if (!url || typeof url !== "string") return "";
+  if (url.startsWith("http://") || url.startsWith("https://")) return url;
+  return url.startsWith("/") ? url : `/${url}`;
+}
+
+function chunkAssetTags(chunk: ChunkAssets | undefined): { scripts: string; styles: string } {
+  if (!chunk) return { scripts: "", styles: "" };
+
+  const scripts =
+    (chunk.js ?? "")
+      ? (Array.isArray(chunk.js) ? chunk.js : [chunk.js])
+          .map((jsFile) => `<script type="module" src="${normalizeAssetUrl(jsFile)}"></script>\n`)
+          .join("")
+      : "";
+
+  const styles =
+    (chunk.css ?? "")
+      ? (Array.isArray(chunk.css) ? chunk.css : [chunk.css])
+          .map((cssFile) => `<link rel="stylesheet" href="${normalizeAssetUrl(cssFile)}">\n`)
+          .join("")
+      : "";
+
+  return { scripts, styles };
+}
+
+export function getRouteAssetTags(manifest: RouteManifest, activeChunk: string): { scripts: string; styles: string } {
+  const chunkNames = ["client", "commons", "vendors"];
+  if (activeChunk && activeChunk !== "client") chunkNames.push(activeChunk);
+
+  return chunkNames.reduce(
+    (assetTags, chunkName) => {
+      const tags = chunkAssetTags(manifest.chunks[chunkName]);
+      return {
+        scripts: assetTags.scripts + tags.scripts,
+        styles: assetTags.styles + tags.styles,
+      };
+    },
+    { scripts: "", styles: "" },
+  );
+}
+
+export function createDevNoCacheHeadTags(isDev: boolean): string {
+  return 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`
+    : "";
+}
+
+export function createHtmlStreamShell(args: { template: string; headInjections: string; bodyInjections: string }): {
+  beforeEntry: string;
+  afterEntry: string;
+} {
+  const templateWithHead = args.template.replace("<head>", `<head>${args.headInjections}`);
+  const entryMatch = ENTRY_TAG_REGEX.exec(templateWithHead);
+
+  if (entryMatch) {
+    const [fullMatch, openTag, _tagName, _inner, closeTag] = entryMatch;
+    const beforeEntry = `${templateWithHead.slice(0, entryMatch.index)}${openTag}`;
+    const afterEntry = `${closeTag}${templateWithHead.slice(entryMatch.index + fullMatch.length)}`.replace(
+      "</body>",
+      `${args.bodyInjections}</body>`,
+    );
+
+    return { beforeEntry, afterEntry };
+  }
+
+  const bodyCloseIndex = templateWithHead.lastIndexOf("</body>");
+  if (bodyCloseIndex >= 0) {
+    return {
+      beforeEntry: `${templateWithHead.slice(0, bodyCloseIndex)}<div ${ENTRY_ATTRIBUTE}>`,
+      afterEntry: `</div>${args.bodyInjections}${templateWithHead.slice(bodyCloseIndex)}`,
+    };
+  }
+
+  return {
+    beforeEntry: `${templateWithHead}<div ${ENTRY_ATTRIBUTE}>`,
+    afterEntry: `</div>${args.bodyInjections}`,
+  };
+}

package/src/runtime/server/hydration.ts

@@ -0,0 +1,26 @@
+import { generateHydrationScript } from "solid-js/web";
+import { ANAEMIA_DATA_SCRIPT_ID, LOADER_DATA_KEY, SERVER_FUNCTION_DATA_KEY } from "../shared/constants.js";
+
+function serializeJsonForHtml(value: unknown): string {
+  return JSON.stringify(value)
+    .replace(/&/g, "\\u0026")
+    .replace(/</g, "\\u003c")
+    .replace(/>/g, "\\u003e")
+    .replace(/\//g, "\\u002f");
+}
+
+export function createHydrationDataScript(store: Map<string, unknown>): string {
+  const rawStorePayload = Object.fromEntries(store);
+  const finalHydrationStatePayload = {
+    [LOADER_DATA_KEY]: rawStorePayload[LOADER_DATA_KEY] || {},
+    [SERVER_FUNCTION_DATA_KEY]: rawStorePayload[SERVER_FUNCTION_DATA_KEY] || {},
+  };
+
+  return `<script id="${ANAEMIA_DATA_SCRIPT_ID}" type="application/json">${serializeJsonForHtml(
+    finalHydrationStatePayload,
+  )}</script>\n`;
+}
+
+export function createHydrationRuntimeScript(): string {
+  return generateHydrationScript();
+}

package/src/runtime/server/manifest.ts

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import type { RouteManifest, RuntimeEnv } from "./types.js";
+import { sortRoutes } from "./route-match.js";
+
+export type ManifestSnapshot = {
+  template: string;
+  manifest: RouteManifest | null;
+  sortedRoutes: RouteManifest["routes"];
+  staticRoutes: Set<string>; // routes safe to cache indefinitely
+  loaderRoutes: Set<string>; // routes that need loader execution
+  guardRoutes: Set<string>; // routes that need guard execution
+};
+
+export function createManifestStore(env: RuntimeEnv) {
+  let memoizedHtmlTemplate = "";
+  let memoizedManifest: RouteManifest | null = null;
+  let memoizedSortedRoutes: RouteManifest["routes"] = [];
+
+  const load = async () => {
+    if (env.isDev) {
+      try {
+        memoizedHtmlTemplate = await fetch(`${env.devServerUrl}/index.html`).then((response) => {
+          if (!response.ok) throw new Error(`index.html fetch failed: ${response.status}`);
+          return response.text();
+        });
+      } catch (err) {
+        console.error("[anaemia engine sync error - HTML fetch failed]:", err);
+        memoizedHtmlTemplate = "";
+      }
+
+      try {
+        if (fs.existsSync(env.manifestPath)) {
+          memoizedManifest = JSON.parse(fs.readFileSync(env.manifestPath, "utf-8")) as RouteManifest;
+        } 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(env.templatePath)) memoizedHtmlTemplate = fs.readFileSync(env.templatePath, "utf-8");
+        if (fs.existsSync(env.manifestPath)) {
+          memoizedManifest = JSON.parse(fs.readFileSync(env.manifestPath, "utf-8")) as RouteManifest;
+        }
+      } catch {
+        console.warn("build assets not fully initialized during bootstrapping cycle.");
+      }
+    }
+
+    memoizedSortedRoutes = memoizedManifest ? sortRoutes(memoizedManifest.routes) : [];
+  };
+
+  const getSnapshot = (): ManifestSnapshot => {
+    const routes = memoizedManifest?.routes ?? [];
+
+    return {
+      template: memoizedHtmlTemplate,
+      manifest: memoizedManifest,
+      sortedRoutes: memoizedSortedRoutes,
+      staticRoutes: new Set(routes.filter((r) => r.isStatic).map((r) => r.urlPattern)),
+      loaderRoutes: new Set(routes.filter((r) => r.hasLoader).map((r) => r.urlPattern)),
+      guardRoutes: new Set(routes.filter((r) => r.hasGuard).map((r) => r.urlPattern)),
+    };
+  };
+
+  return { load, getSnapshot };
+}

package/src/runtime/server/render-request.tsx

@@ -0,0 +1,230 @@
+import { Router } from "@solidjs/router";
+import type { Component } from "solid-js";
+import type { Context } from "hono";
+import type { ContentfulStatusCode, RedirectStatusCode, StatusCode } from "hono/utils/http-status";
+import { renderToStream } from "solid-js/web";
+import { ssrStorage } from "../context.js";
+import { LOADER_DATA_KEY } from "../shared/constants.js";
+import { setDevResponseCacheHeaders } from "./assets.js";
+import { runGuards, type GuardFn } from "./guards.js";
+import { createDevNoCacheHeadTags, createHtmlStreamShell, getRouteAssetTags } from "./html.js";
+import { createHydrationDataScript, createHydrationRuntimeScript } from "./hydration.js";
+import { matchRoute } from "./route-match.js";
+import type { RouteManifest, RuntimeEnv } from "./types.js";
+import type { ManifestSnapshot } from "./manifest.js";
+
+const staticCache = new Map<string, string>();
+
+type ServerLoader = (args: { params: Record<string, string>; request: Request }) => unknown | Promise<unknown>;
+
+type RenderRequestOptions = {
+  App: Component;
+  env: RuntimeEnv;
+  preloadActiveClientRoute: (path: string) => unknown | Promise<unknown>;
+  serverLoaderRegistry: Map<string, ServerLoader>;
+  serverGuardRegistry: Map<string, (() => Promise<GuardFn[]>)[]>;
+  getManifestSnapshot: () => ManifestSnapshot;
+  loadManifestAndTemplate: () => Promise<void>;
+};
+
+type SolidStream = ReturnType<typeof renderToStream>;
+
+function renderApp(App: Component, url: string): SolidStream {
+  return renderToStream(() => (
+    <Router url={url}>
+      <App />
+    </Router>
+  ));
+}
+
+async function render500(args: {
+  App: Component;
+  error: unknown;
+  env: RuntimeEnv;
+  manifest: RouteManifest;
+  serverLoaderRegistry: Map<string, ServerLoader>;
+  store: Map<string, unknown>;
+}): Promise<SolidStream | string> {
+  const error500Pattern = args.manifest.errors?.["500"];
+  if (!error500Pattern) {
+    const stack = args.error instanceof Error ? args.error.stack : String(args.error);
+    return `<h1>500 Internal Server Error</h1><pre>${args.env.isDev ? stack : ""}</pre>`;
+  }
+
+  const error500Loader = args.serverLoaderRegistry.get(error500Pattern);
+  if (error500Loader) {
+    const message = args.error instanceof Error ? args.error.message : String(args.error);
+    const stack = args.error instanceof Error ? args.error.stack : undefined;
+    args.store.set(LOADER_DATA_KEY, { message, stack: args.env.isDev ? stack : undefined });
+
+    try {
+      return await ssrStorage.run(args.store, async () => renderApp(args.App, error500Pattern));
+    } catch {
+      return `<h1>500 Internal Server Error</h1>`;
+    }
+  }
+
+  const stack = args.error instanceof Error ? args.error.stack : String(args.error);
+  return `<h1>500 Internal Server Error</h1><pre>${args.env.isDev ? stack : ""}</pre>`;
+}
+
+function createHtmlResponseStream(args: {
+  beforeEntry: string;
+  renderStream: SolidStream | string;
+  afterEntry: () => string;
+  store: Map<string, unknown>;
+  onComplete?: (html: string) => void; // called with full HTML when done
+}): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  const collected: string[] = [];
+  const shouldCollect = Boolean(args.onComplete);
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      const enqueue = (chunk: string) => {
+        if (shouldCollect) collected.push(chunk);
+        controller.enqueue(encoder.encode(chunk));
+      };
+
+      enqueue(args.beforeEntry);
+
+      if (typeof args.renderStream === "string") {
+        enqueue(args.renderStream);
+        const after = args.afterEntry();
+        enqueue(after);
+        args.onComplete?.(collected.join(""));
+        controller.close();
+        return;
+      }
+
+      const renderStream = args.renderStream;
+      const writable = new WritableStream<string>({
+        write(chunk) {
+          enqueue(chunk);
+        },
+        close() {
+          const after = args.afterEntry();
+          enqueue(after);
+          args.onComplete?.(collected.join(""));
+          controller.close();
+        },
+        abort(error) {
+          controller.error(error);
+        },
+      });
+
+      void ssrStorage
+        .run(args.store, async () => {
+          await renderStream.pipeTo(writable);
+        })
+        .catch((error) => {
+          controller.error(error);
+        });
+    },
+  });
+}
+
+export function createRenderRequestHandler(options: RenderRequestOptions) {
+  return async (c: Context) => {
+    if (options.env.isDev) await options.loadManifestAndTemplate();
+
+    const { template, manifest, sortedRoutes, staticRoutes, loaderRoutes, guardRoutes } = options.getManifestSnapshot();
+
+    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, sortedRoutes);
+    let statusCode: StatusCode = matchedStatus;
+    const loaderArgs = { params, request: c.req.raw };
+
+    const store = ssrStorage.getStore() || new Map<string, unknown>();
+    let renderStream: SolidStream | string;
+
+    const isStaticRoute = !options.env.isDev && staticRoutes.has(targetPattern);
+
+    // serve from cache before doing any work
+    if (isStaticRoute) {
+      const cached = staticCache.get(reqPath);
+      if (cached) {
+        c.header("Content-Type", "text/html; charset=UTF-8");
+        c.header("X-Anaemia-Cache", "HIT");
+        return c.html(cached, statusCode as ContentfulStatusCode);
+      }
+    }
+
+    if (targetPattern && guardRoutes.has(targetPattern)) {
+      try {
+        const guardResult = await runGuards(options.serverGuardRegistry, 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 {
+      renderStream = await ssrStorage.run(store, async () => {
+        if (targetPattern && loaderRoutes.has(targetPattern)) {
+          const executableLoader = options.serverLoaderRegistry.get(targetPattern);
+          if (executableLoader) {
+            const initialLoaderData = await executableLoader(loaderArgs);
+            store.set(LOADER_DATA_KEY, initialLoaderData);
+          }
+        }
+
+        await options.preloadActiveClientRoute(reqPath);
+        return renderApp(options.App, reqPath);
+      });
+    } catch (err) {
+      statusCode = 500;
+      console.error("[anaemia framework] runtime execution crash handled:", err);
+      renderStream = await render500({
+        App: options.App,
+        error: err,
+        env: options.env,
+        manifest,
+        serverLoaderRegistry: options.serverLoaderRegistry,
+        store,
+      });
+    }
+
+    const routeAssetTags = getRouteAssetTags(manifest, activeChunk);
+    const headInjections = `${createDevNoCacheHeadTags(options.env.isDev)}${routeAssetTags.styles}${createHydrationRuntimeScript()}`;
+    const shell = createHtmlStreamShell({ template, headInjections, bodyInjections: "" });
+
+    setDevResponseCacheHeaders(c, options.env);
+    c.status(statusCode);
+    c.header("Content-Type", "text/html; charset=UTF-8");
+
+    return c.body(
+      createHtmlResponseStream({
+        beforeEntry: shell.beforeEntry,
+        renderStream,
+        afterEntry: () => {
+          const bodyInjections = `${createHydrationDataScript(store)}${routeAssetTags.scripts}`;
+          return shell.afterEntry.includes("</body>")
+            ? shell.afterEntry.replace("</body>", `${bodyInjections}</body>`)
+            : `${shell.afterEntry}${bodyInjections}`;
+        },
+        store,
+        onComplete: isStaticRoute ? (html) => staticCache.set(reqPath, html) : undefined,
+      }),
+    );
+  };
+}

package/src/runtime/server/route-match.ts

@@ -0,0 +1,45 @@
+import type { RouteManifest, RouteMatch } from "./types.js";
+
+type SortedRoute = RouteManifest["routes"][number];
+
+function scoreRoutePattern(pattern: string): number {
+  const segments = pattern.split("/").filter(Boolean);
+  return segments.reduce((acc, segment) => {
+    if (segment.startsWith(":")) return acc - 1;
+    if (segment === "*" || segment.startsWith("*")) return acc - 2;
+    return acc;
+  }, segments.length * 10);
+}
+
+export function sortRoutes(routes: RouteManifest["routes"]): SortedRoute[] {
+  return [...routes].sort((a, b) => scoreRoutePattern(b.urlPattern) - scoreRoutePattern(a.urlPattern));
+}
+
+export function matchRoute(
+  manifest: RouteManifest,
+  reqPath: string,
+  sortedRoutes = sortRoutes(manifest.routes),
+): RouteMatch {
+  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: {},
+  };
+}

package/src/runtime/server/rpc.ts

@@ -0,0 +1,34 @@
+import type { Hono } from "hono";
+import { serverFunctionsRegistry } from "../context.js";
+import { RPC_PATH } from "../shared/constants.js";
+
+export function registerRpcRoute(app: Hono) {
+  app.post(RPC_PATH, 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);
+    }
+  });
+}

package/src/runtime/server/types.ts

@@ -0,0 +1,36 @@
+import type { StatusCode } from "hono/utils/http-status";
+
+export interface ChunkAssets {
+  js?: string[];
+  css?: string[];
+}
+
+export type RouteManifest = {
+  routes: Array<{
+    urlPattern: string;
+    chunkName: string;
+    params: string[];
+    isStatic: boolean;
+    hasLoader: boolean;
+    hasGuard: boolean;
+    serverFunctionIds: string[];
+  }>;
+  chunks: Record<string, ChunkAssets>;
+  errors?: Record<string, string>;
+};
+
+export type RouteMatch = {
+  activeChunk: string;
+  targetPattern: string;
+  statusCode: StatusCode;
+  params: Record<string, string>;
+};
+
+export type RuntimeEnv = {
+  port: number;
+  isDev: boolean;
+  devServerUrl: string;
+  templatePath: string;
+  manifestPath: string;
+  clientDistPath: string;
+};

package/src/runtime/shared/constants.ts

@@ -0,0 +1,7 @@
+export const ANAEMIA_DATA_SCRIPT_ID = "__ANAEMIA_DATA__";
+export const ENTRY_SELECTOR = "[anaemia-entry]";
+export const ENTRY_ATTRIBUTE = "anaemia-entry";
+export const HONO_CONTEXT_KEY = "honoContext";
+export const LOADER_DATA_KEY = "__LOADER_DATA__";
+export const RPC_PATH = "/_rpc";
+export const SERVER_FUNCTION_DATA_KEY = "__SERVER_FUNCTION_DATA__";