hadars 0.1.9 → 0.1.10

package/dist/cli.js

@@ -149,48 +149,48 @@ async function getStaticMarkupRenderer() {
   }
   return _renderToStaticMarkup;
 }
-var getHeadHtml = (seoData, renderToStaticMarkup) => {
-  const metaEntries = Object.entries(seoData.meta);
-  const linkEntries = Object.entries(seoData.link);
-  const styleEntries = Object.entries(seoData.style);
-  const scriptEntries = Object.entries(seoData.script);
-  return renderToStaticMarkup(
-    /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx("title", { children: seoData.title }),
-      metaEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "meta",
-        {
-          id,
-          ...options
-        },
-        id
-      )),
-      linkEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "link",
-        {
-          id,
-          ...options
-        },
-        id
-      )),
-      styleEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "style",
-        {
-          id,
-          ...options
-        },
-        id
-      )),
-      scriptEntries.map(([id, options]) => /* @__PURE__ */ jsx(
-        "script",
-        {
-          id,
-          ...options
-        },
-        id
-      ))
-    ] })
-  );
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+var escAttr = (s) => s.replace(/[&<>"]/g, (c) => ESC[c]);
+var escText = (s) => s.replace(/[&<>]/g, (c) => ESC[c]);
+var ATTR = {
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv",
+  charSet: "charset",
+  crossOrigin: "crossorigin",
+  noModule: "nomodule",
+  referrerPolicy: "referrerpolicy",
+  fetchPriority: "fetchpriority"
+};
+function renderHeadTag(tag, id, opts, selfClose = false) {
+  let attrs = ` id="${escAttr(id)}"`;
+  let inner = "";
+  for (const [k, v] of Object.entries(opts)) {
+    if (k === "key" || k === "children")
+      continue;
+    if (k === "dangerouslySetInnerHTML") {
+      inner = v.__html ?? "";
+      continue;
+    }
+    const attr = ATTR[k] ?? k;
+    if (v === true)
+      attrs += ` ${attr}`;
+    else if (v !== false && v != null)
+      attrs += ` ${attr}="${escAttr(String(v))}"`;
+  }
+  return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
+}
+var getHeadHtml = (seoData) => {
+  let html = `<title>${escText(seoData.title ?? "")}</title>`;
+  for (const [id, opts] of Object.entries(seoData.meta))
+    html += renderHeadTag("meta", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.link))
+    html += renderHeadTag("link", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.style))
+    html += renderHeadTag("style", id, opts);
+  for (const [id, opts] of Object.entries(seoData.script))
+    html += renderHeadTag("script", id, opts);
+  return html;
 };
 var getReactResponse = async (req, opts) => {
   const App = opts.document.body;
@@ -233,18 +233,17 @@ var getReactResponse = async (req, opts) => {
     if (unsuspend.hasPending)
       await processUnsuspend();
   } while (unsuspend.hasPending && ++iters < 25);
-  props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
-  try {
-    globalThis.__hadarsUnsuspend = unsuspend;
-    renderToStaticMarkup(
-      /* @__PURE__ */ jsx(App, { ...{
-        ...props,
-        location: req.location,
-        context
-      } })
-    );
-  } finally {
-    globalThis.__hadarsUnsuspend = null;
+  if (unsuspend.hasPending) {
+    console.warn("[hadars] SSR render loop hit the 25-iteration cap \u2014 some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.");
+  }
+  if (getAfterRenderProps) {
+    props = await getAfterRenderProps(props, html);
+    try {
+      globalThis.__hadarsUnsuspend = unsuspend;
+      renderToStaticMarkup(/* @__PURE__ */ jsx(App, { ...{ ...props, location: req.location, context } }));
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
+    }
   }
   const serverData = {};
   for (const [k, v] of unsuspend.cache) {
@@ -268,7 +267,7 @@ var getReactResponse = async (req, opts) => {
   return {
     ReactPage,
     status: context.head.status,
-    headHtml: getHeadHtml(context.head, renderToStaticMarkup),
+    headHtml: getHeadHtml(context.head),
     renderPayload: {
       appProps: { ...props, location: req.location, context },
       clientProps
@@ -619,7 +618,45 @@ function nodeReadableToWebStream(readable) {
   });
 }
 var noopCtx = { upgrade: () => false };
+var COMPRESSIBLE_RE = /\b(?:text\/|application\/(?:json|javascript|xml)|image\/svg\+xml)/;
+function withCompression(handler) {
+  return async (req, ctx) => {
+    const res = await handler(req, ctx);
+    if (!res?.body)
+      return res;
+    if (!COMPRESSIBLE_RE.test(res.headers.get("Content-Type") ?? ""))
+      return res;
+    if (res.headers.has("Content-Encoding"))
+      return res;
+    const accept = req.headers.get("Accept-Encoding") ?? "";
+    const encoding = accept.includes("br") ? "br" : accept.includes("gzip") ? "gzip" : null;
+    if (!encoding)
+      return res;
+    try {
+      const compressed = res.body.pipeThrough(new globalThis.CompressionStream(encoding));
+      const headers = new Headers(res.headers);
+      headers.set("Content-Encoding", encoding);
+      headers.delete("Content-Length");
+      return new Response(compressed, { status: res.status, statusText: res.statusText, headers });
+    } catch {
+      return res;
+    }
+  };
+}
+function withRequestLogging(handler) {
+  return async (req, ctx) => {
+    const start = performance.now();
+    const res = await handler(req, ctx);
+    const ms = Math.round(performance.now() - start);
+    const status = res?.status ?? 404;
+    const path2 = new URL(req.url).pathname;
+    console.log(`[hadars] ${req.method} ${path2} ${status} ${ms}ms`);
+    return res;
+  };
+}
 async function serve(port, fetchHandler, websocket) {
+  fetchHandler = withCompression(fetchHandler);
+  fetchHandler = withRequestLogging(fetchHandler);
   if (isBun) {
     globalThis.Bun.serve({
       port,
@@ -740,6 +777,7 @@ import { RspackDevServer } from "@rspack/dev-server";
 import pathMod3 from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
 import { createRequire as createRequire2 } from "node:module";
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 import os from "node:os";
@@ -766,42 +804,52 @@ var RenderWorkerPool = class {
   workerPending = /* @__PURE__ */ new Map();
   nextId = 0;
   rrIndex = 0;
+  _Worker = null;
+  _workerPath = "";
+  _ssrBundlePath = "";
   constructor(workerPath, size, ssrBundlePath) {
     this._init(workerPath, size, ssrBundlePath);
   }
   _init(workerPath, size, ssrBundlePath) {
+    this._workerPath = workerPath;
+    this._ssrBundlePath = ssrBundlePath;
     import("node:worker_threads").then(({ Worker }) => {
-      for (let i = 0; i < size; i++) {
-        const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
-        this.workerPending.set(w, /* @__PURE__ */ new Set());
-        w.on("message", (msg) => {
-          const { id, html, headHtml, status, error } = msg;
-          const p = this.pending.get(id);
-          if (!p)
-            return;
-          this.pending.delete(id);
-          this.workerPending.get(w)?.delete(id);
-          if (error)
-            p.reject(new Error(error));
-          else
-            p.resolve({ html, headHtml, status });
-        });
-        w.on("error", (err) => {
-          console.error("[hadars] Render worker error:", err);
-          this._handleWorkerDeath(w, err);
-        });
-        w.on("exit", (code) => {
-          if (code !== 0) {
-            console.error(`[hadars] Render worker exited with code ${code}`);
-            this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
-          }
-        });
-        this.workers.push(w);
-      }
+      this._Worker = Worker;
+      for (let i = 0; i < size; i++)
+        this._spawnWorker();
     }).catch((err) => {
       console.error("[hadars] Failed to initialise render worker pool:", err);
     });
   }
+  _spawnWorker() {
+    if (!this._Worker)
+      return;
+    const w = new this._Worker(this._workerPath, { workerData: { ssrBundlePath: this._ssrBundlePath } });
+    this.workerPending.set(w, /* @__PURE__ */ new Set());
+    w.on("message", (msg) => {
+      const { id, html, headHtml, status, error } = msg;
+      const p = this.pending.get(id);
+      if (!p)
+        return;
+      this.pending.delete(id);
+      this.workerPending.get(w)?.delete(id);
+      if (error)
+        p.reject(new Error(error));
+      else
+        p.resolve({ html, headHtml, status });
+    });
+    w.on("error", (err) => {
+      console.error("[hadars] Render worker error:", err);
+      this._handleWorkerDeath(w, err);
+    });
+    w.on("exit", (code) => {
+      if (code !== 0) {
+        console.error(`[hadars] Render worker exited with code ${code}`);
+        this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
+      }
+    });
+    this.workers.push(w);
+  }
   _handleWorkerDeath(w, err) {
     const idx = this.workers.indexOf(w);
     if (idx !== -1)
@@ -817,6 +865,8 @@ var RenderWorkerPool = class {
       }
       this.workerPending.delete(w);
     }
+    console.log("[hadars] Spawning replacement render worker");
+    this._spawnWorker();
   }
   nextWorker() {
     if (this.workers.length === 0)
@@ -968,7 +1018,7 @@ var dev = async (options) => {
   }
   const tmpFilePath = pathMod3.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
   await fs.writeFile(tmpFilePath, clientScript);
-  let ssrBuildId = Date.now();
+  let ssrBuildId = crypto.randomBytes(4).toString("hex");
   const clientCompiler = createClientCompiler(tmpFilePath, {
     target: "web",
     output: {
@@ -1083,7 +1133,7 @@ var dev = async (options) => {
           } catch (e) {
           }
           if (chunk.includes(rebuildMarker)) {
-            ssrBuildId = Date.now();
+            ssrBuildId = crypto.randomBytes(4).toString("hex");
             console.log("[hadars] SSR bundle updated, build id:", ssrBuildId);
           }
         }
@@ -1137,23 +1187,32 @@ var dev = async (options) => {
       return projectRes;
     const ssrComponentPath = pathMod3.join(__dirname2, HadarsFolder, SSR_FILENAME);
     const importPath = pathToFileURL2(ssrComponentPath).href + `?t=${ssrBuildId}`;
-    const {
-      default: Component,
-      getInitProps,
-      getAfterRenderProps,
-      getFinalProps
-    } = await import(importPath);
-    const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
-      document: {
-        body: Component,
-        lang: "en",
+    try {
+      const {
+        default: Component,
         getInitProps,
         getAfterRenderProps,
         getFinalProps
-      }
-    });
-    const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+      } = await import(importPath);
+      const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+        document: {
+          body: Component,
+          lang: "en",
+          getInitProps,
+          getAfterRenderProps,
+          getFinalProps
+        }
+      });
+      const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
+      return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+    } catch (err) {
+      console.error("[hadars] SSR render error:", err);
+      const msg = (err?.stack ?? err?.message ?? String(err)).replace(/</g, "&lt;");
+      return new Response(`<!doctype html><pre style="white-space:pre-wrap">${msg}</pre>`, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
   }, options.websocket);
 };
 var build = async (options) => {
@@ -1273,32 +1332,37 @@ var run = async (options) => {
     const componentPath = pathToFileURL2(
       pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME)
     ).href;
-    const {
-      default: Component,
-      getInitProps,
-      getAfterRenderProps,
-      getFinalProps
-    } = await import(componentPath);
-    if (renderPool) {
-      const serialReq = await serializeRequest(request);
-      const { html, headHtml: wHead, status: wStatus } = await renderPool.renderFull(serialReq);
-      const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
-      return new Response(precontentHtml + html + postContent, {
-        headers: { "Content-Type": "text/html; charset=utf-8" },
-        status: wStatus
-      });
-    }
-    const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
-      document: {
-        body: Component,
-        lang: "en",
+    try {
+      const {
+        default: Component,
         getInitProps,
         getAfterRenderProps,
         getFinalProps
+      } = await import(componentPath);
+      if (renderPool) {
+        const serialReq = await serializeRequest(request);
+        const { html, headHtml: wHead, status: wStatus } = await renderPool.renderFull(serialReq);
+        const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
+        return new Response(precontentHtml + html + postContent, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+          status: wStatus
+        });
       }
-    });
-    const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+      const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+        document: {
+          body: Component,
+          lang: "en",
+          getInitProps,
+          getAfterRenderProps,
+          getFinalProps
+        }
+      });
+      const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
+      return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+    } catch (err) {
+      console.error("[hadars] SSR render error:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
   }, options.websocket);
 };
 

package/dist/index.cjs

@@ -172,12 +172,13 @@ var AppProviderCSR = import_react.default.memo(({ children }) => {
 var useApp = () => import_react.default.useContext(AppContext);
 var clientServerDataCache = /* @__PURE__ */ new Map();
 function initServerDataCache(data) {
+  clientServerDataCache.clear();
   for (const [k, v] of Object.entries(data)) {
     clientServerDataCache.set(k, v);
   }
 }
 function useServerData(key, fn) {
-  const cacheKey = Array.isArray(key) ? key.join("\0") : key;
+  const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
   if (typeof window !== "undefined") {
     if (clientServerDataCache.has(cacheKey)) {
       return clientServerDataCache.get(cacheKey);

package/dist/index.d.ts

@@ -106,7 +106,8 @@ interface HadarsRequest extends Request {
 }
 
 /** Call this before hydrating to seed the client cache from the server's data.
- *  Invoked automatically by the hadars client bootstrap. */
+ *  Invoked automatically by the hadars client bootstrap.
+ *  Always clears the existing cache before populating — call with `{}` to just clear. */
 declare function initServerDataCache(data: Record<string, unknown>): void;
 /**
  * Fetch async data on the server during SSR. Returns `undefined` on the first

package/dist/index.js

@@ -132,12 +132,13 @@ var AppProviderCSR = React.memo(({ children }) => {
 var useApp = () => React.useContext(AppContext);
 var clientServerDataCache = /* @__PURE__ */ new Map();
 function initServerDataCache(data) {
+  clientServerDataCache.clear();
   for (const [k, v] of Object.entries(data)) {
     clientServerDataCache.set(k, v);
   }
 }
 function useServerData(key, fn) {
-  const cacheKey = Array.isArray(key) ? key.join("\0") : key;
+  const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
   if (typeof window !== "undefined") {
     if (clientServerDataCache.has(cacheKey)) {
       return clientServerDataCache.get(cacheKey);

package/dist/loader.cjs

@@ -21,14 +21,135 @@ __export(loader_exports, {
   default: () => loader
 });
 module.exports = __toCommonJS(loader_exports);
-const LOAD_MODULE_RE = /\bloadModule\s*(?:<.*?>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
 function loader(source) {
   const isServer = this.target === "node" || this.target === "async-node";
-  return source.replace(LOAD_MODULE_RE, (_match, quote, modulePath) => {
-    if (isServer) {
-      return `Promise.resolve(require(${quote}${modulePath}${quote}))`;
+  const resourcePath = this.resourcePath ?? this.resource ?? "(unknown)";
+  let swc;
+  try {
+    swc = require("@swc/core");
+  } catch {
+    return regexTransform.call(this, source, isServer, resourcePath);
+  }
+  return swcTransform.call(this, swc, source, isServer, resourcePath);
+}
+function swcTransform(swc, source, isServer, resourcePath) {
+  const isTs = /\.[mc]?tsx?$/.test(resourcePath);
+  const isTsx = /\.(tsx|jsx)$/.test(resourcePath);
+  let ast;
+  try {
+    ast = swc.parseSync(source, {
+      syntax: isTs ? "typescript" : "ecmascript",
+      tsx: isTsx
+    });
+  } catch {
+    return regexTransform.call(this, source, isServer, resourcePath);
+  }
+  const srcBytes = Buffer.from(source, "utf8");
+  const fileOffset = ast.span.start - countLeadingNonCodeBytes(source);
+  const replacements = [];
+  walkAst(ast, (node) => {
+    if (node.type !== "CallExpression")
+      return;
+    const callee = node.callee;
+    if (!callee || callee.type !== "Identifier" || callee.value !== "loadModule")
+      return;
+    const args = node.arguments;
+    if (!args || args.length === 0)
+      return;
+    const firstArg = args[0].expression ?? args[0];
+    let modulePath;
+    let quoteChar;
+    if (firstArg.type === "StringLiteral") {
+      modulePath = firstArg.value;
+      const quoteByteIdx = firstArg.span.start - fileOffset;
+      quoteChar = String.fromCharCode(srcBytes[quoteByteIdx]);
+    } else if (firstArg.type === "TemplateLiteral" && firstArg.expressions.length === 0 && firstArg.quasis.length === 1) {
+      modulePath = firstArg.quasis[0].raw;
+      quoteChar = "`";
     } else {
-      return `import(${quote}${modulePath}${quote})`;
+      const start0 = node.span.start - fileOffset;
+      const bytesBefore = srcBytes.slice(0, start0);
+      const line = bytesBefore.toString("utf8").split("\n").length;
+      this.emitWarning(
+        new Error(
+          `[hadars] loadModule() called with a dynamic (non-literal) path at ${resourcePath}:${line}. Only string-literal paths are transformed by the loader; dynamic calls fall back to runtime import().`
+        )
+      );
+      return;
     }
+    const replacement = isServer ? `Promise.resolve(require(${quoteChar}${modulePath}${quoteChar}))` : `import(${quoteChar}${modulePath}${quoteChar})`;
+    replacements.push({ start: node.span.start - fileOffset, end: node.span.end - fileOffset, replacement });
   });
+  if (replacements.length === 0)
+    return source;
+  replacements.sort((a, b) => b.start - a.start);
+  let result = srcBytes;
+  for (const { start, end, replacement } of replacements) {
+    result = Buffer.concat([result.slice(0, start), Buffer.from(replacement, "utf8"), result.slice(end)]);
+  }
+  return result.toString("utf8");
+}
+function walkAst(node, visit) {
+  if (!node || typeof node !== "object")
+    return;
+  visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "span" || key === "type" || key === "ctxt")
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const child of val)
+        walkAst(child, visit);
+    } else if (val && typeof val === "object") {
+      walkAst(val, visit);
+    }
+  }
+}
+function countLeadingNonCodeBytes(source) {
+  let i = 0;
+  while (i < source.length) {
+    if (source[i] === " " || source[i] === "	" || source[i] === "\r" || source[i] === "\n") {
+      i++;
+      continue;
+    }
+    if (source[i] === "/" && source[i + 1] === "/") {
+      while (i < source.length && source[i] !== "\n")
+        i++;
+      continue;
+    }
+    if (source[i] === "/" && source[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < source.length && !(source[i] === "*" && source[i + 1] === "/"))
+        i++;
+      if (i + 1 < source.length)
+        i += 2;
+      continue;
+    }
+    if (i === 0 && source[i] === "#" && source[i + 1] === "!") {
+      while (i < source.length && source[i] !== "\n")
+        i++;
+      continue;
+    }
+    break;
+  }
+  return Buffer.byteLength(source.slice(0, i), "utf8");
+}
+const LOAD_MODULE_RE = /\bloadModule\s*(?:<(?:[^<>]|<[^<>]*>)*>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
+const DYNAMIC_LOAD_MODULE_RE = /\bloadModule\s*(?:<(?:[^<>]|<[^<>]*>)*>\s*)?\(/g;
+function regexTransform(source, isServer, resourcePath) {
+  const transformed = source.replace(
+    LOAD_MODULE_RE,
+    (_match, quote, modulePath) => isServer ? `Promise.resolve(require(${quote}${modulePath}${quote}))` : `import(${quote}${modulePath}${quote})`
+  );
+  let match;
+  DYNAMIC_LOAD_MODULE_RE.lastIndex = 0;
+  while ((match = DYNAMIC_LOAD_MODULE_RE.exec(transformed)) !== null) {
+    const line = transformed.slice(0, match.index).split("\n").length;
+    this.emitWarning(
+      new Error(
+        `[hadars] loadModule() called with a dynamic (non-literal) path at ${resourcePath}:${line}. Only string-literal paths are transformed by the loader; dynamic calls fall back to runtime import().`
+      )
+    );
+  }
+  return transformed;
 }

package/dist/ssr-render-worker.js

@@ -108,6 +108,9 @@ async function runFullLifecycle(serialReq) {
       await Promise.all(pending);
     }
   } while (unsuspend.hasPending && ++iters < 25);
+  if (unsuspend.hasPending) {
+    console.warn("[hadars] SSR render loop hit the 25-iteration cap \u2014 some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.");
+  }
   props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
   try {
     globalThis.__hadarsUnsuspend = unsuspend;

package/dist/utils/Head.tsx

@@ -175,8 +175,10 @@ export const useApp = () => React.useContext(AppContext);
 const clientServerDataCache = new Map<string, unknown>();
 
 /** Call this before hydrating to seed the client cache from the server's data.
- *  Invoked automatically by the hadars client bootstrap. */
+ *  Invoked automatically by the hadars client bootstrap.
+ *  Always clears the existing cache before populating — call with `{}` to just clear. */
 export function initServerDataCache(data: Record<string, unknown>) {
+    clientServerDataCache.clear();
     for (const [k, v] of Object.entries(data)) {
         clientServerDataCache.set(k, v);
     }
@@ -208,7 +210,7 @@ export function initServerDataCache(data: Record<string, unknown>) {
  * if (!user) return null; // undefined while pending on the first SSR pass
  */
 export function useServerData<T>(key: string | string[], fn: () => Promise<T> | T): T | undefined {
-    const cacheKey = Array.isArray(key) ? key.join('\x00') : key;
+    const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
 
     if (typeof window !== 'undefined') {
         // Client: if the server serialised a value for this key, return it directly

package/dist/utils/clientScript.tsx

@@ -32,8 +32,12 @@ const main = async () => {
 
     const { location } = props;
 
-    if ( appMod.getClientProps ) {
-        props = await appMod.getClientProps(props);
+    if (appMod.getClientProps) {
+        try {
+            props = await appMod.getClientProps(props);
+        } catch (err) {
+            console.error('[hadars] getClientProps threw an error:', err);
+        }
     }
 
     props = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
@@ -32,6 +32,7 @@
     "build:lib": "tsup src/index.tsx --format esm,cjs --dts --out-dir dist --clean --external '@rspack/*' --external '@rspack/binding'",
     "build:cli": "node build-scripts/build-cli.mjs",
     "build:all": "npm run build:lib && npm run build:cli",
+    "test": "bun test test/ssr.test.ts",
     "prepare": "npm run build:all",
     "prepublishOnly": "npm run build:all"
   },
@@ -64,6 +65,7 @@
     "@rspack/core": "1.4.9",
     "@rspack/dev-server": "^1.1.4",
     "@rspack/plugin-react-refresh": "^1.5.0",
+    "@swc/core": "^1.4.0",
     "@types/bun": "latest",
     "@types/react-dom": "^19.1.9",
     "react-refresh": "^0.17.0",
@@ -73,8 +75,7 @@
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "esbuild": "^0.19.0",
-    "tsup": "^6.6.0",
-    "@swc/core": "^1.4.0"
+    "tsup": "^6.6.0"
   },
   "dependencies": {
     "@mdx-js/loader": "^3.1.1",