hadars 0.1.17 → 0.1.18

package/dist/cli.js

@@ -134,24 +134,509 @@ var upgradeHandler = (options) => {
   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;
+// src/slim-react/types.ts
+var SLIM_ELEMENT = Symbol.for("react.element");
+var FRAGMENT_TYPE = Symbol.for("react.fragment");
+var SUSPENSE_TYPE = Symbol.for("react.suspense");
+
+// src/slim-react/jsx.ts
+var Fragment = FRAGMENT_TYPE;
+function createElement(type, props, ...children) {
+  const normalizedProps = { ...props || {} };
+  if (children.length === 1) {
+    normalizedProps.children = children[0];
+  } else if (children.length > 1) {
+    normalizedProps.children = children;
+  }
+  const key = normalizedProps.key ?? null;
+  delete normalizedProps.key;
+  return {
+    $$typeof: SLIM_ELEMENT,
+    type,
+    props: normalizedProps,
+    key
+  };
+}
+
+// src/slim-react/renderContext.ts
+var GLOBAL_KEY = "__slimReactRenderState";
+var EMPTY = { id: 0, overflow: "", bits: 0 };
+function s() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = { currentTreeContext: { ...EMPTY }, localIdCounter: 0, idPrefix: "" };
+  }
+  return g[GLOBAL_KEY];
+}
+function resetRenderState() {
+  const st = s();
+  st.currentTreeContext = { ...EMPTY };
+  st.localIdCounter = 0;
+}
+function pushTreeContext(totalChildren, index) {
+  const st = s();
+  const saved = { ...st.currentTreeContext };
+  const pendingBits = 32 - Math.clz32(totalChildren);
+  const slot = index + 1;
+  const totalBits = st.currentTreeContext.bits + pendingBits;
+  if (totalBits <= 30) {
+    st.currentTreeContext = {
+      id: st.currentTreeContext.id << pendingBits | slot,
+      overflow: st.currentTreeContext.overflow,
+      bits: totalBits
+    };
+  } else {
+    let newOverflow = st.currentTreeContext.overflow;
+    if (st.currentTreeContext.bits > 0)
+      newOverflow += st.currentTreeContext.id.toString(32);
+    st.currentTreeContext = { id: 1 << pendingBits | slot, overflow: newOverflow, bits: pendingBits };
+  }
+  return saved;
+}
+function popTreeContext(saved) {
+  s().currentTreeContext = saved;
+}
+function pushComponentScope() {
+  const st = s();
+  const saved = st.localIdCounter;
+  st.localIdCounter = 0;
+  return saved;
+}
+function popComponentScope(saved) {
+  s().localIdCounter = saved;
+}
+function snapshotContext() {
+  const st = s();
+  return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
+}
+function restoreContext(snap) {
+  const st = s();
+  st.currentTreeContext = { ...snap.tree };
+  st.localIdCounter = snap.localId;
+}
+
+// src/slim-react/render.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function styleObjectToString(style) {
+  return Object.entries(style).map(([key, value]) => {
+    const cssKey = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+    return `${cssKey}:${value}`;
+  }).join(";");
+}
+var SVG_ATTR_MAP = {
+  // Presentation / geometry
+  accentHeight: "accent-height",
+  alignmentBaseline: "alignment-baseline",
+  arabicForm: "arabic-form",
+  baselineShift: "baseline-shift",
+  capHeight: "cap-height",
+  clipPath: "clip-path",
+  clipRule: "clip-rule",
+  colorInterpolation: "color-interpolation",
+  colorInterpolationFilters: "color-interpolation-filters",
+  colorProfile: "color-profile",
+  dominantBaseline: "dominant-baseline",
+  enableBackground: "enable-background",
+  fillOpacity: "fill-opacity",
+  fillRule: "fill-rule",
+  floodColor: "flood-color",
+  floodOpacity: "flood-opacity",
+  fontFamily: "font-family",
+  fontSize: "font-size",
+  fontSizeAdjust: "font-size-adjust",
+  fontStretch: "font-stretch",
+  fontStyle: "font-style",
+  fontVariant: "font-variant",
+  fontWeight: "font-weight",
+  glyphName: "glyph-name",
+  glyphOrientationHorizontal: "glyph-orientation-horizontal",
+  glyphOrientationVertical: "glyph-orientation-vertical",
+  horizAdvX: "horiz-adv-x",
+  horizOriginX: "horiz-origin-x",
+  imageRendering: "image-rendering",
+  letterSpacing: "letter-spacing",
+  lightingColor: "lighting-color",
+  markerEnd: "marker-end",
+  markerMid: "marker-mid",
+  markerStart: "marker-start",
+  overlinePosition: "overline-position",
+  overlineThickness: "overline-thickness",
+  paintOrder: "paint-order",
+  panose1: "panose-1",
+  pointerEvents: "pointer-events",
+  renderingIntent: "rendering-intent",
+  shapeRendering: "shape-rendering",
+  stopColor: "stop-color",
+  stopOpacity: "stop-opacity",
+  strikethroughPosition: "strikethrough-position",
+  strikethroughThickness: "strikethrough-thickness",
+  strokeDasharray: "stroke-dasharray",
+  strokeDashoffset: "stroke-dashoffset",
+  strokeLinecap: "stroke-linecap",
+  strokeLinejoin: "stroke-linejoin",
+  strokeMiterlimit: "stroke-miterlimit",
+  strokeOpacity: "stroke-opacity",
+  strokeWidth: "stroke-width",
+  textAnchor: "text-anchor",
+  textDecoration: "text-decoration",
+  textRendering: "text-rendering",
+  underlinePosition: "underline-position",
+  underlineThickness: "underline-thickness",
+  unicodeBidi: "unicode-bidi",
+  unicodeRange: "unicode-range",
+  unitsPerEm: "units-per-em",
+  vAlphabetic: "v-alphabetic",
+  vHanging: "v-hanging",
+  vIdeographic: "v-ideographic",
+  vMathematical: "v-mathematical",
+  vertAdvY: "vert-adv-y",
+  vertOriginX: "vert-origin-x",
+  vertOriginY: "vert-origin-y",
+  wordSpacing: "word-spacing",
+  writingMode: "writing-mode",
+  xHeight: "x-height",
+  // Namespace-prefixed
+  xlinkActuate: "xlink:actuate",
+  xlinkArcrole: "xlink:arcrole",
+  xlinkHref: "xlink:href",
+  xlinkRole: "xlink:role",
+  xlinkShow: "xlink:show",
+  xlinkTitle: "xlink:title",
+  xlinkType: "xlink:type",
+  xmlBase: "xml:base",
+  xmlLang: "xml:lang",
+  xmlSpace: "xml:space",
+  xmlns: "xmlns",
+  xmlnsXlink: "xmlns:xlink",
+  // Filter / lighting
+  baseFrequency: "baseFrequency",
+  colorInterpolation_filters: "color-interpolation-filters",
+  diffuseConstant: "diffuseConstant",
+  edgeMode: "edgeMode",
+  filterUnits: "filterUnits",
+  gradientTransform: "gradientTransform",
+  gradientUnits: "gradientUnits",
+  kernelMatrix: "kernelMatrix",
+  kernelUnitLength: "kernelUnitLength",
+  lengthAdjust: "lengthAdjust",
+  limitingConeAngle: "limitingConeAngle",
+  markerHeight: "markerHeight",
+  markerWidth: "markerWidth",
+  maskContentUnits: "maskContentUnits",
+  maskUnits: "maskUnits",
+  numOctaves: "numOctaves",
+  pathLength: "pathLength",
+  patternContentUnits: "patternContentUnits",
+  patternTransform: "patternTransform",
+  patternUnits: "patternUnits",
+  pointsAtX: "pointsAtX",
+  pointsAtY: "pointsAtY",
+  pointsAtZ: "pointsAtZ",
+  preserveAspectRatio: "preserveAspectRatio",
+  primitiveUnits: "primitiveUnits",
+  refX: "refX",
+  refY: "refY",
+  repeatCount: "repeatCount",
+  repeatDur: "repeatDur",
+  specularConstant: "specularConstant",
+  specularExponent: "specularExponent",
+  spreadMethod: "spreadMethod",
+  startOffset: "startOffset",
+  stdDeviation: "stdDeviation",
+  stitchTiles: "stitchTiles",
+  surfaceScale: "surfaceScale",
+  systemLanguage: "systemLanguage",
+  tableValues: "tableValues",
+  targetX: "targetX",
+  targetY: "targetY",
+  textLength: "textLength",
+  viewBox: "viewBox",
+  xChannelSelector: "xChannelSelector",
+  yChannelSelector: "yChannelSelector"
+};
+function renderAttributes(props, isSvg) {
+  let attrs = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML")
+      continue;
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase())
+      continue;
+    let attrName;
+    if (isSvg && key in SVG_ATTR_MAP) {
+      attrName = SVG_ATTR_MAP[key];
+    } else {
+      attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key === "tabIndex" ? "tabindex" : key;
+    }
+    if (value === false || value == null)
+      continue;
+    if (value === true) {
+      attrs += ` ${attrName}`;
+      continue;
+    }
+    if (key === "style" && typeof value === "object") {
+      attrs += ` style="${escapeAttr(styleObjectToString(value))}"`;
+      continue;
+    }
+    attrs += ` ${attrName}="${escapeAttr(String(value))}"`;
+  }
+  return attrs;
+}
+var BufferWriter = class {
+  chunks = [];
+  write(chunk) {
+    this.chunks.push(chunk);
+  }
+  flush(target) {
+    for (const c of this.chunks)
+      target.write(c);
+  }
+};
+function renderNode(node, writer, isSvg = false) {
+  if (node == null || typeof node === "boolean")
+    return;
+  if (typeof node === "string") {
+    writer.write(escapeHtml(node));
+    return;
+  }
+  if (typeof node === "number") {
+    writer.write(String(node));
+    return;
+  }
+  if (Array.isArray(node)) {
+    return renderChildArray(node, writer, isSvg);
+  }
+  if (typeof node === "object" && node !== null && Symbol.iterator in node && !("$$typeof" in node)) {
+    return renderChildArray(
+      Array.from(node),
+      writer,
+      isSvg
+    );
+  }
+  if (typeof node === "object" && node !== null && "$$typeof" in node && node.$$typeof === SLIM_ELEMENT) {
+    const element = node;
+    const { type, props } = element;
+    if (type === FRAGMENT_TYPE) {
+      return renderChildren(props.children, writer, isSvg);
+    }
+    if (type === SUSPENSE_TYPE) {
+      return renderSuspense(props, writer, isSvg);
+    }
+    if (typeof type === "function") {
+      return renderComponent(type, props, writer, isSvg);
+    }
+    if (typeof type === "string") {
+      return renderHostElement(type, props, writer, isSvg);
+    }
+  }
+}
+function renderHostElement(tag, props, writer, isSvg) {
+  const enteringSvg = tag === "svg";
+  const childSvg = isSvg || enteringSvg;
+  const effectiveProps = enteringSvg && !props.xmlns ? { xmlns: "http://www.w3.org/2000/svg", ...props } : props;
+  writer.write(`<${tag}${renderAttributes(effectiveProps, childSvg)}>`);
+  const childContext = tag === "foreignObject" ? false : childSvg;
+  let inner = void 0;
+  if (props.dangerouslySetInnerHTML) {
+    writer.write(props.dangerouslySetInnerHTML.__html);
+  } else {
+    inner = renderChildren(props.children, writer, childContext);
+  }
+  if (inner && typeof inner.then === "function") {
+    return inner.then(() => {
+      if (!VOID_ELEMENTS.has(tag))
+        writer.write(`</${tag}>`);
+    });
+  }
+  if (!VOID_ELEMENTS.has(tag))
+    writer.write(`</${tag}>`);
+}
+var REACT_MEMO = Symbol.for("react.memo");
+var REACT_FORWARD_REF = Symbol.for("react.forward_ref");
+var REACT_PROVIDER = Symbol.for("react.provider");
+var REACT_CONTEXT = Symbol.for("react.context");
+function renderComponent(type, props, writer, isSvg) {
+  const typeOf = type?.$$typeof;
+  if (typeOf === REACT_MEMO) {
+    return renderNode(
+      { $$typeof: SLIM_ELEMENT, type: type.type, props, key: null },
+      writer,
+      isSvg
+    );
+  }
+  if (typeOf === REACT_FORWARD_REF) {
+    return renderComponent(type.render, props, writer, isSvg);
+  }
+  const isProvider = "_context" in type || typeOf === REACT_PROVIDER || typeOf === REACT_CONTEXT && "value" in props;
+  let prevCtxValue;
+  let ctx;
+  if (isProvider) {
+    ctx = type._context ?? type;
+    prevCtxValue = ctx._currentValue;
+    ctx._currentValue = props.value;
+  }
+  const savedScope = pushComponentScope();
+  let result;
+  try {
+    if (type.prototype && typeof type.prototype.render === "function") {
+      const instance = new type(props);
+      result = instance.render();
+    } else {
+      result = type(props);
+    }
+  } catch (e) {
+    popComponentScope(savedScope);
+    if (isProvider)
+      ctx._currentValue = prevCtxValue;
+    throw e;
+  }
+  const finish = () => {
+    popComponentScope(savedScope);
+    if (isProvider)
+      ctx._currentValue = prevCtxValue;
+  };
+  if (result instanceof Promise) {
+    return result.then((resolved) => {
+      const r2 = renderNode(resolved, writer, isSvg);
+      if (r2 && typeof r2.then === "function") {
+        return r2.then(finish);
+      }
+      finish();
+    });
+  }
+  const r = renderNode(result, writer, isSvg);
+  if (r && typeof r.then === "function") {
+    return r.then(finish);
+  }
+  finish();
+}
+function isTextLike(node) {
+  return typeof node === "string" || typeof node === "number";
 }
+function renderChildArray(children, writer, isSvg) {
+  const totalChildren = children.length;
+  for (let i = 0; i < totalChildren; i++) {
+    if (i > 0 && isTextLike(children[i]) && isTextLike(children[i - 1])) {
+      writer.write("<!-- -->");
+    }
+    const savedTree = pushTreeContext(totalChildren, i);
+    const r = renderNode(children[i], writer, isSvg);
+    if (r && typeof r.then === "function") {
+      return r.then(() => {
+        popTreeContext(savedTree);
+        return renderChildArrayFrom(children, i + 1, writer, isSvg);
+      });
+    }
+    popTreeContext(savedTree);
+  }
+}
+function renderChildArrayFrom(children, startIndex, writer, isSvg) {
+  const totalChildren = children.length;
+  for (let i = startIndex; i < totalChildren; i++) {
+    if (i > 0 && isTextLike(children[i]) && isTextLike(children[i - 1])) {
+      writer.write("<!-- -->");
+    }
+    const savedTree = pushTreeContext(totalChildren, i);
+    const r = renderNode(children[i], writer, isSvg);
+    if (r && typeof r.then === "function") {
+      return r.then(() => {
+        popTreeContext(savedTree);
+        return renderChildArrayFrom(children, i + 1, writer, isSvg);
+      });
+    }
+    popTreeContext(savedTree);
+  }
+}
+function renderChildren(children, writer, isSvg = false) {
+  if (children == null)
+    return;
+  if (Array.isArray(children)) {
+    return renderChildArray(children, writer, isSvg);
+  }
+  return renderNode(children, writer, isSvg);
+}
+var MAX_SUSPENSE_RETRIES = 25;
+async function renderSuspense(props, writer, isSvg = false) {
+  const { children, fallback } = props;
+  let attempts = 0;
+  const snap = snapshotContext();
+  while (attempts < MAX_SUSPENSE_RETRIES) {
+    restoreContext(snap);
+    try {
+      const buffer = new BufferWriter();
+      const r = renderNode(children, buffer, isSvg);
+      if (r && typeof r.then === "function") {
+        await r;
+      }
+      writer.write("<!--$-->");
+      buffer.flush(writer);
+      writer.write("<!--/$-->");
+      return;
+    } catch (error) {
+      if (error && typeof error.then === "function") {
+        await error;
+        attempts++;
+      } else {
+        throw error;
+      }
+    }
+  }
+  restoreContext(snap);
+  writer.write("<!--$?-->");
+  if (fallback) {
+    const r = renderNode(fallback, writer, isSvg);
+    if (r && typeof r.then === "function")
+      await r;
+  }
+  writer.write("<!--/$-->");
+}
+async function renderToString(element) {
+  for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
+    resetRenderState();
+    const chunks = [];
+    const writer = { write(c) {
+      chunks.push(c);
+    } };
+    try {
+      const r = renderNode(element, writer);
+      if (r && typeof r.then === "function")
+        await r;
+      return chunks.join("");
+    } catch (error) {
+      if (error && typeof error.then === "function") {
+        await error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error("[slim-react] renderToString exceeded maximum retries");
+}
+
+// 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 escAttr = (s2) => s2.replace(/[&<>"]/g, (c) => ESC[c] ?? c);
+var escText = (s2) => s2.replace(/[&<>]/g, (c) => ESC[c] ?? c);
 var ATTR = {
   className: "class",
   htmlFor: "for",
@@ -195,77 +680,57 @@ var getHeadHtml = (seoData) => {
 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
+    head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 }
   };
   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);
-  if (unsuspend.hasPending) {
-    console.warn("[hadars] SSR render loop hit the 25-iteration cap \u2014 some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.");
-  }
-  if (getAfterRenderProps) {
-    props = await getAfterRenderProps(props, html);
-    try {
-      globalThis.__hadarsUnsuspend = unsuspend;
-      renderToStaticMarkup(/* @__PURE__ */ jsx(App, { ...{ ...props, location: req.location, context } }));
-    } finally {
-      globalThis.__hadarsUnsuspend = null;
+  const unsuspend = { cache: /* @__PURE__ */ new Map() };
+  globalThis.__hadarsUnsuspend = unsuspend;
+  try {
+    let html = await renderToString(createElement(App, props));
+    if (getAfterRenderProps) {
+      props = await getAfterRenderProps(props, html);
+      await renderToString(
+        createElement(App, { ...props, location: req.location, context })
+      );
     }
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
   }
+  const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
   const serverData = {};
-  for (const [k, v] of unsuspend.cache) {
-    if (v.status === "fulfilled")
-      serverData[k] = v.value;
+  for (const [key, entry] of unsuspend.cache) {
+    if (entry.status === "fulfilled")
+      serverData[key] = entry.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 } }).replace(/</g, "\\u003c") } })
-  ] });
+  const ReactPage = createElement(
+    Fragment,
+    null,
+    createElement(
+      "div",
+      { id: "app" },
+      createElement(App, { ...props, location: req.location, context })
+    ),
+    createElement("script", {
+      id: "hadars",
+      type: "application/json",
+      dangerouslySetInnerHTML: {
+        __html: JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c")
+      }
+    })
+  );
   return {
     ReactPage,
+    unsuspend,
     status: context.head.status,
     headHtml: getHeadHtml(context.head),
     renderPayload: {
@@ -280,12 +745,12 @@ 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 pathMod 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 packageDir = pathMod.dirname(fileURLToPath(import.meta.url));
+var clientScriptPath = pathMod.resolve(packageDir, "template.html");
+var loaderPath = existsSync(pathMod.resolve(packageDir, "loader.cjs")) ? pathMod.resolve(packageDir, "loader.cjs") : pathMod.resolve(packageDir, "loader.ts");
 var getConfigBase = (mode) => {
   const isDev = mode === "development";
   return {
@@ -445,25 +910,21 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
   const isServerBuild = Boolean(
     opts.output && typeof opts.output === "object" && (opts.output.library || String(opts.output.filename || "").includes("ssr"))
   );
+  const slimReactIndex = pathMod.resolve(packageDir, "slim-react", "index.js");
+  const slimReactJsx = pathMod.resolve(packageDir, "slim-react", "jsx-runtime.js");
   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
+    // Route all React imports to slim-react for SSR.
+    react: slimReactIndex,
+    "react/jsx-runtime": slimReactJsx,
+    "react/jsx-dev-runtime": slimReactJsx,
+    // Keep emotion on the project's node_modules (server-safe 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",
+    // react / react-dom are replaced by slim-react via alias above — not external.
     // emotion should be external on server builds to avoid client/browser code
     "@emotion/react",
     "@emotion/server",
@@ -515,11 +976,36 @@ var buildCompilerConfig = (entry, opts, includeHotPlugin) => {
     plugins: [
       new rspack.HtmlRspackPlugin({
         publicPath: base || "/",
-        template: opts.htmlTemplate ? pathMod2.resolve(process.cwd(), opts.htmlTemplate) : clientScriptPath,
+        template: opts.htmlTemplate ? pathMod.resolve(process.cwd(), opts.htmlTemplate) : clientScriptPath,
         scriptLoading: "module",
         filename: "out.html",
-        inject: "body"
+        inject: "head",
+        minify: opts.mode === "production"
       }),
+      // Add `async` to the emitted module script so DOMContentLoaded fires
+      // as soon as HTML is parsed — without waiting for the bundle to execute.
+      // `<script type="module" async>` is valid: it downloads in parallel and
+      // executes without blocking DOMContentLoaded, while retaining module
+      // semantics (strict mode, ES imports, etc.).
+      {
+        apply(compiler) {
+          compiler.hooks.emit.tapAsync("HadarsAsyncModuleScript", (compilation, cb) => {
+            const asset = compilation.assets["out.html"];
+            if (asset) {
+              const html = asset.source();
+              const updated = html.replace(
+                /(<script\b[^>]*\btype="module"[^>]*)(>)/g,
+                (match, before, end) => before.includes("async") ? match : `${before} async${end}`
+              );
+              compilation.assets["out.html"] = {
+                source: () => updated,
+                size: () => Buffer.byteLength(updated)
+              };
+            }
+            cb();
+          });
+        }
+      },
       isDev && new ReactRefreshPlugin(),
       includeHotPlugin && isDev && new rspack.HotModuleReplacementPlugin(),
       ...extraPlugins
@@ -777,15 +1263,55 @@ async function tryServeFile(filePath) {
 
 // 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 pathMod2 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 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";
+
+// src/utils/segmentCache.ts
+function getStore() {
+  const g = globalThis;
+  if (!g.__hadarsSegmentStore) {
+    g.__hadarsSegmentStore = /* @__PURE__ */ new Map();
+  }
+  return g.__hadarsSegmentStore;
+}
+function setSegment(key, html, ttl) {
+  getStore().set(key, {
+    html,
+    expiresAt: ttl != null ? Date.now() + ttl : null
+  });
+}
+function processSegmentCache(html) {
+  let prev;
+  do {
+    prev = html;
+    html = html.replace(
+      /<hadars-c([^>]*)>([\s\S]*?)<\/hadars-c>/g,
+      (match, attrs, content) => {
+        const cacheM = /data-cache="([^"]+)"/.exec(attrs);
+        const keyM = /data-key="([^"]+)"/.exec(attrs);
+        const ttlM = /data-ttl="(\d+)"/.exec(attrs);
+        if (!cacheM || !keyM)
+          return match;
+        if (cacheM[1] === "miss") {
+          setSegment(keyM[1], content, ttlM ? Number(ttlM[1]) : void 0);
+          return content;
+        }
+        if (cacheM[1] === "hit")
+          return content;
+        return match;
+      }
+    );
+  } while (html !== prev);
+  return html;
+}
+
+// src/build.ts
 var encoder = new TextEncoder();
 async function processHtmlTemplate(templatePath) {
   const html = await fs.readFile(templatePath, "utf-8");
@@ -799,7 +1325,7 @@ async function processHtmlTemplate(templatePath) {
     return templatePath;
   await ensureHadarsTmpDir();
   const sourceHash = crypto.createHash("md5").update(html).digest("hex").slice(0, 8);
-  const cachedPath = pathMod3.join(HADARS_TMP_DIR, `template-${sourceHash}.html`);
+  const cachedPath = pathMod2.join(HADARS_TMP_DIR, `template-${sourceHash}.html`);
   try {
     await fs.access(cachedPath);
     return cachedPath;
@@ -827,16 +1353,6 @@ async function processHtmlTemplate(templatePath) {
 }
 var HEAD_MARKER = '<meta name="HADARS_HEAD">';
 var BODY_MARKER = '<meta name="HADARS_BODY">';
-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();
@@ -941,19 +1457,18 @@ var RenderWorkerPool = class {
   }
 };
 async function buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspendForRender) {
-  const renderToString = await getRenderToString();
   const responseStream = new ReadableStream({
     async start(controller) {
       const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
       controller.enqueue(encoder.encode(precontentHtml));
-      await Promise.resolve();
       let bodyHtml;
       try {
         globalThis.__hadarsUnsuspend = unsuspendForRender;
-        bodyHtml = renderToString(ReactPage);
+        bodyHtml = await renderToString(ReactPage);
       } finally {
         globalThis.__hadarsUnsuspend = null;
       }
+      bodyHtml = processSegmentCache(bodyHtml);
       controller.enqueue(encoder.encode(bodyHtml + postContent));
       controller.close();
     }
@@ -1082,7 +1597,7 @@ var __dirname2 = process.cwd();
 var getSuffix = (mode) => mode === "development" ? `?v=${Date.now()}` : "";
 var HadarsFolder = "./.hadars";
 var StaticPath = `${HadarsFolder}/static`;
-var HADARS_TMP_DIR = pathMod3.join(os.tmpdir(), "hadars");
+var HADARS_TMP_DIR = pathMod2.join(os.tmpdir(), "hadars");
 var ensureHadarsTmpDir = () => fs.mkdir(HADARS_TMP_DIR, { recursive: true });
 var validateOptions = (options) => {
   if (!options.entry) {
@@ -1093,8 +1608,8 @@ var validateOptions = (options) => {
   }
 };
 var resolveWorkerCmd = (packageDir2) => {
-  const tsPath = pathMod3.resolve(packageDir2, "ssr-watch.ts");
-  const jsPath = pathMod3.resolve(packageDir2, "ssr-watch.js");
+  const tsPath = pathMod2.resolve(packageDir2, "ssr-watch.ts");
+  const jsPath = pathMod2.resolve(packageDir2, "ssr-watch.js");
   if (isBun && existsSync2(tsPath)) {
     return ["bun", tsPath];
   }
@@ -1128,10 +1643,10 @@ var dev = async (options) => {
   const handleProxy = createProxyHandler(options);
   const handleWS = upgradeHandler(options);
   const handler = options.fetch;
-  const entry = pathMod3.resolve(__dirname2, options.entry);
+  const entry = pathMod2.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 packageDir2 = pathMod2.dirname(fileURLToPath2(import.meta.url));
+  const clientScriptPath2 = pathMod2.resolve(packageDir2, "utils", "clientScript.tsx");
   let clientScript = "";
   try {
     clientScript = (await fs.readFile(clientScriptPath2, "utf-8")).replace("$_MOD_PATH$", entry + getSuffix(options.mode));
@@ -1140,15 +1655,15 @@ var dev = async (options) => {
     throw err;
   }
   await ensureHadarsTmpDir();
-  const tmpFilePath = pathMod3.join(HADARS_TMP_DIR, `client-${Date.now()}.tsx`);
+  const tmpFilePath = pathMod2.join(HADARS_TMP_DIR, `client-${Date.now()}.tsx`);
   await fs.writeFile(tmpFilePath, clientScript);
   let ssrBuildId = crypto.randomBytes(4).toString("hex");
-  const resolvedHtmlTemplate = options.htmlTemplate ? await processHtmlTemplate(pathMod3.resolve(__dirname2, options.htmlTemplate)) : void 0;
+  const resolvedHtmlTemplate = options.htmlTemplate ? await processHtmlTemplate(pathMod2.resolve(__dirname2, options.htmlTemplate)) : void 0;
   const clientCompiler = createClientCompiler(tmpFilePath, {
     target: "web",
     output: {
       filename: "index.js",
-      path: pathMod3.resolve(__dirname2, StaticPath)
+      path: pathMod2.resolve(__dirname2, StaticPath)
     },
     base: baseURL,
     mode: "development",
@@ -1288,7 +1803,7 @@ var dev = async (options) => {
     }
   })();
   const getPrecontentHtml = makePrecontentHtmlGetter(
-    readyPromise.then(() => fs.readFile(pathMod3.join(__dirname2, StaticPath, "out.html"), "utf-8"))
+    readyPromise.then(() => fs.readFile(pathMod2.join(__dirname2, StaticPath, "out.html"), "utf-8"))
   );
   await serve(port, async (req, ctx) => {
     await readyPromise;
@@ -1305,15 +1820,15 @@ var dev = async (options) => {
       return proxied;
     const url = new URL(request.url);
     const path2 = url.pathname;
-    const staticRes = await tryServeFile(pathMod3.join(__dirname2, StaticPath, path2));
+    const staticRes = await tryServeFile(pathMod2.join(__dirname2, StaticPath, path2));
     if (staticRes)
       return staticRes;
-    const projectStaticPath = pathMod3.resolve(process.cwd(), "static");
-    const projectRes = await tryServeFile(pathMod3.join(projectStaticPath, path2));
+    const projectStaticPath = pathMod2.resolve(process.cwd(), "static");
+    const projectRes = await tryServeFile(pathMod2.join(projectStaticPath, path2));
     if (projectRes)
       return projectRes;
-    const ssrComponentPath = pathMod3.join(__dirname2, HadarsFolder, SSR_FILENAME);
-    const importPath = pathToFileURL2(ssrComponentPath).href + `?t=${ssrBuildId}`;
+    const ssrComponentPath = pathMod2.join(__dirname2, HadarsFolder, SSR_FILENAME);
+    const importPath = pathToFileURL(ssrComponentPath).href + `?t=${ssrBuildId}`;
     try {
       const {
         default: Component,
@@ -1321,7 +1836,7 @@ var dev = async (options) => {
         getAfterRenderProps,
         getFinalProps
       } = await import(importPath);
-      const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+      const { ReactPage, unsuspend, status, headHtml } = await getReactResponse(request, {
         document: {
           body: Component,
           lang: "en",
@@ -1330,7 +1845,6 @@ var dev = async (options) => {
           getFinalProps
         }
       });
-      const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
       return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
     } catch (err) {
       console.error("[hadars] SSR render error:", err);
@@ -1344,20 +1858,20 @@ var dev = async (options) => {
 };
 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 entry = pathMod2.resolve(__dirname2, options.entry);
+  const packageDir2 = pathMod2.dirname(fileURLToPath2(import.meta.url));
+  const clientScriptPath2 = pathMod2.resolve(packageDir2, "utils", "clientScript.js");
   let clientScript = "";
   try {
     clientScript = (await fs.readFile(clientScriptPath2, "utf-8")).replace("$_MOD_PATH$", entry + getSuffix(options.mode));
   } catch (err) {
-    const srcClientPath = pathMod3.resolve(packageDir2, "utils", "clientScript.tsx");
+    const srcClientPath = pathMod2.resolve(packageDir2, "utils", "clientScript.tsx");
     clientScript = (await fs.readFile(srcClientPath, "utf-8")).replace("$_MOD_PATH$", entry + `?v=${Date.now()}`);
   }
   await ensureHadarsTmpDir();
-  const tmpFilePath = pathMod3.join(HADARS_TMP_DIR, `client-${Date.now()}.tsx`);
+  const tmpFilePath = pathMod2.join(HADARS_TMP_DIR, `client-${Date.now()}.tsx`);
   await fs.writeFile(tmpFilePath, clientScript);
-  const resolvedHtmlTemplate = options.htmlTemplate ? await processHtmlTemplate(pathMod3.resolve(__dirname2, options.htmlTemplate)) : void 0;
+  const resolvedHtmlTemplate = options.htmlTemplate ? await processHtmlTemplate(pathMod2.resolve(__dirname2, options.htmlTemplate)) : void 0;
   console.log("Building client and server bundles in parallel...");
   await Promise.all([
     compileEntry(tmpFilePath, {
@@ -1365,7 +1879,7 @@ var build = async (options) => {
       output: {
         // Content hash: filename is stable when code is unchanged → better browser/CDN cache.
         filename: "index.[contenthash:8].js",
-        path: pathMod3.resolve(__dirname2, StaticPath)
+        path: pathMod2.resolve(__dirname2, StaticPath)
       },
       base: options.baseURL,
       mode: "production",
@@ -1374,11 +1888,11 @@ var build = async (options) => {
       optimization: options.optimization,
       htmlTemplate: resolvedHtmlTemplate
     }),
-    compileEntry(pathMod3.resolve(__dirname2, options.entry), {
+    compileEntry(pathMod2.resolve(__dirname2, options.entry), {
       output: {
         iife: false,
         filename: SSR_FILENAME,
-        path: pathMod3.resolve(__dirname2, HadarsFolder),
+        path: pathMod2.resolve(__dirname2, HadarsFolder),
         publicPath: "",
         library: { type: "module" }
       },
@@ -1414,16 +1928,16 @@ var run = async (options) => {
   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, "ssr-render-worker.ts");
+    const packageDir2 = pathMod2.dirname(fileURLToPath2(import.meta.url));
+    const workerJs = pathMod2.resolve(packageDir2, "ssr-render-worker.js");
+    const workerTs = pathMod2.resolve(packageDir2, "ssr-render-worker.ts");
     const workerFile = existsSync2(workerJs) ? workerJs : workerTs;
-    const ssrBundlePath = pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME);
+    const ssrBundlePath = pathMod2.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")
+    fs.readFile(pathMod2.join(__dirname2, StaticPath, "out.html"), "utf-8")
   );
   const runHandler = async (req, ctx) => {
     const request = parseRequest(req);
@@ -1439,23 +1953,23 @@ var run = async (options) => {
       return proxied;
     const url = new URL(request.url);
     const path2 = url.pathname;
-    const staticRes = await tryServeFile(pathMod3.join(__dirname2, StaticPath, path2));
+    const staticRes = await tryServeFile(pathMod2.join(__dirname2, StaticPath, path2));
     if (staticRes)
       return staticRes;
-    const projectStaticPath = pathMod3.resolve(process.cwd(), "static");
-    const projectRes = await tryServeFile(pathMod3.join(projectStaticPath, path2));
+    const projectStaticPath = pathMod2.resolve(process.cwd(), "static");
+    const projectRes = await tryServeFile(pathMod2.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")
+        pathMod2.join(__dirname2, StaticPath, routeClean, "index.html")
       );
       if (routeRes)
         return routeRes;
     }
-    const componentPath = pathToFileURL2(
-      pathMod3.resolve(__dirname2, HadarsFolder, SSR_FILENAME)
+    const componentPath = pathToFileURL(
+      pathMod2.resolve(__dirname2, HadarsFolder, SSR_FILENAME)
     ).href;
     try {
       const {
@@ -1473,7 +1987,7 @@ var run = async (options) => {
           status: wStatus
         });
       }
-      const { ReactPage, status, headHtml, renderPayload } = await getReactResponse(request, {
+      const { ReactPage, unsuspend, status, headHtml } = await getReactResponse(request, {
         document: {
           body: Component,
           lang: "en",
@@ -1482,7 +1996,6 @@ var run = async (options) => {
           getFinalProps
         }
       });
-      const unsuspend = renderPayload.appProps.context?._unsuspend ?? null;
       return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
     } catch (err) {
       console.error("[hadars] SSR render error:", err);