hadars 0.1.6 → 0.1.8

package/dist/cli.js

@@ -770,11 +770,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, type, html, headHtml, status, error, chunk } = msg;
           const p = this.pending.get(id);
           if (!p)
             return;
-          if (p.kind === "renderStream") {
+          if (p.kind === "renderFullStream") {
+            if (type === "head") {
+              p.headSettled = true;
+              p.headResolve({ headHtml, status });
+              return;
+            }
             if (type === "chunk") {
               p.controller.enqueue(chunk);
               return;
@@ -783,8 +788,12 @@ var RenderWorkerPool = class {
             this.workerPending.get(w)?.delete(id);
             if (type === "done")
               p.controller.close();
-            else
-              p.controller.error(new Error(error ?? "Stream error"));
+            else {
+              const err = new Error(error ?? "Stream error");
+              if (!p.headSettled)
+                p.headReject(err);
+              p.controller.error(err);
+            }
             return;
           }
           this.pending.delete(id);
@@ -792,7 +801,7 @@ var RenderWorkerPool = class {
           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 +829,13 @@ var RenderWorkerPool = class {
         const p = this.pending.get(id);
         if (p) {
           this.pending.delete(id);
-          if (p.kind === "renderString")
+          if (p.kind === "renderFull")
             p.reject(err);
-          else
+          else {
+            if (!p.headSettled)
+              p.headReject(err);
             p.controller.error(err);
+          }
         }
       }
       this.workerPending.delete(w);
@@ -836,8 +848,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 +857,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,52 +868,56 @@ 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;
-      }
+  /** 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(() => controller.error(new Error("[hadars] No render workers available")));
-      return stream;
+      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: "renderStream", controller });
+    this.pending.set(id, { kind: "renderFullStream", headSettled: false, headResolve, headReject, controller });
     this.workerPending.get(w)?.add(id);
     try {
-      w.postMessage({ id, type: "renderStream", appProps, clientProps });
+      w.postMessage({ id, type: "renderFull", streaming: true, request: req });
     } catch (err) {
       this.pending.delete(id);
       this.workerPending.get(w)?.delete(id);
-      queueMicrotask(() => controller.error(err));
+      queueMicrotask(() => {
+        headReject(err);
+        controller.error(err);
+      });
     }
-    return stream;
+    return { head, 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;
+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;
-    if (renderPool && renderPayload) {
-      bodyHtml = await renderPool.renderString(renderPayload.appProps, renderPayload.clientProps);
-    } else {
-      try {
-        globalThis.__hadarsUnsuspend = unsuspendForRender;
-        bodyHtml = renderToString(ReactPage);
-      } finally {
-        globalThis.__hadarsUnsuspend = null;
-      }
+    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" },
@@ -912,19 +928,14 @@ async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml,
     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;
+      let streamPromise;
+      try {
+        globalThis.__hadarsUnsuspend = unsuspendForRender;
+        streamPromise = renderReadableStream(ReactPage);
+      } finally {
+        globalThis.__hadarsUnsuspend = null;
       }
+      const bodyStream = await streamPromise;
       const reader = bodyStream.getReader();
       while (true) {
         const { done, value } = await reader.read();
@@ -941,6 +952,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 +1223,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 +1232,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, options.streaming === true, unsuspend);
   }, options.websocket);
 };
 var build = async (options) => {
@@ -1332,6 +1362,39 @@ var run = async (options) => {
       getAfterRenderProps,
       getFinalProps
     } = await import(componentPath);
+    if (renderPool) {
+      const serialReq = await serializeRequest(request);
+      if (options.streaming) {
+        const { head, stream } = renderPool.renderFullStream(serialReq);
+        const { headHtml: wHead, status: wStatus } = await head;
+        const [precontentHtml, postContent] = await getPrecontentHtml(wHead);
+        const responseStream = new ReadableStream({
+          async start(controller) {
+            controller.enqueue(encoder.encode(precontentHtml));
+            const reader = stream.getReader();
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              controller.enqueue(value);
+            }
+            controller.enqueue(encoder.encode(postContent));
+            controller.close();
+          }
+        });
+        return new Response(responseStream, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+          status: wStatus
+        });
+      } else {
+        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 +1404,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, options.streaming === true, unsuspend);
   }, options.websocket);
 };
 

package/dist/ssr-render-worker.js

@@ -8,9 +8,9 @@ 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) {
@@ -29,19 +29,51 @@ async function init() {
     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,18 +84,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, streaming } = 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);
-      globalThis.__hadarsUnsuspend = unsuspend;
-      const stream = await _renderToReadableStream(ReactPage2);
-      globalThis.__hadarsUnsuspend = null;
+    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();
@@ -72,18 +165,20 @@ parentPort.on("message", async (msg) => {
         parentPort.postMessage({ id, type: "chunk", chunk: value }, [value.buffer]);
       }
       parentPort.postMessage({ id, type: "done" });
-      return;
+    } else {
+      let html;
+      try {
+        globalThis.__hadarsUnsuspend = unsuspend;
+        html = _renderToString(ReactPage);
+      } finally {
+        globalThis.__hadarsUnsuspend = null;
+      }
+      parentPort.postMessage({ id, html, headHtml, status });
     }
-    const { appProps, clientProps } = msg;
-    const ReactPage = buildReactPage(R, appProps, clientProps);
-    globalThis.__hadarsUnsuspend = unsuspend;
-    const html = _renderToString(ReactPage);
-    globalThis.__hadarsUnsuspend = null;
-    parentPort.postMessage({ id, html });
   } catch (err) {
     globalThis.__hadarsUnsuspend = null;
     const errMsg = err?.message ?? String(err);
-    if (type === "renderStream") {
+    if (streaming) {
       parentPort.postMessage({ id, type: "error", error: errMsg });
     } else {
       parentPort.postMessage({ id, error: errMsg });

package/package.json

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

package/src/build.ts

@@ -58,16 +58,21 @@ async function getRenderToString(): Promise<(element: any) => string> {
 //   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';
+type PendingRenderFullStream = {
+    kind: 'renderFullStream';
+    headSettled: boolean;
+    headResolve: (result: { headHtml: string; status: number }) => void;
+    headReject: (err: Error) => void;
     controller: ReadableStreamDefaultController<Uint8Array>;
 };
-type PendingEntry = PendingRenderString | PendingRenderStream;
+type PendingEntry = PendingRenderFull | PendingRenderFullStream;
 
 class RenderWorkerPool {
     private workers: any[] = [];
@@ -90,27 +95,36 @@ 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, type, html, headHtml, status, error, chunk } = msg;
                     const p = this.pending.get(id);
                     if (!p) return;
 
-                    if (p.kind === 'renderStream') {
+                    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; // keep entry until 'done'
+                            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'));
+                        else {
+                            const err = new Error(error ?? 'Stream error');
+                            if (!p.headSettled) p.headReject(err);
+                            p.controller.error(err);
+                        }
                         return;
                     }
 
-                    // renderString
+                    // renderFull (non-streaming)
                     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 +144,20 @@ 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);
+                    if (p.kind === 'renderFull') p.reject(err);
+                    else {
+                        if (!p.headSettled) p.headReject(err);
+                        p.controller.error(err);
+                    }
                 }
             }
             this.workerPending.delete(w);
@@ -156,19 +171,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,32 +189,34 @@ 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; },
+    /** 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) {
-            // Immediately error the stream if no workers are available.
-            queueMicrotask(() => controller.error(new Error('[hadars] No render workers available')));
-            return stream;
+            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++;
-        // Store controller before postMessage so the handler is ready when
-        // the first chunk arrives.
-        this.pending.set(id, { kind: 'renderStream', controller });
+        this.pending.set(id, { kind: 'renderFullStream', headSettled: false, headResolve, headReject, controller });
         this.workerPending.get(w)?.add(id);
         try {
-            w.postMessage({ id, type: 'renderStream', appProps, clientProps });
+            w.postMessage({ id, type: 'renderFull', streaming: true, request: req });
         } catch (err) {
             this.pending.delete(id);
             this.workerPending.get(w)?.delete(id);
-            queueMicrotask(() => controller.error(err));
+            queueMicrotask(() => { headReject(err as Error); controller.error(err); });
         }
-        return stream;
+        return { head, stream };
     }
 
     async terminate(): Promise<void> {
@@ -216,33 +230,24 @@ async function buildSsrResponse(
     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;
+    const renderToString = !streaming ? await getRenderToString() : null;
+    const renderReadableStream = streaming ? await getReadableStreamRenderer() : 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;
-            }
+        // 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' },
@@ -255,22 +260,17 @@ async function buildSsrResponse(
             const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
             controller.enqueue(encoder.encode(precontentHtml));
 
-            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;
+            // 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;
             }
+            const bodyStream = await streamPromise;
             const reader = bodyStream.getReader();
             while (true) {
                 const { done, value } = await reader.read();
@@ -289,6 +289,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 +611,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 +621,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, options.streaming === true, unsuspend);
     }, options.websocket);
 };
 
@@ -762,6 +781,40 @@ 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);
+            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 { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
             document: {
                 body: Component as React.FC<HadarsProps<object>>,
@@ -772,6 +825,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, options.streaming === true, unsuspend);
     }, options.websocket);
 };

package/src/ssr-render-worker.ts

@@ -1,23 +1,22 @@
 /**
  * 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, streaming: false, request: SerializableRequest }
+ *     → runs full lifecycle (getInitProps → render loop → getAfterRenderProps → getFinalProps)
  *     → renderToString(ReactPage)
- *     → postMessage({ id, html })
+ *     → postMessage({ id, html, headHtml, status })
  *
- *   { type: 'renderStream', id, appProps, clientProps }
- *     → renderToReadableStream(ReactPage) — streams chunks back
+ *   { 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 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';
@@ -33,10 +32,11 @@ 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'));
 
@@ -59,19 +59,59 @@ async function init() {
         _renderToReadableStream = browserMod.renderToReadableStream;
     }
 
-    if (!_Component) {
-        const ssrMod = await import(pathToFileURL(ssrBundlePath).href);
-        _Component = ssrMod.default;
+    if (!_ssrMod) {
+        _ssrMod = await import(pathToFileURL(ssrBundlePath).href);
     }
 }
 
-// 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>) {
+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;
+}
+
+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,53 +123,119 @@ function buildReactPage(R: any, appProps: Record<string, unknown>, 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;
+            html = _renderToStaticMarkup!(R.createElement(Component, props));
+        } finally {
+            (globalThis as any).__hadarsUnsuspend = null;
+        }
+        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;
+
+    // Re-render to capture head changes from getAfterRenderProps.
+    try {
+        (globalThis as any).__hadarsUnsuspend = unsuspend;
+        _renderToStaticMarkup!(R.createElement(Component, { ...props, location: serialReq.location, context }));
+    } finally {
+        (globalThis as any).__hadarsUnsuspend = null;
+    }
+
+    // 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 } = msg;
+    const { id, type, request, streaming } = 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);
-            (globalThis as any).__hadarsUnsuspend = unsuspend;
-            const stream = await _renderToReadableStream!(ReactPage);
-            (globalThis as any).__hadarsUnsuspend = null;
+
+        if (type !== 'renderFull') return;
+
+        const { finalAppProps, clientProps, headHtml, status, unsuspend } =
+            await runFullLifecycle(request as SerializableRequest);
+
+        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;
-                // 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;
+        } 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 });
         }
 
-        // ── 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);
-        (globalThis as any).__hadarsUnsuspend = unsuspend;
-        const html = _renderToString!(ReactPage);
-        (globalThis as any).__hadarsUnsuspend = null;
-        parentPort!.postMessage({ id, html });
-
     } catch (err: any) {
         (globalThis as any).__hadarsUnsuspend = null;
         const errMsg = err?.message ?? String(err);
-        if (type === 'renderStream') {
+        if (streaming) {
             parentPort!.postMessage({ id, type: 'error', error: errMsg });
         } else {
             parentPort!.postMessage({ id, error: errMsg });