hadars 0.1.10 → 0.1.12

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 ninety contributors
+Copyright (c) 2025 hadars contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/cli-lib.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs'
 import { mkdir, writeFile } from 'node:fs/promises'
 import { resolve, join } from 'node:path'
 import * as Hadars from './src/build'
-import type { HadarsOptions } from './src/types/ninety'
+import type { HadarsOptions } from './src/types/hadars'
 
 const SUPPORTED = ['hadars.config.js', 'hadars.config.mjs', 'hadars.config.cjs', 'hadars.config.ts']
 

package/cli.ts

@@ -7,12 +7,12 @@ import { runCli } from './cli-lib'
 // (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)], {
+    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 {} };
+    const fwd = (sig: NodeJS.Signals) => () => { 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);

package/dist/cli.js

@@ -150,8 +150,8 @@ async function getStaticMarkupRenderer() {
   return _renderToStaticMarkup;
 }
 var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
-var escAttr = (s) => s.replace(/[&<>"]/g, (c) => ESC[c]);
-var escText = (s) => s.replace(/[&<>]/g, (c) => ESC[c]);
+var escAttr = (s) => s.replace(/[&<>"]/g, (c) => ESC[c] ?? c);
+var escText = (s) => s.replace(/[&<>]/g, (c) => ESC[c] ?? c);
 var ATTR = {
   className: "class",
   htmlFor: "for",
@@ -766,7 +766,7 @@ async function tryServeFile(filePath) {
     const data = await readFile(filePath);
     const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
     const contentType = MIME[ext] ?? "application/octet-stream";
-    return new Response(data, { headers: { "Content-Type": contentType } });
+    return new Response(data.buffer, { headers: { "Content-Type": contentType } });
   } catch {
     return null;
   }
@@ -784,8 +784,8 @@ import os from "node:os";
 import { spawn } from "node:child_process";
 import cluster from "node:cluster";
 var encoder = new TextEncoder();
-var HEAD_MARKER = '<meta name="NINETY_HEAD">';
-var BODY_MARKER = '<meta name="NINETY_BODY">';
+var HEAD_MARKER = '<meta name="HADARS_HEAD">';
+var BODY_MARKER = '<meta name="HADARS_BODY">';
 var _renderToString = null;
 async function getRenderToString() {
   if (!_renderToString) {
@@ -956,6 +956,86 @@ var makePrecontentHtmlGetter = (htmlFilePromise) => {
     return [preHead + headHtml + postHead, postContent];
   };
 };
+async function transformStream(data, stream) {
+  const writer = stream.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+var gzipCompress = (d) => transformStream(d, new globalThis.CompressionStream("gzip"));
+var gzipDecompress = (d) => transformStream(d, new globalThis.DecompressionStream("gzip"));
+async function buildCacheEntry(res, ttl) {
+  const buf = await res.arrayBuffer();
+  const body = await gzipCompress(new Uint8Array(buf));
+  const headers = [];
+  res.headers.forEach((v, k) => {
+    if (k.toLowerCase() !== "content-encoding" && k.toLowerCase() !== "content-length") {
+      headers.push([k, v]);
+    }
+  });
+  headers.push(["content-encoding", "gzip"]);
+  return { body, status: res.status, headers, expiresAt: ttl != null ? Date.now() + ttl : null };
+}
+async function serveFromEntry(entry, req) {
+  const accept = req.headers.get("Accept-Encoding") ?? "";
+  if (accept.includes("gzip")) {
+    return new Response(entry.body.buffer, { status: entry.status, headers: entry.headers });
+  }
+  const plain = await gzipDecompress(entry.body);
+  const headers = entry.headers.filter(([k]) => k.toLowerCase() !== "content-encoding");
+  return new Response(plain.buffer, { status: entry.status, headers });
+}
+function createRenderCache(opts, handler) {
+  const store = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  return async (req, ctx) => {
+    const hadarsReq = parseRequest(req);
+    const cacheOpts = await opts(hadarsReq);
+    const key = cacheOpts?.key ?? null;
+    if (key != null) {
+      const entry = store.get(key);
+      if (entry) {
+        const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
+        if (!expired) {
+          return serveFromEntry(entry, req);
+        }
+        store.delete(key);
+      }
+      let flight = inFlight.get(key);
+      if (!flight) {
+        const ttl = cacheOpts?.ttl;
+        flight = handler(new Request(req), ctx).then(async (res) => {
+          if (!res || res.status < 200 || res.status >= 300 || res.headers.has("set-cookie")) {
+            return null;
+          }
+          const newEntry2 = await buildCacheEntry(res, ttl);
+          store.set(key, newEntry2);
+          return newEntry2;
+        }).catch(() => null).finally(() => inFlight.delete(key));
+        inFlight.set(key, flight);
+      }
+      const newEntry = await flight;
+      if (newEntry)
+        return serveFromEntry(newEntry, req);
+    }
+    return handler(req, ctx);
+  };
+}
 var SSR_FILENAME = "index.ssr.js";
 var __dirname2 = process.cwd();
 var getSuffix = (mode) => mode === "development" ? `?v=${Date.now()}` : "";
@@ -1044,11 +1124,11 @@ var dev = async (options) => {
     allowedHosts: "all"
   }, clientCompiler);
   console.log(`Starting HMR dev server on port ${hmrPort}`);
-  await new Promise((resolve2, reject) => {
-    let resolved = false;
+  let clientResolved = false;
+  const clientBuildDone = new Promise((resolve2, reject) => {
     clientCompiler.hooks.done.tap("initial-build", (stats) => {
-      if (!resolved) {
-        resolved = true;
+      if (!clientResolved) {
+        clientResolved = true;
         console.log(stats.toString({ colors: true }));
         resolve2();
       }
@@ -1088,37 +1168,40 @@ var dev = async (options) => {
   const marker = "ssr-watch: initial-build-complete";
   const rebuildMarker = "ssr-watch: SSR rebuilt";
   const decoder = new TextDecoder();
-  let gotMarker = false;
   let stdoutReader = null;
-  try {
-    stdoutReader = stdoutWebStream.getReader();
-    let buf = "";
-    const start = Date.now();
-    const timeoutMs = 2e4;
-    while (Date.now() - start < timeoutMs) {
-      const { done, value } = await stdoutReader.read();
-      if (done) {
-        stdoutReader = null;
-        break;
-      }
-      const chunk = decoder.decode(value, { stream: true });
-      buf += chunk;
-      try {
-        process.stdout.write(chunk);
-      } catch (e) {
+  const ssrBuildDone = (async () => {
+    let gotMarker = false;
+    try {
+      stdoutReader = stdoutWebStream.getReader();
+      let buf = "";
+      const start = Date.now();
+      const timeoutMs = 2e4;
+      while (Date.now() - start < timeoutMs) {
+        const { done, value } = await stdoutReader.read();
+        if (done) {
+          stdoutReader = null;
+          break;
+        }
+        const chunk = decoder.decode(value, { stream: true });
+        buf += chunk;
+        try {
+          process.stdout.write(chunk);
+        } catch (e) {
+        }
+        if (buf.includes(marker)) {
+          gotMarker = true;
+          break;
+        }
       }
-      if (buf.includes(marker)) {
-        gotMarker = true;
-        break;
+      if (!gotMarker) {
+        console.warn("SSR worker did not signal initial build completion within timeout");
       }
+    } catch (err) {
+      console.error("Error reading SSR worker output", err);
+      stdoutReader = null;
     }
-    if (!gotMarker) {
-      console.warn("SSR worker did not signal initial build completion within timeout");
-    }
-  } catch (err) {
-    console.error("Error reading SSR worker output", err);
-    stdoutReader = null;
-  }
+  })();
+  await Promise.all([clientBuildDone, ssrBuildDone]);
   if (stdoutReader) {
     const reader = stdoutReader;
     (async () => {
@@ -1295,7 +1378,7 @@ var run = async (options) => {
   const getPrecontentHtml = makePrecontentHtmlGetter(
     fs.readFile(pathMod3.join(__dirname2, StaticPath, "out.html"), "utf-8")
   );
-  await serve(port, async (req, ctx) => {
+  const runHandler = async (req, ctx) => {
     const request = parseRequest(req);
     if (handler) {
       const res = await handler(request);
@@ -1363,7 +1446,12 @@ var run = async (options) => {
       console.error("[hadars] SSR render error:", err);
       return new Response("Internal Server Error", { status: 500 });
     }
-  }, options.websocket);
+  };
+  await serve(
+    port,
+    options.cache ? createRenderCache(options.cache, runHandler) : runHandler,
+    options.websocket
+  );
 };
 
 // cli-lib.ts

package/dist/index.d.ts

@@ -92,6 +92,29 @@ interface HadarsOptions {
      * Has no effect on the SSR bundle or dev mode.
      */
     optimization?: Record<string, unknown>;
+    /**
+     * SSR response cache for `run()` mode. Has no effect in `dev()` mode.
+     *
+     * Receives the incoming request and should return `{ key, ttl? }` to cache
+     * the response, or `null`/`undefined` to skip caching for that request.
+     * `ttl` is the time-to-live in milliseconds; omit for entries that never expire.
+     * The function may be async.
+     *
+     * @example
+     * // Cache every page by pathname (no per-user personalisation):
+     * cache: (req) => ({ key: req.pathname })
+     *
+     * @example
+     * // Cache with a per-route TTL, skip authenticated requests:
+     * cache: (req) => req.cookies.session ? null : { key: req.pathname, ttl: 60_000 }
+     */
+    cache?: (req: HadarsRequest) => {
+        key: string;
+        ttl?: number;
+    } | null | undefined | Promise<{
+        key: string;
+        ttl?: number;
+    } | null | undefined>;
 }
 type SwcPluginItem = string | [string, Record<string, unknown>] | {
     path: string;

package/dist/ssr-render-worker.js

@@ -11,7 +11,7 @@ var _ssrMod = null;
 async function init() {
   if (_React && _ssrMod)
     return;
-  const req = createRequire(pathMod.resolve(process.cwd(), "__ninety_fake__.js"));
+  const req = createRequire(pathMod.resolve(process.cwd(), "__hadars_fake__.js"));
   if (!_React) {
     const reactPath = pathToFileURL(req.resolve("react")).href;
     const reactMod = await import(reactPath);
@@ -30,7 +30,7 @@ async function init() {
 function deserializeRequest(s) {
   const init2 = { method: s.method, headers: new Headers(s.headers) };
   if (s.body)
-    init2.body = s.body;
+    init2.body = s.body.buffer;
   const req = new Request(s.url, init2);
   Object.assign(req, {
     pathname: s.pathname,

package/dist/template.html

@@ -3,9 +3,9 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta name="NINETY_HEAD">
+    <meta name="HADARS_HEAD">
 </head>
 <body>
-    <meta name="NINETY_BODY">
+    <meta name="HADARS_BODY">
 </body>
 </html>

package/dist/utils/Head.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { AppContext, AppUnsuspend, LinkProps, MetaProps, ScriptProps, StyleProps } from '../types/ninety'
+import type { AppContext, AppUnsuspend, LinkProps, MetaProps, ScriptProps, StyleProps } from '../types/hadars'
 
 interface InnerContext {
     setTitle: (title: string) => void;

package/dist/utils/clientScript.tsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import { hydrateRoot, createRoot } from 'react-dom/client';
-import type { HadarsEntryModule } from '../types/ninety';
+import type { HadarsEntryModule } from '../types/hadars';
 import { initServerDataCache } from 'hadars';
 import * as _appMod from '$_MOD_PATH$';
 

package/index.ts

@@ -1,15 +1,15 @@
 // Bun entry point — re-exports the full public API from source so that
-// `ninety-bun` (which runs TypeScript directly) gets the same exports as
+// hadars running TypeScript directly gets the same exports as
 // the compiled `dist/index.js` used by Node.js / Deno.
 export type {
-    NinetyOptions,
-    NinetyProps,
-    NinetyRequest,
-    NinetyGetAfterRenderProps,
-    NinetyGetFinalProps,
-    NinetyGetInitialProps,
-    NinetyGetClientProps,
-    NinetyEntryModule,
-    NinetyApp,
-} from "./src/types/ninety";
-export { NinetyHead, NinetyContext, loadModule } from "./src/index";
+    HadarsOptions,
+    HadarsProps,
+    HadarsRequest,
+    HadarsGetAfterRenderProps,
+    HadarsGetFinalProps,
+    HadarsGetInitialProps,
+    HadarsGetClientProps,
+    HadarsEntryModule,
+    HadarsApp,
+} from "./src/types/hadars";
+export { HadarsHead, HadarsContext, loadModule } from "./src/index";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
@@ -52,8 +52,8 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
     "typescript": "^5"
   },
   "peerDependenciesMeta": {
@@ -63,28 +63,24 @@
   },
   "optionalDependencies": {
     "@rspack/core": "1.4.9",
-    "@rspack/dev-server": "^1.1.4",
-    "@rspack/plugin-react-refresh": "^1.5.0",
-    "@swc/core": "^1.4.0",
+    "@rspack/dev-server": "^1.2.1",
+    "@rspack/plugin-react-refresh": "^1.6.1",
+    "@swc/core": "^1.15.18",
     "@types/bun": "latest",
-    "@types/react-dom": "^19.1.9",
-    "react-refresh": "^0.17.0",
-    "typescript": "^5"
+    "react-refresh": "^0.17.0"
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
-    "esbuild": "^0.19.0",
-    "tsup": "^6.6.0"
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "esbuild": "^0.19.12",
+    "tsup": "^6.7.0",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
     "@mdx-js/loader": "^3.1.1",
-    "@mdx-js/react": "^3.1.1",
     "@svgr/webpack": "^8.1.0",
-    "@tailwindcss/postcss": "^4.1.12",
-    "postcss": "^8.5.6",
-    "postcss-loader": "^8.2.0",
-    "tailwindcss": "^4.1.12"
+    "postcss": "^8.5.8",
+    "postcss-loader": "^8.2.1"
   },
   "license": "MIT",
   "repository": {

package/src/build.ts

@@ -16,11 +16,11 @@ 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";
+import type { HadarsEntryModule, HadarsOptions, HadarsProps } from "./types/hadars";
 const encoder = new TextEncoder();
 
-const HEAD_MARKER = '<meta name="NINETY_HEAD">';
-const BODY_MARKER = '<meta name="NINETY_BODY">';
+const HEAD_MARKER = '<meta name="HADARS_HEAD">';
+const BODY_MARKER = '<meta name="HADARS_BODY">';
 
 // Resolve renderToString from react-dom/server in the project's node_modules.
 let _renderToString: ((element: any) => string) | null = null;
@@ -230,6 +230,116 @@ const makePrecontentHtmlGetter = (htmlFilePromise: Promise<string>) => {
     };
 };
 
+// ── SSR response cache ────────────────────────────────────────────────────────
+
+interface CacheEntry {
+    /** Gzip-compressed response body — much cheaper to keep in RAM than raw HTML. */
+    body: Uint8Array;
+    status: number;
+    /** Headers with Content-Encoding: gzip already set. */
+    headers: [string, string][];
+    expiresAt: number | null;
+}
+
+type CacheFetchHandler = (req: Request, ctx: any) => Promise<Response | undefined>;
+
+async function transformStream(data: Uint8Array, stream: { writable: WritableStream; readable: ReadableStream<Uint8Array> }): Promise<Uint8Array> {
+    const writer = stream.writable.getWriter();
+    writer.write(data);
+    writer.close();
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+    }
+    const total = chunks.reduce((n, c) => n + c.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) { out.set(c, offset); offset += c.length; }
+    return out;
+}
+
+const gzipCompress   = (d: Uint8Array) => transformStream(d, new (globalThis as any).CompressionStream('gzip'));
+const gzipDecompress = (d: Uint8Array) => transformStream(d, new (globalThis as any).DecompressionStream('gzip'));
+
+async function buildCacheEntry(res: Response, ttl: number | undefined): Promise<CacheEntry> {
+    const buf = await res.arrayBuffer();
+    const body = await gzipCompress(new Uint8Array(buf));
+    const headers: [string, string][] = [];
+    res.headers.forEach((v, k) => {
+        if (k.toLowerCase() !== 'content-encoding' && k.toLowerCase() !== 'content-length') {
+            headers.push([k, v]);
+        }
+    });
+    headers.push(['content-encoding', 'gzip']);
+    return { body, status: res.status, headers, expiresAt: ttl != null ? Date.now() + ttl : null };
+}
+
+async function serveFromEntry(entry: CacheEntry, req: Request): Promise<Response> {
+    const accept = req.headers.get('Accept-Encoding') ?? '';
+    if (accept.includes('gzip')) {
+        return new Response(entry.body.buffer as ArrayBuffer, { status: entry.status, headers: entry.headers });
+    }
+    // Client doesn't support gzip — decompress before serving
+    const plain = await gzipDecompress(entry.body);
+    const headers = entry.headers.filter(([k]) => k.toLowerCase() !== 'content-encoding');
+    return new Response(plain.buffer as ArrayBuffer, { status: entry.status, headers });
+}
+
+function createRenderCache(
+    opts: NonNullable<HadarsOptions['cache']>,
+    handler: CacheFetchHandler,
+): CacheFetchHandler {
+    const store    = new Map<string, CacheEntry>();
+    // Single-flight map: coalesces concurrent misses for the same key onto one render.
+    const inFlight = new Map<string, Promise<CacheEntry | null>>();
+
+    return async (req, ctx) => {
+        const hadarsReq = parseRequest(req);
+        const cacheOpts = await opts(hadarsReq);
+        const key = cacheOpts?.key ?? null;
+
+        if (key != null) {
+            const entry = store.get(key);
+            if (entry) {
+                const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
+                if (!expired) {
+                    return serveFromEntry(entry, req);
+                }
+                store.delete(key);
+            }
+
+            // Single-flight: if a render for this key is already in progress, await
+            // it instead of starting a duplicate render (thundering herd prevention).
+            let flight = inFlight.get(key);
+            if (!flight) {
+                const ttl = cacheOpts?.ttl;
+                flight = handler(new Request(req), ctx)
+                    .then(async (res) => {
+                        if (!res || res.status < 200 || res.status >= 300 || res.headers.has('set-cookie')) {
+                            return null;
+                        }
+                        const newEntry = await buildCacheEntry(res, ttl);
+                        store.set(key, newEntry);
+                        return newEntry;
+                    })
+                    .catch(() => null)
+                    .finally(() => inFlight.delete(key));
+                inFlight.set(key, flight);
+            }
+
+            const newEntry = await flight;
+            if (newEntry) return serveFromEntry(newEntry, req);
+            // Render was uncacheable (error, Set-Cookie, etc.) — fall through to a
+            // fresh independent render for this request so it still gets a response.
+        }
+
+        return handler(req, ctx);
+    };
+}
+
 interface HadarsRuntimeOptions extends HadarsOptions {
     mode: "development" | "production";
 }
@@ -367,11 +477,13 @@ export const dev = async (options: HadarsRuntimeOptions) => {
     }, clientCompiler as any);
 
     console.log(`Starting HMR dev server on port ${hmrPort}`);
-    await new Promise<void>((resolve, reject) => {
-        let resolved = false;
+
+    // Kick off client build — does NOT await here so SSR worker can start in parallel.
+    let clientResolved = false;
+    const clientBuildDone = new Promise<void>((resolve, reject) => {
         (clientCompiler as any).hooks.done.tap('initial-build', (stats: any) => {
-            if (!resolved) {
-                resolved = true;
+            if (!clientResolved) {
+                clientResolved = true;
                 console.log(stats.toString({ colors: true }));
                 resolve();
             }
@@ -382,6 +494,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
     // Start SSR watcher in a separate process to avoid creating two rspack
     // compiler instances in the same process. We use node:child_process.spawn
     // which works on Bun, Node.js, and Deno (via compatibility layer).
+    // Spawned immediately so it compiles in parallel with the client build above.
     const workerCmd = resolveWorkerCmd(packageDir);
     console.log('Spawning SSR worker:', workerCmd.join(' '), 'entry:', entry);
 
@@ -411,36 +524,41 @@ export const dev = async (options: HadarsRuntimeOptions) => {
     const marker = 'ssr-watch: initial-build-complete';
     const rebuildMarker = 'ssr-watch: SSR rebuilt';
     const decoder = new TextDecoder();
-    let gotMarker = false;
     // Hoist so the async continuation loop below can keep using it.
     let stdoutReader: ReadableStreamDefaultReader<Uint8Array> | null = null;
-    try {
-        stdoutReader = stdoutWebStream.getReader();
-        let buf = '';
-        const start = Date.now();
-        const timeoutMs = 20000;
-        while (Date.now() - start < timeoutMs) {
-            const { done, value } = await stdoutReader.read();
-            if (done) { stdoutReader = null; break; }
-            const chunk = decoder.decode(value, { stream: true });
-            buf += chunk;
-            try { process.stdout.write(chunk); } catch (e) { /* ignore */ }
-            if (buf.includes(marker)) {
-                gotMarker = true;
-                break;
+    const ssrBuildDone = (async () => {
+        let gotMarker = false;
+        try {
+            stdoutReader = stdoutWebStream.getReader();
+            let buf = '';
+            const start = Date.now();
+            const timeoutMs = 20000;
+            while (Date.now() - start < timeoutMs) {
+                const { done, value } = await stdoutReader.read();
+                if (done) { stdoutReader = null; break; }
+                const chunk = decoder.decode(value, { stream: true });
+                buf += chunk;
+                try { process.stdout.write(chunk); } catch (e) { /* ignore */ }
+                if (buf.includes(marker)) {
+                    gotMarker = true;
+                    break;
+                }
             }
+            if (!gotMarker) {
+                console.warn('SSR worker did not signal initial build completion within timeout');
+            }
+        } catch (err) {
+            console.error('Error reading SSR worker output', err);
+            stdoutReader = null;
         }
-        if (!gotMarker) {
-            console.warn('SSR worker did not signal initial build completion within timeout');
-        }
-    } catch (err) {
-        console.error('Error reading SSR worker output', err);
-        stdoutReader = null;
-    }
+    })();
+
+    // Wait for both client and SSR builds to finish in parallel.
+    await Promise.all([clientBuildDone, ssrBuildDone]);
 
     // Continue reading stdout to forward logs and pick up SSR rebuild signals.
     if (stdoutReader) {
-        const reader = stdoutReader;
+        const reader = stdoutReader as ReadableStreamDefaultReader<Uint8Array>;
         (async () => {
             try {
                 while (true) {
@@ -487,7 +605,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
         const url = new URL(request.url);
         const path = url.pathname;
 
-        // static files in the ninety output folder
+        // static files in the hadars output folder
         const staticRes = await tryServeFile(pathMod.join(__dirname, StaticPath, path));
         if (staticRes) return staticRes;
 
@@ -639,7 +757,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
         fs.readFile(pathMod.join(__dirname, StaticPath, 'out.html'), 'utf-8')
     );
 
-    await serve(port, async (req, ctx) => {
+    const runHandler: CacheFetchHandler = async (req, ctx) => {
         const request = parseRequest(req);
         if (handler) {
             const res = await handler(request);
@@ -653,7 +771,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
         const url = new URL(request.url);
         const path = url.pathname;
 
-        // static files in the ninety output folder
+        // static files in the hadars output folder
         const staticRes = await tryServeFile(pathMod.join(__dirname, StaticPath, path));
         if (staticRes) return staticRes;
 
@@ -715,5 +833,11 @@ export const run = async (options: HadarsRuntimeOptions) => {
             console.error('[hadars] SSR render error:', err);
             return new Response('Internal Server Error', { status: 500 });
         }
-    }, options.websocket);
+    };
+
+    await serve(
+        port,
+        options.cache ? createRenderCache(options.cache, runHandler) : runHandler,
+        options.websocket,
+    );
 };

package/src/index.tsx

@@ -8,7 +8,7 @@ export type {
     HadarsGetClientProps,
     HadarsEntryModule,
     HadarsApp,
-} from "./types/ninety";
+} from "./types/hadars";
 export { Head as HadarsHead, useServerData, initServerDataCache } from './utils/Head';
 import { AppProviderSSR, AppProviderCSR } from "./utils/Head";
 

package/src/ssr-render-worker.ts

@@ -30,7 +30,7 @@ let _ssrMod: any = null;
 async function init() {
     if (_React && _ssrMod) return;
 
-    const req = createRequire(pathMod.resolve(process.cwd(), '__ninety_fake__.js'));
+    const req = createRequire(pathMod.resolve(process.cwd(), '__hadars_fake__.js'));
 
     if (!_React) {
         const reactPath = pathToFileURL(req.resolve('react')).href;
@@ -63,7 +63,7 @@ export type SerializableRequest = {
 
 function deserializeRequest(s: SerializableRequest): any {
     const init: RequestInit = { method: s.method, headers: new Headers(s.headers) };
-    if (s.body) init.body = s.body;
+    if (s.body) init.body = s.body.buffer as ArrayBuffer;
     const req = new Request(s.url, init);
     Object.assign(req, {
         pathname: s.pathname,

package/src/types/{ninety.ts → hadars.ts}

@@ -93,6 +93,24 @@ export interface HadarsOptions {
      * Has no effect on the SSR bundle or dev mode.
      */
     optimization?: Record<string, unknown>;
+    /**
+     * SSR response cache for `run()` mode. Has no effect in `dev()` mode.
+     *
+     * Receives the incoming request and should return `{ key, ttl? }` to cache
+     * the response, or `null`/`undefined` to skip caching for that request.
+     * `ttl` is the time-to-live in milliseconds; omit for entries that never expire.
+     * The function may be async.
+     *
+     * @example
+     * // Cache every page by pathname (no per-user personalisation):
+     * cache: (req) => ({ key: req.pathname })
+     *
+     * @example
+     * // Cache with a per-route TTL, skip authenticated requests:
+     * cache: (req) => req.cookies.session ? null : { key: req.pathname, ttl: 60_000 }
+     */
+    cache?: (req: HadarsRequest) => { key: string; ttl?: number } | null | undefined
+                                  | Promise<{ key: string; ttl?: number } | null | undefined>;
 }
 
 

package/src/utils/Head.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { AppContext, AppUnsuspend, LinkProps, MetaProps, ScriptProps, StyleProps } from '../types/ninety'
+import type { AppContext, AppUnsuspend, LinkProps, MetaProps, ScriptProps, StyleProps } from '../types/hadars'
 
 interface InnerContext {
     setTitle: (title: string) => void;

package/src/utils/clientScript.tsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import { hydrateRoot, createRoot } from 'react-dom/client';
-import type { HadarsEntryModule } from '../types/ninety';
+import type { HadarsEntryModule } from '../types/hadars';
 import { initServerDataCache } from 'hadars';
 import * as _appMod from '$_MOD_PATH$';
 

package/src/utils/proxyHandler.tsx

@@ -1,4 +1,4 @@
-import type { HadarsOptions, HadarsRequest } from "../types/ninety";
+import type { HadarsOptions, HadarsRequest } from "../types/hadars";
 
 type ProxyHandler = (req: HadarsRequest) => ( Promise<Response | undefined> | undefined );
 

package/src/utils/request.tsx

@@ -1,4 +1,4 @@
-import type { HadarsRequest } from "../types/ninety";
+import type { HadarsRequest } from "../types/hadars";
 import { parseCookies } from "./cookies";
 
 export const parseRequest = (request: Request): HadarsRequest => {

package/src/utils/response.tsx

@@ -2,7 +2,7 @@ import type React from "react";
 import { createRequire } from "node:module";
 import pathMod from "node:path";
 import { pathToFileURL } from "node:url";
-import type { AppHead, AppUnsuspend, HadarsRequest, HadarsEntryBase, HadarsEntryModule, HadarsProps, AppContext } from "../types/ninety";
+import type { AppHead, AppUnsuspend, HadarsRequest, HadarsEntryBase, HadarsEntryModule, HadarsProps, AppContext } from "../types/hadars";
 
 // Resolve react-dom/server from the *project's* node_modules (process.cwd()) so
 // the same React instance is used here as in the SSR bundle. Without this,
@@ -33,8 +33,8 @@ interface ReactResponseOptions {
 // ── Head HTML serialisation (no React render needed) ─────────────────────────
 
 const ESC: Record<string, string> = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
-const escAttr = (s: string) => s.replace(/[&<>"]/g, c => ESC[c]);
-const escText = (s: string) => s.replace(/[&<>]/g, c => ESC[c]);
+const escAttr = (s: string) => s.replace(/[&<>"]/g, c => ESC[c] ?? c);
+const escText = (s: string) => s.replace(/[&<>]/g, c => ESC[c] ?? c);
 
 // React prop → HTML attribute name for the subset used in head tags.
 const ATTR: Record<string, string> = {

package/src/utils/rspack.ts

@@ -2,7 +2,7 @@ import rspack from "@rspack/core";
 import type { Configuration, RuleSetLoaderWithOptions, RuleSetRule } from "@rspack/core";
 import ReactRefreshPlugin from '@rspack/plugin-react-refresh';
 import path from 'node:path';
-import type { SwcPluginList } from '../types/ninety';
+import type { SwcPluginList } from '../types/hadars';
 import { fileURLToPath } from "node:url";
 import pathMod from "node:path";
 import { existsSync } from "node:fs";

package/src/utils/staticFile.ts

@@ -41,7 +41,7 @@ export async function tryServeFile(filePath: string): Promise<Response | null> {
         const data = await readFile(filePath);
         const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
         const contentType = MIME[ext] ?? 'application/octet-stream';
-        return new Response(data, { headers: { 'Content-Type': contentType } });
+        return new Response(data.buffer as ArrayBuffer, { headers: { 'Content-Type': contentType } });
     } catch {
         return null;
     }

package/src/utils/template.html

@@ -3,9 +3,9 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta name="NINETY_HEAD">
+    <meta name="HADARS_HEAD">
 </head>
 <body>
-    <meta name="NINETY_BODY">
+    <meta name="HADARS_BODY">
 </body>
 </html>

package/src/utils/upgradeRequest.tsx

@@ -1,5 +1,5 @@
 import type { ServerContext } from './serve';
-import type { HadarsOptions, HadarsRequest } from "../types/ninety";
+import type { HadarsOptions, HadarsRequest } from "../types/hadars";
 
 type UpgradeHandle = (req: HadarsRequest, ctx: ServerContext) => boolean;