hadars 0.2.0 → 0.2.1

package/README.md

@@ -19,27 +19,30 @@ Bring your own router (or none), keep your components as plain React, and get SS
 ## Benchmarks
 
 <!-- BENCHMARK_START -->
-> Last run: 2026-03-18 · 60s · 200 connections · Bun runtime
-> hadars is **7.8x faster** in requests/sec
+> Last run: 2026-03-20 · 60s · 100 connections · Bun runtime
+> hadars is **8.8x faster** in requests/sec
 
 **Throughput** (autocannon, 60s)
 
 | Metric | hadars | Next.js |
 |---|---:|---:|
-| Requests/sec | **132** | 17 |
-| Latency median | **1490 ms** | 2757 ms |
-| Latency p99 | **2289 ms** | 6742 ms |
-| Throughput | **37.38** MB/s | 9.37 MB/s |
-| Build time | 0.7 s | 6.3 s |
+| Requests/sec | **159** | 18 |
+| Latency median | **598 ms** | 2644 ms |
+| Latency p99 | **953 ms** | 6436 ms |
+| Throughput | **45.24** MB/s | 10.28 MB/s |
+| Peak RSS | 1027.8 MB | **469.8 MB** |
+| Avg RSS | 794.1 MB | **417.9 MB** |
+| Build time | 0.8 s | 5.8 s |
 
 **Page load** (Playwright · Chromium headless · median)
 
 | Metric | hadars | Next.js |
 |---|---:|---:|
-| TTFB | **22 ms** | 42 ms |
-| FCP | **124 ms** | 136 ms |
-| DOMContentLoaded | **88 ms** | 126 ms |
-| Load | **155 ms** | 173 ms |
+| TTFB | **17 ms** | 45 ms |
+| FCP | **88 ms** | 128 ms |
+| DOMContentLoaded | **36 ms** | 114 ms |
+| Load | **115 ms** | 157 ms |
+| Peak RSS | 502.8 MB | **282.8 MB** |
 <!-- BENCHMARK_END -->
 
 ## Quick start
@@ -76,17 +79,17 @@ export default config;
 **src/App.tsx**
 ```tsx
 import React from 'react';
-import { HadarsContext, HadarsHead, type HadarsApp, type HadarsRequest } from 'hadars';
+import { HadarsHead, type HadarsApp, type HadarsRequest } from 'hadars';
 
 interface Props { user: { name: string } }
 
-const App: HadarsApp<Props> = ({ user, context }) => (
-    <HadarsContext context={context}>
+const App: HadarsApp<Props> = ({ user }) => (
+    <>
         <HadarsHead status={200}>
             <title>Hello {user.name}</title>
         </HadarsHead>
         <h1>Hello, {user.name}!</h1>
-    </HadarsContext>
+    </>
 );
 
 export const getInitProps = async (req: HadarsRequest): Promise<Props> => ({
@@ -113,6 +116,9 @@ hadars run
 
 # Bundle the app into a single self-contained Lambda .mjs file
 hadars export lambda [output.mjs]
+
+# Bundle the app into a single self-contained Cloudflare Worker .mjs file
+hadars export cloudflare [output.mjs]
 ```
 
 ## Features
@@ -282,6 +288,69 @@ Client-side code (anything that runs in the browser) is an exception: `process.e
 
 Client-side navigation sends a `GET <url>` request with `Accept: application/json` to refetch server data. The Lambda handler returns a JSON `{ serverData }` map for these requests — the same as the regular server does — so `useServerData` works identically in both deployment modes.
 
+## Cloudflare Workers
+
+hadars apps can be deployed to Cloudflare Workers. The Worker handles SSR; static assets (JS, CSS, fonts) are served from R2 or another CDN.
+
+### Single-file bundle
+
+`hadars export cloudflare` produces a self-contained `.mjs` Worker script. Unlike the Lambda adapter, no event format conversion is needed — Cloudflare Workers natively use the Web `Request`/`Response` API.
+
+```bash
+# Outputs cloudflare.mjs in the current directory
+hadars export cloudflare
+
+# Custom output path
+hadars export cloudflare dist/worker.mjs
+```
+
+The command:
+1. Runs `hadars build`
+2. Generates an entry shim with static imports of the SSR module and `out.html`
+3. Bundles everything into a single ESM `.mjs` with esbuild (`platform: browser`, `target: es2022`)
+4. Prints wrangler deploy instructions
+
+### Deploy steps
+
+1. Add a `wrangler.toml` pointing at the output file:
+
+```toml
+name = "my-app"
+main = "cloudflare.mjs"
+compatibility_date = "2024-09-23"
+compatibility_flags = ["nodejs_compat"]
+```
+
+2. Upload `.hadars/static/` assets to R2 and configure routing rules so static file extensions (`*.js`, `*.css`, etc.) are served from R2 and all other requests go to the Worker.
+
+3. Deploy:
+
+```bash
+wrangler deploy
+```
+
+### `createCloudflareHandler` API
+
+```ts
+import { createCloudflareHandler, type CloudflareBundled } from 'hadars/cloudflare';
+import * as ssrModule from './.hadars/index.ssr.js';
+import outHtml from './.hadars/static/out.html';
+import config from './hadars.config';
+
+export default createCloudflareHandler(config, { ssrModule, outHtml });
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `options` | `HadarsOptions` | Same config object used for `dev`/`run` |
+| `bundled` | `CloudflareBundled` | Pre-loaded SSR module + HTML template |
+
+The returned object is a standard Cloudflare Workers export (`{ fetch(req, env, ctx) }`).
+
+### CPU time
+
+hadars uses [slim-react](#slim-react) for SSR which is synchronous and typically renders a page in under 3 ms — well within Cloudflare's 10 ms free-plan CPU budget. Paid plans (Workers Paid) have no CPU time limit.
+
 ## slim-react
 
 hadars ships its own lightweight React-compatible SSR renderer called **slim-react** (`src/slim-react/`). It replaces `react-dom/server` on the server side entirely.

package/cli-lib.ts

@@ -43,6 +43,78 @@ async function loadConfig(configPath: string): Promise<HadarsOptions> {
   return (mod && (mod.default ?? mod)) as HadarsOptions
 }
 
+// ── hadars export cloudflare ─────────────────────────────────────────────────
+
+async function bundleCloudflare(
+    config: HadarsOptions,
+    configPath: string,
+    outputFile: string,
+    cwd: string,
+): Promise<void> {
+    console.log('Building hadars project...')
+    await Hadars.build({ ...config, mode: 'production' })
+
+    const ssrBundle = resolve(cwd, '.hadars', 'index.ssr.js')
+    const outHtml   = resolve(cwd, '.hadars', 'static', 'out.html')
+
+    if (!existsSync(ssrBundle)) {
+        console.error(`SSR bundle not found: ${ssrBundle}`)
+        process.exit(1)
+    }
+    if (!existsSync(outHtml)) {
+        console.error(`HTML template not found: ${outHtml}`)
+        process.exit(1)
+    }
+
+    // Resolve cloudflare.js from the dist/ directory (sibling of cli.js).
+    const cloudflareModule = resolve(dirname(fileURLToPath(import.meta.url)), 'cloudflare.js')
+    const shimPath = join(cwd, `.hadars-cloudflare-shim-${Date.now()}.ts`)
+    const shim = [
+        `import * as ssrModule from ${JSON.stringify(ssrBundle)};`,
+        `import outHtml from ${JSON.stringify(outHtml)};`,
+        `import { createCloudflareHandler } from ${JSON.stringify(cloudflareModule)};`,
+        `import config from ${JSON.stringify(configPath)};`,
+        `export default createCloudflareHandler(config as any, { ssrModule: ssrModule as any, outHtml });`,
+    ].join('\n') + '\n'
+    await writeFile(shimPath, shim, 'utf-8')
+
+    try {
+        const { build: esbuild } = await import('esbuild')
+        console.log(`Bundling Cloudflare Worker → ${outputFile}`)
+        await esbuild({
+            entryPoints: [shimPath],
+            bundle: true,
+            // 'browser' avoids Node.js built-in shims; CF Workers uses Web APIs.
+            // If you use node:* APIs in your app code, add nodejs_compat to wrangler.toml.
+            platform: 'browser',
+            format: 'esm',
+            target: ['es2022'],
+            outfile: outputFile,
+            sourcemap: false,
+            loader: { '.html': 'text', '.tsx': 'tsx', '.ts': 'ts' },
+            // @rspack/* is build-time only — never imported at Worker runtime.
+            external: ['@rspack/*'],
+            // Cloudflare Workers supports the Web Crypto API natively; suppress
+            // esbuild's attempt to polyfill node:crypto.
+            define: { 'global': 'globalThis' },
+        })
+        console.log(`Cloudflare Worker bundle written to ${outputFile}`)
+        console.log(`\nDeploy instructions:`)
+        console.log(`  1. Ensure wrangler.toml points to the output file:`)
+        console.log(`       name = "my-app"`)
+        console.log(`       main = "${outputFile}"`)
+        console.log(`       compatibility_date = "2024-09-23"`)
+        console.log(`       compatibility_flags = ["nodejs_compat"]`)
+        console.log(`  2. Upload .hadars/static/ assets to R2 (or another CDN):`)
+        console.log(`       wrangler r2 object put my-bucket/assets/ --file .hadars/static/ --recursive`)
+        console.log(`  3. Add a route rule in wrangler.toml to send *.js / *.css to R2`)
+        console.log(`     and all other requests to the Worker.`)
+        console.log(`  4. Deploy: wrangler deploy`)
+    } finally {
+        await unlink(shimPath).catch(() => {})
+    }
+}
+
 // ── hadars export lambda ────────────────────────────────────────────────────
 
 async function bundleLambda(
@@ -172,7 +244,7 @@ dist/
 
   'src/App.tsx': () =>
 `import React from 'react';
-import { HadarsContext, HadarsHead, type HadarsApp } from 'hadars';
+import { HadarsHead, type HadarsApp } from 'hadars';
 
 const css = \`
   *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
@@ -284,15 +356,15 @@ const css = \`
 
 \`;
 
-const App: HadarsApp<{}> = ({ context }) => {
+const App: HadarsApp<{}> = () => {
   const [count, setCount] = React.useState(0);
 
   return (
-    <HadarsContext context={context}>
+    <>
       <HadarsHead status={200}>
         <title>My App</title>
-        <meta id="viewport" name="viewport" content="width=device-width, initial-scale=1" />
-        <style id="app-styles" dangerouslySetInnerHTML={{ __html: css }} />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <style data-id="app-styles" dangerouslySetInnerHTML={{ __html: css }} />
       </HadarsHead>
 
       <nav className="nav">
@@ -350,7 +422,7 @@ const App: HadarsApp<{}> = ({ context }) => {
         </div>
       </div>
 
-    </HadarsContext>
+    </>
   );
 };
 
@@ -388,7 +460,7 @@ Done! Next steps:
 // ── CLI entry ─────────────────────────────────────────────────────────────────
 
 function usage(): void {
-  console.log('Usage: hadars <new <name> | dev | build | run | export lambda [output.mjs]>')
+  console.log('Usage: hadars <new <name> | dev | build | run | export lambda [output.mjs] | export cloudflare [output.mjs]>')
 }
 
 export async function runCli(argv: string[], cwd = process.cwd()): Promise<void> {
@@ -436,13 +508,18 @@ export async function runCli(argv: string[], cwd = process.cwd()): Promise<void>
             process.exit(0)
         case 'export': {
             const subCmd = argv[3]
-            if (subCmd !== 'lambda') {
-                console.error(`Unknown export target: ${subCmd ?? '(none)'}. Did you mean: hadars export lambda`)
+            if (subCmd === 'lambda') {
+                const outputFile = resolve(cwd, argv[4] ?? 'lambda.mjs')
+                await bundleLambda(cfg, configPath, outputFile, cwd)
+                process.exit(0)
+            } else if (subCmd === 'cloudflare') {
+                const outputFile = resolve(cwd, argv[4] ?? 'cloudflare.mjs')
+                await bundleCloudflare(cfg, configPath, outputFile, cwd)
+                process.exit(0)
+            } else {
+                console.error(`Unknown export target: ${subCmd ?? '(none)'}. Supported: lambda, cloudflare`)
                 process.exit(1)
             }
-            const outputFile = resolve(cwd, argv[4] ?? 'lambda.mjs')
-            await bundleLambda(cfg, configPath, outputFile, cwd)
-            process.exit(0)
         }
         case 'run':
             console.log('Running project...')

package/dist/chunk-HWOLYLPF.js

@@ -0,0 +1,332 @@
+import {
+  renderPreflight,
+  renderToString
+} from "./chunk-LY5MTHFV.js";
+import {
+  createElement
+} from "./chunk-OS3V4CPN.js";
+
+// src/utils/cookies.ts
+var parseCookies = (cookieString) => {
+  const cookies = {};
+  if (!cookieString) {
+    return cookies;
+  }
+  const pairs = cookieString.split(";");
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index > -1) {
+      const key = pair.slice(0, index).trim();
+      const value = pair.slice(index + 1).trim();
+      try {
+        cookies[key] = decodeURIComponent(value);
+      } catch {
+        cookies[key] = value;
+      }
+    }
+  }
+  return cookies;
+};
+
+// src/utils/request.tsx
+var parseRequest = (request) => {
+  const url = new URL(request.url);
+  const cookies = request.headers.get("Cookie") || "";
+  const cookieRecord = parseCookies(cookies);
+  return Object.assign(request, { pathname: url.pathname, search: url.search, location: url.pathname + url.search, cookies: cookieRecord });
+};
+
+// src/utils/proxyHandler.tsx
+var cloneHeaders = (headers) => {
+  return new Headers(headers);
+};
+var getCORSHeaders = (req) => {
+  const origin = req.headers.get("Origin") || "*";
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
+    "Access-Control-Allow-Headers": req.headers.get("Access-Control-Request-Headers") || "*",
+    "Access-Control-Allow-Credentials": "true"
+  };
+};
+var createProxyHandler = (options) => {
+  const { proxy, proxyCORS } = options;
+  if (!proxy) {
+    return () => void 0;
+  }
+  if (typeof proxy === "function") {
+    return async (req) => {
+      if (req.method === "OPTIONS" && options.proxyCORS) {
+        return new Response(null, {
+          status: 204,
+          headers: getCORSHeaders(req)
+        });
+      }
+      const res = await proxy(req);
+      if (res && proxyCORS) {
+        const modifiedHeaders = new Headers(res.headers);
+        Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
+          modifiedHeaders.set(key, value);
+        });
+        return new Response(res.body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: modifiedHeaders
+        });
+      }
+      return res || void 0;
+    };
+  }
+  const proxyRules = Object.entries(proxy).sort((a, b) => b[0].length - a[0].length);
+  return async (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;
+        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: 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);
+        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,
+          headers: clonedRes
+        });
+      }
+    }
+    return void 0;
+  };
+};
+
+// src/utils/response.tsx
+var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+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",
+  httpEquiv: "http-equiv",
+  charSet: "charset",
+  crossOrigin: "crossorigin",
+  noModule: "nomodule",
+  referrerPolicy: "referrerpolicy",
+  fetchPriority: "fetchpriority",
+  hrefLang: "hreflang"
+};
+function renderHeadTag(tag, id, opts, selfClose = false) {
+  let attrs = ` id="${escAttr(id)}"`;
+  let inner = "";
+  for (const [k, v] of Object.entries(opts)) {
+    if (k === "key" || k === "children") continue;
+    if (k === "dangerouslySetInnerHTML") {
+      inner = v.__html ?? "";
+      continue;
+    }
+    const attr = ATTR[k] ?? k;
+    if (v === true) attrs += ` ${attr}`;
+    else if (v !== false && v != null) attrs += ` ${attr}="${escAttr(String(v))}"`;
+  }
+  return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
+}
+function buildHeadHtml(seoData) {
+  let html = `<title>${escText(seoData.title ?? "")}</title>`;
+  for (const [id, opts] of Object.entries(seoData.meta))
+    html += renderHeadTag("meta", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.link))
+    html += renderHeadTag("link", id, opts, true);
+  for (const [id, opts] of Object.entries(seoData.style))
+    html += renderHeadTag("style", id, opts);
+  for (const [id, opts] of Object.entries(seoData.script))
+    html += renderHeadTag("script", id, opts);
+  return html;
+}
+var getReactResponse = async (req, opts) => {
+  const App = opts.document.body;
+  const { getInitProps, getFinalProps } = opts.document;
+  const context = {
+    head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 }
+  };
+  let props = {
+    ...getInitProps ? await getInitProps(req) : {},
+    location: req.location,
+    context
+  };
+  const unsuspend = { cache: /* @__PURE__ */ new Map() };
+  globalThis.__hadarsUnsuspend = unsuspend;
+  globalThis.__hadarsContext = context;
+  const element = createElement(App, props);
+  try {
+    await renderPreflight(element);
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
+    globalThis.__hadarsContext = null;
+  }
+  const status = context.head.status;
+  const getAppBody = async () => {
+    globalThis.__hadarsUnsuspend = unsuspend;
+    globalThis.__hadarsContext = context;
+    try {
+      return await renderToString(element);
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
+      globalThis.__hadarsContext = null;
+    }
+  };
+  const finalize = async () => {
+    const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+    const serverData = {};
+    let hasServerData = false;
+    for (const [key, entry] of unsuspend.cache) {
+      if (entry.status === "fulfilled") {
+        serverData[key] = entry.value;
+        hasServerData = true;
+      }
+    }
+    return {
+      clientProps: {
+        ...restProps,
+        location: req.location,
+        ...hasServerData ? { __serverData: serverData } : {}
+      }
+    };
+  };
+  return { head: context.head, status, getAppBody, finalize };
+};
+
+// src/utils/ssrHandler.ts
+var HEAD_MARKER = '<meta name="HADARS_HEAD">';
+var BODY_MARKER = '<meta name="HADARS_BODY">';
+var encoder = new TextEncoder();
+async function buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml) {
+  const [precontentHtml, postContent] = await Promise.resolve(getPrecontentHtml(headHtml));
+  const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
+  return precontentHtml + `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent;
+}
+var makePrecontentHtmlGetter = (htmlFilePromise) => {
+  let preHead = null;
+  let postHead = null;
+  let postContent = null;
+  return (headHtml) => {
+    if (preHead !== null) {
+      return [preHead + headHtml + postHead, postContent];
+    }
+    return htmlFilePromise.then((html) => {
+      const headEnd = html.indexOf(HEAD_MARKER);
+      const contentStart = html.indexOf(BODY_MARKER);
+      preHead = html.slice(0, headEnd);
+      postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
+      postContent = html.slice(contentStart + BODY_MARKER.length);
+      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);
+  };
+}
+
+export {
+  parseRequest,
+  createProxyHandler,
+  buildHeadHtml,
+  getReactResponse,
+  buildSsrHtml,
+  makePrecontentHtmlGetter,
+  createRenderCache
+};