@anaemia/core 0.4.0 → 0.5.1

package/dist/runtime/server/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/boot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,UAAU,QAIrD"}

package/dist/runtime/server/boot.js

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

package/dist/runtime/server/env.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeEnv } from "./types.js";
+export declare function createRuntimeEnv(processEnv?: NodeJS.ProcessEnv): RuntimeEnv;
+//# sourceMappingURL=env.d.ts.map

package/dist/runtime/server/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/env.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,gBAAgB,CAAC,UAAU,GAAE,MAAM,CAAC,UAAwB,GAAG,UAAU,CAaxF"}

package/dist/runtime/server/env.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+export function createRuntimeEnv(processEnv = process.env) {
+    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/dist/runtime/server/guards.d.ts

@@ -0,0 +1,29 @@
+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 declare function runGuards(serverGuardRegistry: Map<string, (() => Promise<GuardFn[]>)[]>, pattern: string, ctx: {
+    params: Record<string, string>;
+    request: Request;
+    url: string;
+}): Promise<{
+    status: number;
+    body?: string;
+} | {
+    redirect: string;
+    status?: number;
+} | null>;
+//# sourceMappingURL=guards.d.ts.map

package/dist/runtime/server/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/guards.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,KACG,IAAI,GACJ,SAAS,GACT;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;CAAE,GACpD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC,OAAO,CAAC,IAAI,GAAG,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE1G,wBAAsB,SAAS,CAC7B,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAC9D,OAAO,EAAE,MAAM,EACf,GAAG,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;YAN1D,MAAM;WAAS,MAAM;;cACQ,MAAM;aAAW,MAAM;UAgBjE"}

package/dist/runtime/server/guards.js

@@ -0,0 +1,12 @@
+export async function runGuards(serverGuardRegistry, pattern, ctx) {
+    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/dist/runtime/server/html.d.ts

@@ -0,0 +1,15 @@
+import type { RouteManifest } from "./types.js";
+export declare function getRouteAssetTags(manifest: RouteManifest, activeChunk: string): {
+    scripts: string;
+    styles: string;
+};
+export declare function createDevNoCacheHeadTags(isDev: boolean): string;
+export declare function createHtmlStreamShell(args: {
+    template: string;
+    headInjections: string;
+    bodyInjections: string;
+}): {
+    beforeEntry: string;
+    afterEntry: string;
+};
+//# sourceMappingURL=html.d.ts.map

package/dist/runtime/server/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/html.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,YAAY,CAAC;AA8B7D,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAcnH;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAI/D;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAAG;IACjH,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CA2BA"}

package/dist/runtime/server/html.js

@@ -0,0 +1,62 @@
+import { ENTRY_ATTRIBUTE } from "../shared/constants.js";
+const ENTRY_TAG_REGEX = /(<([a-zA-Z0-9-]+)[^>]*anaemia-entry[^>]*>)(.*?)(<\/\2>)/is;
+function normalizeAssetUrl(url) {
+    if (!url || typeof url !== "string")
+        return "";
+    if (url.startsWith("http://") || url.startsWith("https://"))
+        return url;
+    return url.startsWith("/") ? url : `/${url}`;
+}
+function chunkAssetTags(chunk) {
+    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, activeChunk) {
+    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) {
+    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) {
+    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/dist/runtime/server/hydration.d.ts

@@ -0,0 +1,3 @@
+export declare function createHydrationDataScript(store: Map<string, unknown>): string;
+export declare function createHydrationRuntimeScript(): string;
+//# sourceMappingURL=hydration.d.ts.map

package/dist/runtime/server/hydration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/hydration.ts"],"names":[],"mappings":"AAWA,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAU7E;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD"}

package/dist/runtime/server/hydration.js

@@ -0,0 +1,20 @@
+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) {
+    return JSON.stringify(value)
+        .replace(/&/g, "\\u0026")
+        .replace(/</g, "\\u003c")
+        .replace(/>/g, "\\u003e")
+        .replace(/\//g, "\\u002f");
+}
+export function createHydrationDataScript(store) {
+    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() {
+    return generateHydrationScript();
+}

package/dist/runtime/server/manifest.d.ts

@@ -0,0 +1,14 @@
+import type { RouteManifest, RuntimeEnv } from "./types.js";
+export type ManifestSnapshot = {
+    template: string;
+    manifest: RouteManifest | null;
+    sortedRoutes: RouteManifest["routes"];
+    staticRoutes: Set<string>;
+    loaderRoutes: Set<string>;
+    guardRoutes: Set<string>;
+};
+export declare function createManifestStore(env: RuntimeEnv): {
+    load: () => Promise<void>;
+    getSnapshot: () => ManifestSnapshot;
+};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/runtime/server/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/manifest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG5D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;IAC/B,YAAY,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACtC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU;;uBAyCzB,gBAAgB;EAczC"}

package/dist/runtime/server/manifest.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import { sortRoutes } from "./route-match.js";
+export function createManifestStore(env) {
+    let memoizedHtmlTemplate = "";
+    let memoizedManifest = null;
+    let memoizedSortedRoutes = [];
+    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"));
+                }
+                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"));
+                }
+            }
+            catch {
+                console.warn("build assets not fully initialized during bootstrapping cycle.");
+            }
+        }
+        memoizedSortedRoutes = memoizedManifest ? sortRoutes(memoizedManifest.routes) : [];
+    };
+    const getSnapshot = () => {
+        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/dist/runtime/server/render-request.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from "solid-js";
+import type { Context } from "hono";
+import { type GuardFn } from "./guards.js";
+import type { RuntimeEnv } from "./types.js";
+import type { ManifestSnapshot } from "./manifest.js";
+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>;
+};
+export declare function createRenderRequestHandler(options: RenderRequestOptions): (c: Context) => Promise<Response>;
+export {};
+//# sourceMappingURL=render-request.d.ts.map

package/dist/runtime/server/render-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-request.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/render-request.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAItD,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAItD,KAAK,YAAY,GAAG,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/G,KAAK,oBAAoB,GAAG;IAC1B,GAAG,EAAE,SAAS,CAAC;IACf,GAAG,EAAE,UAAU,CAAC;IAChB,wBAAwB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvE,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAChD,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/D,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;IAC5C,uBAAuB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C,CAAC;AAmGF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,oBAAoB,IACxD,GAAG,OAAO,uBAsGzB"}

package/dist/runtime/server/render-request.jsx

@@ -0,0 +1,170 @@
+import { Router } from "@solidjs/router";
+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 } from "./guards.js";
+import { createDevNoCacheHeadTags, createHtmlStreamShell, getRouteAssetTags } from "./html.js";
+import { createHydrationDataScript, createHydrationRuntimeScript } from "./hydration.js";
+import { matchRoute } from "./route-match.js";
+const staticCache = new Map();
+function renderApp(App, url) {
+    return renderToStream(() => (<Router url={url}>
+      <App />
+    </Router>));
+}
+async function render500(args) {
+    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) {
+    const encoder = new TextEncoder();
+    const collected = [];
+    const shouldCollect = Boolean(args.onComplete);
+    return new ReadableStream({
+        start(controller) {
+            const enqueue = (chunk) => {
+                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({
+                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) {
+    return async (c) => {
+        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 = matchedStatus;
+        const loaderArgs = { params, request: c.req.raw };
+        const store = ssrStorage.getStore() || new Map();
+        let renderStream;
+        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);
+            }
+        }
+        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));
+                    }
+                    if ("status" in guardResult)
+                        statusCode = guardResult.status;
+                }
+            }
+            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/dist/runtime/server/route-match.d.ts

@@ -0,0 +1,14 @@
+import type { RouteManifest, RouteMatch } from "./types.js";
+type SortedRoute = RouteManifest["routes"][number];
+export declare function sortRoutes(routes: RouteManifest["routes"]): SortedRoute[];
+export declare function matchRoute(manifest: RouteManifest, reqPath: string, sortedRoutes?: {
+    urlPattern: string;
+    chunkName: string;
+    params: string[];
+    isStatic: boolean;
+    hasLoader: boolean;
+    hasGuard: boolean;
+    serverFunctionIds: string[];
+}[]): RouteMatch;
+export {};
+//# sourceMappingURL=route-match.d.ts.map

package/dist/runtime/server/route-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-match.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/route-match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE5D,KAAK,WAAW,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAWnD,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,WAAW,EAAE,CAEzE;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,MAAM,EACf,YAAY;;;;;;;;GAA8B,GACzC,UAAU,CAuBZ"}

package/dist/runtime/server/route-match.js

@@ -0,0 +1,35 @@
+function scoreRoutePattern(pattern) {
+    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) {
+    return [...routes].sort((a, b) => scoreRoutePattern(b.urlPattern) - scoreRoutePattern(a.urlPattern));
+}
+export function matchRoute(manifest, reqPath, sortedRoutes = sortRoutes(manifest.routes)) {
+    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/dist/runtime/server/rpc.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from "hono";
+export declare function registerRpcRoute(app: Hono): void;
+//# sourceMappingURL=rpc.d.ts.map

package/dist/runtime/server/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAIjC,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,IAAI,QA6BzC"}

package/dist/runtime/server/rpc.js

@@ -0,0 +1,32 @@
+import { serverFunctionsRegistry } from "../context.js";
+import { RPC_PATH } from "../shared/constants.js";
+export function registerRpcRoute(app) {
+    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;
+        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/dist/runtime/server/types.d.ts

@@ -0,0 +1,33 @@
+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;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/server/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/server/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,WAAW,WAAW;IAC1B,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,KAAK,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,QAAQ,EAAE,OAAO,CAAC;QAClB,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE,OAAO,CAAC;QAClB,iBAAiB,EAAE,MAAM,EAAE,CAAC;KAC7B,CAAC,CAAC;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}

package/dist/runtime/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/shared/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const ANAEMIA_DATA_SCRIPT_ID = "__ANAEMIA_DATA__";
+export declare const ENTRY_SELECTOR = "[anaemia-entry]";
+export declare const ENTRY_ATTRIBUTE = "anaemia-entry";
+export declare const HONO_CONTEXT_KEY = "honoContext";
+export declare const LOADER_DATA_KEY = "__LOADER_DATA__";
+export declare const RPC_PATH = "/_rpc";
+export declare const SERVER_FUNCTION_DATA_KEY = "__SERVER_FUNCTION_DATA__";
+//# sourceMappingURL=constants.d.ts.map

package/dist/runtime/shared/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/runtime/shared/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AACzD,eAAO,MAAM,cAAc,oBAAoB,CAAC;AAChD,eAAO,MAAM,eAAe,kBAAkB,CAAC;AAC/C,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAC9C,eAAO,MAAM,eAAe,oBAAoB,CAAC;AACjD,eAAO,MAAM,QAAQ,UAAU,CAAC;AAChC,eAAO,MAAM,wBAAwB,6BAA6B,CAAC"}

package/dist/runtime/shared/constants.js

@@ -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__";