hadars 0.1.4 → 0.1.6

package/README.md

@@ -49,12 +49,11 @@ export default App;
 
 ## CLI
 
-After installing hadars the `hadars` (Node.js) and `hadars-bun` (Bun) binaries are available:
+After installing hadars the `hadars` binary is available. It works on Node.js, Bun, and Deno — the runtime is auto-detected:
 
 ```bash
 # Development server with React Fast Refresh HMR
 hadars dev
-hadars-bun dev     # Bun — runs TypeScript directly, no build step
 
 # Production build (client + SSR bundles compiled in parallel)
 hadars build

package/cli.ts

@@ -1,13 +1,36 @@
 #!/usr/bin/env node
+import { spawn } from 'node:child_process';
 import { runCli } from './cli-lib'
 
-runCli(process.argv).catch((err) => {
-  console.error(err)
-  // When Bun runs a script, allow non-zero exit codes to propagate
-  try {
-    process.exit(1)
-  } catch (_) {
-    // Some Bun environments may not allow process.exit; just rethrow
-    throw err
-  }
-})
+// When the #!/usr/bin/env node shebang forces Node.js as the interpreter,
+// try to re-exec with Bun so the server runs under Bun's runtime
+// (native Bun.serve, WebSocket support, etc.).
+// Falls back to Node.js silently if bun is not in PATH.
+if (typeof (globalThis as any).Bun === 'undefined' && typeof (globalThis as any).Deno === 'undefined') {
+    const child = spawn('bun', [process.argv[1], ...process.argv.slice(2)], {
+        stdio: 'inherit',
+        env: process.env,
+    });
+    const sigs = ['SIGINT', 'SIGTERM', 'SIGHUP'] as const;
+    const fwd = (sig: string) => () => { try { child.kill(sig); } catch {} };
+    for (const sig of sigs) process.on(sig, fwd(sig));
+    child.on('error', (err: any) => {
+        for (const sig of sigs) process.removeAllListeners(sig);
+        if (err.code !== 'ENOENT') { console.error(err); process.exit(1); }
+        // bun not found — fall through and run with Node.js
+        runCli(process.argv).catch((e) => {
+            console.error(e);
+            try { process.exit(1); } catch (_) { throw e; }
+        });
+    });
+    child.on('exit', (code: number | null) => process.exit(code ?? 0));
+} else {
+    runCli(process.argv).catch((err) => {
+        console.error(err)
+        try {
+            process.exit(1)
+        } catch (_) {
+            throw err
+        }
+    })
+}

package/dist/cli.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// cli.ts
+import { spawn as spawn2 } from "node:child_process";
+
 // cli-lib.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -48,35 +51,38 @@ var createProxyHandler = (options) => {
   }
   const proxyRules = Object.entries(proxy).sort((a, b) => b[0].length - a[0].length);
   return async (req) => {
-    if (req.method === "OPTIONS" && options.proxyCORS) {
-      return new Response(null, {
-        status: 204,
-        headers: getCORSHeaders(req)
-      });
-    }
     for (const [path2, target] of proxyRules) {
       if (req.pathname.startsWith(path2)) {
+        if (req.method === "OPTIONS" && proxyCORS) {
+          return new Response(null, {
+            status: 204,
+            headers: getCORSHeaders(req)
+          });
+        }
         const targetURL = new URL(target);
         targetURL.pathname = targetURL.pathname.replace(/\/$/, "") + req.pathname.slice(path2.length);
         targetURL.search = req.search;
         const sendHeaders = cloneHeaders(req.headers);
         sendHeaders.set("Host", targetURL.host);
+        const hasBody = !["GET", "HEAD"].includes(req.method);
         const proxyReq = new Request(targetURL.toString(), {
           method: req.method,
           headers: sendHeaders,
-          body: ["GET", "HEAD"].includes(req.method) ? void 0 : req.body,
-          redirect: "follow"
+          body: hasBody ? req.body : void 0,
+          redirect: "follow",
+          // Node.js (undici) requires duplex:'half' when body is a ReadableStream
+          ...hasBody ? { duplex: "half" } : {}
         });
         const res = await fetch(proxyReq);
-        if (proxyCORS) {
-          Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
-            res.headers.set(key, value);
-          });
-        }
         const body = await res.arrayBuffer();
         const clonedRes = new Headers(res.headers);
         clonedRes.delete("content-length");
         clonedRes.delete("content-encoding");
+        if (proxyCORS) {
+          Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+            clonedRes.set(key, value);
+          });
+        }
         return new Response(body, {
           status: res.status,
           statusText: res.statusText,
@@ -257,7 +263,7 @@ var getReactResponse = async (req, opts) => {
       location: req.location,
       context
     } }) }),
-    /* @__PURE__ */ jsx("script", { id: "hadars", type: "application/json", dangerouslySetInnerHTML: { __html: JSON.stringify({ hadars: { props: clientProps } }) } })
+    /* @__PURE__ */ jsx("script", { id: "hadars", type: "application/json", dangerouslySetInnerHTML: { __html: JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c") } })
   ] });
   return {
     ReactPage,
@@ -482,7 +488,6 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
   };
   return {
     entry,
-    resolve: resolveConfig,
     output: {
       ...opts.output,
       clean: false
@@ -502,6 +507,13 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
       ...extraPlugins
     ],
     ...localConfig,
+    // Merge base resolve (modules, tsConfig, extensions) with per-build resolve
+    // (alias, mainFields). The spread order matters: resolveConfig wins for keys
+    // it defines, localConfig.resolve wins for keys it defines exclusively.
+    resolve: {
+      ...localConfig.resolve,
+      ...resolveConfig
+    },
     // HMR is not implemented for module chunk format, so disable outputModule
     // for client builds. SSR builds still need it for dynamic import() of exports.
     experiments: {
@@ -744,6 +756,9 @@ async function getRenderToString() {
 var RenderWorkerPool = class {
   workers = [];
   pending = /* @__PURE__ */ new Map();
+  // Track which pending IDs were dispatched to each worker so we can reject
+  // them when that worker crashes.
+  workerPending = /* @__PURE__ */ new Map();
   nextId = 0;
   rrIndex = 0;
   constructor(workerPath, size, ssrBundlePath) {
@@ -753,6 +768,7 @@ var RenderWorkerPool = class {
     import("node:worker_threads").then(({ Worker }) => {
       for (let i = 0; i < size; i++) {
         const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
+        this.workerPending.set(w, /* @__PURE__ */ new Set());
         w.on("message", (msg) => {
           const { id, type, html, error, chunk } = msg;
           const p = this.pending.get(id);
@@ -764,6 +780,7 @@ var RenderWorkerPool = class {
               return;
             }
             this.pending.delete(id);
+            this.workerPending.get(w)?.delete(id);
             if (type === "done")
               p.controller.close();
             else
@@ -771,6 +788,7 @@ var RenderWorkerPool = class {
             return;
           }
           this.pending.delete(id);
+          this.workerPending.get(w)?.delete(id);
           if (error)
             p.reject(new Error(error));
           else
@@ -778,6 +796,13 @@ var RenderWorkerPool = class {
         });
         w.on("error", (err) => {
           console.error("[hadars] Render worker error:", err);
+          this._handleWorkerDeath(w, err);
+        });
+        w.on("exit", (code) => {
+          if (code !== 0) {
+            console.error(`[hadars] Render worker exited with code ${code}`);
+            this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
+          }
         });
         this.workers.push(w);
       }
@@ -785,7 +810,28 @@ var RenderWorkerPool = class {
       console.error("[hadars] Failed to initialise render worker pool:", err);
     });
   }
+  _handleWorkerDeath(w, err) {
+    const idx = this.workers.indexOf(w);
+    if (idx !== -1)
+      this.workers.splice(idx, 1);
+    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);
+        }
+      }
+      this.workerPending.delete(w);
+    }
+  }
   nextWorker() {
+    if (this.workers.length === 0)
+      return void 0;
     const w = this.workers[this.rrIndex % this.workers.length];
     this.rrIndex++;
     return w;
@@ -793,9 +839,21 @@ var RenderWorkerPool = class {
   /** Offload a full renderToString call. Returns the HTML string. */
   renderString(appProps, clientProps) {
     return new Promise((resolve2, reject) => {
+      const w = this.nextWorker();
+      if (!w) {
+        reject(new Error("[hadars] No render workers available"));
+        return;
+      }
       const id = this.nextId++;
       this.pending.set(id, { kind: "renderString", resolve: resolve2, reject });
-      this.nextWorker().postMessage({ id, type: "renderString", appProps, clientProps });
+      this.workerPending.get(w)?.add(id);
+      try {
+        w.postMessage({ id, type: "renderString", appProps, clientProps });
+      } catch (err) {
+        this.pending.delete(id);
+        this.workerPending.get(w)?.delete(id);
+        reject(err);
+      }
     });
   }
   /** Offload a renderToReadableStream call. Returns a ReadableStream fed by
@@ -807,9 +865,21 @@ var RenderWorkerPool = class {
         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.nextWorker().postMessage({ id, type: "renderStream", appProps, clientProps });
+    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() {
@@ -940,10 +1010,9 @@ var dev = async (options) => {
   const hmrPort = options.hmrPort ?? port + 1;
   const packageDir2 = pathMod3.dirname(fileURLToPath2(import.meta.url));
   const clientScriptPath2 = pathMod3.resolve(packageDir2, "utils", "clientScript.tsx");
-  const headPath = pathMod3.resolve(packageDir2, "utils", "Head");
   let clientScript = "";
   try {
-    clientScript = (await fs.readFile(clientScriptPath2, "utf-8")).replace("$_MOD_PATH$", entry + getSuffix(options.mode)).replace("$_HEAD_PATH$", headPath);
+    clientScript = (await fs.readFile(clientScriptPath2, "utf-8")).replace("$_MOD_PATH$", entry + getSuffix(options.mode));
   } catch (err) {
     console.error("Failed to read client script from package dist, falling back to src", err);
     throw err;
@@ -999,6 +1068,22 @@ var dev = async (options) => {
     ...options.define ? [`--define=${JSON.stringify(options.define)}`] : []
   ], { stdio: "pipe" });
   child.stdin?.end();
+  const cleanupChild = () => {
+    try {
+      if (!child.killed)
+        child.kill();
+    } catch {
+    }
+  };
+  process.once("exit", cleanupChild);
+  process.once("SIGINT", () => {
+    cleanupChild();
+    process.exit(0);
+  });
+  process.once("SIGTERM", () => {
+    cleanupChild();
+    process.exit(0);
+  });
   const stdoutWebStream = nodeReadableToWebStream(child.stdout);
   const stderrWebStream = nodeReadableToWebStream(child.stderr);
   const marker = "ssr-watch: initial-build-complete";
@@ -1126,13 +1211,12 @@ var build = async (options) => {
   const entry = pathMod3.resolve(__dirname2, options.entry);
   const packageDir2 = pathMod3.dirname(fileURLToPath2(import.meta.url));
   const clientScriptPath2 = pathMod3.resolve(packageDir2, "utils", "clientScript.js");
-  const headPath = pathMod3.resolve(packageDir2, "utils", "Head");
   let clientScript = "";
   try {
-    clientScript = (await fs.readFile(clientScriptPath2, "utf-8")).replace("$_MOD_PATH$", entry + getSuffix(options.mode)).replace("$_HEAD_PATH$", headPath);
+    clientScript = (await fs.readFile(clientScriptPath2, "utf-8")).replace("$_MOD_PATH$", entry + getSuffix(options.mode));
   } catch (err) {
     const srcClientPath = pathMod3.resolve(packageDir2, "utils", "clientScript.tsx");
-    clientScript = (await fs.readFile(srcClientPath, "utf-8")).replace("$_MOD_PATH$", entry + `?v=${Date.now()}`).replace("$_HEAD_PATH$", pathMod3.resolve(packageDir2, "utils", "Head"));
+    clientScript = (await fs.readFile(srcClientPath, "utf-8")).replace("$_MOD_PATH$", entry + `?v=${Date.now()}`);
   }
   const tmpFilePath = pathMod3.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
   await fs.writeFile(tmpFilePath, clientScript);
@@ -1196,7 +1280,7 @@ var run = async (options) => {
   if (!isNode && workers > 1) {
     const packageDir2 = pathMod3.dirname(fileURLToPath2(import.meta.url));
     const workerJs = pathMod3.resolve(packageDir2, "ssr-render-worker.js");
-    const workerTs = pathMod3.resolve(packageDir2, "src", "ssr-render-worker.ts");
+    const workerTs = pathMod3.resolve(packageDir2, "ssr-render-worker.ts");
     const workerFile = existsSync2(workerJs) ? workerJs : workerTs;
     const ssrBundlePath = pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME);
     renderPool = new RenderWorkerPool(workerFile, workers, ssrBundlePath);
@@ -1433,11 +1517,44 @@ async function runCli(argv, cwd = process.cwd()) {
 }
 
 // cli.ts
-runCli(process.argv).catch((err) => {
-  console.error(err);
-  try {
-    process.exit(1);
-  } catch (_) {
-    throw err;
-  }
-});
+if (typeof globalThis.Bun === "undefined" && typeof globalThis.Deno === "undefined") {
+  const child = spawn2("bun", [process.argv[1], ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: process.env
+  });
+  const sigs = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const fwd = (sig) => () => {
+    try {
+      child.kill(sig);
+    } catch {
+    }
+  };
+  for (const sig of sigs)
+    process.on(sig, fwd(sig));
+  child.on("error", (err) => {
+    for (const sig of sigs)
+      process.removeAllListeners(sig);
+    if (err.code !== "ENOENT") {
+      console.error(err);
+      process.exit(1);
+    }
+    runCli(process.argv).catch((e) => {
+      console.error(e);
+      try {
+        process.exit(1);
+      } catch (_) {
+        throw e;
+      }
+    });
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+} else {
+  runCli(process.argv).catch((err) => {
+    console.error(err);
+    try {
+      process.exit(1);
+    } catch (_) {
+      throw err;
+    }
+  });
+}

package/dist/index.cjs

@@ -32,6 +32,7 @@ var src_exports = {};
 __export(src_exports, {
   HadarsContext: () => HadarsContext,
   HadarsHead: () => Head,
+  initServerDataCache: () => initServerDataCache,
   loadModule: () => loadModule,
   useServerData: () => useServerData
 });
@@ -170,6 +171,11 @@ var AppProviderCSR = import_react.default.memo(({ children }) => {
 });
 var useApp = () => import_react.default.useContext(AppContext);
 var clientServerDataCache = /* @__PURE__ */ new Map();
+function initServerDataCache(data) {
+  for (const [k, v] of Object.entries(data)) {
+    clientServerDataCache.set(k, v);
+  }
+}
 function useServerData(key, fn) {
   const cacheKey = Array.isArray(key) ? key.join("\0") : key;
   if (typeof window !== "undefined") {
@@ -184,11 +190,16 @@ function useServerData(key, fn) {
   const existing = unsuspend.cache.get(cacheKey);
   if (existing?.status === "suspense-resolved") {
     try {
-      return fn();
+      const value = fn();
+      unsuspend.cache.set(cacheKey, { status: "suspense-cached", value });
+      return value;
     } catch {
       return void 0;
     }
   }
+  if (existing?.status === "suspense-cached") {
+    return existing.value;
+  }
   if (!existing) {
     let result;
     try {
@@ -298,6 +309,7 @@ function loadModule(path) {
 0 && (module.exports = {
   HadarsContext,
   HadarsHead,
+  initServerDataCache,
   loadModule,
   useServerData
 });

package/dist/index.d.ts

@@ -29,6 +29,9 @@ type UnsuspendEntry = {
     value: unknown;
 } | {
     status: 'suspense-resolved';
+} | {
+    status: 'suspense-cached';
+    value: unknown;
 } | {
     status: 'rejected';
     reason: unknown;
@@ -102,6 +105,9 @@ interface HadarsRequest extends Request {
     cookies: Record<string, string>;
 }
 
+/** Call this before hydrating to seed the client cache from the server's data.
+ *  Invoked automatically by the hadars client bootstrap. */
+declare function initServerDataCache(data: Record<string, unknown>): void;
 /**
  * Fetch async data on the server during SSR. Returns `undefined` on the first
  * render pass(es) while the promise is in flight; returns the resolved value
@@ -157,4 +163,4 @@ declare const HadarsContext: React$1.FC<{
  */
 declare function loadModule<T = any>(path: string): Promise<T>;
 
-export { HadarsApp, HadarsContext, HadarsEntryModule, HadarsGetAfterRenderProps, HadarsGetClientProps, HadarsGetFinalProps, HadarsGetInitialProps, Head as HadarsHead, HadarsOptions, HadarsProps, HadarsRequest, loadModule, useServerData };
+export { HadarsApp, HadarsContext, HadarsEntryModule, HadarsGetAfterRenderProps, HadarsGetClientProps, HadarsGetFinalProps, HadarsGetInitialProps, Head as HadarsHead, HadarsOptions, HadarsProps, HadarsRequest, initServerDataCache, loadModule, useServerData };

package/dist/index.js

@@ -131,6 +131,11 @@ var AppProviderCSR = React.memo(({ children }) => {
 });
 var useApp = () => React.useContext(AppContext);
 var clientServerDataCache = /* @__PURE__ */ new Map();
+function initServerDataCache(data) {
+  for (const [k, v] of Object.entries(data)) {
+    clientServerDataCache.set(k, v);
+  }
+}
 function useServerData(key, fn) {
   const cacheKey = Array.isArray(key) ? key.join("\0") : key;
   if (typeof window !== "undefined") {
@@ -145,11 +150,16 @@ function useServerData(key, fn) {
   const existing = unsuspend.cache.get(cacheKey);
   if (existing?.status === "suspense-resolved") {
     try {
-      return fn();
+      const value = fn();
+      unsuspend.cache.set(cacheKey, { status: "suspense-cached", value });
+      return value;
     } catch {
       return void 0;
     }
   }
+  if (existing?.status === "suspense-cached") {
+    return existing.value;
+  }
   if (!existing) {
     let result;
     try {
@@ -258,6 +268,7 @@ function loadModule(path) {
 export {
   HadarsContext,
   Head as HadarsHead,
+  initServerDataCache,
   loadModule,
   useServerData
 };

package/dist/ssr-render-worker.js

@@ -47,7 +47,7 @@ function buildReactPage(R, appProps, clientProps) {
       id: "hadars",
       type: "application/json",
       dangerouslySetInnerHTML: {
-        __html: JSON.stringify({ hadars: { props: clientProps } })
+        __html: JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c")
       }
     })
   );

package/dist/ssr-watch.js

@@ -213,7 +213,6 @@ var buildCompilerConfig = (entry2, opts, includeHotPlugin) => {
   };
   return {
     entry: entry2,
-    resolve: resolveConfig,
     output: {
       ...opts.output,
       clean: false
@@ -233,6 +232,13 @@ var buildCompilerConfig = (entry2, opts, includeHotPlugin) => {
       ...extraPlugins
     ],
     ...localConfig,
+    // Merge base resolve (modules, tsConfig, extensions) with per-build resolve
+    // (alias, mainFields). The spread order matters: resolveConfig wins for keys
+    // it defines, localConfig.resolve wins for keys it defines exclusively.
+    resolve: {
+      ...localConfig.resolve,
+      ...resolveConfig
+    },
     // HMR is not implemented for module chunk format, so disable outputModule
     // for client builds. SSR builds still need it for dynamic import() of exports.
     experiments: {

package/dist/utils/Head.tsx

@@ -231,17 +231,27 @@ export function useServerData<T>(key: string | string[], fn: () => Promise<T> |
     const existing = unsuspend.cache.get(cacheKey);
 
     // Suspense promise has resolved — re-call fn() so the hook returns its value
-    // synchronously from its own internal cache. The result is returned directly
-    // without being stored as 'fulfilled', so it is never included in the
-    // serialised serverData sent to the client (the library owns its own hydration).
+    // synchronously from its own internal cache. Cache the result as
+    // 'suspense-cached' so later renders (e.g. the final renderToString in
+    // buildSsrResponse, which runs after getFinalProps may have cleared the
+    // user's QueryClient) can return the value without calling fn() again.
+    // NOT stored as 'fulfilled' so it is never included in serverData sent to
+    // the client — the Suspense library owns its own hydration.
     if (existing?.status === 'suspense-resolved') {
         try {
-            return fn() as T | undefined;
+            const value = fn() as T;
+            unsuspend.cache.set(cacheKey, { status: 'suspense-cached', value });
+            return value;
         } catch {
             return undefined;
         }
     }
 
+    // Return the cached Suspense value on all subsequent renders.
+    if (existing?.status === 'suspense-cached') {
+        return existing.value as T;
+    }
+
     if (!existing) {
         // First encounter — call fn(), which may:
         //   (a) return a Promise<T>  — normal async usage (serialised for the client)

package/dist/utils/clientScript.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import { hydrateRoot, createRoot } from 'react-dom/client';
 import type { HadarsEntryModule } from '../types/ninety';
-import { initServerDataCache } from '$_HEAD_PATH$';
+import { initServerDataCache } from 'hadars';
 import * as _appMod from '$_MOD_PATH$';
 
 const appMod = _appMod as HadarsEntryModule<{}>;

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "hadars",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
   "bin": {
-    "hadars": "dist/cli.js",
-    "hadars-bun": "cli-bun.ts"
+    "hadars": "dist/cli.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +14,6 @@
     "src",
     "cli-lib.ts",
     "cli.ts",
-    "cli-bun.ts",
     "index.ts",
     "LICENSE"
   ],

package/src/build.ts

@@ -72,6 +72,9 @@ type PendingEntry = PendingRenderString | PendingRenderStream;
 class RenderWorkerPool {
     private workers: any[] = [];
     private pending = new Map<number, PendingEntry>();
+    // Track which pending IDs were dispatched to each worker so we can reject
+    // them when that worker crashes.
+    private workerPending = new Map<any, Set<number>>();
     private nextId = 0;
     private rrIndex = 0;
 
@@ -85,6 +88,7 @@ class RenderWorkerPool {
         import('node:worker_threads').then(({ Worker }) => {
             for (let i = 0; i < size; i++) {
                 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 p = this.pending.get(id);
@@ -96,6 +100,7 @@ class RenderWorkerPool {
                             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;
@@ -103,11 +108,19 @@ class RenderWorkerPool {
 
                     // renderString
                     this.pending.delete(id);
+                    this.workerPending.get(w)?.delete(id);
                     if (error) p.reject(new Error(error));
                     else p.resolve(html);
                 });
                 w.on('error', (err: Error) => {
                     console.error('[hadars] Render worker error:', err);
+                    this._handleWorkerDeath(w, err);
+                });
+                w.on('exit', (code: number) => {
+                    if (code !== 0) {
+                        console.error(`[hadars] Render worker exited with code ${code}`);
+                        this._handleWorkerDeath(w, new Error(`Render worker exited with code ${code}`));
+                    }
                 });
                 this.workers.push(w);
             }
@@ -116,7 +129,28 @@ class RenderWorkerPool {
         });
     }
 
-    private nextWorker() {
+    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);
+                }
+            }
+            this.workerPending.delete(w);
+        }
+    }
+
+    private nextWorker(): any | undefined {
+        if (this.workers.length === 0) return undefined;
         const w = this.workers[this.rrIndex % this.workers.length];
         this.rrIndex++;
         return w;
@@ -125,9 +159,21 @@ class RenderWorkerPool {
     /** Offload a full renderToString call. Returns the HTML string. */
     renderString(appProps: Record<string, unknown>, clientProps: Record<string, unknown>): Promise<string> {
         return new Promise((resolve, reject) => {
+            const w = this.nextWorker();
+            if (!w) {
+                reject(new Error('[hadars] No render workers available'));
+                return;
+            }
             const id = this.nextId++;
             this.pending.set(id, { kind: 'renderString', resolve, reject });
-            this.nextWorker().postMessage({ id, type: 'renderString', appProps, clientProps });
+            this.workerPending.get(w)?.add(id);
+            try {
+                w.postMessage({ id, type: 'renderString', appProps, clientProps });
+            } catch (err) {
+                this.pending.delete(id);
+                this.workerPending.get(w)?.delete(id);
+                reject(err);
+            }
         });
     }
 
@@ -138,11 +184,24 @@ class RenderWorkerPool {
         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.nextWorker().postMessage({ id, type: 'renderStream', appProps, clientProps });
+        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;
     }
 
@@ -341,13 +400,10 @@ export const dev = async (options: HadarsRuntimeOptions) => {
     const packageDir = pathMod.dirname(fileURLToPath(import.meta.url));
     const clientScriptPath = pathMod.resolve(packageDir, 'utils', 'clientScript.tsx');
 
-    const headPath = pathMod.resolve(packageDir, 'utils', 'Head');
-
     let clientScript = '';
     try {
         clientScript = (await fs.readFile(clientScriptPath, 'utf-8'))
-            .replace('$_MOD_PATH$', entry + getSuffix(options.mode))
-            .replace('$_HEAD_PATH$', headPath);
+            .replace('$_MOD_PATH$', entry + getSuffix(options.mode));
     }
     catch (err) {
         console.error("Failed to read client script from package dist, falling back to src", err);
@@ -421,6 +477,12 @@ export const dev = async (options: HadarsRuntimeOptions) => {
     ], { stdio: 'pipe' });
     child.stdin?.end();
 
+    // Ensure the SSR watcher child is killed when this process exits.
+    const cleanupChild = () => { try { if (!child.killed) child.kill(); } catch {} };
+    process.once('exit', cleanupChild);
+    process.once('SIGINT', () => { cleanupChild(); process.exit(0); });
+    process.once('SIGTERM', () => { cleanupChild(); process.exit(0); });
+
     // Convert Node.js Readable streams to Web ReadableStream so the rest of
     // the logic works identically across all runtimes.
     const stdoutWebStream = nodeReadableToWebStream(child.stdout!);
@@ -553,17 +615,14 @@ export const build = async (options: HadarsRuntimeOptions) => {
     // prepare client script
     const packageDir = pathMod.dirname(fileURLToPath(import.meta.url));
     const clientScriptPath = pathMod.resolve(packageDir, 'utils', 'clientScript.js');
-    const headPath = pathMod.resolve(packageDir, 'utils', 'Head');
     let clientScript = '';
     try {
         clientScript = (await fs.readFile(clientScriptPath, 'utf-8'))
-            .replace('$_MOD_PATH$', entry + getSuffix(options.mode))
-            .replace('$_HEAD_PATH$', headPath);
+            .replace('$_MOD_PATH$', entry + getSuffix(options.mode));
     } catch (err) {
         const srcClientPath = pathMod.resolve(packageDir, 'utils', 'clientScript.tsx');
         clientScript = (await fs.readFile(srcClientPath, 'utf-8'))
-            .replace('$_MOD_PATH$', entry + `?v=${Date.now()}`)
-            .replace('$_HEAD_PATH$', pathMod.resolve(packageDir, 'utils', 'Head'));
+            .replace('$_MOD_PATH$', entry + `?v=${Date.now()}`);
     }
 
     const tmpFilePath = pathMod.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
@@ -645,7 +704,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
     if (!isNode && workers > 1) {
         const packageDir = pathMod.dirname(fileURLToPath(import.meta.url));
         const workerJs = pathMod.resolve(packageDir, 'ssr-render-worker.js');
-        const workerTs = pathMod.resolve(packageDir, 'src', 'ssr-render-worker.ts');
+        const workerTs = pathMod.resolve(packageDir, 'ssr-render-worker.ts');
         const workerFile = existsSync(workerJs) ? workerJs : workerTs;
         const ssrBundlePath = pathMod.resolve(__dirname, HadarsFolder, SSR_FILENAME);
         renderPool = new RenderWorkerPool(workerFile, workers, ssrBundlePath);

package/src/index.tsx

@@ -9,7 +9,7 @@ export type {
     HadarsEntryModule,
     HadarsApp,
 } from "./types/ninety";
-export { Head as HadarsHead, useServerData } from './utils/Head';
+export { Head as HadarsHead, useServerData, initServerDataCache } from './utils/Head';
 import { AppProviderSSR, AppProviderCSR } from "./utils/Head";
 
 export const HadarsContext = typeof window === 'undefined' ? AppProviderSSR : AppProviderCSR;

package/src/ssr-render-worker.ts

@@ -77,7 +77,7 @@ function buildReactPage(R: any, appProps: Record<string, unknown>, clientProps:
             id: 'hadars',
             type: 'application/json',
             dangerouslySetInnerHTML: {
-                __html: JSON.stringify({ hadars: { props: clientProps } }),
+                __html: JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, '\\u003c'),
             },
         }),
     );

package/src/types/ninety.ts

@@ -27,6 +27,7 @@ export type UnsuspendEntry =
     | { status: 'pending'; promise: Promise<unknown> }
     | { status: 'fulfilled'; value: unknown }
     | { status: 'suspense-resolved' }
+    | { status: 'suspense-cached'; value: unknown }
     | { status: 'rejected'; reason: unknown };
 
 /** @internal Populated by the framework's render loop — use useServerData() instead. */

package/src/utils/Head.tsx

@@ -231,17 +231,27 @@ export function useServerData<T>(key: string | string[], fn: () => Promise<T> |
     const existing = unsuspend.cache.get(cacheKey);
 
     // Suspense promise has resolved — re-call fn() so the hook returns its value
-    // synchronously from its own internal cache. The result is returned directly
-    // without being stored as 'fulfilled', so it is never included in the
-    // serialised serverData sent to the client (the library owns its own hydration).
+    // synchronously from its own internal cache. Cache the result as
+    // 'suspense-cached' so later renders (e.g. the final renderToString in
+    // buildSsrResponse, which runs after getFinalProps may have cleared the
+    // user's QueryClient) can return the value without calling fn() again.
+    // NOT stored as 'fulfilled' so it is never included in serverData sent to
+    // the client — the Suspense library owns its own hydration.
     if (existing?.status === 'suspense-resolved') {
         try {
-            return fn() as T | undefined;
+            const value = fn() as T;
+            unsuspend.cache.set(cacheKey, { status: 'suspense-cached', value });
+            return value;
         } catch {
             return undefined;
         }
     }
 
+    // Return the cached Suspense value on all subsequent renders.
+    if (existing?.status === 'suspense-cached') {
+        return existing.value as T;
+    }
+
     if (!existing) {
         // First encounter — call fn(), which may:
         //   (a) return a Promise<T>  — normal async usage (serialised for the client)

package/src/utils/clientScript.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import { hydrateRoot, createRoot } from 'react-dom/client';
 import type { HadarsEntryModule } from '../types/ninety';
-import { initServerDataCache } from '$_HEAD_PATH$';
+import { initServerDataCache } from 'hadars';
 import * as _appMod from '$_MOD_PATH$';
 
 const appMod = _appMod as HadarsEntryModule<{}>;

package/src/utils/proxyHandler.tsx

@@ -53,14 +53,14 @@ export const createProxyHandler = (options: HadarsOptions): ProxyHandler => {
     const proxyRules = Object.entries(proxy).sort((a, b) => b[0].length - a[0].length);
 
     return async (req: HadarsRequest) => {
-        if (req.method === 'OPTIONS' && options.proxyCORS) {
-            return new Response(null, {
-                status: 204,
-                headers: getCORSHeaders(req),
-            });
-        }
         for (const [path, target] of proxyRules) {
             if (req.pathname.startsWith(path)) {
+                if (req.method === 'OPTIONS' && proxyCORS) {
+                    return new Response(null, {
+                        status: 204,
+                        headers: getCORSHeaders(req),
+                    });
+                }
                 const targetURL = new URL(target);
                 targetURL.pathname = targetURL.pathname.replace(/\/$/, '') + req.pathname.slice(path.length);
                 targetURL.search = req.search;
@@ -69,25 +69,28 @@ export const createProxyHandler = (options: HadarsOptions): ProxyHandler => {
                 // Overwrite the Host header to match the target
                 sendHeaders.set('Host', targetURL.host);
 
+                const hasBody = !['GET', 'HEAD'].includes(req.method);
                 const proxyReq = new Request(targetURL.toString(), {
                     method: req.method,
                     headers: sendHeaders,
-                    body: ['GET', 'HEAD'].includes(req.method) ? undefined : req.body,
+                    body: hasBody ? req.body : undefined,
                     redirect: 'follow',
-                });
+                    // Node.js (undici) requires duplex:'half' when body is a ReadableStream
+                    ...(hasBody ? { duplex: 'half' } : {}),
+                } as RequestInit);
 
                 const res = await fetch(proxyReq);
-                if (proxyCORS) {
-                    Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
-                        res.headers.set(key, value);
-                    });
-                }
                 // Read the response body
                 const body = await res.arrayBuffer();
                 // remove content-length and content-encoding headers to avoid issues with modified body
                 const clonedRes = new Headers(res.headers);
                 clonedRes.delete('content-length');
                 clonedRes.delete('content-encoding');
+                if (proxyCORS) {
+                    Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+                        clonedRes.set(key, value);
+                    });
+                }
                 // return a new Response with the modified headers and original body
                 return new Response(body, {
                     status: res.status,

package/src/utils/response.tsx

@@ -181,7 +181,7 @@ export const getReactResponse = async (
                     context,
                 })} />
             </div>
-            <script id="hadars" type="application/json" dangerouslySetInnerHTML={{ __html: JSON.stringify({ hadars: { props: clientProps } }) }}></script>
+            <script id="hadars" type="application/json" dangerouslySetInnerHTML={{ __html: JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, '\\u003c') }}></script>
         </>
     )
 

package/src/utils/rspack.ts

@@ -260,7 +260,6 @@ const buildCompilerConfig = (
 
     return {
         entry,
-        resolve: resolveConfig,
         output: {
             ...opts.output,
             clean: false,
@@ -280,6 +279,13 @@ const buildCompilerConfig = (
             ...extraPlugins,
         ],
         ...localConfig,
+        // Merge base resolve (modules, tsConfig, extensions) with per-build resolve
+        // (alias, mainFields). The spread order matters: resolveConfig wins for keys
+        // it defines, localConfig.resolve wins for keys it defines exclusively.
+        resolve: {
+            ...localConfig.resolve,
+            ...resolveConfig,
+        },
         // HMR is not implemented for module chunk format, so disable outputModule
         // for client builds. SSR builds still need it for dynamic import() of exports.
         experiments: {

package/cli-bun.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env bun
-import { runCli } from './cli-lib'
-
-runCli(process.argv).catch((err) => {
-  console.error(err)
-  // When Bun runs a script, allow non-zero exit codes to propagate
-  try {
-    process.exit(1)
-  } catch (_) {
-    // Some Bun environments may not allow process.exit; just rethrow
-    throw err
-  }
-})