sibujs 1.4.0 → 2.0.0

package/dist/index.cjs

@@ -99,6 +99,7 @@ __export(index_exports, {
   footer: () => footer,
   form: () => form,
   g: () => g,
+  getSSRStore: () => getSSRStore,
   getSlot: () => getSlot,
   h1: () => h1,
   h2: () => h2,
@@ -171,6 +172,7 @@ __export(index_exports, {
   rp: () => rp,
   rt: () => rt,
   ruby: () => ruby,
+  runInSSRContext: () => runInSSRContext,
   s: () => s,
   samp: () => samp,
   script: () => script,
@@ -196,6 +198,7 @@ __export(index_exports, {
   symbol: () => symbol,
   table: () => table,
   tagFactory: () => tagFactory,
+  takePendingError: () => takePendingError,
   tbody: () => tbody,
   td: () => td,
   template: () => template,
@@ -210,6 +213,7 @@ __export(index_exports, {
   track: () => track2,
   transition: () => transition,
   trapFocus: () => trapFocus,
+  trustHTML: () => trustHTML,
   tspan: () => tspan,
   u: () => u,
   ul: () => ul,
@@ -232,33 +236,80 @@ function isDev() {
 var _isDev = isDev();
 function devAssert(condition, message) {
   if (_isDev && !condition) {
-    throw new Error(`[Sibu] ${message}`);
+    throw new Error(`[SibuJS] ${message}`);
   }
 }
 function devWarn(message) {
   if (_isDev) {
-    console.warn(`[Sibu] ${message}`);
+    console.warn(`[SibuJS] ${message}`);
   }
 }
 
 // src/utils/sanitize.ts
+var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
 function sanitizeUrl(url) {
   const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
   if (!trimmed) return "";
   const lower = trimmed.toLowerCase();
-  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
-    return "";
+  let schemeEnd = -1;
+  for (let i2 = 0; i2 < lower.length; i2++) {
+    const ch = lower.charCodeAt(i2);
+    if (ch === 58) {
+      schemeEnd = i2;
+      break;
+    }
+    if (ch === 47 || ch === 63 || ch === 35) break;
   }
+  if (schemeEnd === -1) return trimmed;
+  const scheme = lower.slice(0, schemeEnd + 1);
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return trimmed;
+  if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
   return trimmed;
 }
+function sanitizeSrcset(value) {
+  const parts = value.split(",");
+  const out = [];
+  for (let i2 = 0; i2 < parts.length; i2++) {
+    const part = parts[i2].trim();
+    if (!part) continue;
+    const m = part.match(/^(\S+)(\s+.+)?$/);
+    if (!m) continue;
+    const safe = sanitizeUrl(m[1]);
+    if (!safe) continue;
+    out.push(m[2] ? `${safe}${m[2]}` : safe);
+  }
+  return out.join(", ");
+}
 function sanitizeCSSValue(value) {
-  const lower = value.toLowerCase().replace(/\s+/g, "");
-  if (lower.includes("url(") || lower.includes("expression(") || lower.includes("javascript:") || lower.includes("-moz-binding")) {
+  const decoded = value.replace(/\\([0-9a-fA-F]{1,6})\s?/g, (_m, hex) => {
+    const code2 = Number.parseInt(hex, 16);
+    if (!Number.isFinite(code2) || code2 < 0 || code2 > 1114111) return "";
+    try {
+      return String.fromCodePoint(code2);
+    } catch {
+      return "";
+    }
+  });
+  const lower = decoded.toLowerCase().replace(/\s+/g, "");
+  if (lower.includes("url(") || lower.includes("expression(") || lower.includes("javascript:") || lower.includes("vbscript:") || lower.includes("-moz-binding") || lower.includes("behavior:") || lower.includes("@import") || lower.includes("image-set(") || lower.includes("filter:progid")) {
     return "";
   }
   return value;
 }
-var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "xlink:href",
+  "src",
+  "action",
+  "formaction",
+  "formtarget",
+  "cite",
+  "poster",
+  "background",
+  "srcset",
+  "ping",
+  "data"
+]);
 function isUrlAttribute(attr) {
   return URL_ATTRIBUTES.has(attr);
 }
@@ -269,11 +320,11 @@ var subscriberStack = new Array(32);
 var stackCapacity = 32;
 var stackTop = -1;
 var currentSubscriber = null;
-var signalSubscribers = /* @__PURE__ */ new WeakMap();
 var SUBS = "__s";
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
 function safeInvoke(sub2) {
   try {
     sub2();
@@ -283,6 +334,15 @@ function safeInvoke(sub2) {
 }
 var suspendDepth = 0;
 var trackingSuspended = false;
+function retrack(effectFn, subscriber) {
+  const prev = currentSubscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
 function track(effectFn, subscriber) {
   if (!subscriber) subscriber = effectFn;
   cleanup(subscriber);
@@ -350,7 +410,6 @@ function recordDependency(signal2) {
   let subs = signal2[SUBS];
   if (!subs) {
     subs = /* @__PURE__ */ new Set();
-    signalSubscribers.set(signal2, subs);
     signal2[SUBS] = subs;
   }
   subs.add(currentSubscriber);
@@ -372,57 +431,71 @@ function queueSignalNotification(signal2) {
     }
   }
 }
+var maxDrainIterations = 1e5;
 function drainNotificationQueue() {
   if (notifyDepth > 0) return;
   notifyDepth++;
   try {
     let i2 = 0;
     while (i2 < pendingQueue.length) {
+      if (i2 >= maxDrainIterations) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
       safeInvoke(pendingQueue[i2]);
       i2++;
     }
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
 function propagateDirty(sub2) {
   sub2();
-  let sig = sub2._sig;
-  while (sig) {
+  const rootSig = sub2._sig;
+  if (!rootSig) return;
+  const stack = propagateStack;
+  const baseLen = stack.length;
+  stack.push(rootSig);
+  while (stack.length > baseLen) {
+    const sig = stack.pop();
     const first = sig.__f;
     if (first) {
       if (first._c) {
         const nSig = first._sig;
-        nSig._d = true;
-        sig = nSig;
-        continue;
-      }
-      if (!pendingSet.has(first)) {
+        if (!nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        }
+      } else if (!pendingSet.has(first)) {
         pendingSet.add(first);
         pendingQueue.push(first);
       }
-      break;
+      continue;
     }
     const subs = sig[SUBS];
-    if (!subs) break;
-    let nextSig;
+    if (!subs) continue;
     for (const s2 of subs) {
       if (s2._c) {
-        s2();
         const nSig = s2._sig;
-        if (nSig && !nextSig) {
-          nextSig = nSig;
-        } else if (nSig) {
-          propagateDirty(s2);
+        if (nSig && !nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        } else if (!nSig) {
+          s2();
         }
       } else if (!pendingSet.has(s2)) {
         pendingSet.add(s2);
         pendingQueue.push(s2);
       }
     }
-    sig = nextSig;
   }
 }
 function notifySubscribers(signal2) {
@@ -446,13 +519,23 @@ function notifySubscribers(signal2) {
       }
       let i2 = 0;
       while (i2 < pendingQueue.length) {
+        if (i2 >= maxDrainIterations) {
+          if (typeof console !== "undefined") {
+            console.error(
+              `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+            );
+          }
+          break;
+        }
         safeInvoke(pendingQueue[i2]);
         i2++;
       }
     } finally {
-      pendingQueue.length = 0;
-      pendingSet.clear();
       notifyDepth--;
+      if (notifyDepth === 0) {
+        pendingQueue.length = 0;
+        pendingSet.clear();
+      }
     }
     return;
   }
@@ -472,30 +555,48 @@ function notifySubscribers(signal2) {
   notifyDepth++;
   try {
     let directCount = 0;
+    let hasComputedSub = false;
     for (const sub2 of subs) {
+      if (sub2._c) hasComputedSub = true;
       pendingQueue[directCount++] = sub2;
     }
-    for (let i3 = 0; i3 < directCount; i3++) {
-      if (pendingQueue[i3]._c) {
-        propagateDirty(pendingQueue[i3]);
+    if (!hasComputedSub) {
+      for (let i3 = 0; i3 < directCount; i3++) {
+        safeInvoke(pendingQueue[i3]);
       }
-    }
-    for (let i3 = 0; i3 < directCount; i3++) {
-      if (!pendingQueue[i3]._c) {
-        if (!pendingSet.has(pendingQueue[i3])) {
-          safeInvoke(pendingQueue[i3]);
+    } else {
+      for (let i3 = 0; i3 < directCount; i3++) {
+        if (pendingQueue[i3]._c) {
+          propagateDirty(pendingQueue[i3]);
+        }
+      }
+      for (let i3 = 0; i3 < directCount; i3++) {
+        const sub2 = pendingQueue[i3];
+        if (!sub2._c && !pendingSet.has(sub2)) {
+          pendingSet.add(sub2);
+          safeInvoke(sub2);
         }
       }
     }
     let i2 = directCount;
     while (i2 < pendingQueue.length) {
+      if (i2 - directCount >= maxDrainIterations) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
       safeInvoke(pendingQueue[i2]);
       i2++;
     }
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
 function cleanup(subscriber) {
@@ -506,7 +607,9 @@ function cleanup(subscriber) {
     if (subs) {
       subs.delete(subscriber);
       if (singleDep.__f === subscriber) {
-        singleDep.__f = void 0;
+        singleDep.__f = subs.size === 1 ? subs.values().next().value : void 0;
+      } else if (subs.size === 1 && singleDep.__f === void 0) {
+        singleDep.__f = subs.values().next().value;
       }
     }
     sub2._dep = void 0;
@@ -519,7 +622,9 @@ function cleanup(subscriber) {
     if (subs) {
       subs.delete(subscriber);
       if (signal2.__f === subscriber) {
-        signal2.__f = void 0;
+        signal2.__f = subs.size === 1 ? subs.values().next().value : void 0;
+      } else if (subs.size === 1 && signal2.__f === void 0) {
+        signal2.__f = subs.values().next().value;
       }
     }
   }
@@ -528,6 +633,9 @@ function cleanup(subscriber) {
 
 // src/reactivity/bindAttribute.ts
 var _isDev3 = isDev();
+function setProp(el, key, val) {
+  el[key] = val;
+}
 function isEventHandlerAttr(name) {
   if (name.length < 3) return false;
   const lower = name.toLowerCase();
@@ -553,7 +661,7 @@ function bindAttribute(el, attr, getter) {
     }
     if (typeof value === "boolean") {
       if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
-        el[attr] = value;
+        setProp(el, attr, value);
       } else if (value) {
         el.setAttribute(attr, "");
       } else {
@@ -563,7 +671,7 @@ function bindAttribute(el, attr, getter) {
     }
     const str = String(value);
     if ((attr === "value" || attr === "checked") && attr in el) {
-      el[attr] = attr === "checked" ? Boolean(value) : str;
+      setProp(el, attr, attr === "checked" ? Boolean(value) : str);
     } else {
       el.setAttribute(attr, isUrlAttribute(attr) ? sanitizeUrl(str) : str);
     }
@@ -594,7 +702,7 @@ function bindDynamic(el, nameGetter, valueGetter) {
     }
     const str = String(value);
     if ((name === "value" || name === "checked") && name in el) {
-      el[name] = name === "checked" ? Boolean(value) : str;
+      setProp(el, name, name === "checked" ? Boolean(value) : str);
     } else {
       el.setAttribute(name, isUrlAttribute(name) ? sanitizeUrl(str) : str);
     }
@@ -637,24 +745,29 @@ function bindChildNode(placeholder, getter) {
     let newNodes;
     if (Array.isArray(result)) {
       newNodes = [];
+      const seen = /* @__PURE__ */ new Set();
       for (let i2 = 0; i2 < result.length; i2++) {
         const item = result[i2];
         if (item == null || typeof item === "boolean") continue;
-        newNodes.push(item instanceof Node ? item : document.createTextNode(String(item)));
+        const node = item instanceof Node ? item : document.createTextNode(String(item));
+        if (seen.has(node)) {
+          if (_isDev4)
+            devWarn("bindChildNode: duplicate node reference in array \u2014 only the first occurrence is rendered.");
+          continue;
+        }
+        seen.add(node);
+        newNodes.push(node);
       }
     } else {
       const node = result instanceof Node ? result : document.createTextNode(String(result));
       newNodes = [node];
     }
-    const reused = lastNodes.length > 0 && newNodes.length > 0 ? /* @__PURE__ */ new Set() : void 0;
-    if (reused) {
+    let reused;
+    if (lastNodes.length > 0 && newNodes.length > 0) {
+      const lastSet = new Set(lastNodes);
+      reused = /* @__PURE__ */ new Set();
       for (let i2 = 0; i2 < newNodes.length; i2++) {
-        for (let j = 0; j < lastNodes.length; j++) {
-          if (newNodes[i2] === lastNodes[j]) {
-            reused.add(newNodes[i2]);
-            break;
-          }
-        }
+        if (lastSet.has(newNodes[i2])) reused.add(newNodes[i2]);
       }
     }
     for (let i2 = 0; i2 < lastNodes.length; i2++) {
@@ -697,7 +810,7 @@ function dispose(node) {
   while (stack.length > 0) {
     const current = stack.pop();
     order.push(current);
-    const children = current.childNodes;
+    const children = Array.from(current.childNodes);
     for (let i2 = 0; i2 < children.length; i2++) {
       stack.push(children[i2]);
     }
@@ -706,9 +819,35 @@ function dispose(node) {
     const current = order[i2];
     const disposers = elementDisposers.get(current);
     if (disposers) {
-      if (_isDev5) activeBindingCount -= disposers.length;
-      for (const d of disposers) d();
+      const snapshot = disposers.slice();
       elementDisposers.delete(current);
+      if (_isDev5) activeBindingCount -= snapshot.length;
+      for (const d of snapshot) {
+        try {
+          d();
+        } catch (err) {
+          if (_isDev5 && typeof console !== "undefined") {
+            console.warn("[SibuJS] Disposer threw during cleanup:", err);
+          }
+        }
+      }
+      let extraPasses = 0;
+      while (extraPasses++ < 8) {
+        const added = elementDisposers.get(current);
+        if (!added || added.length === 0) break;
+        const moreSnapshot = added.slice();
+        elementDisposers.delete(current);
+        if (_isDev5) activeBindingCount -= moreSnapshot.length;
+        for (const d of moreSnapshot) {
+          try {
+            d();
+          } catch (err) {
+            if (_isDev5 && typeof console !== "undefined") {
+              console.warn("[SibuJS] Disposer threw during cleanup:", err);
+            }
+          }
+        }
+      }
     }
   }
 }
@@ -724,6 +863,30 @@ function checkLeaks(warnThreshold = 0) {
 
 // src/core/rendering/tagFactory.ts
 var SVG_NS = "http://www.w3.org/2000/svg";
+var _isDev6 = isDev();
+var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
+function validateTagName(tag) {
+  const lower = tag.toLowerCase();
+  if (BLOCKED_TAGS.has(lower)) {
+    throw new Error(`tagFactory: refusing to create <${tag}> \u2014 tag is blocked for security reasons.`);
+  }
+}
+var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
+  "config",
+  "location",
+  "history",
+  "document",
+  "window",
+  "navigator",
+  "name",
+  "top",
+  "parent",
+  "self",
+  "frames"
+]);
+function setProp2(el, key, val) {
+  el[key] = val;
+}
 var kebabCache = /* @__PURE__ */ new Map();
 function toKebab(prop) {
   let cached = kebabCache.get(prop);
@@ -848,79 +1011,103 @@ function appendChildren(el, nodes) {
     }
   }
 }
-var tagFactory = (tag, ns) => (first, second) => {
-  const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
-  if (first === void 0) return el;
-  if (typeof first === "string") {
-    if (second !== void 0) {
-      el.setAttribute("class", first);
-      appendChildren(el, second);
+var tagFactory = (tag, ns) => {
+  return (first, second) => {
+    validateTagName(tag);
+    const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+    if (first === void 0) return el;
+    if (typeof first === "string") {
+      if (second !== void 0) {
+        el.setAttribute("class", first);
+        appendChildren(el, second);
+        return el;
+      }
+      el.textContent = first;
       return el;
     }
-    el.textContent = first;
-    return el;
-  }
-  if (typeof first === "number") {
-    el.textContent = String(first);
-    return el;
-  }
-  if (Array.isArray(first) || first instanceof Node || typeof first === "function") {
-    appendChildren(el, first);
-    return el;
-  }
-  const props = first;
-  const pClass = props.class;
-  if (pClass != null) applyClass(el, pClass);
-  const pId = props.id;
-  if (pId != null) el.id = pId;
-  const pNodes = second !== void 0 ? second : props.nodes;
-  if (pNodes != null) appendChildren(el, pNodes);
-  const pOn = props.on;
-  if (pOn) {
-    for (const ev in pOn) {
-      el.addEventListener(ev, pOn[ev]);
-    }
-  }
-  const pStyle = props.style;
-  if (pStyle != null) applyStyle(el, pStyle);
-  const pRef = props.ref;
-  if (pRef) pRef.current = el;
-  for (const key in props) {
-    switch (key) {
-      case "class":
-      case "id":
-      case "nodes":
-      case "on":
-      case "style":
-      case "ref":
-      case "onElement":
-        continue;
-      // already handled above / below
-      default: {
-        const value = props[key];
-        if (value == null) continue;
-        if (key[0] === "o" && key[1] === "n") continue;
-        if (typeof value === "function") {
-          registerDisposer(el, bindAttribute(el, key, value));
-        } else if (typeof value === "boolean") {
-          if (key in el && (key === "checked" || key === "disabled" || key === "selected")) {
-            el[key] = value;
-          } else if (value) {
-            el.setAttribute(key, "");
+    if (typeof first === "number") {
+      el.textContent = String(first);
+      return el;
+    }
+    if (Array.isArray(first) || first instanceof Node || typeof first === "function") {
+      appendChildren(el, first);
+      return el;
+    }
+    const props = first;
+    const pClass = props.class;
+    if (pClass != null) applyClass(el, pClass);
+    const pId = props.id;
+    if (pId != null) {
+      if (_isDev6 && typeof pId === "string" && CLOBBER_RISKY_IDS.has(pId.toLowerCase())) {
+        devWarn(
+          `tagFactory: element id="${pId}" matches a common global and may cause DOM clobbering. Avoid setting ids from untrusted input.`
+        );
+      }
+      el.id = pId;
+    }
+    const pNodes = second !== void 0 ? second : props.nodes;
+    if (pNodes != null) appendChildren(el, pNodes);
+    const pOn = props.on;
+    if (pOn) {
+      for (const ev in pOn) {
+        const handler = pOn[ev];
+        if (typeof handler === "function") {
+          el.addEventListener(ev, handler);
+        } else if (_isDev6) {
+          devWarn(
+            `tagFactory: on.${ev} handler is not a function (got ${typeof handler}). Event listener was not attached.`
+          );
+        }
+      }
+    }
+    const pStyle = props.style;
+    if (pStyle != null) applyStyle(el, pStyle);
+    const pRef = props.ref;
+    if (pRef) pRef.current = el;
+    for (const key in props) {
+      switch (key) {
+        case "class":
+        case "id":
+        case "nodes":
+        case "on":
+        case "style":
+        case "ref":
+        case "onElement":
+          continue;
+        // already handled above / below
+        default: {
+          const value = props[key];
+          if (value == null) continue;
+          const lkey = key.toLowerCase();
+          if (lkey[0] === "o" && lkey[1] === "n") continue;
+          if (typeof value === "function") {
+            registerDisposer(el, bindAttribute(el, key, value));
+          } else if (typeof value === "boolean") {
+            if (key in el && (key === "checked" || key === "disabled" || key === "selected")) {
+              setProp2(el, key, value);
+            } else if (value) {
+              el.setAttribute(key, "");
+            } else {
+              el.removeAttribute(key);
+            }
           } else {
-            el.removeAttribute(key);
+            const str = String(value);
+            if (lkey === "srcset") {
+              el.setAttribute(key, sanitizeSrcset(str));
+            } else if (isUrlAttribute(lkey)) {
+              el.setAttribute(key, sanitizeUrl(str));
+            } else {
+              el.setAttribute(key, str);
+            }
           }
-        } else {
-          const str = String(value);
-          el.setAttribute(key, isUrlAttribute(key) ? sanitizeUrl(str) : str);
         }
       }
     }
-  }
-  if (props.onElement && typeof props.onElement === "function") {
-    props.onElement(el);
-  }
-  return el;
+    if (props.onElement && typeof props.onElement === "function") {
+      props.onElement(el);
+    }
+    return el;
+  };
 };
 
 // src/core/rendering/html.ts
@@ -1063,6 +1250,8 @@ var marquee = tagFactory("marquee");
 var customElement = (tagName) => tagFactory(tagName);
 
 // src/core/rendering/htm.ts
+var _isDev7 = isDev();
+var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -1247,6 +1436,15 @@ function parseTemplate(strings) {
           children.push({ t: 0, el: { tag, svg: SVG_TAGS.has(tag), attrs, children: [] } });
         } else {
           const inner = parseChildren();
+          if (RAW_TEXT_TAGS.has(tag.toLowerCase())) {
+            for (let i2 = 0; i2 < inner.length; i2++) {
+              if (inner[i2].t === 2) {
+                throw new Error(
+                  `html: dynamic \${...} expressions are not allowed inside <${tag}> (raw-text context). Build the content separately and append it as a Node.`
+                );
+              }
+            }
+          }
           if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") {
             pos += 2;
             readTagName();
@@ -1273,27 +1471,50 @@ function executeElement(tmpl, values) {
         break;
       case 1: {
         const name = attr.name;
-        if (name[0] === "o" && name[1] === "n") break;
+        const lname = name.toLowerCase();
+        if (lname[0] === "o" && lname[1] === "n") break;
         const val = values[attr.idx];
         if (typeof val === "function") {
           registerDisposer(el, bindAttribute(el, name, val));
         } else if (val != null) {
           const str = String(val);
-          el.setAttribute(name, isUrlAttribute(name) ? sanitizeUrl(str) : str);
+          if (lname === "srcset") {
+            el.setAttribute(name, sanitizeSrcset(str));
+          } else if (isUrlAttribute(lname)) {
+            el.setAttribute(name, sanitizeUrl(str));
+          } else {
+            el.setAttribute(name, str);
+          }
         }
         break;
       }
       case 2: {
         let val = attr.statics[0];
         for (let j = 0; j < attr.exprs.length; j++) {
-          val += String(values[attr.exprs[j]]) + attr.statics[j + 1];
+          const ev = values[attr.exprs[j]];
+          val += (ev == null ? "" : String(ev)) + attr.statics[j + 1];
+        }
+        const lname2 = attr.name.toLowerCase();
+        if (lname2 === "srcset") {
+          el.setAttribute(attr.name, sanitizeSrcset(val));
+        } else if (isUrlAttribute(lname2)) {
+          el.setAttribute(attr.name, sanitizeUrl(val));
+        } else {
+          el.setAttribute(attr.name, val);
         }
-        el.setAttribute(attr.name, val);
         break;
       }
-      case 3:
-        el.addEventListener(attr.name, values[attr.idx]);
+      case 3: {
+        const fn = values[attr.idx];
+        if (typeof fn === "function") {
+          el.addEventListener(attr.name, fn);
+        } else if (_isDev7) {
+          devWarn(
+            `html: on:${attr.name} handler is not a function (got ${typeof fn}). Event listener was not attached.`
+          );
+        }
         break;
+      }
       case 4:
         el.setAttribute(attr.name, "");
         break;
@@ -1387,7 +1608,7 @@ function html2(strings, ...values) {
 function mount(component, container) {
   if (!container) {
     throw new Error(
-      "[Sibu] mount: container element not found. Make sure the DOM element exists before calling mount()."
+      "[SibuJS mount] container element not found. Make sure the DOM element exists before calling mount()."
     );
   }
   devAssert(
@@ -1415,7 +1636,7 @@ function mount(component, container) {
 }
 
 // src/core/rendering/each.ts
-var _isDev6 = isDev();
+var _isDev8 = isDev();
 function resolveNodeChild(child) {
   if (typeof child === "function") {
     return resolveNodeChild(child());
@@ -1510,17 +1731,31 @@ function each(getArray, render, options) {
         node = existing;
       } else {
         const itemKey = key;
-        const itemGetter = () => getArray()[keyIndexMap.get(itemKey)];
+        const itemGetter = () => untracked(() => getArray()[keyIndexMap.get(itemKey)]);
         const indexGetter = () => keyIndexMap.get(itemKey);
         try {
           node = resolveNodeChild(render(itemGetter, indexGetter));
         } catch (err) {
-          if (_isDev6) {
+          if (_isDev8) {
             devWarn(
               `each: render threw for item at index ${i2} (key="${newKeys[i2]}"): ${err instanceof Error ? err.message : String(err)}`
             );
           }
           node = document.createComment(`each:error:${i2}`);
+          const errorObj = err instanceof Error ? err : new Error(String(err));
+          queueMicrotask(() => {
+            try {
+              const target = anchor.parentNode;
+              if (target?.dispatchEvent) {
+                target.dispatchEvent(
+                  new CustomEvent("sibu:error-propagate", { bubbles: true, detail: { error: errorObj } })
+                );
+              } else if (_isDev8) {
+                devWarn(`each: error not surfaced \u2014 anchor detached: ${errorObj.message}`);
+              }
+            } catch {
+            }
+          });
         }
       }
       workMap.set(key, node);
@@ -1589,7 +1824,8 @@ function each(getArray, render, options) {
     workMap = tmp;
     initialized = true;
   };
-  track(update);
+  const untrack = track(update);
+  registerDisposer(anchor, untrack);
   if (!initialized) {
     queueMicrotask(() => {
       if (!initialized && anchor.parentNode) {
@@ -1636,24 +1872,36 @@ function Portal(nodes, target) {
   const anchor = document.createComment("portal");
   const container = target || document.body;
   let portalContent = null;
+  let disposed = false;
   queueMicrotask(() => {
+    if (disposed) return;
     try {
       portalContent = nodes();
       container.appendChild(portalContent);
     } catch (err) {
-      console.error("[Portal] Render error:", err);
+      if (typeof console !== "undefined") {
+        console.error("[Portal] Render error:", err);
+      }
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      queueMicrotask(() => {
+        try {
+          const target2 = anchor.parentNode;
+          if (target2?.dispatchEvent) {
+            target2.dispatchEvent(
+              new CustomEvent("sibu:error-propagate", { bubbles: true, detail: { error: errorObj } })
+            );
+          }
+        } catch {
+        }
+      });
     }
   });
-  const observer = new MutationObserver(() => {
-    if (!anchor.isConnected && portalContent) {
+  registerDisposer(anchor, () => {
+    disposed = true;
+    if (portalContent) {
+      dispose(portalContent);
       portalContent.remove();
       portalContent = null;
-      observer.disconnect();
-    }
-  });
-  queueMicrotask(() => {
-    if (anchor.parentNode) {
-      observer.observe(anchor.parentNode, { childList: true });
     }
   });
   return anchor;
@@ -1689,7 +1937,8 @@ function DynamicComponent(is) {
     }
     container.replaceChildren(el);
   }
-  track(render);
+  const untrack = track(render);
+  registerDisposer(container, untrack);
   return container;
 }
 
@@ -1779,11 +2028,16 @@ function KeepAlive(activeKey, cases, options) {
   const anchor = document.createComment("keep-alive");
   const cache2 = /* @__PURE__ */ new Map();
   const lruOrder = [];
-  const max = options?.max ?? 0;
+  const max = options?.max ?? 10;
+  if (max === 0 && isDev()) {
+    devWarn("KeepAlive: unbounded cache (max: 0). Cached subtrees will never be evicted \u2014 set `max` to bound memory.");
+  }
   let currentKey;
   let currentNode = null;
   let initialized = false;
+  let disposed = false;
   const update = () => {
+    if (disposed) return;
     const key = activeKey();
     const parent = anchor.parentNode;
     if (!parent) return;
@@ -1823,12 +2077,23 @@ function KeepAlive(activeKey, cases, options) {
     currentNode = node;
     initialized = true;
   };
-  track(update);
+  const untrack = track(update);
   if (!initialized) {
     queueMicrotask(() => {
       if (!initialized && anchor.parentNode) update();
     });
   }
+  registerDisposer(anchor, () => {
+    disposed = true;
+    untrack();
+    for (const node of cache2.values()) {
+      dispose(node);
+      if (node.parentNode) node.parentNode.removeChild(node);
+    }
+    cache2.clear();
+    lruOrder.length = 0;
+    currentNode = null;
+  });
   return anchor;
 }
 
@@ -1990,19 +2255,22 @@ function isBatching() {
   return batchDepth > 0;
 }
 function flushBatch() {
-  for (const signal2 of pendingSignals) {
-    queueSignalNotification(signal2);
+  try {
+    for (const signal2 of pendingSignals) {
+      queueSignalNotification(signal2);
+    }
+  } finally {
+    pendingSignals.clear();
   }
-  pendingSignals.clear();
   drainNotificationQueue();
 }
 
 // src/core/signals/signal.ts
 var _g = globalThis;
-var _isDev7 = isDev();
+var _isDev9 = isDev();
 function signal(initial, options) {
   const state = { value: initial };
-  const debugName = _isDev7 ? options?.name : void 0;
+  const debugName = _isDev9 ? options?.name : void 0;
   const equalsFn = options?.equals;
   if (debugName) {
     state.__name = debugName;
@@ -2016,7 +2284,7 @@ function signal(initial, options) {
   function set(next) {
     const newValue = typeof next === "function" ? next(state.value) : next;
     if (equalsFn ? equalsFn(state.value, newValue) : Object.is(newValue, state.value)) return;
-    if (_isDev7) {
+    if (_isDev9) {
       const oldValue = state.value;
       state.value = newValue;
       const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
@@ -2028,7 +2296,7 @@ function signal(initial, options) {
       notifySubscribers(state);
     }
   }
-  if (_isDev7) {
+  if (_isDev9) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
     if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
   }
@@ -2036,23 +2304,59 @@ function signal(initial, options) {
 }
 
 // src/core/ssr-context.ts
-var ssrMode = false;
+var als = null;
+try {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const req = Function("return typeof require==='function'?require:null")();
+    if (req) {
+      const mod = req("node:async_hooks");
+      als = new mod.AsyncLocalStorage();
+    }
+  }
+} catch {
+  als = null;
+}
+var fallbackStore = { ssr: false, suspenseIdCounter: 0 };
+function getSSRStore() {
+  if (als) {
+    const s2 = als.getStore();
+    if (s2) return s2;
+  }
+  return fallbackStore;
+}
 function isSSR() {
-  return ssrMode;
+  return getSSRStore().ssr;
 }
 function enableSSR() {
-  ssrMode = true;
+  getSSRStore().ssr = true;
 }
 function disableSSR() {
-  ssrMode = false;
+  getSSRStore().ssr = false;
+}
+function runInSSRContext(fn) {
+  const store2 = { ssr: true, suspenseIdCounter: 0 };
+  if (als) {
+    return als.run(store2, fn);
+  }
+  const prevSSR = fallbackStore.ssr;
+  const prevCounter = fallbackStore.suspenseIdCounter;
+  fallbackStore.ssr = true;
+  fallbackStore.suspenseIdCounter = 0;
+  try {
+    return fn();
+  } finally {
+    fallbackStore.ssr = prevSSR;
+    fallbackStore.suspenseIdCounter = prevCounter;
+  }
 }
 function withSSR(fn) {
-  const wasSSR = ssrMode;
-  enableSSR();
+  const store2 = getSSRStore();
+  const wasSSR = store2.ssr;
+  store2.ssr = true;
   try {
     return fn();
   } finally {
-    if (!wasSSR) disableSSR();
+    if (!wasSSR) store2.ssr = false;
   }
 }
 
@@ -2079,26 +2383,86 @@ function effect(effectFn, options) {
   if (isSSR()) return () => {
   };
   const onError = options?.onError;
+  let userCleanups = [];
+  const onCleanup2 = (fn) => {
+    userCleanups.push(fn);
+  };
+  const runUserCleanups = () => {
+    if (userCleanups.length === 0) return;
+    const list = userCleanups;
+    userCleanups = [];
+    for (let i2 = list.length - 1; i2 >= 0; i2--) {
+      try {
+        list[i2]();
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS effect] onCleanup threw:", err);
+        }
+      }
+    }
+  };
+  const invokeBody = () => effectFn(onCleanup2);
   const wrappedFn = onError ? () => {
     try {
-      effectFn();
+      invokeBody();
     } catch (err) {
       onError(err);
     }
-  } : effectFn;
+  } : invokeBody;
   let cleanupHandle = () => {
   };
+  let running = false;
   const subscriber = () => {
-    cleanupHandle();
-    cleanupHandle = track(wrappedFn, subscriber);
+    if (running) {
+      if (_g2.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+        console.warn(
+          "[SibuJS] effect re-entered itself while running \u2014 the triggering update will be ignored. Wrap mutual writes in `batch()` or split the effect to avoid this."
+        );
+      }
+      return;
+    }
+    running = true;
+    try {
+      runUserCleanups();
+      cleanupHandle();
+      cleanupHandle = track(wrappedFn, subscriber);
+    } finally {
+      running = false;
+    }
   };
-  cleanupHandle = track(wrappedFn, subscriber);
+  running = true;
+  try {
+    cleanupHandle = track(wrappedFn, subscriber);
+  } finally {
+    running = false;
+  }
   const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });
+  let disposed = false;
   return () => {
+    if (disposed) return;
+    disposed = true;
     const h = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (h) h.emit("effect:destroy", { effectFn });
-    cleanupHandle();
+    if (h) {
+      try {
+        h.emit("effect:destroy", { effectFn });
+      } catch {
+      }
+    }
+    try {
+      runUserCleanups();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
+      }
+    }
+    try {
+      cleanupHandle();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] dispose threw:", err);
+      }
+    }
   };
 }
 
@@ -2106,6 +2470,7 @@ function effect(effectFn, options) {
 function derived(getter, options) {
   devAssert(typeof getter === "function", "derived: argument must be a getter function.");
   const debugName = options?.name;
+  const equals = options?.equals;
   const cs = {};
   cs._d = false;
   cs._g = getter;
@@ -2116,25 +2481,56 @@ function derived(getter, options) {
   markDirty._c = 1;
   markDirty._sig = cs;
   track(() => {
-    cs._d = false;
-    cs._v = getter();
+    let threw = true;
+    try {
+      cs._v = getter();
+      cs._d = false;
+      threw = false;
+    } finally {
+      if (threw) cs._d = true;
+    }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  let evaluating = false;
   function computedGetter() {
+    if (evaluating) {
+      throw new Error(
+        `[SibuJS] Circular dependency detected in derived${debugName ? ` "${debugName}"` : ""}. A derived signal cannot read itself (directly or through a chain).`
+      );
+    }
     if (trackingSuspended) {
       if (cs._d) {
-        cs._d = false;
-        cs._v = getter();
+        evaluating = true;
+        let threw = true;
+        try {
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
+        } finally {
+          evaluating = false;
+          if (threw) cs._d = true;
+        }
       }
       return cs._v;
     }
     recordDependency(cs);
     if (cs._d) {
       const oldValue = cs._v;
-      track(() => {
-        cs._d = false;
-        cs._v = getter();
-      }, markDirty);
+      evaluating = true;
+      let threw = true;
+      try {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
+          cs._d = false;
+          threw = false;
+        }, markDirty);
+      } finally {
+        evaluating = false;
+        if (threw) cs._d = true;
+      }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
       }
@@ -2195,7 +2591,7 @@ function store(initialState) {
     },
     set() {
       throw new Error(
-        "[Sibu] store: Direct mutation is not allowed. Use actions.setState() to update store properties."
+        "[SibuJS store] Direct mutation is not allowed. Use actions.setState() to update store properties."
       );
     }
   });
@@ -2209,16 +2605,20 @@ function store(initialState) {
   const setState = (patch) => {
     const current = getSnapshot();
     const nextState = typeof patch === "function" ? patch(current) : patch;
-    Object.entries(nextState).forEach(([key, value]) => {
-      if (key in signals) {
-        signals[key][1](value);
-      }
+    batch(() => {
+      Object.entries(nextState).forEach(([key, value]) => {
+        if (key in signals) {
+          signals[key][1](value);
+        }
+      });
     });
   };
   const reset = () => {
-    Object.keys(initialState).forEach((key) => {
-      const setter = signals[key][1];
-      setter(initialState[key]);
+    batch(() => {
+      Object.keys(initialState).forEach((key) => {
+        const setter = signals[key][1];
+        setter(initialState[key]);
+      });
     });
   };
   const subscribe = (callback) => {
@@ -2352,7 +2752,8 @@ function reactiveArray(initial = []) {
   function get() {
     recordDependency(signal2);
     if (snapshot === null) {
-      snapshot = Object.freeze([...data2]);
+      const copy = data2.slice();
+      snapshot = Object.freeze(copy);
     }
     return snapshot;
   }
@@ -2462,21 +2863,67 @@ function deepEqual(a2, b2, seen) {
   if (a2 == null || b2 == null) return false;
   if (typeof a2 !== typeof b2) return false;
   if (typeof a2 !== "object") return false;
-  if (a2 instanceof Date && b2 instanceof Date) return a2.getTime() === b2.getTime();
-  if (a2 instanceof RegExp && b2 instanceof RegExp) return a2.toString() === b2.toString();
-  if (!seen) seen = /* @__PURE__ */ new Set();
-  if (seen.has(a2)) return true;
-  seen.add(a2);
+  const objA = a2;
+  const objB = b2;
+  if (objA.constructor !== objB.constructor) return false;
+  if (a2 instanceof Date) return a2.getTime() === b2.getTime();
+  if (a2 instanceof RegExp) {
+    const rb = b2;
+    return a2.source === rb.source && a2.flags === rb.flags;
+  }
+  if (!seen) seen = /* @__PURE__ */ new Map();
+  let peers = seen.get(objA);
+  if (peers?.has(objB)) return true;
+  if (!peers) {
+    peers = /* @__PURE__ */ new Set();
+    seen.set(objA, peers);
+  }
+  peers.add(objB);
+  if (a2 instanceof Map) {
+    const mb = b2;
+    if (a2.size !== mb.size) return false;
+    for (const [k, v] of a2) {
+      if (!mb.has(k)) return false;
+      if (!deepEqual(v, mb.get(k), seen)) return false;
+    }
+    return true;
+  }
+  if (a2 instanceof Set) {
+    const sb = b2;
+    if (a2.size !== sb.size) return false;
+    for (const item of a2) {
+      if (!sb.has(item)) return false;
+    }
+    return true;
+  }
+  if (a2 instanceof ArrayBuffer) {
+    const viewA = new Uint8Array(a2);
+    const viewB = new Uint8Array(b2);
+    if (viewA.length !== viewB.length) return false;
+    for (let i2 = 0; i2 < viewA.length; i2++) {
+      if (viewA[i2] !== viewB[i2]) return false;
+    }
+    return true;
+  }
+  if (ArrayBuffer.isView(a2) && ArrayBuffer.isView(b2)) {
+    const ta = a2;
+    const tb = b2;
+    if (ta.length !== tb.length) return false;
+    for (let i2 = 0; i2 < ta.length; i2++) {
+      if (ta[i2] !== tb[i2]) return false;
+    }
+    return true;
+  }
   if (Array.isArray(a2)) {
     if (!Array.isArray(b2)) return false;
     if (a2.length !== b2.length) return false;
     return a2.every((val, i2) => deepEqual(val, b2[i2], seen));
   }
-  const keysA = Object.keys(a2);
-  const keysB = Object.keys(b2);
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
   if (keysA.length !== keysB.length) return false;
   return keysA.every(
-    (key) => deepEqual(a2[key], b2[key], seen)
+    (key) => deepEqual(objA[key], objB[key], seen)
   );
 }
 function deepSignal(initial) {
@@ -2502,26 +2949,34 @@ function asyncDerived(factory, initial) {
   effect(() => {
     tick();
     const currentRun = ++runId;
-    setLoading(true);
-    setError(null);
+    batch(() => {
+      setLoading(true);
+      setError(null);
+    });
     let promise;
     try {
       promise = factory();
     } catch (err) {
-      setError(err);
-      setLoading(false);
+      batch(() => {
+        setError(err);
+        setLoading(false);
+      });
       return;
     }
     promise.then(
       (result) => {
         if (currentRun !== runId) return;
-        setValue(result);
-        setLoading(false);
+        batch(() => {
+          setValue(result);
+          setLoading(false);
+        });
       },
       (err) => {
         if (currentRun !== runId) return;
-        setError(err);
-        setLoading(false);
+        batch(() => {
+          setError(err);
+          setLoading(false);
+        });
       }
     );
   });
@@ -2536,32 +2991,198 @@ function asyncDerived(factory, initial) {
 // src/core/rendering/lifecycle.ts
 function safeCall(cb, hookName) {
   try {
-    cb();
+    return cb();
   } catch (err) {
     devWarn(`${hookName}: callback threw: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
+function runMountCallback(callback, hookName, element) {
+  const cleanup2 = safeCall(callback, hookName);
+  if (typeof cleanup2 === "function" && element) {
+    registerDisposer(element, cleanup2);
+  }
+}
+var mountWatchers = /* @__PURE__ */ new WeakMap();
+var unmountWatchers = /* @__PURE__ */ new WeakMap();
+var watchedMountElements = /* @__PURE__ */ new Set();
+var watchedUnmountElements = /* @__PURE__ */ new Set();
+var sharedObserver = null;
+var mutationCounter = 0;
+var FULL_SWEEP_INTERVAL = 256;
+function fireMount(el) {
+  const cbs = mountWatchers.get(el);
+  if (!cbs) return;
+  mountWatchers.delete(el);
+  watchedMountElements.delete(el);
+  for (const cb of cbs) {
+    try {
+      cb();
+    } catch {
+    }
+  }
+}
+function fireUnmount(el) {
+  const cbs = unmountWatchers.get(el);
+  if (!cbs) return;
+  queueMicrotask(() => {
+    if (el.isConnected) return;
+    const stillCbs = unmountWatchers.get(el);
+    if (!stillCbs) return;
+    unmountWatchers.delete(el);
+    watchedUnmountElements.delete(el);
+    for (const cb of stillCbs) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  });
+}
+function visitAddedNode(node) {
+  if (watchedMountElements.size === 0) return;
+  if (node.nodeType !== 1) return;
+  const el = node;
+  if (watchedMountElements.has(el) && el.isConnected) {
+    fireMount(el);
+  }
+  if (el.firstElementChild) {
+    for (const watched of Array.from(watchedMountElements)) {
+      if (watched !== el && watched.isConnected && el.contains(watched)) {
+        fireMount(watched);
+      }
+    }
+  }
+}
+function visitRemovedNode(node) {
+  if (watchedUnmountElements.size === 0) return;
+  if (node.nodeType !== 1) return;
+  const el = node;
+  if (watchedUnmountElements.has(el) && !el.isConnected) {
+    fireUnmount(el);
+  }
+  if (el.firstElementChild) {
+    for (const watched of Array.from(watchedUnmountElements)) {
+      if (watched !== el && !watched.isConnected && el.contains(watched)) {
+        fireUnmount(watched);
+      }
+    }
+  }
+}
+function fullSweep() {
+  if (watchedMountElements.size > 0) {
+    for (const el of Array.from(watchedMountElements)) {
+      if (el.isConnected) fireMount(el);
+    }
+  }
+  if (watchedUnmountElements.size > 0) {
+    for (const el of Array.from(watchedUnmountElements)) {
+      if (!el.isConnected) fireUnmount(el);
+    }
   }
 }
+function ensureObserver() {
+  if (sharedObserver || typeof document === "undefined") return;
+  sharedObserver = new MutationObserver((mutations) => {
+    for (const m of mutations) {
+      if (m.type !== "childList") continue;
+      if (m.addedNodes.length > 0) {
+        for (let i2 = 0; i2 < m.addedNodes.length; i2++) {
+          visitAddedNode(m.addedNodes[i2]);
+        }
+      }
+      if (m.removedNodes.length > 0) {
+        for (let i2 = 0; i2 < m.removedNodes.length; i2++) {
+          visitRemovedNode(m.removedNodes[i2]);
+        }
+      }
+    }
+    mutationCounter += mutations.length;
+    if (mutationCounter >= FULL_SWEEP_INTERVAL) {
+      mutationCounter = 0;
+      fullSweep();
+    }
+    maybeDisconnectObserver();
+  });
+  sharedObserver.observe(document.body, { childList: true, subtree: true });
+}
+function maybeDisconnectObserver() {
+  if (!sharedObserver) return;
+  if (watchedMountElements.size === 0 && watchedUnmountElements.size === 0) {
+    sharedObserver.disconnect();
+    sharedObserver = null;
+    mutationCounter = 0;
+  }
+}
+function registerMountWatcher(element, cb) {
+  let list = mountWatchers.get(element);
+  if (!list) {
+    list = [];
+    mountWatchers.set(element, list);
+  }
+  list.push(cb);
+  watchedMountElements.add(element);
+  ensureObserver();
+  return () => {
+    const cbs = mountWatchers.get(element);
+    if (cbs) {
+      const idx = cbs.indexOf(cb);
+      if (idx !== -1) cbs.splice(idx, 1);
+      if (cbs.length === 0) {
+        mountWatchers.delete(element);
+        watchedMountElements.delete(element);
+      }
+    }
+    maybeDisconnectObserver();
+  };
+}
+function registerUnmountWatcher(element, cb) {
+  let list = unmountWatchers.get(element);
+  if (!list) {
+    list = [];
+    unmountWatchers.set(element, list);
+  }
+  list.push(cb);
+  watchedUnmountElements.add(element);
+  ensureObserver();
+  return () => {
+    const cbs = unmountWatchers.get(element);
+    if (cbs) {
+      const idx = cbs.indexOf(cb);
+      if (idx !== -1) cbs.splice(idx, 1);
+      if (cbs.length === 0) {
+        unmountWatchers.delete(element);
+        watchedUnmountElements.delete(element);
+      }
+    }
+    maybeDisconnectObserver();
+  };
+}
 function onMount(callback, element) {
   if (typeof document === "undefined") return;
   if (element) {
+    let disposed = false;
+    registerDisposer(element, () => {
+      disposed = true;
+    });
     if (element.isConnected) {
       queueMicrotask(() => {
-        safeCall(callback, "onMount");
+        if (disposed) return;
+        runMountCallback(callback, "onMount", element);
       });
       return;
     }
-    const observer = new MutationObserver(() => {
-      if (element.isConnected) {
-        observer.disconnect();
-        safeCall(callback, "onMount");
-      }
-    });
     queueMicrotask(() => {
+      if (disposed) return;
       if (element.isConnected) {
-        safeCall(callback, "onMount");
-      } else {
-        observer.observe(document.body, { childList: true, subtree: true });
+        runMountCallback(callback, "onMount", element);
+        return;
       }
+      const unregister = registerMountWatcher(element, () => {
+        if (disposed) return;
+        runMountCallback(callback, "onMount", element);
+      });
+      registerDisposer(element, unregister);
     });
   } else {
     queueMicrotask(() => {
@@ -2570,20 +3191,24 @@ function onMount(callback, element) {
   }
 }
 function onUnmount(callback, element) {
-  const startObserving = () => {
-    const observer = new MutationObserver(() => {
-      if (!element.isConnected) {
-        observer.disconnect();
-        safeCall(callback, "onUnmount");
-      }
-    });
-    observer.observe(document.body, { childList: true, subtree: true });
+  if (typeof document === "undefined") return;
+  let fired = false;
+  const fireOnce = () => {
+    if (fired) return;
+    fired = true;
+    safeCall(callback, "onUnmount");
+  };
+  registerDisposer(element, fireOnce);
+  const startWatching = () => {
+    if (fired) return;
+    const unregister = registerUnmountWatcher(element, fireOnce);
+    registerDisposer(element, unregister);
   };
   if (element.isConnected) {
-    startObserving();
+    startWatching();
   } else {
     onMount(() => {
-      startObserving();
+      startWatching();
       return void 0;
     }, element);
   }
@@ -2595,9 +3220,11 @@ function onCleanup(callback, element) {
 // src/core/rendering/context.ts
 function context(defaultValue) {
   const [getValue, setValue] = signal(defaultValue);
-  return {
+  const ctx = {
     provide(value) {
+      const previous = getValue();
       setValue(value);
+      return () => setValue(previous);
     },
     use() {
       return getValue;
@@ -2607,8 +3234,18 @@ function context(defaultValue) {
     },
     set(value) {
       setValue(value);
+    },
+    withContext(value, fn) {
+      const previous = getValue();
+      setValue(value);
+      try {
+        return fn();
+      } finally {
+        setValue(previous);
+      }
     }
   };
+  return ctx;
 }
 
 // src/core/strict.ts
@@ -2619,7 +3256,7 @@ function strict(fn) {
       try {
         fn();
       } catch (err) {
-        console.warn("[Sibu strict] second run threw:", err);
+        console.warn("[SibuJS strict] second run threw:", err);
       }
     });
   }
@@ -2635,7 +3272,7 @@ function strictEffect(fn) {
     try {
       secondTeardown = effect(fn);
     } catch (err) {
-      console.warn("[Sibu strictEffect] second run threw:", err);
+      console.warn("[SibuJS strictEffect] second run threw:", err);
     }
   });
   return () => {
@@ -2661,9 +3298,11 @@ function nextTick() {
 function defer(getter) {
   const [value, setValue] = signal(getter());
   let pending = false;
+  let disposed = false;
   let latest = value();
   const flush = () => {
     pending = false;
+    if (disposed) return;
     setValue(latest);
   };
   const schedule = () => {
@@ -2677,11 +3316,17 @@ function defer(getter) {
       }
     });
   };
-  track(() => {
+  const teardown = track(() => {
     latest = getter();
     schedule();
   });
-  return value;
+  const accessor = (() => value());
+  accessor.dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    teardown();
+  };
+  return accessor;
 }
 var IDLE_FALLBACK_MS = 16;
 function scheduleIdle(fn) {
@@ -2722,32 +3367,56 @@ function transition() {
 }
 
 // src/core/rendering/lazy.ts
+var PENDING_ERROR = "__sibuPendingError";
+function dispatchPropagate(node, error) {
+  const fire = () => {
+    try {
+      if (!node.parentNode) return false;
+      node.dispatchEvent(new CustomEvent("sibu:error-propagate", { bubbles: true, detail: { error } }));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (node.parentNode && fire()) return;
+  queueMicrotask(() => {
+    if (fire()) return;
+    node[PENDING_ERROR] = error;
+  });
+}
+function takePendingError(node) {
+  const rec = node;
+  const err = rec[PENDING_ERROR];
+  if (err instanceof Error) {
+    delete rec[PENDING_ERROR];
+    return err;
+  }
+  return void 0;
+}
 function lazy(importFn) {
   let cached = null;
   return function LazyComponent() {
     if (cached) {
       return cached();
     }
-    const [_status, setStatus] = signal("loading");
-    const [_error, setError] = signal(null);
     const container = div({ class: "sibu-lazy" });
+    let disposed = false;
     importFn().then((mod) => {
+      if (disposed) return;
       cached = mod.default;
       const rendered = cached();
       container.replaceChildren(rendered);
-      setStatus("loaded");
     }).catch((err) => {
+      if (disposed) return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
-      setError(errorObj);
-      setStatus("error");
-      container.replaceChildren(
-        div({
-          class: "sibu-lazy-error",
-          nodes: `Failed to load component: ${errorObj.message}`
-        })
-      );
+      devWarn(`[SibuJS] lazy() failed to load component: ${errorObj.message}`);
+      container.replaceChildren(div({ class: "sibu-lazy-error" }, `Failed to load component: ${errorObj.message}`));
+      dispatchPropagate(container, errorObj);
+    });
+    container.appendChild(span("sibu-lazy-loading", "Loading..."));
+    registerDisposer(container, () => {
+      disposed = true;
     });
-    container.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));
     return container;
   };
 }
@@ -2755,32 +3424,55 @@ function Suspense({ nodes, fallback }) {
   const container = div({ class: "sibu-suspense" });
   const fallbackEl = fallback();
   container.appendChild(fallbackEl);
+  let suspenseDisposed = false;
+  let observer = null;
+  registerDisposer(container, () => {
+    suspenseDisposed = true;
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  });
   queueMicrotask(() => {
+    if (suspenseDisposed) return;
     try {
       const childEl = nodes();
       if (childEl.classList.contains("sibu-lazy")) {
-        const observer = new MutationObserver(() => {
+        if (!childEl.querySelector(".sibu-lazy-loading")) {
+          container.replaceChildren(childEl);
+          return;
+        }
+        observer = new MutationObserver(() => {
+          if (suspenseDisposed) return;
           const loading = childEl.querySelector(".sibu-lazy-loading");
           if (!loading) {
-            observer.disconnect();
+            observer?.disconnect();
+            observer = null;
             container.replaceChildren(childEl);
           }
         });
         observer.observe(childEl, { childList: true, subtree: true });
-        if (!childEl.querySelector(".sibu-lazy-loading")) {
-          container.replaceChildren(childEl);
-        }
       } else {
         container.replaceChildren(childEl);
       }
-    } catch {
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      devWarn(`[SibuJS] Suspense nodes() threw: ${errorObj.message}`);
+      dispatchPropagate(container, errorObj);
     }
   });
   return container;
 }
 
+// src/platform/ssr.ts
+var _isDev10 = isDev();
+function trustHTML(html3) {
+  return html3;
+}
+var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
+
 // src/components/ErrorDisplay.ts
-var _isDev8 = isDev();
+var _isDev11 = isDev();
 var STYLES = `
   .sibu-error-display {
     border: 1px solid var(--sibu-err-border, #e5484d);
@@ -2866,20 +3558,21 @@ var STYLES = `
     font-weight: 600;
   }
   .sibu-error-display .sibu-err-copy-btn {
-    background: transparent;
-    border: 1px solid #3a3a4e;
+    background: rgba(0, 0, 0, 0.22);
+    border: 1px solid rgba(255, 255, 255, 0.15);
     border-radius: 4px;
-    color: #a0a3b8;
+    color: rgba(255, 255, 255, 0.85);
     cursor: pointer;
     padding: 2px 10px;
-    font-size: 0.95em;
+    font-size: 0.78em;
     font-family: inherit;
     transition: all 0.12s ease;
+    flex-shrink: 0;
   }
   .sibu-error-display .sibu-err-copy-btn:hover {
-    background: #2a2a3e;
-    color: #e5e7eb;
-    border-color: #4a4a5e;
+    background: rgba(0, 0, 0, 0.35);
+    color: white;
+    border-color: rgba(255, 255, 255, 0.3);
   }
 
   .sibu-error-display .sibu-err-stack {
@@ -3004,21 +3697,25 @@ function normalizeError(err) {
     cause: null
   };
 }
-function buildCopyText(err, meta2) {
+function buildCopyText(err, meta2, headline) {
   const lines = [];
+  lines.push(headline);
   lines.push(`[${err.code}] ${err.message}`);
   if (err.stack) {
     lines.push("");
+    lines.push("Stack Trace:");
     lines.push(err.stack);
   }
-  if (err.cause) {
+  let cause = err.cause;
+  while (cause) {
     lines.push("");
     lines.push("Caused by:");
-    lines.push(`  [${err.cause.code}] ${err.cause.message}`);
-    if (err.cause.stack) {
-      const indented = err.cause.stack.split("\n").map((l) => `  ${l}`).join("\n");
+    lines.push(`  [${cause.code}] ${cause.message}`);
+    if (cause.stack) {
+      const indented = cause.stack.split("\n").map((l) => `  ${l}`).join("\n");
       lines.push(indented);
     }
+    cause = cause.cause;
   }
   if (meta2 && Object.keys(meta2).length > 0) {
     lines.push("");
@@ -3028,9 +3725,13 @@ function buildCopyText(err, meta2) {
     }
   }
   lines.push("");
-  lines.push(`At: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("Environment:");
+  lines.push(`  Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  if (typeof location !== "undefined") {
+    lines.push(`  URL: ${location.href}`);
+  }
   if (typeof navigator !== "undefined" && navigator.userAgent) {
-    lines.push(`UA: ${navigator.userAgent}`);
+    lines.push(`  User Agent: ${navigator.userAgent}`);
   }
   return lines.join("\n");
 }
@@ -3082,7 +3783,7 @@ function ErrorDisplay(props) {
   injectStyles();
   const severity = props.severity ?? "error";
   const normalized = normalizeError(props.error);
-  const showDetails = props.alwaysShowDetails ?? _isDev8;
+  const showDetails = props.alwaysShowDetails ?? _isDev11;
   const headline = props.title ?? normalized.message;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
   const [copyLabel, setCopyLabel] = signal("Copy");
@@ -3091,7 +3792,7 @@ function ErrorDisplay(props) {
     nodes: () => copyLabel(),
     on: {
       click: () => {
-        const text2 = buildCopyText(normalized, props.metadata);
+        const text2 = buildCopyText(normalized, props.metadata, headline);
         if (typeof navigator !== "undefined" && navigator.clipboard) {
           navigator.clipboard.writeText(text2).then(
             () => {
@@ -3112,6 +3813,7 @@ function ErrorDisplay(props) {
     nodes: [
       code({ class: "sibu-err-icon", nodes: normalized.code }),
       h3({ class: "sibu-err-title", nodes: headline }),
+      copyBtn,
       span({ class: "sibu-err-timestamp", nodes: timestamp })
     ]
   });
@@ -3123,25 +3825,12 @@ function ErrorDisplay(props) {
         nodes: [
           div({
             class: "sibu-err-section-head",
-            nodes: [span({ nodes: "Stack Trace" }), copyBtn]
+            nodes: [span({ nodes: "Stack Trace" })]
           }),
           renderFrames(normalized.frames)
         ]
       })
     );
-  } else if (showDetails) {
-    bodyChildren.push(
-      div({
-        class: "sibu-err-section",
-        nodes: [
-          div({
-            class: "sibu-err-section-head",
-            nodes: [span({ nodes: "Details" }), copyBtn]
-          }),
-          div({ class: "sibu-err-stack", nodes: "(no stack available)" })
-        ]
-      })
-    );
   }
   if (showDetails) {
     bodyChildren.push(...renderCauseChain(normalized.cause));
@@ -3157,37 +3846,6 @@ function ErrorDisplay(props) {
       })
     );
   }
-  if (showDetails && typeof navigator !== "undefined" && navigator.userAgent) {
-    bodyChildren.push(
-      div({
-        class: "sibu-err-section",
-        nodes: [
-          div({ class: "sibu-err-section-head", nodes: [span({ nodes: "Environment" })] }),
-          div({
-            class: "sibu-err-meta",
-            nodes: (() => {
-              const dl2 = document.createElement("dl");
-              dl2.className = "sibu-err-meta";
-              const entries = [
-                ["User Agent", navigator.userAgent],
-                ["URL", typeof location !== "undefined" ? location.href : "(n/a)"],
-                ["Timestamp", (/* @__PURE__ */ new Date()).toISOString()]
-              ];
-              for (const [k, v] of entries) {
-                const dt2 = document.createElement("dt");
-                dt2.textContent = k;
-                const dd2 = document.createElement("dd");
-                dd2.textContent = v;
-                dl2.appendChild(dt2);
-                dl2.appendChild(dd2);
-              }
-              return dl2;
-            })()
-          })
-        ]
-      })
-    );
-  }
   const actionButtons = [];
   if (props.onRetry) {
     actionButtons.push(
@@ -3382,6 +4040,7 @@ function injectStyles2() {
     stylesInjected = true;
   }
 }
+var FALLBACK_CACHE_MAX = 50;
 var fallbackCache = /* @__PURE__ */ new WeakMap();
 function getMemoizedFallback(fallbackFn, error, retry) {
   let cache2 = fallbackCache.get(fallbackFn);
@@ -3390,27 +4049,42 @@ function getMemoizedFallback(fallbackFn, error, retry) {
     fallbackCache.set(fallbackFn, cache2);
   }
   const key = error.message;
-  if (!cache2.has(key)) {
-    cache2.set(key, fallbackFn(error, retry));
+  let factory = cache2.get(key);
+  if (factory) {
+    cache2.delete(key);
+    cache2.set(key, factory);
+  } else {
+    factory = () => fallbackFn(error, retry);
+    cache2.set(key, factory);
+    if (cache2.size > FALLBACK_CACHE_MAX) {
+      const oldestKey = cache2.keys().next().value;
+      if (oldestKey !== void 0) cache2.delete(oldestKey);
+    }
   }
-  return cache2.get(key);
+  return factory();
 }
 function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
   injectStyles2();
   const [error, setError] = signal(null);
   const retry = () => {
     if (fallback) {
-      fallbackCache.delete(fallback);
+      const cur = error();
+      const inner = fallbackCache.get(fallback);
+      if (cur && inner) inner.delete(cur.message);
     }
     setError(null);
   };
+  let resetKeysTeardown = null;
   if (resetKeys && resetKeys.length > 0) {
     let initialized = false;
-    effect(() => {
+    resetKeysTeardown = effect(() => {
       for (const k of resetKeys) {
         try {
           k();
-        } catch {
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[SibuJS ErrorBoundary] resetKeys getter threw:", err);
+          }
         }
       }
       if (!initialized) {
@@ -3423,7 +4097,15 @@ function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
   const handleError = (e) => {
     const errorObj = e instanceof Error ? e : new Error(String(e));
     setError(errorObj);
-    onError?.(errorObj);
+    if (onError) {
+      try {
+        onError(errorObj);
+      } catch (cbErr) {
+        if (typeof console !== "undefined") {
+          console.error("[SibuJS ErrorBoundary] onError callback threw:", cbErr);
+        }
+      }
+    }
     return errorObj;
   };
   const defaultFallback = (err, retryFn) => {
@@ -3475,7 +4157,7 @@ function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
       }
     }
   });
-  container.addEventListener("sibu:error-propagate", (e) => {
+  const propagateListener = (e) => {
     if (error()) return;
     e.stopPropagation();
     const customEvent = e;
@@ -3483,6 +4165,30 @@ function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
     if (propagatedError) {
       handleError(propagatedError);
     }
+  };
+  container.addEventListener("sibu:error-propagate", propagateListener);
+  onMount(() => {
+    const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT);
+    const collected = [];
+    let node = walker.currentNode;
+    while (node) {
+      const pending = takePendingError(node);
+      if (pending) collected.push(pending);
+      node = walker.nextNode();
+    }
+    if (collected.length === 1) {
+      handleError(collected[0]);
+    } else if (collected.length > 1) {
+      const Agg = globalThis.AggregateError;
+      handleError(
+        Agg ? new Agg(collected, `${collected.length} pre-mount errors caught by ErrorBoundary`) : new Error(collected.map((e) => e.message).join("; "))
+      );
+    }
+    return void 0;
+  }, container);
+  registerDisposer(container, () => {
+    if (resetKeysTeardown) resetKeysTeardown();
+    container.removeEventListener("sibu:error-propagate", propagateListener);
   });
   return container;
 }
@@ -3658,6 +4364,7 @@ function Loading(props = {}) {
   footer,
   form,
   g,
+  getSSRStore,
   getSlot,
   h1,
   h2,
@@ -3730,6 +4437,7 @@ function Loading(props = {}) {
   rp,
   rt,
   ruby,
+  runInSSRContext,
   s,
   samp,
   script,
@@ -3755,6 +4463,7 @@ function Loading(props = {}) {
   symbol,
   table,
   tagFactory,
+  takePendingError,
   tbody,
   td,
   template,
@@ -3769,6 +4478,7 @@ function Loading(props = {}) {
   track,
   transition,
   trapFocus,
+  trustHTML,
   tspan,
   u,
   ul,