hadars 0.1.7 → 0.1.9

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

@@ -486,6 +486,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 +509,7 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
     },
     mode: opts.mode,
     externals,
+    ...optimization !== void 0 ? { optimization } : {},
     plugins: [
       new rspack.HtmlRspackPlugin({
         publicPath: base || "/",
@@ -724,7 +740,6 @@ 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";
@@ -733,16 +748,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) {
@@ -770,29 +775,16 @@ var RenderWorkerPool = class {
         const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
         this.workerPending.set(w, /* @__PURE__ */ new Set());
         w.on("message", (msg) => {
-          const { id, type, html, error, chunk } = msg;
+          const { id, html, headHtml, status, error } = msg;
           const p = this.pending.get(id);
           if (!p)
             return;
-          if (p.kind === "renderStream") {
-            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
-              p.controller.error(new Error(error ?? "Stream error"));
-            return;
-          }
           this.pending.delete(id);
           this.workerPending.get(w)?.delete(id);
           if (error)
             p.reject(new Error(error));
           else
-            p.resolve(html);
+            p.resolve({ html, headHtml, status });
         });
         w.on("error", (err) => {
           console.error("[hadars] Render worker error:", err);
@@ -820,10 +812,7 @@ var RenderWorkerPool = class {
         const p = this.pending.get(id);
         if (p) {
           this.pending.delete(id);
-          if (p.kind === "renderString")
-            p.reject(err);
-          else
-            p.controller.error(err);
+          p.reject(err);
         }
       }
       this.workerPending.delete(w);
@@ -836,8 +825,8 @@ var RenderWorkerPool = class {
     this.rrIndex++;
     return w;
   }
-  /** Offload a full renderToString call. Returns the HTML string. */
-  renderString(appProps, clientProps) {
+  /** Run the full SSR lifecycle in a worker thread. Returns html, headHtml, status. */
+  renderFull(req) {
     return new Promise((resolve2, reject) => {
       const w = this.nextWorker();
       if (!w) {
@@ -845,10 +834,10 @@ var RenderWorkerPool = class {
         return;
       }
       const id = this.nextId++;
-      this.pending.set(id, { kind: "renderString", resolve: resolve2, reject });
+      this.pending.set(id, { kind: "renderFull", resolve: resolve2, reject });
       this.workerPending.get(w)?.add(id);
       try {
-        w.postMessage({ id, type: "renderString", appProps, clientProps });
+        w.postMessage({ id, type: "renderFull", streaming: false, request: req });
       } catch (err) {
         this.pending.delete(id);
         this.workerPending.get(w)?.delete(id);
@@ -856,83 +845,25 @@ var RenderWorkerPool = class {
       }
     });
   }
-  /** Offload a renderToReadableStream call. Returns a ReadableStream fed by
-   *  worker chunk messages. */
-  renderStream(appProps, clientProps) {
-    let controller;
-    const stream = new ReadableStream({
-      start: (ctrl) => {
-        controller = ctrl;
-      }
-    });
-    const w = this.nextWorker();
-    if (!w) {
-      queueMicrotask(() => controller.error(new Error("[hadars] No render workers available")));
-      return stream;
-    }
-    const id = this.nextId++;
-    this.pending.set(id, { kind: "renderStream", controller });
-    this.workerPending.get(w)?.add(id);
-    try {
-      w.postMessage({ id, type: "renderStream", appProps, clientProps });
-    } catch (err) {
-      this.pending.delete(id);
-      this.workerPending.get(w)?.delete(id);
-      queueMicrotask(() => controller.error(err));
-    }
-    return stream;
-  }
   async terminate() {
     await Promise.all(this.workers.map((w) => w.terminate()));
   }
 };
-async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, streaming, renderPool, renderPayload) {
-  const renderToString = !streaming && !renderPool ? await getRenderToString() : null;
-  const renderReadableStream = streaming && !renderPool ? await getReadableStreamRenderer() : null;
-  const unsuspendForRender = renderPayload?.appProps?.context?._unsuspend ?? null;
-  if (!streaming) {
-    const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-    let bodyHtml;
-    if (renderPool && renderPayload) {
-      bodyHtml = await renderPool.renderString(renderPayload.appProps, renderPayload.clientProps);
-    } else {
+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));
+      await Promise.resolve();
+      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
-    });
-  }
-  const responseStream = new ReadableStream({
-    async start(controller) {
-      const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-      controller.enqueue(encoder.encode(precontentHtml));
-      let bodyStream;
-      if (renderPool && renderPayload) {
-        bodyStream = renderPool.renderStream(renderPayload.appProps, renderPayload.clientProps);
-      } else {
-        let streamPromise;
-        try {
-          globalThis.__hadarsUnsuspend = unsuspendForRender;
-          streamPromise = renderReadableStream(ReactPage);
-        } finally {
-          globalThis.__hadarsUnsuspend = null;
-        }
-        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();
     }
   });
@@ -941,6 +872,24 @@ async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml,
     status
   });
 }
+async function serializeRequest(req) {
+  const isGetOrHead = ["GET", "HEAD"].includes(req.method ?? "GET");
+  const body = isGetOrHead ? null : new Uint8Array(await req.clone().arrayBuffer());
+  const headers = {};
+  req.headers.forEach((v, k) => {
+    headers[k] = v;
+  });
+  return {
+    url: req.url,
+    method: req.method ?? "GET",
+    headers,
+    body,
+    pathname: req.pathname,
+    search: req.search,
+    location: req.location,
+    cookies: req.cookies
+  };
+}
 var makePrecontentHtmlGetter = (htmlFilePromise) => {
   let preHead = null;
   let postHead = null;
@@ -1194,7 +1143,7 @@ var dev = async (options) => {
       getAfterRenderProps,
       getFinalProps
     } = await import(importPath);
-    const { ReactPage, status, headHtml } = await getReactResponse(request, {
+    const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
       document: {
         body: Component,
         lang: "en",
@@ -1203,7 +1152,8 @@ var dev = async (options) => {
         getFinalProps
       }
     });
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true);
+    const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
+    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
   }, options.websocket);
 };
 var build = async (options) => {
@@ -1220,19 +1170,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: {
@@ -1250,10 +1201,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) => {
@@ -1332,6 +1279,15 @@ var run = async (options) => {
       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,
@@ -1341,7 +1297,8 @@ var run = async (options) => {
         getFinalProps
       }
     });
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, renderPool, renderPayload);
+    const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
+    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
   }, options.websocket);
 };
 

package/dist/index.d.ts

@@ -83,15 +83,15 @@ interface HadarsOptions {
      *
      * **Bun / Deno** — creates a `node:worker_threads` render pool of this size.
      * Each thread handles the synchronous `renderToString` step, freeing the
-     * main event loop for I/O. Only applies when `streaming` is `false` (the default).
+     * main event loop for I/O.
      */
     workers?: number;
     /**
-     * Whether to use streaming SSR (`renderToReadableStream`) for rendering React
-     * components. Defaults to `false`. Set to `true` to use streaming via
-     * `renderToReadableStream` instead of the synchronous `renderToString`.
+     * Override or extend rspack's `optimization` config for production client builds.
+     * Merged on top of hadars defaults (splitChunks vendor splitting, deterministic moduleIds).
+     * Has no effect on the SSR bundle or dev mode.
      */
-    streaming?: boolean;
+    optimization?: Record<string, unknown>;
 }
 type SwcPluginItem = string | [string, Record<string, unknown>] | {
     path: string;

package/dist/ssr-render-worker.js

@@ -7,10 +7,9 @@ var { ssrBundlePath } = workerData;
 var _React = null;
 var _renderToStaticMarkup = null;
 var _renderToString = null;
-var _renderToReadableStream = null;
-var _Component = null;
+var _ssrMod = null;
 async function init() {
-  if (_React && _renderToStaticMarkup && _renderToString && _renderToReadableStream && _Component)
+  if (_React && _ssrMod)
     return;
   const req = createRequire(pathMod.resolve(process.cwd(), "__ninety_fake__.js"));
   if (!_React) {
@@ -24,24 +23,51 @@ async function init() {
     _renderToString = serverMod.renderToString;
     _renderToStaticMarkup = serverMod.renderToStaticMarkup;
   }
-  if (!_renderToReadableStream) {
-    const browserPath = pathToFileURL(req.resolve("react-dom/server.browser")).href;
-    const browserMod = await import(browserPath);
-    _renderToReadableStream = browserMod.renderToReadableStream;
-  }
-  if (!_Component) {
-    const ssrMod = await import(pathToFileURL(ssrBundlePath).href);
-    _Component = ssrMod.default;
+  if (!_ssrMod) {
+    _ssrMod = await import(pathToFileURL(ssrBundlePath).href);
   }
 }
-function buildReactPage(R, appProps, clientProps) {
+function deserializeRequest(s) {
+  const init2 = { method: s.method, headers: new Headers(s.headers) };
+  if (s.body)
+    init2.body = s.body;
+  const req = new Request(s.url, init2);
+  Object.assign(req, {
+    pathname: s.pathname,
+    search: s.search,
+    location: s.location,
+    cookies: s.cookies
+  });
+  return req;
+}
+function buildHeadHtml(head) {
+  const R = _React;
+  const metaEntries = Object.entries(head.meta ?? {});
+  const linkEntries = Object.entries(head.link ?? {});
+  const styleEntries = Object.entries(head.style ?? {});
+  const scriptEntries = Object.entries(head.script ?? {});
+  return _renderToStaticMarkup(
+    R.createElement(
+      R.Fragment,
+      null,
+      R.createElement("title", null, head.title),
+      ...metaEntries.map(([id, opts]) => R.createElement("meta", { key: id, id, ...opts })),
+      ...linkEntries.map(([id, opts]) => R.createElement("link", { key: id, id, ...opts })),
+      ...styleEntries.map(([id, opts]) => R.createElement("style", { key: id, id, ...opts })),
+      ...scriptEntries.map(([id, opts]) => R.createElement("script", { key: id, id, ...opts }))
+    )
+  );
+}
+function buildReactPage(appProps, clientProps) {
+  const R = _React;
+  const Component = _ssrMod.default;
   return R.createElement(
     R.Fragment,
     null,
     R.createElement(
       "div",
       { id: "app" },
-      R.createElement(_Component, appProps)
+      R.createElement(Component, appProps)
     ),
     R.createElement("script", {
       id: "hadars",
@@ -52,41 +78,79 @@ function buildReactPage(R, appProps, clientProps) {
     })
   );
 }
+async function runFullLifecycle(serialReq) {
+  const R = _React;
+  const Component = _ssrMod.default;
+  const { getInitProps, getAfterRenderProps, getFinalProps } = _ssrMod;
+  const parsedReq = deserializeRequest(serialReq);
+  const unsuspend = { cache: /* @__PURE__ */ new Map(), hasPending: false };
+  const context = {
+    head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 },
+    _unsuspend: unsuspend
+  };
+  let props = {
+    ...getInitProps ? await getInitProps(parsedReq) : {},
+    location: serialReq.location,
+    context
+  };
+  let html = "";
+  let iters = 0;
+  do {
+    unsuspend.hasPending = false;
+    try {
+      globalThis.__hadarsUnsuspend = unsuspend;
+      html = _renderToStaticMarkup(R.createElement(Component, props));
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
+    }
+    if (unsuspend.hasPending) {
+      const pending = [...unsuspend.cache.values()].filter((e) => e.status === "pending").map((e) => e.promise);
+      await Promise.all(pending);
+    }
+  } while (unsuspend.hasPending && ++iters < 25);
+  props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
+  try {
+    globalThis.__hadarsUnsuspend = unsuspend;
+    _renderToStaticMarkup(R.createElement(Component, { ...props, location: serialReq.location, context }));
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
+  }
+  const serverData = {};
+  for (const [k, v] of unsuspend.cache) {
+    if (v.status === "fulfilled")
+      serverData[k] = v.value;
+    if (v.status === "suspense-cached")
+      serverData[k] = v.value;
+  }
+  const { context: _ctx, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+  const clientProps = {
+    ...restProps,
+    location: serialReq.location,
+    ...Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}
+  };
+  const headHtml = buildHeadHtml(context.head);
+  const status = context.head.status ?? 200;
+  const finalAppProps = { ...props, location: serialReq.location, context };
+  return { finalAppProps, clientProps, headHtml, status, unsuspend };
+}
 parentPort.on("message", async (msg) => {
-  const { id, type } = msg;
+  const { id, type, request } = msg;
   try {
     await init();
-    const R = _React;
-    const unsuspend = msg.appProps?.context?._unsuspend ?? null;
-    if (type === "renderStream") {
-      const { appProps: appProps2, clientProps: clientProps2 } = msg;
-      const ReactPage2 = buildReactPage(R, appProps2, clientProps2);
+    if (type !== "renderFull")
+      return;
+    const { finalAppProps, clientProps, headHtml, status, unsuspend } = await runFullLifecycle(request);
+    const ReactPage = buildReactPage(finalAppProps, clientProps);
+    let html;
+    try {
       globalThis.__hadarsUnsuspend = unsuspend;
-      const stream = await _renderToReadableStream(ReactPage2);
+      html = _renderToString(ReactPage);
+    } finally {
       globalThis.__hadarsUnsuspend = null;
-      const reader = stream.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        parentPort.postMessage({ id, type: "chunk", chunk: value }, [value.buffer]);
-      }
-      parentPort.postMessage({ id, type: "done" });
-      return;
     }
-    const { appProps, clientProps } = msg;
-    const ReactPage = buildReactPage(R, appProps, clientProps);
-    globalThis.__hadarsUnsuspend = unsuspend;
-    const html = _renderToString(ReactPage);
-    globalThis.__hadarsUnsuspend = null;
-    parentPort.postMessage({ id, html });
+    parentPort.postMessage({ id, html, headHtml, status });
   } catch (err) {
     globalThis.__hadarsUnsuspend = null;
-    const errMsg = err?.message ?? String(err);
-    if (type === "renderStream") {
-      parentPort.postMessage({ id, type: "error", error: errMsg });
-    } else {
-      parentPort.postMessage({ id, error: errMsg });
-    }
+    parentPort.postMessage({ id, error: err?.message ?? String(err) });
   }
 });

package/dist/ssr-watch.js

@@ -211,6 +211,21 @@ var buildCompilerConfig = (entry2, 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: entry2,
     output: {
@@ -219,6 +234,7 @@ var buildCompilerConfig = (entry2, opts, includeHotPlugin) => {
     },
     mode: opts.mode,
     externals,
+    ...optimization !== void 0 ? { optimization } : {},
     plugins: [
       new rspack.HtmlRspackPlugin({
         publicPath: base2 || "/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",

package/src/build.ts

@@ -10,36 +10,18 @@ import { RspackDevServer } from "@rspack/dev-server";
 import pathMod from "node:path";
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
-import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import os from 'node:os';
 import { spawn } from 'node:child_process';
 import cluster from 'node:cluster';
 import type { HadarsEntryModule, HadarsOptions, HadarsProps } from "./types/ninety";
-
 const encoder = new TextEncoder();
 
 const HEAD_MARKER = '<meta name="NINETY_HEAD">';
 const BODY_MARKER = '<meta name="NINETY_BODY">';
 
-// Resolve react-dom/server.browser from the *project's* node_modules (process.cwd())
-// rather than from hadars's own install location. This guarantees the same React
-// instance is used here and in the SSR bundle (which is also built relative to cwd),
-// preventing "Invalid hook call" errors when hadars is installed as a file: symlink.
-let _renderToReadableStream: ((element: any, options?: any) => Promise<ReadableStream<Uint8Array>>) | null = null;
-async function getReadableStreamRenderer(): Promise<(element: any, options?: any) => Promise<ReadableStream<Uint8Array>>> {
-    if (!_renderToReadableStream) {
-        const req = createRequire(pathMod.resolve(process.cwd(), '__hadars_fake__.js'));
-        const resolved = req.resolve('react-dom/server.browser');
-        const mod = await import(pathToFileURL(resolved).href);
-        _renderToReadableStream = mod.renderToReadableStream;
-    }
-    return _renderToReadableStream!;
-}
-
 // Resolve renderToString from react-dom/server in the project's node_modules.
-// Used when streaming is disabled via `streaming: false` in hadars config.
 let _renderToString: ((element: any) => string) | null = null;
 async function getRenderToString(): Promise<(element: any) => string> {
     if (!_renderToString) {
@@ -53,21 +35,15 @@ async function getRenderToString(): Promise<(element: any) => string> {
 
 // Round-robin thread pool for SSR rendering — used on Bun/Deno where
 // node:cluster is not available but node:worker_threads is.
-// Supports three render modes matching the worker's message protocol:
-//   staticMarkup — renderToStaticMarkup for lifecycle passes in getReactResponse
-//   renderString — renderToString for non-streaming responses
-//   renderStream — renderToReadableStream chunks forwarded as a ReadableStream
-
-type PendingRenderString = {
-    kind: 'renderString';
-    resolve: (html: string) => void;
+
+import type { SerializableRequest } from './ssr-render-worker';
+
+type PendingRenderFull = {
+    kind: 'renderFull';
+    resolve: (result: { html: string; headHtml: string; status: number }) => void;
     reject: (err: Error) => void;
 };
-type PendingRenderStream = {
-    kind: 'renderStream';
-    controller: ReadableStreamDefaultController<Uint8Array>;
-};
-type PendingEntry = PendingRenderString | PendingRenderStream;
+type PendingEntry = PendingRenderFull;
 
 class RenderWorkerPool {
     private workers: any[] = [];
@@ -90,27 +66,13 @@ class RenderWorkerPool {
                 const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
                 this.workerPending.set(w, new Set());
                 w.on('message', (msg: any) => {
-                    const { id, type, html, error, chunk } = msg;
+                    const { id, html, headHtml, status, error } = msg;
                     const p = this.pending.get(id);
                     if (!p) return;
-
-                    if (p.kind === 'renderStream') {
-                        if (type === 'chunk') {
-                            p.controller.enqueue(chunk as Uint8Array);
-                            return; // keep entry until 'done'
-                        }
-                        this.pending.delete(id);
-                        this.workerPending.get(w)?.delete(id);
-                        if (type === 'done') p.controller.close();
-                        else p.controller.error(new Error(error ?? 'Stream error'));
-                        return;
-                    }
-
-                    // renderString
                     this.pending.delete(id);
                     this.workerPending.get(w)?.delete(id);
                     if (error) p.reject(new Error(error));
-                    else p.resolve(html);
+                    else p.resolve({ html, headHtml, status });
                 });
                 w.on('error', (err: Error) => {
                     console.error('[hadars] Render worker error:', err);
@@ -130,19 +92,16 @@ class RenderWorkerPool {
     }
 
     private _handleWorkerDeath(w: any, err: Error) {
-        // Remove the dead worker from the rotation so it is never selected again.
         const idx = this.workers.indexOf(w);
         if (idx !== -1) this.workers.splice(idx, 1);
 
-        // Reject every in-flight request that was sent to this worker.
         const ids = this.workerPending.get(w);
         if (ids) {
             for (const id of ids) {
                 const p = this.pending.get(id);
                 if (p) {
                     this.pending.delete(id);
-                    if (p.kind === 'renderString') p.reject(err);
-                    else p.controller.error(err);
+                    p.reject(err);
                 }
             }
             this.workerPending.delete(w);
@@ -156,19 +115,16 @@ class RenderWorkerPool {
         return w;
     }
 
-    /** Offload a full renderToString call. Returns the HTML string. */
-    renderString(appProps: Record<string, unknown>, clientProps: Record<string, unknown>): Promise<string> {
+    /** Run the full SSR lifecycle in a worker thread. Returns html, headHtml, status. */
+    renderFull(req: SerializableRequest): Promise<{ html: string; headHtml: string; status: number }> {
         return new Promise((resolve, reject) => {
             const w = this.nextWorker();
-            if (!w) {
-                reject(new Error('[hadars] No render workers available'));
-                return;
-            }
+            if (!w) { reject(new Error('[hadars] No render workers available')); return; }
             const id = this.nextId++;
-            this.pending.set(id, { kind: 'renderString', resolve, reject });
+            this.pending.set(id, { kind: 'renderFull', resolve, reject });
             this.workerPending.get(w)?.add(id);
             try {
-                w.postMessage({ id, type: 'renderString', appProps, clientProps });
+                w.postMessage({ id, type: 'renderFull', streaming: false, request: req });
             } catch (err) {
                 this.pending.delete(id);
                 this.workerPending.get(w)?.delete(id);
@@ -177,34 +133,6 @@ class RenderWorkerPool {
         });
     }
 
-    /** Offload a renderToReadableStream call. Returns a ReadableStream fed by
-     *  worker chunk messages. */
-    renderStream(appProps: Record<string, unknown>, clientProps: Record<string, unknown>): ReadableStream<Uint8Array> {
-        let controller!: ReadableStreamDefaultController<Uint8Array>;
-        const stream = new ReadableStream<Uint8Array>({
-            start: (ctrl) => { controller = ctrl; },
-        });
-        const w = this.nextWorker();
-        if (!w) {
-            // Immediately error the stream if no workers are available.
-            queueMicrotask(() => controller.error(new Error('[hadars] No render workers available')));
-            return stream;
-        }
-        const id = this.nextId++;
-        // Store controller before postMessage so the handler is ready when
-        // the first chunk arrives.
-        this.pending.set(id, { kind: 'renderStream', controller });
-        this.workerPending.get(w)?.add(id);
-        try {
-            w.postMessage({ id, type: 'renderStream', appProps, clientProps });
-        } catch (err) {
-            this.pending.delete(id);
-            this.workerPending.get(w)?.delete(id);
-            queueMicrotask(() => controller.error(err));
-        }
-        return stream;
-    }
-
     async terminate(): Promise<void> {
         await Promise.all(this.workers.map((w: any) => w.terminate()));
     }
@@ -215,70 +143,29 @@ async function buildSsrResponse(
     headHtml: string,
     status: number,
     getPrecontentHtml: (headHtml: string) => Promise<[string, string]>,
-    streaming: boolean,
-    renderPool?: RenderWorkerPool,
-    renderPayload?: { appProps: Record<string, unknown>; clientProps: Record<string, unknown> },
+    unsuspendForRender: any,
 ): Promise<Response> {
-    // Resolve renderers before touching globalThis.__hadarsUnsuspend.
-    // Any await after setting the global would create a window where a concurrent
-    // request on the same thread could overwrite it before the render call runs.
-    // Loading the renderer first ensures the set→call→clear sequence is synchronous.
-    const renderToString = (!streaming && !renderPool) ? await getRenderToString() : null;
-    const renderReadableStream = (streaming && !renderPool) ? await getReadableStreamRenderer() : null;
-
-    // Extract the unsuspend cache from renderPayload so non-pool renders can expose
-    // resolved useServerData() values to the SSR bundle via globalThis.__hadarsUnsuspend.
-    const unsuspendForRender = (renderPayload?.appProps?.context as any)?._unsuspend ?? null;
-
-    if (!streaming) {
-        const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-        let bodyHtml: string;
-        if (renderPool && renderPayload) {
-            bodyHtml = await renderPool.renderString(renderPayload.appProps, renderPayload.clientProps);
-        } else {
-            // set → call (synchronous) → clear: no await in between, safe under concurrency
-            try {
-                (globalThis as any).__hadarsUnsuspend = unsuspendForRender;
-                bodyHtml = renderToString!(ReactPage);
-            } finally {
-                (globalThis as any).__hadarsUnsuspend = null;
-            }
-        }
-        return new Response(precontentHtml + bodyHtml + postContent, {
-            headers: { 'Content-Type': 'text/html; charset=utf-8' },
-            status,
-        });
-    }
+    // Pre-load renderer before starting the stream so the set→call→clear
+    // sequence around __hadarsUnsuspend is fully synchronous (no await between them).
+    const renderToString = await getRenderToString();
 
     const responseStream = new ReadableStream({
         async start(controller) {
             const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
+            // Flush the shell (precontentHtml) immediately so the browser can
+            // start loading CSS/fonts before renderToString blocks the thread.
             controller.enqueue(encoder.encode(precontentHtml));
+            await Promise.resolve(); // yield to let the runtime flush the shell chunk
 
-            let bodyStream: ReadableStream<Uint8Array>;
-            if (renderPool && renderPayload) {
-                bodyStream = renderPool.renderStream(renderPayload.appProps, renderPayload.clientProps);
-            } else {
-                // React's renderToReadableStream starts rendering synchronously on call,
-                // so hooks fire before the returned Promise settles. Set the global
-                // immediately before the call and clear right after — no await in between.
-                let streamPromise: Promise<ReadableStream<Uint8Array>>;
-                try {
-                    (globalThis as any).__hadarsUnsuspend = unsuspendForRender;
-                    streamPromise = renderReadableStream!(ReactPage);
-                } finally {
-                    (globalThis as any).__hadarsUnsuspend = null;
-                }
-                bodyStream = await streamPromise;
-            }
-            const reader = bodyStream.getReader();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                controller.enqueue(value);
+            // set → call (synchronous) → clear: no await in between, safe under concurrency
+            let bodyHtml: string;
+            try {
+                (globalThis as any).__hadarsUnsuspend = unsuspendForRender;
+                bodyHtml = renderToString(ReactPage);
+            } finally {
+                (globalThis as any).__hadarsUnsuspend = null;
             }
-
-            controller.enqueue(encoder.encode(postContent));
+            controller.enqueue(encoder.encode(bodyHtml + postContent));
             controller.close();
         },
     });
@@ -289,6 +176,24 @@ async function buildSsrResponse(
     });
 }
 
+/** Serialize a HadarsRequest into a structure-clonable object for postMessage. */
+async function serializeRequest(req: any): Promise<SerializableRequest> {
+    const isGetOrHead = ['GET', 'HEAD'].includes(req.method ?? 'GET');
+    const body = isGetOrHead ? null : new Uint8Array(await req.clone().arrayBuffer());
+    const headers: Record<string, string> = {};
+    (req.headers as Headers).forEach((v: string, k: string) => { headers[k] = v; });
+    return {
+        url: req.url,
+        method: req.method ?? 'GET',
+        headers,
+        body,
+        pathname: req.pathname,
+        search: req.search,
+        location: req.location,
+        cookies: req.cookies,
+    };
+}
+
 /**
  * Returns a function that parses `out.html` into pre-head, post-head, and
  * post-content segments and caches the result. Call the returned function with
@@ -593,7 +498,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
             getFinalProps,
         } = (await import(importPath)) as HadarsEntryModule<any>;
 
-        const { ReactPage, status, headHtml } = await getReactResponse(request, {
+        const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
             document: {
                 body: Component as React.FC<HadarsProps<object>>,
                 lang: 'en',
@@ -603,7 +508,8 @@ export const dev = async (options: HadarsRuntimeOptions) => {
             },
         });
 
-        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true); // no pool in dev
+        const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
+        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
     }, options.websocket);
 };
 
@@ -628,8 +534,6 @@ export const build = async (options: HadarsRuntimeOptions) => {
     const tmpFilePath = pathMod.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
     await fs.writeFile(tmpFilePath, clientScript);
 
-    const randomStr = crypto.randomBytes(6).toString('hex');
-
     // Compile client and SSR bundles in parallel — they write to different
     // output directories and use different entry files, so they are fully
     // independent and safe to run concurrently.
@@ -638,13 +542,15 @@ export const build = async (options: HadarsRuntimeOptions) => {
         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: pathMod.resolve(__dirname, StaticPath),
             },
             base: options.baseURL,
             mode: 'production',
             swcPlugins: options.swcPlugins,
             define: options.define,
+            optimization: options.optimization,
         }),
         compileEntry(pathMod.resolve(__dirname, options.entry), {
             output: {
@@ -662,11 +568,6 @@ export const build = async (options: HadarsRuntimeOptions) => {
         }),
     ]);
     await fs.rm(tmpFilePath);
-
-    await fs.writeFile(
-        pathMod.join(__dirname, HadarsFolder, 'hadars.json'),
-        JSON.stringify({ buildId: randomStr }),
-    );
     console.log("Build complete.");
 };
 
@@ -762,6 +663,17 @@ export const run = async (options: HadarsRuntimeOptions) => {
             getFinalProps,
         } = (await import(componentPath)) as HadarsEntryModule<any>;
 
+        if (renderPool) {
+            // Worker runs the full lifecycle — no non-serializable objects cross the thread boundary.
+            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 as React.FC<HadarsProps<object>>,
@@ -772,6 +684,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
             },
         });
 
-        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, renderPool, renderPayload);
+        const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
+        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
     }, options.websocket);
 };

package/src/ssr-render-worker.ts

@@ -1,23 +1,15 @@
 /**
  * SSR render worker — runs in a node:worker_threads thread.
  *
- * Handles three message types sent by RenderWorkerPool in build.ts:
+ * Handles one message type sent by RenderWorkerPool in build.ts:
  *
- *   { type: 'staticMarkup', id, props }
- *     → renderToStaticMarkup(_Component, props)
- *     → postMessage({ id, type: 'staticMarkup', html, context: props.context })
- *
- *   { type: 'renderString', id, appProps, clientProps }
+ *   { type: 'renderFull', id, request: SerializableRequest }
+ *     → runs full lifecycle (getInitProps → render loop → getAfterRenderProps → getFinalProps)
  *     → renderToString(ReactPage)
- *     → postMessage({ id, html })
- *
- *   { type: 'renderStream', id, appProps, clientProps }
- *     → renderToReadableStream(ReactPage) — streams chunks back
- *     → postMessage({ id, type: 'chunk', chunk }) × N
- *     → postMessage({ id, type: 'done' })
+ *     → postMessage({ id, html, headHtml, status })
  *
  * The SSR bundle path is passed once via workerData at thread creation time so
- * the component is only imported once per worker lifetime.
+ * the SSR module is only imported once per worker lifetime.
  */
 
 import { workerData, parentPort } from 'node:worker_threads';
@@ -32,11 +24,11 @@ const { ssrBundlePath } = workerData as { ssrBundlePath: string };
 let _React: any = null;
 let _renderToStaticMarkup: ((element: any) => string) | null = null;
 let _renderToString: ((element: any) => string) | null = null;
-let _renderToReadableStream: ((element: any, options?: any) => Promise<ReadableStream<Uint8Array>>) | null = null;
-let _Component: any = null;
+// Full SSR module — includes default (App component) + lifecycle exports.
+let _ssrMod: any = null;
 
 async function init() {
-    if (_React && _renderToStaticMarkup && _renderToString && _renderToReadableStream && _Component) return;
+    if (_React && _ssrMod) return;
 
     const req = createRequire(pathMod.resolve(process.cwd(), '__ninety_fake__.js'));
 
@@ -53,25 +45,59 @@ async function init() {
         _renderToStaticMarkup = serverMod.renderToStaticMarkup;
     }
 
-    if (!_renderToReadableStream) {
-        const browserPath = pathToFileURL(req.resolve('react-dom/server.browser')).href;
-        const browserMod = await import(browserPath);
-        _renderToReadableStream = browserMod.renderToReadableStream;
+    if (!_ssrMod) {
+        _ssrMod = await import(pathToFileURL(ssrBundlePath).href);
     }
+}
 
-    if (!_Component) {
-        const ssrMod = await import(pathToFileURL(ssrBundlePath).href);
-        _Component = ssrMod.default;
-    }
+export type SerializableRequest = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: Uint8Array | null;
+    pathname: string;
+    search: string;
+    location: string;
+    cookies: Record<string, string>;
+};
+
+function deserializeRequest(s: SerializableRequest): any {
+    const init: RequestInit = { method: s.method, headers: new Headers(s.headers) };
+    if (s.body) init.body = s.body;
+    const req = new Request(s.url, init);
+    Object.assign(req, {
+        pathname: s.pathname,
+        search: s.search,
+        location: s.location,
+        cookies: s.cookies,
+    });
+    return req;
 }
 
-// Build the full ReactPage element tree — mirrors the shape in response.tsx / build.ts.
-// Uses React.createElement to avoid needing a JSX transform in the worker.
-function buildReactPage(R: any, appProps: Record<string, unknown>, clientProps: Record<string, unknown>) {
+function buildHeadHtml(head: any): string {
+    const R = _React;
+    const metaEntries = Object.entries(head.meta ?? {});
+    const linkEntries = Object.entries(head.link ?? {});
+    const styleEntries = Object.entries(head.style ?? {});
+    const scriptEntries = Object.entries(head.script ?? {});
+    return _renderToStaticMarkup!(
+        R.createElement(R.Fragment, null,
+            R.createElement('title', null, head.title),
+            ...metaEntries.map(([id, opts]) => R.createElement('meta', { key: id, id, ...(opts as any) })),
+            ...linkEntries.map(([id, opts]) => R.createElement('link', { key: id, id, ...(opts as any) })),
+            ...styleEntries.map(([id, opts]) => R.createElement('style', { key: id, id, ...(opts as any) })),
+            ...scriptEntries.map(([id, opts]) => R.createElement('script', { key: id, id, ...(opts as any) })),
+        )
+    );
+}
+
+function buildReactPage(appProps: any, clientProps: any) {
+    const R = _React;
+    const Component = _ssrMod.default;
     return R.createElement(
         R.Fragment, null,
         R.createElement('div', { id: 'app' },
-            R.createElement(_Component, appProps),
+            R.createElement(Component, appProps),
         ),
         R.createElement('script', {
             id: 'hadars',
@@ -83,56 +109,98 @@ function buildReactPage(R: any, appProps: Record<string, unknown>, clientProps:
     );
 }
 
-parentPort!.on('message', async (msg: any) => {
-    const { id, type } = msg;
-    try {
-        await init();
-        const R = _React;
-
-        // Expose the resolved useServerData() cache to the SSR bundle via
-        // globalThis.__hadarsUnsuspend — same bridge used on the main thread.
-        // Safe in a worker because rendering is sequential (no concurrent requests).
-        const unsuspend = (msg.appProps?.context as any)?._unsuspend ?? null;
-
-        // ── renderStream — streaming response via ReadableStream chunks ───────────
-        if (type === 'renderStream') {
-            const { appProps, clientProps } = msg as {
-                appProps: Record<string, unknown>;
-                clientProps: Record<string, unknown>;
-            };
-            const ReactPage = buildReactPage(R, appProps, clientProps);
+async function runFullLifecycle(serialReq: SerializableRequest) {
+    const R = _React;
+    const Component = _ssrMod.default;
+    const { getInitProps, getAfterRenderProps, getFinalProps } = _ssrMod;
+
+    const parsedReq = deserializeRequest(serialReq);
+
+    const unsuspend: any = { cache: new Map(), hasPending: false };
+    const context: any = {
+        head: { title: 'Hadars App', meta: {}, link: {}, style: {}, script: {}, status: 200 },
+        _unsuspend: unsuspend,
+    };
+
+    let props: any = {
+        ...(getInitProps ? await getInitProps(parsedReq) : {}),
+        location: serialReq.location,
+        context,
+    };
+
+    // useServerData render loop — same logic as getReactResponse on main thread.
+    let html = '';
+    let iters = 0;
+    do {
+        unsuspend.hasPending = false;
+        try {
             (globalThis as any).__hadarsUnsuspend = unsuspend;
-            const stream = await _renderToReadableStream!(ReactPage);
+            html = _renderToStaticMarkup!(R.createElement(Component, props));
+        } finally {
             (globalThis as any).__hadarsUnsuspend = null;
-            const reader = stream.getReader();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                // Transfer the underlying ArrayBuffer to avoid a copy across threads.
-                parentPort!.postMessage({ id, type: 'chunk', chunk: value }, [value.buffer as ArrayBuffer]);
-            }
-            parentPort!.postMessage({ id, type: 'done' });
-            return;
         }
+        if (unsuspend.hasPending) {
+            const pending = [...unsuspend.cache.values()]
+                .filter((e: any) => e.status === 'pending')
+                .map((e: any) => e.promise);
+            await Promise.all(pending);
+        }
+    } while (unsuspend.hasPending && ++iters < 25);
+
+    props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
 
-        // ── renderString (type === 'renderString' or legacy messages) ────────────
-        const { appProps, clientProps } = msg as {
-            appProps: Record<string, unknown>;
-            clientProps: Record<string, unknown>;
-        };
-        const ReactPage = buildReactPage(R, appProps, clientProps);
+    // Re-render to capture head changes from getAfterRenderProps.
+    try {
         (globalThis as any).__hadarsUnsuspend = unsuspend;
-        const html = _renderToString!(ReactPage);
+        _renderToStaticMarkup!(R.createElement(Component, { ...props, location: serialReq.location, context }));
+    } finally {
         (globalThis as any).__hadarsUnsuspend = null;
-        parentPort!.postMessage({ id, html });
+    }
+
+    // Collect resolved useServerData values for client hydration.
+    const serverData: Record<string, unknown> = {};
+    for (const [k, v] of unsuspend.cache) {
+        if ((v as any).status === 'fulfilled') serverData[k] = (v as any).value;
+        if ((v as any).status === 'suspense-cached') serverData[k] = (v as any).value;
+    }
+
+    const { context: _ctx, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+    const clientProps = {
+        ...restProps,
+        location: serialReq.location,
+        ...(Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}),
+    };
+
+    const headHtml = buildHeadHtml(context.head);
+    const status: number = context.head.status ?? 200;
+    const finalAppProps = { ...props, location: serialReq.location, context };
+
+    return { finalAppProps, clientProps, headHtml, status, unsuspend };
+}
+
+parentPort!.on('message', async (msg: any) => {
+    const { id, type, request } = msg;
+    try {
+        await init();
+
+        if (type !== 'renderFull') return;
+
+        const { finalAppProps, clientProps, headHtml, status, unsuspend } =
+            await runFullLifecycle(request as SerializableRequest);
+
+        const ReactPage = buildReactPage(finalAppProps, clientProps);
+
+        let html: string;
+        try {
+            (globalThis as any).__hadarsUnsuspend = unsuspend;
+            html = _renderToString!(ReactPage);
+        } finally {
+            (globalThis as any).__hadarsUnsuspend = null;
+        }
+        parentPort!.postMessage({ id, html, headHtml, status });
 
     } catch (err: any) {
         (globalThis as any).__hadarsUnsuspend = null;
-        const errMsg = err?.message ?? String(err);
-        if (type === 'renderStream') {
-            parentPort!.postMessage({ id, type: 'error', error: errMsg });
-        } else {
-            parentPort!.postMessage({ id, error: errMsg });
-        }
+        parentPort!.postMessage({ id, error: err?.message ?? String(err) });
     }
 });

package/src/types/ninety.ts

@@ -84,15 +84,15 @@ export interface HadarsOptions {
      *
      * **Bun / Deno** — creates a `node:worker_threads` render pool of this size.
      * Each thread handles the synchronous `renderToString` step, freeing the
-     * main event loop for I/O. Only applies when `streaming` is `false` (the default).
+     * main event loop for I/O.
      */
     workers?: number;
     /**
-     * Whether to use streaming SSR (`renderToReadableStream`) for rendering React
-     * components. Defaults to `false`. Set to `true` to use streaming via
-     * `renderToReadableStream` instead of the synchronous `renderToString`.
+     * Override or extend rspack's `optimization` config for production client builds.
+     * Merged on top of hadars defaults (splitChunks vendor splitting, deterministic moduleIds).
+     * Has no effect on the SSR bundle or dev mode.
      */
-    streaming?: boolean;
+    optimization?: Record<string, unknown>;
 }
 
 

package/src/utils/rspack.ts

@@ -138,6 +138,8 @@ interface EntryOptions {
     // optional compile-time defines (e.g. { 'process.env.NODE_ENV': '"development"' })
     define?: Record<string, string>;
     base?: string;
+    // optional rspack optimization overrides (production client builds only)
+    optimization?: Record<string, unknown>;
 }
 
 const buildCompilerConfig = (
@@ -258,6 +260,25 @@ const buildCompilerConfig = (
         mainFields: isServerBuild ? ['main', 'module'] : ['browser', 'module', 'main'],
     };
 
+    // Production client builds get vendor splitting and deterministic module IDs.
+    // User-supplied optimization is merged on top so it can extend or override defaults.
+    // Dev and SSR builds skip this — splitChunks slows HMR, SSR uses externals instead.
+    const optimization: any = (!isServerBuild && !isDev) ? {
+        moduleIds: 'deterministic',
+        splitChunks: {
+            chunks: 'all',
+            cacheGroups: {
+                react: {
+                    test: /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/,
+                    name: 'vendor-react',
+                    chunks: 'all' as const,
+                    priority: 20,
+                },
+            },
+        },
+        ...(opts.optimization ?? {}),
+    } : (opts.optimization ? { ...opts.optimization } : undefined);
+
     return {
         entry,
         output: {
@@ -266,6 +287,7 @@ const buildCompilerConfig = (
         },
         mode: opts.mode,
         externals,
+        ...(optimization !== undefined ? { optimization } : {}),
         plugins: [
             new rspack.HtmlRspackPlugin({
                 publicPath: base || '/',