hadars 0.1.8 → 0.1.10

package/README.md

@@ -66,12 +66,32 @@ hadars run         # multi-core when workers > 1
 
 - **React Fast Refresh** — full HMR via rspack-dev-server, module-level patches
 - **True SSR** — components render on the server with your data, then hydrate on the client
+- **Shell streaming** — HTML shell is flushed immediately so browsers can start loading assets before the body arrives
 - **Code splitting** — `loadModule('./Comp')` splits on the browser, bundles statically on the server
 - **Head management** — `HadarsHead` controls `<title>`, `<meta>`, `<link>` on server and client
 - **Cross-runtime** — Bun, Node.js, Deno; uses the standard Fetch API throughout
 - **Multi-core** — `workers: os.cpus().length` forks a process per CPU core via `node:cluster`
 - **TypeScript-first** — full types for props, lifecycle hooks, config, and the request object
 
+## useServerData
+
+Fetch async data inside a component during SSR. The framework's render loop awaits the promise and re-renders until all values are resolved, then serialises them into the page for zero-cost client hydration.
+
+```tsx
+import { useServerData } from 'hadars';
+
+const UserCard = ({ userId }: { userId: string }) => {
+    const user = useServerData(['user', userId], () => db.getUser(userId));
+    if (!user) return null; // undefined while pending on the first SSR pass
+    return <p>{user.name}</p>;
+};
+```
+
+- **`key`** — string or string array; must be stable and unique within the page
+- **Server** — calls `fn()`, awaits the result across render iterations, returns `undefined` until resolved
+- **Client** — reads the pre-resolved value from the hydration cache serialised by the server; `fn()` is never called in the browser
+- **Suspense libraries** — also works when `fn()` throws a thenable (e.g. Relay `useLazyLoadQuery` with `suspense: true`); the thrown promise is awaited and the next render re-calls `fn()` synchronously
+
 ## Data lifecycle hooks
 
 | Hook | Runs on | Purpose |
@@ -97,20 +117,7 @@ hadars run         # multi-core when workers > 1
 | `fetch` | `function` | — | Custom fetch handler; return a `Response` to short-circuit SSR |
 | `websocket` | `object` | — | WebSocket handler (Bun only) |
 | `wsPath` | `string` | `"/ws"` | Path that triggers WebSocket upgrade |
-| `streaming` | `boolean` | `false` | Set to `true` to use `renderToReadableStream` (streaming SSR) instead of the default `renderToString` |
-
-## Local build
-
-```bash
-npm install
-npm run build:all
-```
-
-## Publishing
-
-1. Update `version`, `repository`, `license` in `package.json`
-2. `npm login`
-3. `npm publish`
+| `optimization` | `object` | — | Override rspack `optimization` for production client builds (merged on top of defaults) |
 
 ## License
 

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
@@ -486,6 +485,21 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
     // for server builds prefer the package "main"/"module" fields and avoid "browser" so we don't pick browser-specific entrypoints
     mainFields: isServerBuild ? ["main", "module"] : ["browser", "module", "main"]
   };
+  const optimization = !isServerBuild && !isDev ? {
+    moduleIds: "deterministic",
+    splitChunks: {
+      chunks: "all",
+      cacheGroups: {
+        react: {
+          test: /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/,
+          name: "vendor-react",
+          chunks: "all",
+          priority: 20
+        }
+      }
+    },
+    ...opts.optimization ?? {}
+  } : opts.optimization ? { ...opts.optimization } : void 0;
   return {
     entry,
     output: {
@@ -494,6 +508,7 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
     },
     mode: opts.mode,
     externals,
+    ...optimization !== void 0 ? { optimization } : {},
     plugins: [
       new rspack.HtmlRspackPlugin({
         publicPath: base || "/",
@@ -603,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,
@@ -733,16 +786,6 @@ import cluster from "node:cluster";
 var encoder = new TextEncoder();
 var HEAD_MARKER = '<meta name="NINETY_HEAD">';
 var BODY_MARKER = '<meta name="NINETY_BODY">';
-var _renderToReadableStream = null;
-async function getReadableStreamRenderer() {
-  if (!_renderToReadableStream) {
-    const req = createRequire2(pathMod3.resolve(process.cwd(), "__hadars_fake__.js"));
-    const resolved = req.resolve("react-dom/server.browser");
-    const mod = await import(pathToFileURL2(resolved).href);
-    _renderToReadableStream = mod.renderToReadableStream;
-  }
-  return _renderToReadableStream;
-}
 var _renderToString = null;
 async function getRenderToString() {
   if (!_renderToString) {
@@ -761,64 +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, type, html, headHtml, status, error, chunk } = msg;
-          const p = this.pending.get(id);
-          if (!p)
-            return;
-          if (p.kind === "renderFullStream") {
-            if (type === "head") {
-              p.headSettled = true;
-              p.headResolve({ headHtml, status });
-              return;
-            }
-            if (type === "chunk") {
-              p.controller.enqueue(chunk);
-              return;
-            }
-            this.pending.delete(id);
-            this.workerPending.get(w)?.delete(id);
-            if (type === "done")
-              p.controller.close();
-            else {
-              const err = new Error(error ?? "Stream error");
-              if (!p.headSettled)
-                p.headReject(err);
-              p.controller.error(err);
-            }
-            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)
@@ -829,17 +860,13 @@ var RenderWorkerPool = class {
         const p = this.pending.get(id);
         if (p) {
           this.pending.delete(id);
-          if (p.kind === "renderFull")
-            p.reject(err);
-          else {
-            if (!p.headSettled)
-              p.headReject(err);
-            p.controller.error(err);
-          }
+          p.reject(err);
         }
       }
       this.workerPending.delete(w);
     }
+    console.log("[hadars] Spawning replacement render worker");
+    this._spawnWorker();
   }
   nextWorker() {
     if (this.workers.length === 0)
@@ -868,82 +895,25 @@ var RenderWorkerPool = class {
       }
     });
   }
-  /** Run the full SSR lifecycle in a worker thread, streaming the response. */
-  renderFullStream(req) {
-    let headResolve;
-    let headReject;
-    const head = new Promise((res, rej) => {
-      headResolve = res;
-      headReject = rej;
-    });
-    let controller;
-    const stream = new ReadableStream({ start: (ctrl) => {
-      controller = ctrl;
-    } });
-    const w = this.nextWorker();
-    if (!w) {
-      queueMicrotask(() => {
-        headReject(new Error("[hadars] No render workers available"));
-        controller.error(new Error("[hadars] No render workers available"));
-      });
-      return { head, stream };
-    }
-    const id = this.nextId++;
-    this.pending.set(id, { kind: "renderFullStream", headSettled: false, headResolve, headReject, controller });
-    this.workerPending.get(w)?.add(id);
-    try {
-      w.postMessage({ id, type: "renderFull", streaming: true, request: req });
-    } catch (err) {
-      this.pending.delete(id);
-      this.workerPending.get(w)?.delete(id);
-      queueMicrotask(() => {
-        headReject(err);
-        controller.error(err);
-      });
-    }
-    return { head, stream };
-  }
   async terminate() {
     await Promise.all(this.workers.map((w) => w.terminate()));
   }
 };
-async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, streaming, unsuspendForRender) {
-  const renderToString = !streaming ? await getRenderToString() : null;
-  const renderReadableStream = streaming ? await getReadableStreamRenderer() : null;
-  if (!streaming) {
-    const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-    let bodyHtml;
-    try {
-      globalThis.__hadarsUnsuspend = unsuspendForRender;
-      bodyHtml = renderToString(ReactPage);
-    } finally {
-      globalThis.__hadarsUnsuspend = null;
-    }
-    return new Response(precontentHtml + bodyHtml + postContent, {
-      headers: { "Content-Type": "text/html; charset=utf-8" },
-      status
-    });
-  }
+async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspendForRender) {
+  const renderToString = await getRenderToString();
   const responseStream = new ReadableStream({
     async start(controller) {
       const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
       controller.enqueue(encoder.encode(precontentHtml));
-      let streamPromise;
+      await Promise.resolve();
+      let bodyHtml;
       try {
         globalThis.__hadarsUnsuspend = unsuspendForRender;
-        streamPromise = renderReadableStream(ReactPage);
+        bodyHtml = renderToString(ReactPage);
       } finally {
         globalThis.__hadarsUnsuspend = null;
       }
-      const bodyStream = await streamPromise;
-      const reader = bodyStream.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        controller.enqueue(value);
-      }
-      controller.enqueue(encoder.encode(postContent));
+      controller.enqueue(encoder.encode(bodyHtml + postContent));
       controller.close();
     }
   });
@@ -1048,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: {
@@ -1163,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);
           }
         }
@@ -1217,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, options.streaming === true, 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) => {
@@ -1250,19 +1229,20 @@ var build = async (options) => {
   }
   const tmpFilePath = pathMod3.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
   await fs.writeFile(tmpFilePath, clientScript);
-  const randomStr = crypto.randomBytes(6).toString("hex");
   console.log("Building client and server bundles in parallel...");
   await Promise.all([
     compileEntry(tmpFilePath, {
       target: "web",
       output: {
-        filename: `index-${randomStr}.js`,
+        // Content hash: filename is stable when code is unchanged → better browser/CDN cache.
+        filename: "index.[contenthash:8].js",
         path: pathMod3.resolve(__dirname2, StaticPath)
       },
       base: options.baseURL,
       mode: "production",
       swcPlugins: options.swcPlugins,
-      define: options.define
+      define: options.define,
+      optimization: options.optimization
     }),
     compileEntry(pathMod3.resolve(__dirname2, options.entry), {
       output: {
@@ -1280,10 +1260,6 @@ var build = async (options) => {
     })
   ]);
   await fs.rm(tmpFilePath);
-  await fs.writeFile(
-    pathMod3.join(__dirname2, HadarsFolder, "hadars.json"),
-    JSON.stringify({ buildId: randomStr })
-  );
   console.log("Build complete.");
 };
 var run = async (options) => {
@@ -1356,37 +1332,15 @@ 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);
-      if (options.streaming) {
-        const { head, stream } = renderPool.renderFullStream(serialReq);
-        const { headHtml: wHead, status: wStatus } = await head;
-        const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
-        const responseStream = new ReadableStream({
-          async start(controller) {
-            controller.enqueue(encoder.encode(precontentHtml));
-            const reader = stream.getReader();
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              controller.enqueue(value);
-            }
-            controller.enqueue(encoder.encode(postContent));
-            controller.close();
-          }
-        });
-        return new Response(responseStream, {
-          headers: { "Content-Type": "text/html; charset=utf-8" },
-          status: wStatus
-        });
-      } else {
+    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, {
@@ -1394,18 +1348,21 @@ var run = async (options) => {
           status: wStatus
         });
       }
+      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 });
     }
-    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, options.streaming === true, unsuspend);
   }, 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);