hadars 0.1.8 → 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,32 +775,10 @@ 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, headHtml, status, error, chunk } = msg;
+          const { id, html, headHtml, status, error } = 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)
@@ -829,13 +812,7 @@ 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);
@@ -868,82 +845,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();
     }
   });
@@ -1233,7 +1153,7 @@ var dev = async (options) => {
       }
     });
     const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, unsuspend);
+    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
   }, options.websocket);
 };
 var build = async (options) => {
@@ -1250,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: {
@@ -1280,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) => {
@@ -1364,36 +1281,12 @@ var run = async (options) => {
     } = 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 {
-        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 { 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: {
@@ -1405,7 +1298,7 @@ var run = async (options) => {
       }
     });
     const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
-    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, unsuspend);
+    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,7 +7,6 @@ var { ssrBundlePath } = workerData;
 var _React = null;
 var _renderToStaticMarkup = null;
 var _renderToString = null;
-var _renderToReadableStream = null;
 var _ssrMod = null;
 async function init() {
   if (_React && _ssrMod)
@@ -24,11 +23,6 @@ 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 (!_ssrMod) {
     _ssrMod = await import(pathToFileURL(ssrBundlePath).href);
   }
@@ -140,48 +134,23 @@ async function runFullLifecycle(serialReq) {
   return { finalAppProps, clientProps, headHtml, status, unsuspend };
 }
 parentPort.on("message", async (msg) => {
-  const { id, type, request, streaming } = msg;
+  const { id, type, request } = msg;
   try {
     await init();
     if (type !== "renderFull")
       return;
     const { finalAppProps, clientProps, headHtml, status, unsuspend } = await runFullLifecycle(request);
     const ReactPage = buildReactPage(finalAppProps, clientProps);
-    if (streaming) {
-      parentPort.postMessage({ id, type: "head", headHtml, status });
-      let streamPromise;
-      try {
-        globalThis.__hadarsUnsuspend = unsuspend;
-        streamPromise = _renderToReadableStream(ReactPage);
-      } finally {
-        globalThis.__hadarsUnsuspend = null;
-      }
-      const stream = await streamPromise;
-      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" });
-    } else {
-      let html;
-      try {
-        globalThis.__hadarsUnsuspend = unsuspend;
-        html = _renderToString(ReactPage);
-      } finally {
-        globalThis.__hadarsUnsuspend = null;
-      }
-      parentPort.postMessage({ id, html, headHtml, status });
+    let html;
+    try {
+      globalThis.__hadarsUnsuspend = unsuspend;
+      html = _renderToString(ReactPage);
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
     }
+    parentPort.postMessage({ id, html, headHtml, status });
   } catch (err) {
     globalThis.__hadarsUnsuspend = null;
-    const errMsg = err?.message ?? String(err);
-    if (streaming) {
-      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.8",
+  "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,10 +35,6 @@ 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
 
 import type { SerializableRequest } from './ssr-render-worker';
 
@@ -65,14 +43,7 @@ type PendingRenderFull = {
     resolve: (result: { html: string; headHtml: string; status: number }) => void;
     reject: (err: Error) => void;
 };
-type PendingRenderFullStream = {
-    kind: 'renderFullStream';
-    headSettled: boolean;
-    headResolve: (result: { headHtml: string; status: number }) => void;
-    headReject: (err: Error) => void;
-    controller: ReadableStreamDefaultController<Uint8Array>;
-};
-type PendingEntry = PendingRenderFull | PendingRenderFullStream;
+type PendingEntry = PendingRenderFull;
 
 class RenderWorkerPool {
     private workers: any[] = [];
@@ -95,32 +66,9 @@ class RenderWorkerPool {
                 const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
                 this.workerPending.set(w, new Set());
                 w.on('message', (msg: any) => {
-                    const { id, type, html, headHtml, status, error, chunk } = msg;
+                    const { id, html, headHtml, status, error } = 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 as Uint8Array);
-                            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;
-                    }
-
-                    // renderFull (non-streaming)
                     this.pending.delete(id);
                     this.workerPending.get(w)?.delete(id);
                     if (error) p.reject(new Error(error));
@@ -153,11 +101,7 @@ class RenderWorkerPool {
                 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);
@@ -189,36 +133,6 @@ class RenderWorkerPool {
         });
     }
 
-    /** Run the full SSR lifecycle in a worker thread, streaming the response. */
-    renderFullStream(req: SerializableRequest): { head: Promise<{ headHtml: string; status: number }>; stream: ReadableStream<Uint8Array> } {
-        let headResolve!: (r: { headHtml: string; status: number }) => void;
-        let headReject!: (err: Error) => void;
-        const head = new Promise<{ headHtml: string; status: number }>((res, rej) => {
-            headResolve = res; headReject = rej;
-        });
-        let controller!: ReadableStreamDefaultController<Uint8Array>;
-        const stream = new ReadableStream<Uint8Array>({ 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 as Error); controller.error(err); });
-        }
-        return { head, stream };
-    }
-
     async terminate(): Promise<void> {
         await Promise.all(this.workers.map((w: any) => w.terminate()));
     }
@@ -229,56 +143,29 @@ async function buildSsrResponse(
     headHtml: string,
     status: number,
     getPrecontentHtml: (headHtml: string) => Promise<[string, string]>,
-    streaming: boolean,
     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 ? await getRenderToString() : null;
-    const renderReadableStream = streaming ? await getReadableStreamRenderer() : null;
-
-    if (!streaming) {
-        const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-        let bodyHtml: string;
-        // 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
 
-            // 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>>;
+            // set → call (synchronous) → clear: no await in between, safe under concurrency
+            let bodyHtml: string;
             try {
                 (globalThis as any).__hadarsUnsuspend = unsuspendForRender;
-                streamPromise = renderReadableStream!(ReactPage);
+                bodyHtml = renderToString(ReactPage);
             } finally {
                 (globalThis as any).__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();
         },
     });
@@ -622,7 +509,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
         });
 
         const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
-        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, unsuspend);
+        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
     }, options.websocket);
 };
 
@@ -647,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.
@@ -657,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: {
@@ -681,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.");
 };
 
@@ -784,35 +666,12 @@ export const run = async (options: HadarsRuntimeOptions) => {
         if (renderPool) {
             // Worker runs the full lifecycle — no non-serializable objects cross the thread boundary.
             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 {
-                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 { 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, {
@@ -826,6 +685,6 @@ export const run = async (options: HadarsRuntimeOptions) => {
         });
 
         const unsuspend = (renderPayload.appProps.context as any)?._unsuspend ?? null;
-        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, unsuspend);
+        return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
     }, options.websocket);
 };

package/src/ssr-render-worker.ts

@@ -3,18 +3,11 @@
  *
  * Handles one message type sent by RenderWorkerPool in build.ts:
  *
- *   { type: 'renderFull', id, streaming: false, request: SerializableRequest }
+ *   { type: 'renderFull', id, request: SerializableRequest }
  *     → runs full lifecycle (getInitProps → render loop → getAfterRenderProps → getFinalProps)
  *     → renderToString(ReactPage)
  *     → postMessage({ id, html, headHtml, status })
  *
- *   { type: 'renderFull', id, streaming: true, request: SerializableRequest }
- *     → runs full lifecycle
- *     → renderToReadableStream(ReactPage), streams chunks back
- *     → postMessage({ id, type: 'head', headHtml, status })
- *     → postMessage({ id, type: 'chunk', chunk }) × N
- *     → postMessage({ id, type: 'done' })
- *
  * The SSR bundle path is passed once via workerData at thread creation time so
  * the SSR module is only imported once per worker lifetime.
  */
@@ -31,7 +24,6 @@ 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;
 // Full SSR module — includes default (App component) + lifecycle exports.
 let _ssrMod: any = null;
 
@@ -53,12 +45,6 @@ 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);
     }
@@ -193,7 +179,7 @@ async function runFullLifecycle(serialReq: SerializableRequest) {
 }
 
 parentPort!.on('message', async (msg: any) => {
-    const { id, type, request, streaming } = msg;
+    const { id, type, request } = msg;
     try {
         await init();
 
@@ -204,41 +190,17 @@ parentPort!.on('message', async (msg: any) => {
 
         const ReactPage = buildReactPage(finalAppProps, clientProps);
 
-        if (streaming) {
-            parentPort!.postMessage({ id, type: 'head', headHtml, status });
-            let streamPromise: Promise<ReadableStream<Uint8Array>>;
-            try {
-                (globalThis as any).__hadarsUnsuspend = unsuspend;
-                streamPromise = _renderToReadableStream!(ReactPage);
-            } finally {
-                (globalThis as any).__hadarsUnsuspend = null;
-            }
-            const stream = await streamPromise;
-            const reader = stream.getReader();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                parentPort!.postMessage({ id, type: 'chunk', chunk: value }, [value.buffer as ArrayBuffer]);
-            }
-            parentPort!.postMessage({ id, type: 'done' });
-        } else {
-            let html: string;
-            try {
-                (globalThis as any).__hadarsUnsuspend = unsuspend;
-                html = _renderToString!(ReactPage);
-            } finally {
-                (globalThis as any).__hadarsUnsuspend = null;
-            }
-            parentPort!.postMessage({ id, html, headHtml, status });
+        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 (streaming) {
-            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 || '/',