hadars 0.1.40 → 0.2.1

package/dist/cli.js

@@ -107,7 +107,11 @@ var parseCookies = (cookieString) => {
     if (index > -1) {
       const key = pair.slice(0, index).trim();
       const value = pair.slice(index + 1).trim();
-      cookies[key] = decodeURIComponent(value);
+      try {
+        cookies[key] = decodeURIComponent(value);
+      } catch {
+        cookies[key] = value;
+      }
     }
   }
   return cookies;
@@ -171,6 +175,13 @@ function swapContextMap(map) {
 function captureMap() {
   return _g[MAP_KEY];
 }
+var UNSUSPEND_KEY = "__hadarsUnsuspend";
+function captureUnsuspend() {
+  return _g[UNSUSPEND_KEY];
+}
+function restoreUnsuspend(u) {
+  _g[UNSUSPEND_KEY] = u;
+}
 function getContextValue(context) {
   const map = _g[MAP_KEY];
   if (map && map.has(context)) return map.get(context);
@@ -178,10 +189,14 @@ function getContextValue(context) {
   return "_defaultValue" in c ? c._defaultValue : c._currentValue;
 }
 function pushContextValue(context, value) {
-  const map = _g[MAP_KEY];
+  let map = _g[MAP_KEY];
+  if (map === null) {
+    map = /* @__PURE__ */ new Map();
+    _g[MAP_KEY] = map;
+  }
   const c = context;
-  const prev = map && map.has(context) ? map.get(context) : "_defaultValue" in c ? c._defaultValue : c._currentValue;
-  map?.set(context, value);
+  const prev = map.has(context) ? map.get(context) : "_defaultValue" in c ? c._defaultValue : c._currentValue;
+  map.set(context, value);
   return prev;
 }
 function popContextValue(context, prev) {
@@ -189,48 +204,57 @@ function popContextValue(context, prev) {
 }
 var GLOBAL_KEY = "__slimReactRenderState";
 var EMPTY = { id: 1, overflow: "" };
+var _stateCache = null;
 function s() {
-  const g = globalThis;
-  if (!g[GLOBAL_KEY]) {
-    g[GLOBAL_KEY] = { currentTreeContext: { ...EMPTY }, localIdCounter: 0, idPrefix: "" };
+  if (_stateCache !== null) return _stateCache;
+  if (!_g[GLOBAL_KEY]) {
+    _g[GLOBAL_KEY] = { currentTreeContext: { ...EMPTY }, localIdCounter: 0, idPrefix: "" };
   }
-  return g[GLOBAL_KEY];
+  _stateCache = _g[GLOBAL_KEY];
+  return _stateCache;
 }
+var _treeIdStack = [];
+var _treeOvStack = [];
+var _treeDepth = 0;
 function resetRenderState(idPrefix = "") {
   const st = s();
-  st.currentTreeContext = { ...EMPTY };
+  st.currentTreeContext.id = EMPTY.id;
+  st.currentTreeContext.overflow = EMPTY.overflow;
   st.localIdCounter = 0;
   st.idPrefix = idPrefix;
+  _treeDepth = 0;
 }
 function pushTreeContext(totalChildren, index) {
   const st = s();
-  const saved = { ...st.currentTreeContext };
-  const baseIdWithLeadingBit = st.currentTreeContext.id;
-  const baseOverflow = st.currentTreeContext.overflow;
+  const ctx = st.currentTreeContext;
+  const depth = _treeDepth++;
+  _treeIdStack[depth] = ctx.id;
+  _treeOvStack[depth] = ctx.overflow;
+  const baseIdWithLeadingBit = ctx.id;
+  const baseOverflow = ctx.overflow;
   const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
   let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
   const slot = index + 1;
   const newBits = 32 - Math.clz32(totalChildren);
   const length = newBits + baseLength;
   if (30 < length) {
-    const numberOfOverflowBits = baseLength - baseLength % 5;
-    const overflowStr = (baseId & (1 << numberOfOverflowBits) - 1).toString(32);
-    baseId >>= numberOfOverflowBits;
-    const newBaseLength = baseLength - numberOfOverflowBits;
-    st.currentTreeContext = {
-      id: 1 << newBits + newBaseLength | slot << newBaseLength | baseId,
-      overflow: overflowStr + baseOverflow
-    };
+    const overflowBits = baseLength - baseLength % 5;
+    const overflowStr = (baseId & (1 << overflowBits) - 1).toString(32);
+    baseId >>= overflowBits;
+    const newBaseLength = baseLength - overflowBits;
+    ctx.id = 1 << newBits + newBaseLength | slot << newBaseLength | baseId;
+    ctx.overflow = overflowStr + baseOverflow;
   } else {
-    st.currentTreeContext = {
-      id: 1 << length | slot << baseLength | baseId,
-      overflow: baseOverflow
-    };
+    ctx.id = 1 << length | slot << baseLength | baseId;
+    ctx.overflow = baseOverflow;
   }
-  return saved;
+  return depth;
 }
-function popTreeContext(saved) {
-  s().currentTreeContext = saved;
+function popTreeContext(depth) {
+  const ctx = s().currentTreeContext;
+  ctx.id = _treeIdStack[depth];
+  ctx.overflow = _treeOvStack[depth];
+  _treeDepth = depth;
 }
 function pushComponentScope() {
   const st = s();
@@ -246,12 +270,16 @@ function componentCalledUseId() {
 }
 function snapshotContext() {
   const st = s();
-  return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
+  const ctx = st.currentTreeContext;
+  return { tree: { id: ctx.id, overflow: ctx.overflow }, localId: st.localIdCounter, treeDepth: _treeDepth };
 }
 function restoreContext(snap) {
   const st = s();
-  st.currentTreeContext = { ...snap.tree };
+  const ctx = st.currentTreeContext;
+  ctx.id = snap.tree.id;
+  ctx.overflow = snap.tree.overflow;
   st.localIdCounter = snap.localId;
+  _treeDepth = snap.treeDepth;
 }
 function getTreeId() {
   const { id, overflow } = s().currentTreeContext;
@@ -382,19 +410,80 @@ var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "wbr"
 ]);
 var HTML_ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "'": "&#x27;" };
+var HTML_ESC_RE = /[&<>']/;
 function escapeHtml(str) {
+  if (!HTML_ESC_RE.test(str)) return str;
   return str.replace(/[&<>']/g, (c) => HTML_ESC[c]);
 }
 var ATTR_ESC = { "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" };
+var ATTR_ESC_RE = /[&"<>]/;
 function escapeAttr(str) {
+  if (!ATTR_ESC_RE.test(str)) return str;
   return str.replace(/[&"<>]/g, (c) => ATTR_ESC[c]);
 }
+var UNITLESS_CSS = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]);
+var _cssKeyCache = /* @__PURE__ */ new Map();
 function styleObjectToString(style) {
   let result = "";
   for (const key in style) {
+    const value = style[key];
+    if (value == null || typeof value === "boolean") continue;
     if (result) result += ";";
-    const cssKey = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
-    result += cssKey + ":" + style[key];
+    let cssKey = _cssKeyCache.get(key);
+    if (cssKey === void 0) {
+      cssKey = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+      _cssKeyCache.set(key, cssKey);
+    }
+    if (typeof value === "number" && value !== 0 && !UNITLESS_CSS.has(key)) {
+      result += cssKey + ":" + value + "px";
+    } else {
+      result += cssKey + ":" + value;
+    }
   }
   return result;
 }
@@ -529,14 +618,22 @@ var SVG_ATTR_MAP = {
   xChannelSelector: "xChannelSelector",
   yChannelSelector: "yChannelSelector"
 };
-function renderAttributes(props, isSvg) {
-  let attrs = "";
+var TEXTAREA_SKIP_PROPS = /* @__PURE__ */ new Set(["value", "defaultValue", "children"]);
+var SELECT_SKIP_PROPS = /* @__PURE__ */ new Set(["value", "defaultValue"]);
+var INTERNAL_PROPS = /* @__PURE__ */ new Set([
+  "children",
+  "key",
+  "ref",
+  "dangerouslySetInnerHTML",
+  "suppressHydrationWarning",
+  "suppressContentEditableWarning"
+]);
+function writeAttributes(writer, props, isSvg, skip) {
   for (const key in props) {
+    if (skip !== void 0 && skip.has(key)) continue;
     const value = props[key];
-    if (key === "children" || key === "key" || key === "ref" || key === "dangerouslySetInnerHTML" || key === "suppressHydrationWarning" || key === "suppressContentEditableWarning")
-      continue;
-    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase())
-      continue;
+    if (INTERNAL_PROPS.has(key)) continue;
+    if (key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) >= 65 && key.charCodeAt(2) <= 90) continue;
     let attrName;
     if (isSvg && key in SVG_ATTR_MAP) {
       attrName = SVG_ATTR_MAP[key];
@@ -544,41 +641,46 @@ function renderAttributes(props, isSvg) {
       attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key === "tabIndex" ? "tabindex" : key === "defaultValue" ? "value" : key === "defaultChecked" ? "checked" : key;
     }
     if (value === false || value == null) {
-      if (value === false && (attrName.startsWith("aria-") || attrName.startsWith("data-"))) {
-        attrs += ` ${attrName}="false"`;
+      if (value === false && (attrName.charCodeAt(0) === 97 && attrName.startsWith("aria-") || attrName.charCodeAt(0) === 100 && attrName.startsWith("data-"))) {
+        writer.write(` ${attrName}="false"`);
       }
       continue;
     }
     if (value === true) {
-      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
-        attrs += ` ${attrName}="true"`;
+      if (attrName.charCodeAt(0) === 97 && attrName.startsWith("aria-") || attrName.charCodeAt(0) === 100 && attrName.startsWith("data-")) {
+        writer.write(` ${attrName}="true"`);
       } else {
-        attrs += ` ${attrName}=""`;
+        writer.write(` ${attrName}=""`);
       }
       continue;
     }
     if (key === "style" && typeof value === "object") {
       const styleStr = styleObjectToString(value);
-      if (styleStr) attrs += ` style="${escapeAttr(styleStr)}"`;
+      if (styleStr) writer.write(` style="${escapeAttr(styleStr)}"`);
       continue;
     }
-    attrs += ` ${attrName}="${escapeAttr(String(value))}"`;
+    writer.write(` ${attrName}="${escapeAttr(typeof value === "string" ? value : String(value))}"`);
   }
-  return attrs;
 }
-var BufferWriter = class {
-  chunks = [];
+var BufferWriter = class _BufferWriter {
+  data = "";
   lastWasText = false;
   write(chunk) {
-    this.chunks.push(chunk);
+    this.data += chunk;
     this.lastWasText = false;
   }
   text(s2) {
-    this.chunks.push(s2);
+    this.data += s2;
     this.lastWasText = true;
   }
-  flush(target) {
-    for (const c of this.chunks) target.write(c);
+  /** Flush accumulated output into a parent writer and reset. */
+  flushTo(target) {
+    if (!this.data) return;
+    if (target instanceof _BufferWriter) {
+      target.data += this.data;
+    } else {
+      target.write(this.data);
+    }
     target.lastWasText = this.lastWasText;
   }
 };
@@ -595,15 +697,12 @@ function renderNode(node, writer, isSvg = false) {
   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
-    );
+  const obj = node;
+  if (Symbol.iterator in obj && !("$$typeof" in obj)) {
+    return renderChildArray(Array.from(obj), writer, isSvg);
   }
-  if (typeof node === "object" && node !== null && "$$typeof" in node) {
-    const elType = node["$$typeof"];
+  if ("$$typeof" in obj) {
+    const elType = obj["$$typeof"];
     if (elType !== SLIM_ELEMENT && elType !== REACT19_ELEMENT) return;
     const element = node;
     const { type, props } = element;
@@ -613,15 +712,15 @@ function renderNode(node, writer, isSvg = false) {
     if (type === SUSPENSE_TYPE) {
       return renderSuspense(props, writer, isSvg);
     }
+    if (typeof type === "string") {
+      return renderHostElement(type, props, writer, isSvg);
+    }
     if (typeof type === "function") {
       return renderComponent(type, props, writer, isSvg);
     }
     if (typeof type === "object" && type !== null) {
       return renderComponent(type, props, writer, isSvg);
     }
-    if (typeof type === "string") {
-      return renderHostElement(type, props, writer, isSvg);
-    }
   }
 }
 function markSelectedOptionsMulti(children, selectedValues) {
@@ -647,26 +746,21 @@ function markSelectedOptionsMulti(children, selectedValues) {
   return children;
 }
 function renderHostElement(tag, props, writer, isSvg) {
-  const enteringSvg = tag === "svg";
-  const childSvg = isSvg || enteringSvg;
+  const childSvg = isSvg || tag === "svg";
   if (tag === "textarea") {
     const textContent = props.value ?? props.defaultValue ?? props.children ?? "";
-    const filteredProps = {};
-    for (const k of Object.keys(props)) {
-      if (k !== "value" && k !== "defaultValue" && k !== "children") filteredProps[k] = props[k];
-    }
-    writer.write(`<textarea${renderAttributes(filteredProps, false)}>`);
+    writer.write("<textarea");
+    writeAttributes(writer, props, false, TEXTAREA_SKIP_PROPS);
+    writer.write(">");
     writer.text(escapeHtml(String(textContent)));
     writer.write("</textarea>");
     return;
   }
   if (tag === "select") {
     const selectedValue = props.value ?? props.defaultValue;
-    const filteredProps = {};
-    for (const k of Object.keys(props)) {
-      if (k !== "value" && k !== "defaultValue") filteredProps[k] = props[k];
-    }
-    writer.write(`<select${renderAttributes(filteredProps, false)}>`);
+    writer.write("<select");
+    writeAttributes(writer, props, false, SELECT_SKIP_PROPS);
+    writer.write(">");
     const selectedSet = selectedValue == null ? null : Array.isArray(selectedValue) ? new Set(selectedValue.map(String)) : /* @__PURE__ */ new Set([String(selectedValue)]);
     const patchedChildren = selectedSet != null ? markSelectedOptionsMulti(props.children, selectedSet) : props.children;
     const inner2 = renderChildren(patchedChildren, writer, false);
@@ -678,7 +772,8 @@ function renderHostElement(tag, props, writer, isSvg) {
     writer.write("</select>");
     return;
   }
-  writer.write(`<${tag}${renderAttributes(props, childSvg)}`);
+  writer.write(`<${tag}`);
+  writeAttributes(writer, props, childSvg);
   if (VOID_ELEMENTS.has(tag)) {
     writer.write("/>");
     return;
@@ -704,8 +799,25 @@ var REACT_PROVIDER = /* @__PURE__ */ Symbol.for("react.provider");
 var REACT_CONTEXT = /* @__PURE__ */ Symbol.for("react.context");
 var REACT_CONSUMER = /* @__PURE__ */ Symbol.for("react.consumer");
 var REACT_LAZY = /* @__PURE__ */ Symbol.for("react.lazy");
-function renderComponent(type, props, writer, isSvg) {
-  const typeOf = type?.$$typeof;
+var SUSPENSE_RETRY_LIMIT = /* @__PURE__ */ Symbol("SuspenseRetryLimit");
+var MAX_COMPONENT_SUSPENSE_RETRIES = 25;
+function patchPromiseStatus(p) {
+  const w = p;
+  if (w.status) return;
+  w.status = "pending";
+  w.then(
+    (v) => {
+      w.status = "fulfilled";
+      w.value = v;
+    },
+    (r) => {
+      w.status = "rejected";
+      w.reason = r;
+    }
+  );
+}
+function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
+  const typeOf = type.$$typeof;
   if (typeOf === REACT_MEMO) {
     return renderNode(
       { $$typeof: SLIM_ELEMENT, type: type.type, props, key: null },
@@ -717,7 +829,23 @@ function renderComponent(type, props, writer, isSvg) {
     return renderComponent(type.render, props, writer, isSvg);
   }
   if (typeOf === REACT_LAZY) {
-    const resolved = type._init(type._payload);
+    let resolved;
+    try {
+      resolved = type._init(type._payload);
+    } catch (e) {
+      if (e && typeof e.then === "function") {
+        if (_suspenseRetries + 1 >= MAX_COMPONENT_SUSPENSE_RETRIES) throw SUSPENSE_RETRY_LIMIT;
+        patchPromiseStatus(e);
+        const m = captureMap();
+        const u = captureUnsuspend();
+        return e.then(() => {
+          swapContextMap(m);
+          restoreUnsuspend(u);
+          return renderComponent(type, props, writer, isSvg, _suspenseRetries + 1);
+        });
+      }
+      throw e;
+    }
     const LazyComp = resolved?.default ?? resolved;
     return renderComponent(LazyComp, props, writer, isSvg);
   }
@@ -726,12 +854,12 @@ function renderComponent(type, props, writer, isSvg) {
     const value = ctx2 ? getContextValue(ctx2) : void 0;
     const result2 = typeof props.children === "function" ? props.children(value) : null;
     const savedScope2 = pushComponentScope();
-    const finish2 = () => popComponentScope(savedScope2);
+    const finish = () => popComponentScope(savedScope2);
     const r2 = renderNode(result2, writer, isSvg);
     if (r2 && typeof r2.then === "function") {
-      return r2.then(finish2);
+      return r2.then(finish);
     }
-    finish2();
+    finish();
     return;
   }
   const isProvider = "_context" in type || typeOf === REACT_PROVIDER || typeOf === REACT_CONTEXT && "value" in props;
@@ -743,26 +871,29 @@ function renderComponent(type, props, writer, isSvg) {
   }
   const savedScope = pushComponentScope();
   if (isProvider && typeof type !== "function") {
-    const finish2 = () => {
+    const finish = () => {
       popComponentScope(savedScope);
       popContextValue(ctx, prevCtxValue);
     };
     const r2 = renderChildren(props.children, writer, isSvg);
     if (r2 && typeof r2.then === "function") {
       const m = captureMap();
+      const u = captureUnsuspend();
       return r2.then(
         () => {
           swapContextMap(m);
-          finish2();
+          restoreUnsuspend(u);
+          finish();
         },
         (e) => {
           swapContextMap(m);
-          finish2();
+          restoreUnsuspend(u);
+          finish();
           throw e;
         }
       );
     }
-    finish2();
+    finish();
     return;
   }
   let result;
@@ -782,6 +913,17 @@ function renderComponent(type, props, writer, isSvg) {
     restoreDispatcher(prevDispatcher);
     popComponentScope(savedScope);
     if (isProvider) popContextValue(ctx, prevCtxValue);
+    if (e && typeof e.then === "function") {
+      if (_suspenseRetries + 1 >= MAX_COMPONENT_SUSPENSE_RETRIES) throw SUSPENSE_RETRY_LIMIT;
+      patchPromiseStatus(e);
+      const m = captureMap();
+      const u = captureUnsuspend();
+      return e.then(() => {
+        swapContextMap(m);
+        restoreUnsuspend(u);
+        return renderComponent(type, props, writer, isSvg, _suspenseRetries + 1);
+      });
+    }
     throw e;
   }
   restoreDispatcher(prevDispatcher);
@@ -789,97 +931,93 @@ function renderComponent(type, props, writer, isSvg) {
   if (!(result instanceof Promise) && componentCalledUseId()) {
     savedIdTree = pushTreeContext(1, 0);
   }
-  const finish = () => {
-    if (savedIdTree !== void 0) popTreeContext(savedIdTree);
-    popComponentScope(savedScope);
-    if (isProvider) popContextValue(ctx, prevCtxValue);
-  };
   if (result instanceof Promise) {
     const m = captureMap();
+    const u = captureUnsuspend();
     return result.then((resolved) => {
       swapContextMap(m);
+      restoreUnsuspend(u);
       let asyncSavedIdTree;
       if (componentCalledUseId()) {
         asyncSavedIdTree = pushTreeContext(1, 0);
       }
-      const asyncFinish = () => {
-        if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
-        popComponentScope(savedScope);
-        if (isProvider) popContextValue(ctx, prevCtxValue);
-      };
       const r2 = renderNode(resolved, writer, isSvg);
       if (r2 && typeof r2.then === "function") {
         const m2 = captureMap();
+        const u2 = captureUnsuspend();
         return r2.then(
           () => {
             swapContextMap(m2);
-            asyncFinish();
+            restoreUnsuspend(u2);
+            if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
+            popComponentScope(savedScope);
+            if (isProvider) popContextValue(ctx, prevCtxValue);
           },
           (e) => {
             swapContextMap(m2);
-            asyncFinish();
+            restoreUnsuspend(u2);
+            if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
+            popComponentScope(savedScope);
+            if (isProvider) popContextValue(ctx, prevCtxValue);
             throw e;
           }
         );
       }
-      asyncFinish();
+      if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
+      popComponentScope(savedScope);
+      if (isProvider) popContextValue(ctx, prevCtxValue);
     }, (e) => {
       swapContextMap(m);
-      finish();
+      restoreUnsuspend(u);
+      popComponentScope(savedScope);
+      if (isProvider) popContextValue(ctx, prevCtxValue);
       throw e;
     });
   }
   const r = renderNode(result, writer, isSvg);
   if (r && typeof r.then === "function") {
     const m = captureMap();
+    const u = captureUnsuspend();
     return r.then(
       () => {
         swapContextMap(m);
-        finish();
+        restoreUnsuspend(u);
+        if (savedIdTree !== void 0) popTreeContext(savedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider) popContextValue(ctx, prevCtxValue);
       },
       (e) => {
         swapContextMap(m);
-        finish();
+        restoreUnsuspend(u);
+        if (savedIdTree !== void 0) popTreeContext(savedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider) popContextValue(ctx, prevCtxValue);
         throw e;
       }
     );
   }
-  finish();
-}
-function isTextLike(node) {
-  return typeof node === "string" || typeof node === "number";
+  if (savedIdTree !== void 0) popTreeContext(savedIdTree);
+  popComponentScope(savedScope);
+  if (isProvider) popContextValue(ctx, prevCtxValue);
 }
 function renderChildArray(children, writer, isSvg) {
-  const totalChildren = children.length;
-  for (let i = 0; i < totalChildren; i++) {
-    if (isTextLike(children[i]) && writer.lastWasText) {
-      writer.write("<!-- -->");
-    }
-    const savedTree = pushTreeContext(totalChildren, i);
-    const r = renderNode(children[i], writer, isSvg);
-    if (r && typeof r.then === "function") {
-      const m = captureMap();
-      return r.then(() => {
-        swapContextMap(m);
-        popTreeContext(savedTree);
-        return renderChildArrayFrom(children, i + 1, writer, isSvg);
-      });
-    }
-    popTreeContext(savedTree);
-  }
+  return renderChildArrayFrom(children, 0, writer, isSvg);
 }
 function renderChildArrayFrom(children, startIndex, writer, isSvg) {
   const totalChildren = children.length;
   for (let i = startIndex; i < totalChildren; i++) {
-    if (isTextLike(children[i]) && writer.lastWasText) {
+    const child = children[i];
+    if ((typeof child === "string" || typeof child === "number") && writer.lastWasText) {
       writer.write("<!-- -->");
     }
     const savedTree = pushTreeContext(totalChildren, i);
-    const r = renderNode(children[i], writer, isSvg);
+    const r = renderNode(child, writer, isSvg);
     if (r && typeof r.then === "function") {
       const m = captureMap();
+      const u = captureUnsuspend();
       return r.then(() => {
         swapContextMap(m);
+        restoreUnsuspend(u);
         popTreeContext(savedTree);
         return renderChildArrayFrom(children, i + 1, writer, isSvg);
       });
@@ -894,87 +1032,94 @@ function renderChildren(children, writer, isSvg = false) {
   }
   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);
-    let buffer = new BufferWriter();
-    try {
-      const r = renderNode(children, buffer, isSvg);
-      if (r && typeof r.then === "function") {
-        const m = captureMap();
-        await r;
-        swapContextMap(m);
+  const savedMap = captureMap();
+  const savedMapClone = savedMap ? new Map(savedMap) : null;
+  const buffer = new BufferWriter();
+  try {
+    const r = renderNode(children, buffer, isSvg);
+    if (r && typeof r.then === "function") {
+      const m = captureMap();
+      const u = captureUnsuspend();
+      await r;
+      swapContextMap(m);
+      restoreUnsuspend(u);
+    }
+    writer.write("<!--$-->");
+    buffer.flushTo(writer);
+    writer.write("<!--/$-->");
+    writer.flush?.();
+  } catch (error) {
+    if (error === SUSPENSE_RETRY_LIMIT) {
+      restoreContext(snap);
+      swapContextMap(savedMapClone);
+      writer.write("<!--$?-->");
+      if (fallback) {
+        const r = renderNode(fallback, writer, isSvg);
+        if (r && typeof r.then === "function") {
+          const m = captureMap();
+          const u = captureUnsuspend();
+          await r;
+          swapContextMap(m);
+          restoreUnsuspend(u);
+        }
       }
-      writer.write("<!--$-->");
-      buffer.flush(writer);
       writer.write("<!--/$-->");
-      return;
-    } catch (error) {
-      if (error && typeof error.then === "function") {
-        const m = captureMap();
-        await error;
-        swapContextMap(m);
-        attempts++;
-      } else {
-        throw error;
-      }
+    } else {
+      throw error;
     }
   }
-  restoreContext(snap);
-  writer.write("<!--$?-->");
-  if (fallback) {
-    const r = renderNode(fallback, writer, isSvg);
+}
+var _streamEncoder = new TextEncoder();
+var NULL_WRITER = {
+  lastWasText: false,
+  write(_c) {
+  },
+  text(_s) {
+  }
+};
+async function renderPreflight(element, options) {
+  const idPrefix = options?.identifierPrefix ?? "";
+  const prev = swapContextMap(null);
+  try {
+    resetRenderState(idPrefix);
+    NULL_WRITER.lastWasText = false;
+    const r = renderNode(element, NULL_WRITER);
     if (r && typeof r.then === "function") {
       const m = captureMap();
       await r;
       swapContextMap(m);
     }
+  } finally {
+    swapContextMap(prev);
   }
-  writer.write("<!--/$-->");
 }
 async function renderToString(element, options) {
   const idPrefix = options?.identifierPrefix ?? "";
-  const contextMap = /* @__PURE__ */ new Map();
-  const prev = swapContextMap(contextMap);
+  const prev = swapContextMap(null);
+  let output = "";
+  const writer = {
+    lastWasText: false,
+    write(c) {
+      output += c;
+      this.lastWasText = false;
+    },
+    text(s2) {
+      output += s2;
+      this.lastWasText = true;
+    }
+  };
   try {
-    for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
-      resetRenderState(idPrefix);
-      swapContextMap(contextMap);
-      const chunks = [];
-      const writer = {
-        lastWasText: false,
-        write(c) {
-          chunks.push(c);
-          this.lastWasText = false;
-        },
-        text(s2) {
-          chunks.push(s2);
-          this.lastWasText = true;
-        }
-      };
-      try {
-        const r = renderNode(element, writer);
-        if (r && typeof r.then === "function") {
-          const m = captureMap();
-          await r;
-          swapContextMap(m);
-        }
-        return chunks.join("");
-      } catch (error) {
-        if (error && typeof error.then === "function") {
-          const m = captureMap();
-          await error;
-          swapContextMap(m);
-          continue;
-        }
-        throw error;
-      }
+    resetRenderState(idPrefix);
+    const r = renderNode(element, writer);
+    if (r && typeof r.then === "function") {
+      const m = captureMap();
+      await r;
+      swapContextMap(m);
     }
-    throw new Error("[slim-react] renderToString exceeded maximum retries");
+    return output;
   } finally {
     swapContextMap(prev);
   }
@@ -995,8 +1140,8 @@ var ATTR = {
   fetchPriority: "fetchpriority",
   hrefLang: "hreflang"
 };
-function renderHeadTag(tag, opts, selfClose = false) {
-  let attrs = "";
+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;
@@ -1010,18 +1155,18 @@ function renderHeadTag(tag, opts, selfClose = false) {
   }
   return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
 }
-var getHeadHtml = (seoData) => {
+function buildHeadHtml(seoData) {
   let html = `<title>${escText(seoData.title ?? "")}</title>`;
-  for (const opts of Object.values(seoData.meta))
-    html += renderHeadTag("meta", opts, true);
-  for (const opts of Object.values(seoData.link))
-    html += renderHeadTag("link", opts, true);
-  for (const opts of Object.values(seoData.style))
-    html += renderHeadTag("style", opts);
-  for (const opts of Object.values(seoData.script))
-    html += renderHeadTag("script", opts);
+  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;
@@ -1035,28 +1180,44 @@ var getReactResponse = async (req, opts) => {
   };
   const unsuspend = { cache: /* @__PURE__ */ new Map() };
   globalThis.__hadarsUnsuspend = unsuspend;
-  let bodyHtml;
+  globalThis.__hadarsContext = context;
+  const element = createElement(App, props);
   try {
-    bodyHtml = await renderToString(createElement(App, props));
+    await renderPreflight(element);
   } finally {
     globalThis.__hadarsUnsuspend = null;
+    globalThis.__hadarsContext = null;
   }
-  const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
-  const serverData = {};
-  for (const [key, entry] of unsuspend.cache) {
-    if (entry.status === "fulfilled") serverData[key] = entry.value;
-  }
-  const clientProps = {
-    ...restProps,
-    location: req.location,
-    ...Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}
+  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;
+    }
   };
-  return {
-    bodyHtml,
-    clientProps,
-    status: context.head.status,
-    headHtml: getHeadHtml(context.head)
+  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/rspack.ts
@@ -1454,27 +1615,6 @@ function nodeReadableToWebStream(readable) {
   });
 }
 var noopCtx = { upgrade: () => false };
-var COMPRESSIBLE_RE = /\b(?:text\/|application\/(?:json|javascript|xml)|image\/svg\+xml)/;
-function withCompression(handler) {
-  return async (req, ctx) => {
-    const res = await handler(req, ctx);
-    if (!res?.body) return res;
-    if (!COMPRESSIBLE_RE.test(res.headers.get("Content-Type") ?? "")) return res;
-    if (res.headers.has("Content-Encoding")) return res;
-    const accept = req.headers.get("Accept-Encoding") ?? "";
-    const encoding = accept.includes("br") ? "br" : accept.includes("gzip") ? "gzip" : null;
-    if (!encoding) return res;
-    try {
-      const compressed = res.body.pipeThrough(new globalThis.CompressionStream(encoding));
-      const headers = new Headers(res.headers);
-      headers.set("Content-Encoding", encoding);
-      headers.delete("Content-Length");
-      return new Response(compressed, { status: res.status, statusText: res.statusText, headers });
-    } catch {
-      return res;
-    }
-  };
-}
 function withRequestLogging(handler) {
   return async (req, ctx) => {
     const start = performance.now();
@@ -1486,9 +1626,27 @@ function withRequestLogging(handler) {
     return res;
   };
 }
+var COMPRESSIBLE_RE = /^text\/|\/json|\/javascript|\/xml|\/wasm/;
+function withCompression(handler) {
+  return async (req, ctx) => {
+    const res = await handler(req, ctx);
+    if (!res || !res.body) return res;
+    const accept = req.headers.get("Accept-Encoding") ?? "";
+    if (!accept.includes("gzip")) return res;
+    if (res.headers.has("content-encoding")) return res;
+    const ct = res.headers.get("content-type") ?? "";
+    if (!COMPRESSIBLE_RE.test(ct)) return res;
+    const compressed = res.body.pipeThrough(
+      new globalThis.CompressionStream("gzip")
+    );
+    const headers = new Headers(res.headers);
+    headers.set("content-encoding", "gzip");
+    headers.delete("content-length");
+    return new Response(compressed, { status: res.status, headers });
+  };
+}
 async function serve(port, fetchHandler, websocket) {
-  fetchHandler = withCompression(fetchHandler);
-  fetchHandler = withRequestLogging(fetchHandler);
+  fetchHandler = withCompression(withRequestLogging(fetchHandler));
   if (isBun) {
     globalThis.Bun.serve({
       port,
@@ -1561,7 +1719,7 @@ async function serve(port, fetchHandler, websocket) {
 }
 
 // src/utils/staticFile.ts
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 var MIME = {
   html: "text/html; charset=utf-8",
   htm: "text/html; charset=utf-8",
@@ -1587,16 +1745,11 @@ var MIME = {
   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.buffer, { headers: { "Content-Type": contentType } });
+    return new Response(data, { headers: { "Content-Type": contentType } });
   } catch {
     return null;
   }
@@ -1617,16 +1770,25 @@ import cluster from "node:cluster";
 var HEAD_MARKER = '<meta name="HADARS_HEAD">';
 var BODY_MARKER = '<meta name="HADARS_BODY">';
 var encoder = new TextEncoder();
-async function buildSsrResponse(bodyHtml, clientProps, headHtml, status, getPrecontentHtml) {
+function buildSsrResponse(head, status, getAppBody, finalize, getPrecontentHtml) {
+  const headHtml = buildHeadHtml(head);
+  const precontentResult = getPrecontentHtml(headHtml);
   const responseStream = new ReadableStream({
     async start(controller) {
-      const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-      controller.enqueue(encoder.encode(precontentHtml));
-      const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
-      controller.enqueue(encoder.encode(
-        `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent
-      ));
-      controller.close();
+      try {
+        const [precontentHtml, postContent] = precontentResult instanceof Promise ? await precontentResult : precontentResult;
+        controller.enqueue(encoder.encode(precontentHtml));
+        const bodyHtml = await getAppBody();
+        controller.enqueue(encoder.encode(`<div id="app">${bodyHtml}</div>`));
+        const { clientProps } = await finalize();
+        const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
+        controller.enqueue(encoder.encode(
+          `<script id="hadars" type="application/json">${scriptContent}</script>` + postContent
+        ));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
     }
   });
   return new Response(responseStream, {
@@ -1638,16 +1800,18 @@ 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;
+  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];
+      return [preHead + headHtml + postHead, postContent];
+    });
   };
 };
 async function transformStream(data, stream) {
@@ -2117,7 +2281,7 @@ var dev = async (options) => {
         getInitProps,
         getFinalProps
       } = await import(importPath);
-      const { bodyHtml, clientProps, status, headHtml } = await getReactResponse(request, {
+      const { head, status, getAppBody, finalize } = await getReactResponse(request, {
         document: {
           body: Component,
           lang: "en",
@@ -2126,13 +2290,14 @@ var dev = async (options) => {
         }
       });
       if (request.headers.get("Accept") === "application/json") {
+        const { clientProps } = await finalize();
         const serverData = clientProps.__serverData ?? {};
         return new Response(JSON.stringify({ serverData }), {
           status,
           headers: { "Content-Type": "application/json; charset=utf-8" }
         });
       }
-      return buildSsrResponse(bodyHtml, clientProps, headHtml, status, getPrecontentHtml);
+      return buildSsrResponse(head, status, getAppBody, finalize, getPrecontentHtml);
     } catch (err) {
       console.error("[hadars] SSR render error:", err);
       const msg = (err?.stack ?? err?.message ?? String(err)).replace(/</g, "&lt;");
@@ -2274,7 +2439,7 @@ var run = async (options) => {
           status: wStatus
         });
       }
-      const { bodyHtml, clientProps, status, headHtml } = await getReactResponse(request, {
+      const { head, status, getAppBody, finalize } = await getReactResponse(request, {
         document: {
           body: Component,
           lang: "en",
@@ -2283,13 +2448,14 @@ var run = async (options) => {
         }
       });
       if (request.headers.get("Accept") === "application/json") {
+        const { clientProps } = await finalize();
         const serverData = clientProps.__serverData ?? {};
         return new Response(JSON.stringify({ serverData }), {
           status,
           headers: { "Content-Type": "application/json; charset=utf-8" }
         });
       }
-      return buildSsrResponse(bodyHtml, clientProps, headHtml, status, getPrecontentHtml);
+      return buildSsrResponse(head, status, getAppBody, finalize, getPrecontentHtml);
     } catch (err) {
       console.error("[hadars] SSR render error:", err);
       return new Response("Internal Server Error", { status: 500 });
@@ -2335,6 +2501,67 @@ async function loadConfig(configPath) {
   const mod = await import(url);
   return mod && (mod.default ?? mod);
 }
+async function bundleCloudflare(config, configPath, outputFile, cwd) {
+  console.log("Building hadars project...");
+  await build({ ...config, mode: "production" });
+  const ssrBundle = resolve(cwd, ".hadars", "index.ssr.js");
+  const outHtml = resolve(cwd, ".hadars", "static", "out.html");
+  if (!existsSync3(ssrBundle)) {
+    console.error(`SSR bundle not found: ${ssrBundle}`);
+    process.exit(1);
+  }
+  if (!existsSync3(outHtml)) {
+    console.error(`HTML template not found: ${outHtml}`);
+    process.exit(1);
+  }
+  const cloudflareModule = resolve(dirname(fileURLToPath3(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 \u2192 ${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(`
+Deploy 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(() => {
+    });
+  }
+}
 async function bundleLambda(config, configPath, outputFile, cwd) {
   console.log("Building hadars project...");
   await build({ ...config, mode: "production" });
@@ -2436,7 +2663,7 @@ export default config;
 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; }
@@ -2548,15 +2775,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">
@@ -2614,7 +2841,7 @@ const App: HadarsApp<{}> = ({ context }) => {
         </div>
       </div>
 
-    </HadarsContext>
+    </>
   );
 };
 
@@ -2643,7 +2870,7 @@ Done! Next steps:
 `);
 }
 function usage() {
-  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]>");
 }
 async function runCli(argv, cwd = process.cwd()) {
   const cmd = argv[2];
@@ -2686,13 +2913,18 @@ async function runCli(argv, cwd = process.cwd()) {
         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...");