@anaemia/core 0.0.1

package/dist/runtime/entry-server.jsx

@@ -0,0 +1,346 @@
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+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";
+// @ts-ignore - mapped by Rspack
+import App from "anaemia-user-app";
+// @ts-ignore - mapped by Rspack
+import { preloadActiveClientRoute, serverLoaderRegistry, serverGuardRegistry } from "anaemia-user-app";
+// @ts-ignore - mapped 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}`;
+let sortedRoutes = 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();
+    store.set("honoContext", c);
+    return await ssrStorage.run(store, next);
+});
+if (isDev) {
+    const devAssetProxy = async (c) => {
+        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 (err) {
+            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;
+    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) {
+        return c.json({ error: 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 = 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 (err) {
+            console.warn("build assets not fully initialized during bootstrapping cycle.");
+        }
+    }
+    sortedRoutes = null;
+};
+const normalizeAssetUrl = (url) => {
+    if (!url || typeof url !== "string")
+        return "";
+    if (url.startsWith("http://") || url.startsWith("https://"))
+        return url;
+    return url.startsWith("/") ? url : `/${url}`;
+};
+async function runGuards(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;
+}
+function matchRoute(manifest, reqPath) {
+    if (!sortedRoutes) {
+        sortedRoutes = [...manifest.routes].sort((a, b) => {
+            const score = (pattern) => {
+                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: {},
+    };
+}
+// Look at your app.get("*") loop and update the processing logic:
+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 = matchedStatus;
+    const loaderArgs = { params, request: c.req.raw };
+    // Re-verify and isolate our store reference map instance
+    const store = ssrStorage.getStore() || new Map();
+    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));
+                if ("status" in guardResult)
+                    statusCode = guardResult.status;
+            }
+        }
+        catch (err) {
+            console.error("[anaemia] guard threw unexpectedly:", err);
+            return c.text("Internal Server Error", 500);
+        }
+    }
+    // ─── THE ARCHITECTURE WRAPPER FIX ───
+    // We force both the awaitable loader execution AND the Solid rendering cycle 
+    // to run explicitly inside a fresh execution slice of the tracking store.
+    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);
+            // Now when Solid calls $$executeClientRpc, the store is 100% active and tracked!
+            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 runtimeContextPayload = { message: err.message, stack: isDev ? err.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 {
+            htmlPayload = `<h1>500 Internal Server Error</h1><pre>${isDev ? err.stack : ""}</pre>`;
+        }
+    }
+    // ─── THE REMAINING INJECTIONS (Keep this exactly as you had it) ───
+    let assetScripts = "";
+    let assetStyles = "";
+    if (manifest.chunks) {
+        const processChunkAssets = (chunk) => {
+            if (!chunk)
+                return;
+            if (chunk.js) {
+                const jsSpecs = Array.isArray(chunk.js) ? chunk.js : [chunk.js];
+                jsSpecs.forEach((jsFile) => {
+                    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) => {
+                    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);
+});
+loadManifestAndTemplate()
+    .then(() => {
+    serve({ fetch: app.fetch, port }, (info) => {
+        console.log(`[anaemia framework] server live at http://localhost:${info.port}`);
+    });
+})
+    .catch((err) => {
+    console.error("[anaemia] failed to initialize:", err);
+    process.exit(1);
+});
+export default app;

package/dist/runtime/resources.d.ts

@@ -0,0 +1,6 @@
+import { type ResourceOptions, type ResourceReturn } from "solid-js";
+export declare function createServerResource<Source, Return>(source: () => Source, serverFn: ((sourceData: Source) => Promise<Return>) & {
+    readHydrationCache?: (s: any) => any;
+    id?: string;
+}, options?: ResourceOptions<Return, Source>): ResourceReturn<Return, unknown>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/runtime/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/runtime/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAGrF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EACjD,MAAM,EAAE,MAAM,MAAM,EACpB,QAAQ,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG;IACpD,kBAAkB,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IACrC,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,EACD,OAAO,CAAC,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,GACxC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAsCjC"}

package/dist/runtime/resources.js

@@ -0,0 +1,36 @@
+import { createResource } from "solid-js";
+import { isServer } from "solid-js/web";
+export function createServerResource(source, serverFn, options) {
+    if (isServer) {
+        let ssrInitialValue = undefined;
+        const store = globalThis.__ANAEMIA_SERVER_STORAGE__?.getStore?.();
+        if (store && serverFn.id) {
+            const fnCache = store.get("__SERVER_FUNCTION_DATA__")?.[serverFn.id];
+            if (fnCache) {
+                const key = JSON.stringify([source()]);
+                if (fnCache[key] !== undefined)
+                    ssrInitialValue = fnCache[key];
+            }
+        }
+        return createResource(source, serverFn, {
+            ...options,
+            initialValue: ssrInitialValue !== undefined ? ssrInitialValue : options?.initialValue,
+            ssrLoadFrom: ssrInitialValue !== undefined ? "initial" : options?.ssrLoadFrom,
+        });
+    }
+    let hydrationChecked = false;
+    const wrappedFetcher = (s) => {
+        if (!hydrationChecked) {
+            hydrationChecked = true;
+            if (typeof serverFn.readHydrationCache === "function") {
+                const cached = serverFn.readHydrationCache(s);
+                if (cached !== undefined)
+                    return Promise.resolve(cached);
+            }
+        }
+        return serverFn(s);
+    };
+    wrappedFetcher.id = serverFn.id;
+    wrappedFetcher.readHydrationCache = serverFn.readHydrationCache;
+    return createResource(source, wrappedFetcher, options);
+}

package/dist/runtime/route-data.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+import { type Params } from "@solidjs/router";
+import type { Location } from "@solidjs/router";
+type RouteDataControllerProps<TParams extends Params = Params> = {
+    loader: (args: {
+        params: TParams;
+        location: Location;
+        request: Request;
+    }) => any | Promise<any>;
+    children: JSX.Element;
+};
+export declare function RouteDataController<TParams extends Params = Params>(props: RouteDataControllerProps<TParams>): JSX.Element;
+export declare function useRouteData<T = any>(): () => T;
+export {};
+//# sourceMappingURL=route-data.d.ts.map

package/dist/runtime/route-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-data.d.ts","sourceRoot":"","sources":["../../src/runtime/route-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,GAAG,EACT,MAAM,UAAU,CAAC;AAElB,OAAO,EAA0B,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhD,KAAK,wBAAwB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI;IAC/D,MAAM,EAAE,CAAC,IAAI,EAAE;QACb,MAAM,EAAE,OAAO,CAAC;QAChB,QAAQ,EAAE,QAAQ,CAAC;QACnB,OAAO,EAAE,OAAO,CAAC;KAClB,KAAK,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;CACvB,CAAC;AA2BF,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACjE,KAAK,EAAE,wBAAwB,CAAC,OAAO,CAAC,eAkCzC;AAED,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,KAAK,MAAM,CAAC,CAQ/C"}

package/dist/runtime/route-data.js

@@ -0,0 +1,57 @@
+import { createContext, useContext, createResource, createComponent } from "solid-js";
+import { isServer } from "solid-js/web";
+import { useParams, useLocation } from "@solidjs/router";
+import { ssrStorage } from "./context.js";
+import { createRouteRequest } from "./route-request.js";
+const RouteDataContext = createContext();
+let hasReadClientHydrationData = false;
+function readSSRData() {
+    if (isServer) {
+        return ssrStorage.getStore()?.get("__LOADER_DATA__");
+    }
+    if (hasReadClientHydrationData)
+        return undefined;
+    hasReadClientHydrationData = true;
+    const el = document.getElementById("__ANAEMIA_DATA__");
+    if (!el?.textContent)
+        return undefined;
+    try {
+        return JSON.parse(el.textContent).__LOADER_DATA__;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function RouteDataController(props) {
+    const params = useParams();
+    const location = useLocation();
+    const ssrData = readSSRData();
+    const [resource] = createResource(() => location.pathname, () => {
+        if (isServer && ssrData !== undefined) {
+            return ssrData;
+        }
+        return props.loader({
+            params,
+            location,
+            request: createRouteRequest(location.pathname)
+        });
+    }, {
+        initialValue: ssrData,
+        ssrLoadFrom: "initial"
+    });
+    return createComponent(RouteDataContext.Provider, {
+        value: {
+            data: resource
+        },
+        get children() {
+            return props.children;
+        }
+    });
+}
+export function useRouteData() {
+    const ctx = useContext(RouteDataContext);
+    if (!ctx) {
+        throw new Error("useRouteData must be used inside RouteDataController");
+    }
+    return ctx.data;
+}

package/dist/runtime/route-request.d.ts

@@ -0,0 +1,2 @@
+export declare function createRouteRequest(pathname: string): any;
+//# sourceMappingURL=route-request.d.ts.map

package/dist/runtime/route-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-request.d.ts","sourceRoot":"","sources":["../../src/runtime/route-request.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,OAQlD"}

package/dist/runtime/route-request.js

@@ -0,0 +1,11 @@
+import { isServer } from "solid-js/web";
+import { ssrStorage } from "./context.js";
+export function createRouteRequest(pathname) {
+    if (isServer) {
+        const request = ssrStorage.getStore()?.get("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/dist/runtime/rpc-client.d.ts

@@ -0,0 +1,6 @@
+export declare function $$executeClientRpc(hashId: string): {
+    (...args: unknown[]): Promise<any>;
+    id: string;
+    readHydrationCache(...args: unknown[]): any;
+};
+//# sourceMappingURL=rpc-client.d.ts.map

package/dist/runtime/rpc-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-client.d.ts","sourceRoot":"","sources":["../../src/runtime/rpc-client.ts"],"names":[],"mappings":"AA4BA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM;cACD,OAAO,EAAE;;gCAoCF,OAAO,EAAE;EAqB/D"}

package/dist/runtime/rpc-client.js

@@ -0,0 +1,78 @@
+import { isServer } from "solid-js/web";
+let _clientCache = null;
+function ensureCacheInitialized() {
+    if (isServer || _clientCache)
+        return;
+    const script = document.getElementById("__ANAEMIA_DATA__");
+    try {
+        _clientCache = JSON.parse(script?.textContent || "{}");
+    }
+    catch {
+        _clientCache = {};
+    }
+}
+function findLooseCacheMatch(serverFunctionData, targetArg) {
+    if (!serverFunctionData)
+        return undefined;
+    const strictKey = JSON.stringify([targetArg]);
+    if (strictKey in serverFunctionData) {
+        return { matchingKey: strictKey, data: serverFunctionData[strictKey] };
+    }
+    const lookUpString = `["${targetArg}"`;
+    const matchedKey = Object.keys(serverFunctionData).find(key => key.startsWith(lookUpString));
+    return matchedKey ? { matchingKey: matchedKey, data: serverFunctionData[matchedKey] } : undefined;
+}
+export function $$executeClientRpc(hashId) {
+    const asyncRpcCall = async function (...args) {
+        if (isServer) {
+            const globalStorage = globalThis.__ANAEMIA_SERVER_STORAGE__;
+            const store = globalStorage?.getStore();
+            if (store) {
+                const functionCache = store.get("__SERVER_FUNCTION_DATA__");
+                if (functionCache && functionCache[hashId]) {
+                    const match = findLooseCacheMatch(functionCache[hashId], args[0]);
+                    if (match)
+                        return match.data;
+                }
+            }
+            return undefined;
+        }
+        ensureCacheInitialized();
+        const serverFunctionData = _clientCache.__SERVER_FUNCTION_DATA__?.[hashId];
+        const match = findLooseCacheMatch(serverFunctionData, args[0]);
+        if (match) {
+            const { matchingKey, data } = match;
+            delete serverFunctionData[matchingKey];
+            return data;
+        }
+        const response = await fetch(`/_rpc?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();
+    };
+    asyncRpcCall.id = hashId;
+    asyncRpcCall.readHydrationCache = function (...args) {
+        if (isServer) {
+            const globalStorage = globalThis.__ANAEMIA_SERVER_STORAGE__;
+            const store = globalStorage?.getStore();
+            if (store) {
+                const functionCache = store.get("__SERVER_FUNCTION_DATA__");
+                if (functionCache && functionCache[hashId]) {
+                    const match = findLooseCacheMatch(functionCache[hashId], args[0]);
+                    if (match)
+                        return match.data;
+                }
+            }
+            return undefined;
+        }
+        ensureCacheInitialized();
+        const serverFunctionData = _clientCache.__SERVER_FUNCTION_DATA__?.[hashId];
+        const match = findLooseCacheMatch(serverFunctionData, args[0]);
+        return match ? match.data : undefined;
+    };
+    return asyncRpcCall;
+}

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+import type { RedirectStatusCode } from "hono/utils/http-status";
+/**
+ * the standard argument object injected into every server-side page loader.
+ */
+export interface LoaderArgs<Params extends Record<string, string> = Record<string, string>> {
+    /** parsed URL dynamic variables (e.g., { id: "123" } from /users/[id]) */
+    params: Params;
+    /** the native underlying Web API Request object from the Hono server instance */
+    request: Request;
+}
+/**
+ * represents an application page loader function.
+ */
+export type LoaderFunction<ResponseData = any, Params extends Record<string, string> = Record<string, string>> = (args: LoaderArgs<Params>) => Promise<ResponseData> | ResponseData;
+/**
+ * extracts and unwraps the true data structure returned by a server function or loader.
+ * essential for typing useRouteData() effortlessly in user-space.
+ */
+export type InferServerData<T extends (...args: any[]) => any> = Awaited<ReturnType<T>>;
+export type GuardContext = {
+    params: Record<string, string>;
+    request: Request;
+    url: string;
+};
+export type GuardResult = void | undefined | {
+    redirect: string;
+    status?: 301 | 302 | 307 | 308;
+} | {
+    status: 401 | 403 | 404 | 500;
+    body?: string;
+};
+export type GuardFn = (ctx: {
+    params: Record<string, string>;
+    request: Request;
+    url: string;
+}) => void | undefined | {
+    redirect: string;
+    status?: RedirectStatusCode;
+} | {
+    status: number;
+    body?: string;
+} | Promise<void | undefined | {
+    redirect: string;
+    status?: RedirectStatusCode;
+} | {
+    status: number;
+    body?: string;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IACxF,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,YAAY,GAAG,GAAG,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;AAEpL;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAExF,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAErJ,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,GAAG,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,kBAAkB,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,kBAAkB,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC"}

package/dist/types.js

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