hadars 0.1.11 → 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) {
@@ -979,8 +979,30 @@ async function transformStream(data, stream) {
 }
 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);
@@ -988,40 +1010,30 @@ function createRenderCache(opts, handler) {
     if (key != null) {
       const entry = store.get(key);
       if (entry) {
-        if (entry.expiresAt == null || Date.now() < entry.expiresAt) {
-          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 });
+        const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
+        if (!expired) {
+          return serveFromEntry(entry, req);
         }
         store.delete(key);
       }
-    }
-    const res = await handler(req, ctx);
-    if (key != null && res) {
-      const ttl = cacheOpts?.ttl;
-      res.clone().arrayBuffer().then(async (buf) => {
-        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]);
+      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;
           }
-        });
-        headers.push(["content-encoding", "gzip"]);
-        store.set(key, {
-          body,
-          status: res.status,
-          headers,
-          expiresAt: ttl != null ? Date.now() + ttl : null
-        });
-      }).catch(() => {
-      });
+          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 res;
+    return handler(req, ctx);
   };
 }
 var SSR_FILENAME = "index.ssr.js";
@@ -1112,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();
       }
@@ -1156,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 () => {

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.11",
+  "version": "0.1.12",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
@@ -67,24 +67,20 @@
     "@rspack/plugin-react-refresh": "^1.6.1",
     "@swc/core": "^1.15.18",
     "@types/bun": "latest",
-    "@types/react-dom": "^19.2.3",
-    "react-refresh": "^0.17.0",
-    "typescript": "^5.9.3"
+    "react-refresh": "^0.17.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
-    "@types/react-dom": "^19.0.0",
+    "@types/react-dom": "^19.2.3",
     "esbuild": "^0.19.12",
-    "tsup": "^6.7.0"
+    "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.2.1",
     "postcss": "^8.5.8",
-    "postcss-loader": "^8.2.1",
-    "tailwindcss": "^4.2.1"
+    "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;
@@ -264,11 +264,37 @@ async function transformStream(data: Uint8Array, stream: { writable: WritableStr
 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>();
+    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);
@@ -278,45 +304,39 @@ function createRenderCache(
         if (key != null) {
             const entry = store.get(key);
             if (entry) {
-                if (entry.expiresAt == null || Date.now() < entry.expiresAt) {
-                    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 });
+                const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
+                if (!expired) {
+                    return serveFromEntry(entry, req);
                 }
                 store.delete(key);
             }
-        }
 
-        const res = await handler(req, ctx);
-
-        // Compress and cache in the background via clone() so the original
-        // stream is returned to the client immediately.
-        if (key != null && res) {
-            const ttl = cacheOpts?.ttl;
-            res.clone().arrayBuffer().then(async (buf) => {
-                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']);
-                store.set(key, {
-                    body,
-                    status: res.status,
-                    headers,
-                    expiresAt: ttl != null ? Date.now() + ttl : null,
-                });
-            }).catch(() => { /* ignore read errors on clone */ });
+            // 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 res;
+        return handler(req, ctx);
     };
 }
 
@@ -457,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();
             }
@@ -472,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);
 
@@ -501,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) {
@@ -577,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;
 
@@ -743,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;
 

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/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;