@anaemia/core 0.0.1 → 0.1.1

package/src/runtime/context.ts

@@ -1,34 +1,29 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
-export const serverFunctionsRegistry = new Map<string, Function>();
-export const ssrStorage = new AsyncLocalStorage<Map<string, any>>();
+type AnyFn = (...args: unknown[]) => unknown;
 
-(globalThis as any).__ANAEMIA_SERVER_STORAGE__ = ssrStorage;
+export const serverFunctionsRegistry = new Map<string, AnyFn>();
+export const ssrStorage = new AsyncLocalStorage<Map<string, unknown>>();
+(globalThis as unknown as Record<string, unknown>).__ANAEMIA_SERVER_STORAGE__ = ssrStorage;
 
-export function runOnServer(backendFn: Function, id?: string) {
+export function runOnServer<T extends AnyFn>(backendFn: T, id?: string): T & { id: string } {
   const hashId = id || "";
-
-  const rpcProxy = async function (...args: any[]) {
+  const rpcProxy = async function (...args: unknown[]) {
     const result = await backendFn(...args);
-
     const store = ssrStorage.getStore();
     if (store && hashId) {
       if (!store.has("__SERVER_FUNCTION_DATA__")) {
         store.set("__SERVER_FUNCTION_DATA__", {});
       }
-      
-      const functionCache = store.get("__SERVER_FUNCTION_DATA__");
+      const functionCache = store.get("__SERVER_FUNCTION_DATA__") as Record<string, Record<string, unknown>>;
       if (!functionCache[hashId]) {
         functionCache[hashId] = {};
       }
-      
       const paramKey = JSON.stringify(args);
       functionCache[hashId][paramKey] = result;
     }
-
     return result;
   };
-
   rpcProxy.id = hashId;
-  return rpcProxy;
+  return rpcProxy as unknown as T & { id: string };
 }

package/src/runtime/entry-client.tsx

@@ -1,7 +1,7 @@
 import { hydrate, render } from "solid-js/web";
 import { Router } from "@solidjs/router";
 
-// @ts-ignore
+// @ts-expect-error - resolved by Rspack
 import App, { preloadActiveClientRoute } from "anaemia-user-app";
 
 const mountTarget = document.querySelector(

package/src/runtime/entry-server.tsx

@@ -1,5 +1,6 @@
 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";
@@ -9,13 +10,13 @@ import fs from "node:fs";
 import path from "path";
 import type { StatusCode, RedirectStatusCode } from "hono/utils/http-status";
 
-// @ts-ignore - mapped by Rspack
+// @ts-expect-error - resolved by Rspack
 import App from "anaemia-user-app";
 
-// @ts-ignore - mapped by Rspack
+// @ts-expect-error - resolved by Rspack
 import { preloadActiveClientRoute, serverLoaderRegistry, serverGuardRegistry } from "anaemia-user-app";
 
-// @ts-ignore - mapped by Rspack
+// @ts-expect-error - resolved by Rspack
 import { registerServerRoutes } from "__anaemia_server_routes__";
 
 const port = Number(process.env.PORT) || 3000;
@@ -24,22 +25,34 @@ const isDev = process.env.NODE_ENV !== "production";
 const devPort = Number(process.env.RSPACK_DEV_PORT) || 4445;
 const devServerUrl = `http://localhost:${devPort}`;
 
-let sortedRoutes: any[] | null = null;
+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 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, any>();
+  const store = new Map<string, unknown>();
   store.set("honoContext", c);
   return await ssrStorage.run(store, next);
 });
 
 if (isDev) {
-  const devAssetProxy = async (c: any) => {
+  const devAssetProxy = async (c: Context) => {
     const targetUrl = `${devServerUrl}${c.req.path}`;
     try {
       const response = await fetch(targetUrl);
@@ -53,7 +66,7 @@ if (isDev) {
       c.header("Expires", "0");
 
       return c.body(await response.arrayBuffer());
-    } catch (err) {
+    } catch {
       return c.text("failed to connect to Rspack dev server asset bridge", 500);
     }
   };
@@ -96,8 +109,9 @@ app.post("/_rpc", async (c) => {
   try {
     const result = await serverFunctionsRegistry.get(functionId)!(...argumentsArray);
     return c.json(result);
-  } catch (error: any) {
-    return c.json({ error: error.message }, 500);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Internal server error";
+    return c.json({ error: message }, 500);
   }
 });
 
@@ -108,12 +122,12 @@ app.use(async (c, next) => {
     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);
@@ -122,11 +136,10 @@ app.use(async (c, next) => {
   await next();
 });
 
-
 registerServerRoutes(app);
 
 let memoizedHtmlTemplate = "";
-let memoizedManifest: any = null;
+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");
@@ -157,7 +170,7 @@ const loadManifestAndTemplate = async () => {
     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) {
+    } catch {
       console.warn("build assets not fully initialized during bootstrapping cycle.");
     }
   }
@@ -192,9 +205,9 @@ async function runGuards(pattern: string, ctx: { params: Record<string, string>;
   return null;
 }
 
-function matchRoute(manifest: any, reqPath: string): RouteMatch {
+function matchRoute(manifest: RouteManifest, reqPath: string): RouteMatch {
   if (!sortedRoutes) {
-    sortedRoutes = [...manifest.routes].sort((a: any, b: any) => {
+    sortedRoutes = [...manifest.routes].sort((a, b) => {
       const score = (pattern: string) => {
         const segments = pattern.split("/").filter(Boolean);
         return segments.reduce((acc, s) => {
@@ -229,8 +242,6 @@ function matchRoute(manifest: any, reqPath: string): RouteMatch {
   };
 }
 
-// Look at your app.get("*") loop and update the processing logic:
-
 app.get("*", async (c) => {
   if (isDev) await loadManifestAndTemplate();
 
@@ -246,9 +257,8 @@ app.get("*", async (c) => {
   let statusCode: StatusCode = matchedStatus;
   const loaderArgs = { params, request: c.req.raw };
 
-  // Re-verify and isolate our store reference map instance
-  const store = ssrStorage.getStore() || new Map<string, any>();
-  let htmlPayload = "";
+  const store = ssrStorage.getStore() || new Map<string, unknown>();
+  let htmlPayload;
 
   if (targetPattern) {
     try {
@@ -263,9 +273,6 @@ app.get("*", async (c) => {
     }
   }
 
-  // ─── 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) {
@@ -278,14 +285,13 @@ app.get("*", async (c) => {
 
       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: any) {
+  } catch (err) {
     statusCode = 500;
     console.error("[anaemia framework] runtime execution crash handled:", err);
 
@@ -293,7 +299,9 @@ app.get("*", async (c) => {
     const error500Loader = error500Pattern ? serverLoaderRegistry.get(error500Pattern) : null;
 
     if (error500Loader) {
-      const runtimeContextPayload = { message: err.message, stack: isDev ? err.stack : undefined };
+      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 {
@@ -308,16 +316,16 @@ app.get("*", async (c) => {
         htmlPayload = `<h1>500 Internal Server Error</h1>`;
       }
     } else {
-      htmlPayload = `<h1>500 Internal Server Error</h1><pre>${isDev ? err.stack : ""}</pre>`;
+      const stack = err instanceof Error ? err.stack : String(err);
+      htmlPayload = `<h1>500 Internal Server Error</h1><pre>${isDev ? stack : ""}</pre>`;
     }
   }
 
-  // ─── THE REMAINING INJECTIONS (Keep this exactly as you had it) ───
   let assetScripts = "";
   let assetStyles = "";
 
   if (manifest.chunks) {
-    const processChunkAssets = (chunk: any) => {
+    const processChunkAssets = (chunk: ChunkAssets | undefined) => {
       if (!chunk) return;
       if (chunk.js) {
         const jsSpecs = Array.isArray(chunk.js) ? chunk.js : [chunk.js];
@@ -338,33 +346,25 @@ app.get("*", async (c) => {
     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__ || {}
+    __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 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 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>`);
+  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>`);

package/src/runtime/resources.ts

@@ -1,37 +1,48 @@
 import { createResource, type ResourceOptions, type ResourceReturn } from "solid-js";
 import { isServer } from "solid-js/web";
 
+interface ServerStorage {
+  getStore?: () => Map<string, unknown> | undefined;
+}
+
+interface AnaemiaGlobal {
+  __ANAEMIA_SERVER_STORAGE__?: ServerStorage;
+}
+
+type FnCache = Record<string, unknown>;
+type ServerFunctionData = Record<string, FnCache>;
+
 export function createServerResource<Source, Return>(
   source: () => Source,
   serverFn: ((sourceData: Source) => Promise<Return>) & {
-    readHydrationCache?: (s: any) => any;
+    readHydrationCache?: (s: Source) => Return | undefined;
     id?: string;
   },
   options?: ResourceOptions<Return, Source>
 ): ResourceReturn<Return, unknown> {
   if (isServer) {
-    let ssrInitialValue: any = undefined;
-    const store: Map<string, any> | undefined = 
-      (globalThis as any).__ANAEMIA_SERVER_STORAGE__?.getStore?.();
+    let ssrInitialValue: Return | undefined = undefined;
+    const store = (globalThis as unknown as AnaemiaGlobal).__ANAEMIA_SERVER_STORAGE__?.getStore?.();
 
     if (store && serverFn.id) {
-      const fnCache = store.get("__SERVER_FUNCTION_DATA__")?.[serverFn.id];
+      const fnData = store.get("__SERVER_FUNCTION_DATA__") as ServerFunctionData | undefined;
+      const fnCache = fnData?.[serverFn.id];
       if (fnCache) {
-        const key = JSON.stringify([source()]);
-        if (fnCache[key] !== undefined) ssrInitialValue = fnCache[key];
+        const sourceValue = source();
+        const key = sourceValue === undefined ? JSON.stringify([]) : JSON.stringify([sourceValue]);
+        if (fnCache[key] !== undefined) ssrInitialValue = fnCache[key] as Return;
       }
     }
 
-    return createResource(source, serverFn as any, {
+    return createResource(source, serverFn, {
       ...options,
       initialValue: ssrInitialValue !== undefined ? ssrInitialValue : options?.initialValue,
       ssrLoadFrom: ssrInitialValue !== undefined ? "initial" : options?.ssrLoadFrom,
-    } as any) as ResourceReturn<Return, unknown>;
+    }) as ResourceReturn<Return, unknown>;
   }
 
   let hydrationChecked = false;
-
-  const wrappedFetcher = (s: Source) => {
+  const wrappedFetcher = (s: Source): Promise<Return> => {
     if (!hydrationChecked) {
       hydrationChecked = true;
       if (typeof serverFn.readHydrationCache === "function") {
@@ -39,11 +50,12 @@ export function createServerResource<Source, Return>(
         if (cached !== undefined) return Promise.resolve(cached);
       }
     }
-    return serverFn(s);
+
+    return s === undefined ? (serverFn as () => Promise<Return>)() : serverFn(s);
   };
 
-  (wrappedFetcher as any).id = serverFn.id;
-  (wrappedFetcher as any).readHydrationCache = serverFn.readHydrationCache;
+  (wrappedFetcher as typeof serverFn).id = serverFn.id;
+  (wrappedFetcher as typeof serverFn).readHydrationCache = serverFn.readHydrationCache;
 
-  return createResource(source, wrappedFetcher as any, options) as ResourceReturn<Return, unknown>;
-}
+  return createResource(source, wrappedFetcher, options) as ResourceReturn<Return, unknown>;
+}

package/src/runtime/route-data.ts

@@ -1,93 +1,81 @@
-import {
-  createContext,
-  useContext,
-  createResource,
-  createComponent,
-  type JSX
-} from "solid-js";
+import { createContext, useContext, createResource, createComponent, type JSX } from "solid-js";
 import { isServer } from "solid-js/web";
 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";
 
+type LoaderArgs<TParams extends Params> = {
+  params: TParams;
+  location: Location;
+  request: Request;
+};
+
 type RouteDataControllerProps<TParams extends Params = Params> = {
-  loader: (args: {
-    params: TParams;
-    location: Location;
-    request: Request;
-  }) => any | Promise<any>;
+  loader: (args: LoaderArgs<TParams>) => unknown | Promise<unknown>;
   children: JSX.Element;
 };
 
-type RouteDataContextValue<T = any> = {
+type RouteDataContextValue<T = unknown> = {
   data: () => T;
 };
 
 const RouteDataContext = createContext<RouteDataContextValue>();
+
 let hasReadClientHydrationData = false;
 
-function readSSRData() {
+interface AnaemiaHydrationData {
+  __LOADER_DATA__?: unknown;
+}
+
+function readSSRData(): unknown {
   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__;
+    return (JSON.parse(el.textContent) as AnaemiaHydrationData).__LOADER_DATA__;
   } catch {
     return undefined;
   }
 }
 
-export function RouteDataController<TParams extends Params = Params>(
-  props: RouteDataControllerProps<TParams>
-) {
+export function RouteDataController<TParams extends Params = Params>(props: RouteDataControllerProps<TParams>) {
   const params = useParams<TParams>();
   const location = useLocation();
-
   const ssrData = readSSRData();
 
   const [resource] = createResource(
     () => location.pathname,
     () => {
-      if (isServer && ssrData !== undefined) {
-        return ssrData;
-      }
-
+      if (isServer && ssrData !== undefined) return ssrData;
       return props.loader({
         params,
         location,
-        request: createRouteRequest(location.pathname)
+        request: createRouteRequest(location.pathname),
       });
     },
     {
       initialValue: ssrData,
-      ssrLoadFrom: "initial"
+      ssrLoadFrom: "initial",
     }
   );
 
   return createComponent(RouteDataContext.Provider, {
-    value: {
-      data: resource
-    },
+    value: { data: resource },
     get children() {
       return props.children;
-    }
+    },
   });
 }
 
-export function useRouteData<T = any>(): () => T {
+export function useRouteData<T = unknown>(): () => T {
   const ctx = useContext(RouteDataContext);
-
   if (!ctx) {
     throw new Error("useRouteData must be used inside RouteDataController");
   }
-
-  return ctx.data;
+  return ctx.data as () => T;
 }

package/src/runtime/route-request.ts

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

package/src/runtime/rpc-client.ts

@@ -1,39 +1,63 @@
 import { isServer } from "solid-js/web";
 
-let _clientCache: any = null;
+interface CacheMatch {
+  matchingKey: string;
+  data: unknown;
+}
+
+interface ServerFunctionCache {
+  [hashId: string]: Record<string, unknown>;
+}
+
+interface AnaemiaClientCache {
+  __SERVER_FUNCTION_DATA__?: ServerFunctionCache;
+}
+
+interface AnaemiaServerStorage {
+  getStore?: () => Map<string, unknown> | undefined;
+}
+
+interface AnaemiaGlobal {
+  __ANAEMIA_SERVER_STORAGE__?: AnaemiaServerStorage;
+}
+
+let _clientCache: AnaemiaClientCache | null = null;
 
 function ensureCacheInitialized() {
   if (isServer || _clientCache) return;
   const script = document.getElementById("__ANAEMIA_DATA__");
   try {
-    _clientCache = JSON.parse(script?.textContent || "{}");
+    _clientCache = JSON.parse(script?.textContent || "{}") as AnaemiaClientCache;
   } catch {
     _clientCache = {};
   }
 }
 
-function findLooseCacheMatch(serverFunctionData: Record<string, any>, targetArg: string) {
+function findLooseCacheMatch(
+  serverFunctionData: Record<string, unknown>,
+  targetArg: string
+): CacheMatch | undefined {
   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));
-
+  const matchedKey = Object.keys(serverFunctionData).find((key) => key.startsWith(lookUpString));
   return matchedKey ? { matchingKey: matchedKey, data: serverFunctionData[matchedKey] } : undefined;
 }
 
+function getServerStore(): Map<string, unknown> | undefined {
+  return (globalThis as unknown as AnaemiaGlobal).__ANAEMIA_SERVER_STORAGE__?.getStore?.();
+}
+
 export function $$executeClientRpc(hashId: string) {
   const asyncRpcCall = async function (...args: unknown[]) {
     if (isServer) {
-      const globalStorage = (globalThis as any).__ANAEMIA_SERVER_STORAGE__;
-      const store = globalStorage?.getStore();
+      const store = getServerStore();
       if (store) {
-        const functionCache = store.get("__SERVER_FUNCTION_DATA__");
-        if (functionCache && functionCache[hashId]) {
+        const functionCache = store.get("__SERVER_FUNCTION_DATA__") as ServerFunctionCache | undefined;
+        if (functionCache?.[hashId]) {
           const match = findLooseCacheMatch(functionCache[hashId], args[0] as string);
           if (match) return match.data;
         }
@@ -42,12 +66,11 @@ export function $$executeClientRpc(hashId: string) {
     }
 
     ensureCacheInitialized();
-    const serverFunctionData = _clientCache.__SERVER_FUNCTION_DATA__?.[hashId];
-    const match = findLooseCacheMatch(serverFunctionData, args[0] as string);
-
+    const serverFunctionData = _clientCache?.__SERVER_FUNCTION_DATA__?.[hashId];
+    const match = findLooseCacheMatch(serverFunctionData ?? {}, args[0] as string);
     if (match) {
       const { matchingKey, data } = match;
-      delete serverFunctionData[matchingKey];
+      delete serverFunctionData![matchingKey];
       return data;
     }
 
@@ -56,20 +79,17 @@ export function $$executeClientRpc(hashId: string) {
       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();
+    return await response.json() as unknown;
   };
 
   asyncRpcCall.id = hashId;
-
   asyncRpcCall.readHydrationCache = function (...args: unknown[]) {
     if (isServer) {
-      const globalStorage = (globalThis as any).__ANAEMIA_SERVER_STORAGE__;
-      const store = globalStorage?.getStore();
+      const store = getServerStore();
       if (store) {
-        const functionCache = store.get("__SERVER_FUNCTION_DATA__");
-        if (functionCache && functionCache[hashId]) {
+        const functionCache = store.get("__SERVER_FUNCTION_DATA__") as ServerFunctionCache | undefined;
+        if (functionCache?.[hashId]) {
           const match = findLooseCacheMatch(functionCache[hashId], args[0] as string);
           if (match) return match.data;
         }
@@ -78,8 +98,8 @@ export function $$executeClientRpc(hashId: string) {
     }
 
     ensureCacheInitialized();
-    const serverFunctionData = _clientCache.__SERVER_FUNCTION_DATA__?.[hashId];
-    const match = findLooseCacheMatch(serverFunctionData, args[0] as string);
+    const serverFunctionData = _clientCache?.__SERVER_FUNCTION_DATA__?.[hashId];
+    const match = findLooseCacheMatch(serverFunctionData ?? {}, args[0] as string);
     return match ? match.data : undefined;
   };
 

package/src/runtime/webpack.d.ts

@@ -1,6 +1,6 @@
 interface ImportMeta {
   webpackHot?: {
     accept(dep: string | string[], callback?: () => void): void;
-    dispose(callback: (data: any) => void): void;
+    dispose(callback: (data: unknown) => void): void;
   };
 }