hadars 0.1.1

package/dist/cli.js

@@ -0,0 +1,1441 @@
+#!/usr/bin/env node
+
+// cli-lib.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve, join } from "node:path";
+
+// 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) => {
+    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)) {
+        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 proxyReq = new Request(targetURL.toString(), {
+          method: req.method,
+          headers: sendHeaders,
+          body: ["GET", "HEAD"].includes(req.method) ? void 0 : req.body,
+          redirect: "follow"
+        });
+        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");
+        return new Response(body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: clonedRes
+        });
+      }
+    }
+    return void 0;
+  };
+};
+
+// 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();
+      cookies[key] = decodeURIComponent(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/upgradeRequest.tsx
+var upgradeHandler = (options) => {
+  const { wsPath = "/ws" } = options;
+  if (options.websocket) {
+    return (req, ctx) => {
+      if (req.pathname === wsPath) {
+        return ctx.upgrade(req);
+      }
+      return false;
+    };
+  }
+  return null;
+};
+
+// src/utils/response.tsx
+import { createRequire } from "node:module";
+import pathMod from "node:path";
+import { pathToFileURL } from "node:url";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var _renderToStaticMarkup = null;
+async function getStaticMarkupRenderer() {
+  if (!_renderToStaticMarkup) {
+    const req = createRequire(pathMod.resolve(process.cwd(), "__hadars_fake__.js"));
+    const resolved = req.resolve("react-dom/server");
+    const mod = await import(pathToFileURL(resolved).href);
+    _renderToStaticMarkup = mod.renderToStaticMarkup;
+  }
+  return _renderToStaticMarkup;
+}
+var getHeadHtml = (seoData, renderToStaticMarkup) => {
+  const metaEntries = Object.entries(seoData.meta);
+  const linkEntries = Object.entries(seoData.link);
+  const styleEntries = Object.entries(seoData.style);
+  const scriptEntries = Object.entries(seoData.script);
+  return renderToStaticMarkup(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("title", { children: seoData.title }),
+      metaEntries.map(([id, options]) => /* @__PURE__ */ jsx(
+        "meta",
+        {
+          id,
+          ...options
+        },
+        id
+      )),
+      linkEntries.map(([id, options]) => /* @__PURE__ */ jsx(
+        "link",
+        {
+          id,
+          ...options
+        },
+        id
+      )),
+      styleEntries.map(([id, options]) => /* @__PURE__ */ jsx(
+        "style",
+        {
+          id,
+          ...options
+        },
+        id
+      )),
+      scriptEntries.map(([id, options]) => /* @__PURE__ */ jsx(
+        "script",
+        {
+          id,
+          ...options
+        },
+        id
+      ))
+    ] })
+  );
+};
+var getReactResponse = async (req, opts) => {
+  const App = opts.document.body;
+  const { getInitProps, getAfterRenderProps, getFinalProps } = opts.document;
+  const renderToStaticMarkup = await getStaticMarkupRenderer();
+  const unsuspend = {
+    cache: /* @__PURE__ */ new Map(),
+    hasPending: false
+  };
+  const processUnsuspend = async () => {
+    const pending = [...unsuspend.cache.values()].filter((e) => e.status === "pending").map((e) => e.promise);
+    await Promise.all(pending);
+  };
+  const context = {
+    head: {
+      title: "Hadars App",
+      meta: {},
+      link: {},
+      style: {},
+      script: {},
+      status: 200
+    },
+    _unsuspend: unsuspend
+  };
+  let props = {
+    ...getInitProps ? await getInitProps(req) : {},
+    location: req.location,
+    context
+  };
+  let html = "";
+  let iters = 0;
+  do {
+    unsuspend.hasPending = false;
+    try {
+      globalThis.__hadarsUnsuspend = unsuspend;
+      html = renderToStaticMarkup(/* @__PURE__ */ jsx(App, { ...props }));
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
+    }
+    if (unsuspend.hasPending)
+      await processUnsuspend();
+  } while (unsuspend.hasPending && ++iters < 25);
+  props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
+  try {
+    globalThis.__hadarsUnsuspend = unsuspend;
+    renderToStaticMarkup(
+      /* @__PURE__ */ jsx(App, { ...{
+        ...props,
+        location: req.location,
+        context
+      } })
+    );
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
+  }
+  const serverData = {};
+  for (const [k, v] of unsuspend.cache) {
+    if (v.status === "fulfilled")
+      serverData[k] = v.value;
+  }
+  const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+  const clientProps = {
+    ...restProps,
+    location: req.location,
+    ...Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}
+  };
+  const ReactPage = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("div", { id: "app", children: /* @__PURE__ */ jsx(App, { ...{
+      ...props,
+      location: req.location,
+      context
+    } }) }),
+    /* @__PURE__ */ jsx("script", { id: "hadars", type: "application/json", dangerouslySetInnerHTML: { __html: JSON.stringify({ hadars: { props: clientProps } }) } })
+  ] });
+  return {
+    ReactPage,
+    status: context.head.status,
+    headHtml: getHeadHtml(context.head, renderToStaticMarkup),
+    renderPayload: {
+      appProps: { ...props, location: req.location, context },
+      clientProps
+    }
+  };
+};
+
+// src/utils/rspack.ts
+import rspack from "@rspack/core";
+import ReactRefreshPlugin from "@rspack/plugin-react-refresh";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import pathMod2 from "node:path";
+import { existsSync } from "node:fs";
+var __dirname = process.cwd();
+var packageDir = pathMod2.dirname(fileURLToPath(import.meta.url));
+var clientScriptPath = pathMod2.resolve(packageDir, "template.html");
+var loaderPath = existsSync(pathMod2.resolve(packageDir, "loader.cjs")) ? pathMod2.resolve(packageDir, "loader.cjs") : pathMod2.resolve(packageDir, "loader.ts");
+var getConfigBase = (mode) => {
+  const isDev = mode === "development";
+  return {
+    experiments: {
+      css: true,
+      outputModule: true
+    },
+    resolve: {
+      modules: [
+        path.resolve(__dirname, "node_modules"),
+        // 'node_modules' (relative) enables the standard upward-traversal
+        // resolution so rspack can find transitive deps (e.g. webpack-dev-server)
+        // that live in a parent node_modules when running from a sub-project.
+        "node_modules"
+      ],
+      tsConfig: path.resolve(__dirname, "tsconfig.json"),
+      extensions: [".tsx", ".ts", ".js", ".jsx"]
+    },
+    module: {
+      rules: [
+        {
+          test: /\.mdx?$/,
+          use: [
+            {
+              loader: "@mdx-js/loader",
+              options: {}
+            }
+          ]
+        },
+        {
+          test: /\.css$/,
+          use: ["postcss-loader"],
+          type: "css"
+        },
+        {
+          test: /\.svg$/i,
+          issuer: /\.[jt]sx?$/,
+          use: ["@svgr/webpack"]
+        },
+        {
+          test: /\.m?jsx?$/,
+          resolve: {
+            fullySpecified: false
+          },
+          exclude: [loaderPath],
+          use: [
+            // Transforms loadModule('./path') based on build target.
+            // Runs before swc-loader (loaders execute right-to-left).
+            {
+              loader: loaderPath
+            },
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "ecmascript",
+                    jsx: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic",
+                      development: isDev,
+                      refresh: isDev
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          type: "javascript/auto"
+        },
+        {
+          test: /\.tsx?$/,
+          resolve: {
+            fullySpecified: false
+          },
+          exclude: [loaderPath],
+          use: [
+            {
+              loader: loaderPath
+            },
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "typescript",
+                    tsx: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic",
+                      development: isDev,
+                      refresh: isDev
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          type: "javascript/auto"
+        }
+      ]
+    }
+  };
+};
+var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
+  const Config = getConfigBase(opts.mode);
+  const { base } = opts;
+  const isDev = opts.mode === "development";
+  const localConfig = {
+    ...Config,
+    module: {
+      ...Config.module,
+      rules: (Config.module && Array.isArray(Config.module.rules) ? Config.module.rules : []).map((r) => {
+        const nr = { ...r };
+        if (r && Array.isArray(r.use)) {
+          nr.use = r.use.map((u) => ({ ...typeof u === "object" ? u : { loader: u } }));
+        }
+        return nr;
+      })
+    }
+  };
+  if (opts.swcPlugins && Array.isArray(opts.swcPlugins) && opts.swcPlugins.length > 0) {
+    const rules = localConfig.module && localConfig.module.rules;
+    if (Array.isArray(rules)) {
+      for (const rule of rules) {
+        const ruleUse = rule;
+        if (ruleUse.use && Array.isArray(ruleUse.use)) {
+          for (const entry2 of ruleUse.use) {
+            const useEntry = entry2;
+            if (useEntry && useEntry.loader && typeof useEntry.loader === "string" && useEntry.loader.includes("swc-loader")) {
+              const options = useEntry.options || {};
+              useEntry.options = options;
+              useEntry.options.jsc = useEntry.options.jsc || {};
+              useEntry.options.jsc.experimental = useEntry.options.jsc.experimental || {};
+              useEntry.options.jsc.experimental.runPluginFirst = true;
+              const existingPlugins = Array.isArray(useEntry.options.jsc.experimental.plugins) ? useEntry.options.jsc.experimental.plugins : [];
+              const incomingPlugins = Array.isArray(opts.swcPlugins) ? opts.swcPlugins : [];
+              const seen = /* @__PURE__ */ new Set();
+              const merged = [];
+              for (const p of existingPlugins.concat(incomingPlugins)) {
+                const name = Array.isArray(p) && p.length > 0 ? String(p[0]) : String(p);
+                if (!seen.has(name)) {
+                  seen.add(name);
+                  merged.push(p);
+                }
+              }
+              useEntry.options.jsc.experimental.plugins = merged;
+            }
+          }
+        }
+      }
+    }
+  }
+  const isServerBuild = Boolean(
+    opts.output && typeof opts.output === "object" && (opts.output.library || String(opts.output.filename || "").includes("ssr"))
+  );
+  const resolveAliases = isServerBuild ? {
+    // force all react imports to resolve to this project's react
+    react: path.resolve(process.cwd(), "node_modules", "react"),
+    "react-dom": path.resolve(process.cwd(), "node_modules", "react-dom"),
+    // also map react/jsx-runtime to avoid duplicates when automatic runtime is used
+    "react/jsx-runtime": path.resolve(process.cwd(), "node_modules", "react", "jsx-runtime.js"),
+    "react/jsx-dev-runtime": path.resolve(process.cwd(), "node_modules", "react", "jsx-dev-runtime.js"),
+    // ensure emotion packages resolve to the project's node_modules so we don't pick up a browser-specific entry
+    "@emotion/react": path.resolve(process.cwd(), "node_modules", "@emotion", "react"),
+    "@emotion/server": path.resolve(process.cwd(), "node_modules", "@emotion", "server"),
+    "@emotion/cache": path.resolve(process.cwd(), "node_modules", "@emotion", "cache"),
+    "@emotion/styled": path.resolve(process.cwd(), "node_modules", "@emotion", "styled")
+  } : void 0;
+  const externals = isServerBuild ? [
+    "react",
+    "react-dom",
+    // keep common aliases external as well
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    // emotion should be external on server builds to avoid client/browser code
+    "@emotion/react",
+    "@emotion/server",
+    "@emotion/cache",
+    "@emotion/styled"
+  ] : void 0;
+  const extraPlugins = [];
+  if (opts.define && typeof opts.define === "object") {
+    const DefinePlugin = rspack.DefinePlugin || rspack.plugins?.DefinePlugin;
+    if (DefinePlugin) {
+      extraPlugins.push(new DefinePlugin(opts.define));
+    } else {
+      extraPlugins.push({ name: "DefinePlugin", value: opts.define });
+    }
+  }
+  const resolveConfig = {
+    extensions: [".tsx", ".ts", ".js", ".jsx"],
+    alias: resolveAliases,
+    // for server builds prefer the package "main"/"module" fields and avoid "browser" so we don't pick browser-specific entrypoints
+    mainFields: isServerBuild ? ["main", "module"] : ["browser", "module", "main"]
+  };
+  return {
+    entry,
+    resolve: resolveConfig,
+    output: {
+      ...opts.output,
+      clean: false
+    },
+    mode: opts.mode,
+    externals,
+    plugins: [
+      new rspack.HtmlRspackPlugin({
+        publicPath: base || "/",
+        template: clientScriptPath,
+        scriptLoading: "module",
+        filename: "out.html",
+        inject: "body"
+      }),
+      isDev && new ReactRefreshPlugin(),
+      includeHotPlugin && isDev && new rspack.HotModuleReplacementPlugin(),
+      ...extraPlugins
+    ],
+    ...localConfig,
+    // 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: {
+      ...localConfig.experiments || {},
+      outputModule: isServerBuild
+    }
+  };
+};
+var createClientCompiler = (entry, opts) => {
+  return rspack(buildCompilerConfig(entry, opts, false));
+};
+var compileEntry = async (entry, opts) => {
+  const compiler = rspack(buildCompilerConfig(entry, opts, true));
+  if (opts.watch) {
+    await new Promise((resolve2, reject) => {
+      let first = true;
+      compiler.watch({}, (err, stats) => {
+        if (err) {
+          if (first) {
+            first = false;
+            reject(err);
+          } else {
+            console.error("rspack watch error", err);
+          }
+          return;
+        }
+        console.log(stats?.toString({
+          colors: true,
+          modules: true,
+          children: true,
+          chunks: true,
+          chunkModules: true
+        }));
+        if (first) {
+          first = false;
+          resolve2(stats);
+        } else {
+          try {
+            opts.onChange && opts.onChange(stats);
+          } catch (e) {
+            console.error("onChange handler error", e);
+          }
+        }
+      });
+    });
+    return;
+  }
+  await new Promise((resolve2, reject) => {
+    compiler.run((err, stats) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      console.log(stats?.toString({
+        colors: true,
+        modules: true,
+        children: true,
+        chunks: true,
+        chunkModules: true
+      }));
+      resolve2(stats);
+    });
+  });
+};
+
+// src/utils/runtime.ts
+var isBun = typeof globalThis.Bun !== "undefined";
+var isDeno = typeof globalThis.Deno !== "undefined";
+var isNode = !isBun && !isDeno;
+
+// src/utils/serve.ts
+function nodeReadableToWebStream(readable) {
+  const enc = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      readable.on("data", (chunk) => {
+        controller.enqueue(
+          typeof chunk === "string" ? enc.encode(chunk) : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+        );
+      });
+      readable.on("end", () => controller.close());
+      readable.on("error", (err) => controller.error(err));
+    },
+    cancel() {
+      readable.destroy?.();
+    }
+  });
+}
+var noopCtx = { upgrade: () => false };
+async function serve(port, fetchHandler, websocket) {
+  if (isBun) {
+    globalThis.Bun.serve({
+      port,
+      websocket,
+      async fetch(req, server2) {
+        const ctx = { upgrade: (r) => server2.upgrade(r) };
+        return await fetchHandler(req, ctx) ?? void 0;
+      }
+    });
+    return;
+  }
+  if (isDeno) {
+    globalThis.Deno.serve({
+      port,
+      handler: async (req) => {
+        const res = await fetchHandler(req, noopCtx);
+        return res ?? new Response("Not Found", { status: 404 });
+      }
+    });
+    return;
+  }
+  const { createServer } = await import("node:http");
+  const server = createServer(async (nodeReq, nodeRes) => {
+    try {
+      const chunks = [];
+      if (!["GET", "HEAD"].includes(nodeReq.method ?? "GET")) {
+        for await (const chunk of nodeReq) {
+          chunks.push(chunk);
+        }
+      }
+      const body = chunks.length > 0 ? Buffer.concat(chunks) : void 0;
+      const url = `http://localhost:${port}${nodeReq.url ?? "/"}`;
+      const reqInit = {
+        method: nodeReq.method ?? "GET",
+        headers: new Headers(nodeReq.headers)
+      };
+      if (body) {
+        reqInit.body = body;
+        reqInit.duplex = "half";
+      }
+      const req = new Request(url, reqInit);
+      const res = await fetchHandler(req, noopCtx);
+      const response = res ?? new Response("Not Found", { status: 404 });
+      const headers = {};
+      response.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      nodeRes.writeHead(response.status, headers);
+      if (response.body) {
+        const reader = response.body.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          await new Promise(
+            (resolve2, reject) => nodeRes.write(value, (err) => err ? reject(err) : resolve2())
+          );
+        }
+      }
+    } catch (err) {
+      console.error("[hadars] request error", err);
+      if (!nodeRes.headersSent)
+        nodeRes.writeHead(500);
+    } finally {
+      nodeRes.end();
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    server.listen(port, () => resolve2());
+    server.once("error", reject);
+  });
+}
+
+// src/utils/staticFile.ts
+import { readFile, stat } from "node:fs/promises";
+var MIME = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css",
+  js: "application/javascript",
+  mjs: "application/javascript",
+  cjs: "application/javascript",
+  json: "application/json",
+  map: "application/json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  txt: "text/plain",
+  xml: "application/xml",
+  pdf: "application/pdf"
+};
+async function tryServeFile(filePath) {
+  try {
+    await stat(filePath);
+  } catch {
+    return null;
+  }
+  try {
+    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 } });
+  } catch {
+    return null;
+  }
+}
+
+// src/build.ts
+import { RspackDevServer } from "@rspack/dev-server";
+import pathMod3 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+import { createRequire as createRequire2 } from "node:module";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+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 _renderToReadableStream = null;
+async function getReadableStreamRenderer() {
+  if (!_renderToReadableStream) {
+    const req = createRequire2(pathMod3.resolve(process.cwd(), "__hadars_fake__.js"));
+    const resolved = req.resolve("react-dom/server.browser");
+    const mod = await import(pathToFileURL2(resolved).href);
+    _renderToReadableStream = mod.renderToReadableStream;
+  }
+  return _renderToReadableStream;
+}
+var _renderToString = null;
+async function getRenderToString() {
+  if (!_renderToString) {
+    const req = createRequire2(pathMod3.resolve(process.cwd(), "__hadars_fake__.js"));
+    const resolved = req.resolve("react-dom/server");
+    const mod = await import(pathToFileURL2(resolved).href);
+    _renderToString = mod.renderToString;
+  }
+  return _renderToString;
+}
+var RenderWorkerPool = class {
+  workers = [];
+  pending = /* @__PURE__ */ new Map();
+  nextId = 0;
+  rrIndex = 0;
+  constructor(workerPath, size, ssrBundlePath) {
+    this._init(workerPath, size, ssrBundlePath);
+  }
+  _init(workerPath, size, ssrBundlePath) {
+    import("node:worker_threads").then(({ Worker }) => {
+      for (let i = 0; i < size; i++) {
+        const w = new Worker(workerPath, { workerData: { ssrBundlePath } });
+        w.on("message", (msg) => {
+          const { id, type, html, error, chunk } = msg;
+          const p = this.pending.get(id);
+          if (!p)
+            return;
+          if (p.kind === "renderStream") {
+            if (type === "chunk") {
+              p.controller.enqueue(chunk);
+              return;
+            }
+            this.pending.delete(id);
+            if (type === "done")
+              p.controller.close();
+            else
+              p.controller.error(new Error(error ?? "Stream error"));
+            return;
+          }
+          this.pending.delete(id);
+          if (error)
+            p.reject(new Error(error));
+          else
+            p.resolve(html);
+        });
+        w.on("error", (err) => {
+          console.error("[hadars] Render worker error:", err);
+        });
+        this.workers.push(w);
+      }
+    }).catch((err) => {
+      console.error("[hadars] Failed to initialise render worker pool:", err);
+    });
+  }
+  nextWorker() {
+    const w = this.workers[this.rrIndex % this.workers.length];
+    this.rrIndex++;
+    return w;
+  }
+  /** Offload a full renderToString call. Returns the HTML string. */
+  renderString(appProps, clientProps) {
+    return new Promise((resolve2, reject) => {
+      const id = this.nextId++;
+      this.pending.set(id, { kind: "renderString", resolve: resolve2, reject });
+      this.nextWorker().postMessage({ id, type: "renderString", appProps, clientProps });
+    });
+  }
+  /** Offload a renderToReadableStream call. Returns a ReadableStream fed by
+   *  worker chunk messages. */
+  renderStream(appProps, clientProps) {
+    let controller;
+    const stream = new ReadableStream({
+      start: (ctrl) => {
+        controller = ctrl;
+      }
+    });
+    const id = this.nextId++;
+    this.pending.set(id, { kind: "renderStream", controller });
+    this.nextWorker().postMessage({ id, type: "renderStream", appProps, clientProps });
+    return stream;
+  }
+  async terminate() {
+    await Promise.all(this.workers.map((w) => w.terminate()));
+  }
+};
+async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, streaming, renderPool, renderPayload) {
+  const renderToString = !streaming && !renderPool ? await getRenderToString() : null;
+  const renderReadableStream = streaming && !renderPool ? await getReadableStreamRenderer() : null;
+  const unsuspendForRender = renderPayload?.appProps?.context?._unsuspend ?? null;
+  if (!streaming) {
+    const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
+    let bodyHtml;
+    if (renderPool && renderPayload) {
+      bodyHtml = await renderPool.renderString(renderPayload.appProps, renderPayload.clientProps);
+    } else {
+      try {
+        globalThis.__hadarsUnsuspend = unsuspendForRender;
+        bodyHtml = renderToString(ReactPage);
+      } finally {
+        globalThis.__hadarsUnsuspend = null;
+      }
+    }
+    return new Response(precontentHtml + bodyHtml + postContent, {
+      headers: { "Content-Type": "text/html; charset=utf-8" },
+      status
+    });
+  }
+  const responseStream = new ReadableStream({
+    async start(controller) {
+      const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
+      controller.enqueue(encoder.encode(precontentHtml));
+      let bodyStream;
+      if (renderPool && renderPayload) {
+        bodyStream = renderPool.renderStream(renderPayload.appProps, renderPayload.clientProps);
+      } else {
+        let streamPromise;
+        try {
+          globalThis.__hadarsUnsuspend = unsuspendForRender;
+          streamPromise = renderReadableStream(ReactPage);
+        } finally {
+          globalThis.__hadarsUnsuspend = null;
+        }
+        bodyStream = await streamPromise;
+      }
+      const reader = bodyStream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        controller.enqueue(value);
+      }
+      controller.enqueue(encoder.encode(postContent));
+      controller.close();
+    }
+  });
+  return new Response(responseStream, {
+    headers: { "Content-Type": "text/html; charset=utf-8" },
+    status
+  });
+}
+var makePrecontentHtmlGetter = (htmlFilePromise) => {
+  let preHead = null;
+  let postHead = null;
+  let postContent = null;
+  return async (headHtml) => {
+    if (preHead === null || postHead === null || postContent === null) {
+      const html = await htmlFilePromise;
+      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];
+  };
+};
+var SSR_FILENAME = "index.ssr.js";
+var __dirname2 = process.cwd();
+var getSuffix = (mode) => mode === "development" ? `?v=${Date.now()}` : "";
+var HadarsFolder = "./.hadars";
+var StaticPath = `${HadarsFolder}/static`;
+var validateOptions = (options) => {
+  if (!options.entry) {
+    throw new Error("Entry file is required");
+  }
+  if (options.mode !== "development" && options.mode !== "production") {
+    throw new Error("Mode must be either 'development' or 'production'");
+  }
+};
+var resolveWorkerCmd = (packageDir2) => {
+  const tsPath = pathMod3.resolve(packageDir2, "ssr-watch.ts");
+  const jsPath = pathMod3.resolve(packageDir2, "ssr-watch.js");
+  if (isBun && existsSync2(tsPath)) {
+    return ["bun", tsPath];
+  }
+  if (isDeno && existsSync2(tsPath)) {
+    return ["deno", "run", "--allow-all", tsPath];
+  }
+  if (existsSync2(tsPath)) {
+    const allArgs = [...process.execArgv, process.argv[1] ?? ""];
+    const hasTsx = allArgs.some((a) => a.includes("tsx"));
+    const hasTsNode = allArgs.some((a) => a.includes("ts-node"));
+    if (hasTsx)
+      return ["tsx", tsPath];
+    if (hasTsNode)
+      return ["ts-node", tsPath];
+  }
+  if (existsSync2(jsPath)) {
+    return ["node", jsPath];
+  }
+  throw new Error(
+    `[hadars] SSR worker not found. Expected:
+  ${jsPath}
+Run "npm run build:cli" to compile it, or launch hadars via a TypeScript runner:
+  npx tsx cli.ts dev`
+  );
+};
+var dev = async (options) => {
+  await fs.rm(HadarsFolder, { recursive: true, force: true });
+  let { port = 9090, baseURL = "" } = options;
+  console.log(`Starting Hadars on port ${port}`);
+  validateOptions(options);
+  const handleProxy = createProxyHandler(options);
+  const handleWS = upgradeHandler(options);
+  const handler = options.fetch;
+  const entry = pathMod3.resolve(__dirname2, options.entry);
+  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);
+  } catch (err) {
+    console.error("Failed to read client script from package dist, falling back to src", err);
+    throw err;
+  }
+  const tmpFilePath = pathMod3.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
+  await fs.writeFile(tmpFilePath, clientScript);
+  let ssrBuildId = Date.now();
+  const clientCompiler = createClientCompiler(tmpFilePath, {
+    target: "web",
+    output: {
+      filename: "index.js",
+      path: pathMod3.resolve(__dirname2, StaticPath)
+    },
+    base: baseURL,
+    mode: "development",
+    swcPlugins: options.swcPlugins,
+    define: options.define
+  });
+  const devServer = new RspackDevServer({
+    port: hmrPort,
+    hot: true,
+    liveReload: false,
+    client: {
+      webSocketURL: `ws://localhost:${hmrPort}/ws`
+    },
+    devMiddleware: {
+      writeToDisk: true
+    },
+    headers: { "Access-Control-Allow-Origin": "*" },
+    allowedHosts: "all"
+  }, clientCompiler);
+  console.log(`Starting HMR dev server on port ${hmrPort}`);
+  await new Promise((resolve2, reject) => {
+    let resolved = false;
+    clientCompiler.hooks.done.tap("initial-build", (stats) => {
+      if (!resolved) {
+        resolved = true;
+        console.log(stats.toString({ colors: true }));
+        resolve2();
+      }
+    });
+    devServer.start().catch(reject);
+  });
+  const workerCmd = resolveWorkerCmd(packageDir2);
+  console.log("Spawning SSR worker:", workerCmd.join(" "), "entry:", entry);
+  const child = spawn(workerCmd[0], [
+    ...workerCmd.slice(1),
+    `--entry=${entry}`,
+    `--outDir=${HadarsFolder}`,
+    `--outFile=${SSR_FILENAME}`,
+    `--base=${baseURL}`
+  ], { stdio: "pipe" });
+  child.stdin?.end();
+  const stdoutWebStream = nodeReadableToWebStream(child.stdout);
+  const stderrWebStream = nodeReadableToWebStream(child.stderr);
+  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) {
+      }
+      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 (stdoutReader) {
+    const reader = stdoutReader;
+    (async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          const chunk = decoder.decode(value, { stream: true });
+          try {
+            process.stdout.write(chunk);
+          } catch (e) {
+          }
+          if (chunk.includes(rebuildMarker)) {
+            ssrBuildId = Date.now();
+            console.log("[hadars] SSR bundle updated, build id:", ssrBuildId);
+          }
+        }
+      } catch (e) {
+      }
+    })();
+  }
+  (async () => {
+    try {
+      const r = stderrWebStream.getReader();
+      while (true) {
+        const { done, value } = await r.read();
+        if (done)
+          break;
+        try {
+          process.stderr.write(decoder.decode(value));
+        } catch (e) {
+        }
+      }
+    } catch (e) {
+    }
+  })();
+  const getPrecontentHtml = makePrecontentHtmlGetter(
+    fs.readFile(pathMod3.join(__dirname2, StaticPath, "out.html"), "utf-8")
+  );
+  await serve(port, async (req, ctx) => {
+    const request = parseRequest(req);
+    if (handler) {
+      const res = await handler(request);
+      if (res)
+        return res;
+    }
+    if (handleWS && handleWS(request, ctx))
+      return void 0;
+    const proxied = await handleProxy(request);
+    if (proxied)
+      return proxied;
+    const url = new URL(request.url);
+    const path2 = url.pathname;
+    const staticRes = await tryServeFile(pathMod3.join(__dirname2, StaticPath, path2));
+    if (staticRes)
+      return staticRes;
+    const projectStaticPath = pathMod3.resolve(process.cwd(), "static");
+    if (path2 === "/" || path2 === "") {
+      const indexRes = await tryServeFile(pathMod3.join(projectStaticPath, "index.html"));
+      if (indexRes)
+        return indexRes;
+    }
+    const projectRes = await tryServeFile(pathMod3.join(projectStaticPath, path2));
+    if (projectRes)
+      return projectRes;
+    const ssrComponentPath = pathMod3.join(__dirname2, HadarsFolder, SSR_FILENAME);
+    const importPath = pathToFileURL2(ssrComponentPath).href + `?t=${ssrBuildId}`;
+    const {
+      default: Component,
+      getInitProps,
+      getAfterRenderProps,
+      getFinalProps
+    } = await import(importPath);
+    const { ReactPage, status, headHtml } = await getReactResponse(request, {
+      document: {
+        body: Component,
+        lang: "en",
+        getInitProps,
+        getAfterRenderProps,
+        getFinalProps
+      }
+    });
+    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true);
+  }, options.websocket);
+};
+var build = async (options) => {
+  validateOptions(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);
+  } 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"));
+  }
+  const tmpFilePath = pathMod3.join(os.tmpdir(), `hadars-client-${Date.now()}.tsx`);
+  await fs.writeFile(tmpFilePath, clientScript);
+  const randomStr = crypto.randomBytes(6).toString("hex");
+  console.log("Building client and server bundles in parallel...");
+  await Promise.all([
+    compileEntry(tmpFilePath, {
+      target: "web",
+      output: {
+        filename: `index-${randomStr}.js`,
+        path: pathMod3.resolve(__dirname2, StaticPath)
+      },
+      base: options.baseURL,
+      mode: "production",
+      swcPlugins: options.swcPlugins,
+      define: options.define
+    }),
+    compileEntry(pathMod3.resolve(__dirname2, options.entry), {
+      output: {
+        iife: false,
+        filename: SSR_FILENAME,
+        path: pathMod3.resolve(__dirname2, HadarsFolder),
+        publicPath: "",
+        library: { type: "module" }
+      },
+      base: options.baseURL,
+      target: "node",
+      mode: "production",
+      swcPlugins: options.swcPlugins,
+      define: options.define
+    })
+  ]);
+  await fs.rm(tmpFilePath);
+  await fs.writeFile(
+    pathMod3.join(__dirname2, HadarsFolder, "hadars.json"),
+    JSON.stringify({ buildId: randomStr })
+  );
+  console.log("Build complete.");
+};
+var run = async (options) => {
+  validateOptions(options);
+  let { port = 9090, workers = 1 } = options;
+  if (isNode && workers > 1 && cluster.isPrimary) {
+    console.log(`[hadars] Starting ${workers} worker processes on port ${port}`);
+    for (let i = 0; i < workers; i++) {
+      cluster.fork();
+    }
+    cluster.on("exit", (worker, code, signal) => {
+      console.warn(`[hadars] Worker ${worker.process.pid} exited (${signal ?? code}), restarting...`);
+      cluster.fork();
+    });
+    await new Promise(() => {
+    });
+    return;
+  }
+  const handleProxy = createProxyHandler(options);
+  const handleWS = upgradeHandler(options);
+  const handler = options.fetch;
+  console.log(`Starting Hadars (run) on port ${port}`);
+  let renderPool;
+  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 workerFile = existsSync2(workerJs) ? workerJs : workerTs;
+    const ssrBundlePath = pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME);
+    renderPool = new RenderWorkerPool(workerFile, workers, ssrBundlePath);
+    console.log(`[hadars] SSR render pool: ${workers} worker threads`);
+  }
+  const getPrecontentHtml = makePrecontentHtmlGetter(
+    fs.readFile(pathMod3.join(__dirname2, StaticPath, "out.html"), "utf-8")
+  );
+  await serve(port, async (req, ctx) => {
+    const request = parseRequest(req);
+    if (handler) {
+      const res = await handler(request);
+      if (res)
+        return res;
+    }
+    if (handleWS && handleWS(request, ctx))
+      return void 0;
+    const proxied = await handleProxy(request);
+    if (proxied)
+      return proxied;
+    const url = new URL(request.url);
+    const path2 = url.pathname;
+    const staticRes = await tryServeFile(pathMod3.join(__dirname2, StaticPath, path2));
+    if (staticRes)
+      return staticRes;
+    if (path2 === "/" || path2 === "") {
+      const indexRes = await tryServeFile(pathMod3.join(__dirname2, StaticPath, "index.html"));
+      if (indexRes)
+        return indexRes;
+    }
+    const projectStaticPath = pathMod3.resolve(process.cwd(), "static");
+    const projectRes = await tryServeFile(pathMod3.join(projectStaticPath, path2));
+    if (projectRes)
+      return projectRes;
+    const routeClean = path2.replace(/(^\/|\/$)/g, "");
+    if (routeClean) {
+      const routeRes = await tryServeFile(
+        pathMod3.join(__dirname2, StaticPath, routeClean, "index.html")
+      );
+      if (routeRes)
+        return routeRes;
+    }
+    const componentPath = pathToFileURL2(
+      pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME)
+    ).href;
+    const {
+      default: Component,
+      getInitProps,
+      getAfterRenderProps,
+      getFinalProps
+    } = await import(componentPath);
+    const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+      document: {
+        body: Component,
+        lang: "en",
+        getInitProps,
+        getAfterRenderProps,
+        getFinalProps
+      }
+    });
+    return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, options.streaming === true, renderPool, renderPayload);
+  }, options.websocket);
+};
+
+// cli-lib.ts
+var SUPPORTED = ["hadars.config.js", "hadars.config.mjs", "hadars.config.cjs", "hadars.config.ts"];
+function findConfig(cwd) {
+  for (const name of SUPPORTED) {
+    const p = resolve(cwd, name);
+    if (existsSync3(p))
+      return p;
+  }
+  return null;
+}
+async function dev2(config) {
+  await dev({
+    ...config,
+    baseURL: "",
+    mode: "development"
+  });
+}
+async function build2(config) {
+  await build({
+    ...config,
+    mode: "production"
+  });
+}
+async function run2(config) {
+  await run({
+    ...config,
+    mode: "production"
+  });
+}
+async function loadConfig(configPath) {
+  const url = `file://${configPath}`;
+  const mod = await import(url);
+  return mod && (mod.default ?? mod);
+}
+var TEMPLATES = {
+  "package.json": (name) => JSON.stringify({
+    name,
+    version: "0.1.0",
+    type: "module",
+    private: true,
+    scripts: {
+      dev: "hadars dev",
+      build: "hadars build",
+      start: "hadars run"
+    },
+    dependencies: {
+      "hadars": "latest",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0"
+    }
+  }, null, 2) + "\n",
+  "hadars.config.ts": () => `import type { HadarsOptions } from 'hadars';
+
+const config: HadarsOptions = {
+  entry: 'src/App.tsx',
+  port: 3000,
+};
+
+export default config;
+`,
+  "tsconfig.json": () => JSON.stringify({
+    compilerOptions: {
+      lib: ["ESNext", "DOM"],
+      target: "ESNext",
+      module: "Preserve",
+      moduleDetection: "force",
+      jsx: "react-jsx",
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      verbatimModuleSyntax: true,
+      noEmit: true,
+      strict: true,
+      skipLibCheck: true
+    }
+  }, null, 2) + "\n",
+  ".gitignore": () => `node_modules/
+.hadars/
+dist/
+`,
+  "src/App.tsx": () => `import React from 'react';
+import { HadarsContext, HadarsHead, type HadarsApp } from 'hadars';
+
+const App: HadarsApp<{}> = ({ context }) => (
+  <HadarsContext context={context}>
+    <HadarsHead status={200}>
+      <title>My App</title>
+    </HadarsHead>
+    <main>
+      <h1>Hello from hadars!</h1>
+      <p>Edit <code>src/App.tsx</code> to get started.</p>
+    </main>
+  </HadarsContext>
+);
+
+export default App;
+`
+};
+async function createProject(name, cwd) {
+  const dir = resolve(cwd, name);
+  if (existsSync3(dir)) {
+    console.error(`Directory already exists: ${dir}`);
+    process.exit(1);
+  }
+  console.log(`Creating hadars project in ${dir}`);
+  await mkdir(join(dir, "src"), { recursive: true });
+  for (const [file, template] of Object.entries(TEMPLATES)) {
+    const content = template(name);
+    await writeFile(join(dir, file), content, "utf-8");
+    console.log(`  created  ${file}`);
+  }
+  console.log(`
+Done! Next steps:
+
+  cd ${name}
+  npm install       # or: bun install / pnpm install
+  npm run dev       # or: bun run dev
+`);
+}
+function usage() {
+  console.log("Usage: hadars <new <name> | dev | build | run>");
+}
+async function runCli(argv, cwd = process.cwd()) {
+  const cmd = argv[2];
+  if (cmd === "new") {
+    const name = argv[3];
+    if (!name) {
+      console.error("Usage: hadars new <project-name>");
+      process.exit(1);
+    }
+    try {
+      await createProject(name, cwd);
+    } catch (err) {
+      console.error("Failed to create project:", err?.message ?? err);
+      process.exit(2);
+    }
+    return;
+  }
+  if (!cmd || !["dev", "build", "run"].includes(cmd)) {
+    usage();
+    process.exit(1);
+  }
+  const configPath = findConfig(cwd);
+  if (!configPath) {
+    console.log(`No hadars.config.* found in ${cwd}`);
+    console.log("Proceeding with default behavior (no config)");
+    return;
+  }
+  try {
+    const cfg = await loadConfig(configPath);
+    console.log(`Loaded config from ${configPath}`);
+    switch (cmd) {
+      case "dev":
+        console.log("Starting development server...");
+        await dev2(cfg);
+        break;
+      case "build":
+        console.log("Building project...");
+        await build2(cfg);
+        console.log("Build complete");
+        process.exit(0);
+      case "run":
+        console.log("Running project...");
+        await run2(cfg);
+        break;
+    }
+  } catch (err) {
+    console.error("Failed to load config:", err?.message ?? err);
+    process.exit(2);
+  }
+}
+
+// cli.ts
+runCli(process.argv).catch((err) => {
+  console.error(err);
+  try {
+    process.exit(1);
+  } catch (_) {
+    throw err;
+  }
+});