sibujs 1.5.0 → 2.1.0

package/dist/{chunk-JCDUJN2F.js → chunk-AMK2TYNW.js}

@@ -139,60 +139,70 @@ import {
   use,
   var_,
   video
-} from "./chunk-P3XWXJZU.js";
+} from "./chunk-CWBVQML6.js";
 import {
   watch
-} from "./chunk-GJPXRJ45.js";
+} from "./chunk-45YP72ZQ.js";
+import {
+  trustHTML
+} from "./chunk-JYD2PWXH.js";
 import {
   context
-} from "./chunk-6BMPXPUW.js";
+} from "./chunk-OJ3P4ECI.js";
 import {
   SVG_NS,
   bindChildNode,
   tagFactory
-} from "./chunk-SFKNRVCU.js";
+} from "./chunk-P2HSJDDN.js";
 import {
   bindAttribute,
-  bindDynamic,
+  bindDynamic
+} from "./chunk-WIPZPFBQ.js";
+import {
+  derived
+} from "./chunk-DRUZZAK4.js";
+import {
   checkLeaks,
   dispose,
   registerDisposer
-} from "./chunk-5ZYQ6KDD.js";
-import {
-  derived
-} from "./chunk-XHK6BDAJ.js";
+} from "./chunk-2UPRY23K.js";
 import {
   isUrlAttribute,
+  sanitizeSrcset,
   sanitizeUrl
-} from "./chunk-CMBFNA7L.js";
+} from "./chunk-UCS6AMJ7.js";
 import {
   effect,
   on
-} from "./chunk-VQNQZCWJ.js";
+} from "./chunk-WZA53FXU.js";
 import {
   disableSSR,
   enableSSR,
+  getSSRStore,
   isSSR,
+  runInSSRContext,
   withSSR
-} from "./chunk-EUZND3CB.js";
+} from "./chunk-2RA7SHDA.js";
 import {
   batch,
   enqueueBatchedSignal,
   isBatching,
   signal
-} from "./chunk-NZIIMDWI.js";
+} from "./chunk-RDTDJCAB.js";
 import {
   notifySubscribers,
   recordDependency,
+  retrack,
+  setMaxDrainIterations,
   track,
   untracked
-} from "./chunk-K4G4ZQNR.js";
+} from "./chunk-QO3WC6FS.js";
 import {
   __export,
   devAssert,
   devWarn,
   isDev
-} from "./chunk-5X6PP2UK.js";
+} from "./chunk-LMLD24FC.js";
 
 // index.ts
 var index_exports = {};
@@ -276,6 +286,7 @@ __export(index_exports, {
   footer: () => footer,
   form: () => form,
   g: () => g,
+  getSSRStore: () => getSSRStore,
   getSlot: () => getSlot,
   h1: () => h1,
   h2: () => h2,
@@ -345,15 +356,18 @@ __export(index_exports, {
   registerComponent: () => registerComponent,
   registerDisposer: () => registerDisposer,
   resolveComponent: () => resolveComponent,
+  retrack: () => retrack,
   rp: () => rp,
   rt: () => rt,
   ruby: () => ruby,
+  runInSSRContext: () => runInSSRContext,
   s: () => s,
   samp: () => samp,
   script: () => script,
   section: () => section,
   select: () => select,
   setGlobalErrorHandler: () => setGlobalErrorHandler,
+  setMaxDrainIterations: () => setMaxDrainIterations,
   show: () => show,
   signal: () => signal,
   slot: () => slot,
@@ -373,6 +387,7 @@ __export(index_exports, {
   symbol: () => symbol,
   table: () => table,
   tagFactory: () => tagFactory,
+  takePendingError: () => takePendingError,
   tbody: () => tbody,
   td: () => td,
   template: () => template,
@@ -387,6 +402,7 @@ __export(index_exports, {
   track: () => track2,
   transition: () => transition,
   trapFocus: () => trapFocus,
+  trustHTML: () => trustHTML,
   tspan: () => tspan,
   u: () => u,
   ul: () => ul,
@@ -402,6 +418,8 @@ __export(index_exports, {
 });
 
 // src/core/rendering/htm.ts
+var _isDev = isDev();
+var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -586,6 +604,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();
@@ -612,27 +639,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 (_isDev) {
+          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;
@@ -726,7 +776,7 @@ function html(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(
@@ -754,7 +804,7 @@ function mount(component, container) {
 }
 
 // src/core/rendering/each.ts
-var _isDev = isDev();
+var _isDev2 = isDev();
 function resolveNodeChild(child) {
   if (typeof child === "function") {
     return resolveNodeChild(child());
@@ -849,17 +899,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 (_isDev) {
+          if (_isDev2) {
             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 (_isDev2) {
+                devWarn(`each: error not surfaced \u2014 anchor detached: ${errorObj.message}`);
+              }
+            } catch {
+            }
+          });
         }
       }
       workMap.set(key, node);
@@ -928,7 +992,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) {
@@ -975,7 +1040,9 @@ 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);
@@ -983,9 +1050,22 @@ function Portal(nodes, target) {
       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 {
+        }
+      });
     }
   });
   registerDisposer(anchor, () => {
+    disposed = true;
     if (portalContent) {
       dispose(portalContent);
       portalContent.remove();
@@ -1025,7 +1105,8 @@ function DynamicComponent(is) {
     }
     container.replaceChildren(el);
   }
-  track(render);
+  const untrack = track(render);
+  registerDisposer(container, untrack);
   return container;
 }
 
@@ -1115,11 +1196,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;
@@ -1159,12 +1245,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;
 }
 
@@ -1314,7 +1411,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."
       );
     }
   });
@@ -1328,16 +1425,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) => {
@@ -1471,7 +1572,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;
   }
@@ -1667,26 +1769,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);
+        });
       }
     );
   });
@@ -1713,26 +1823,186 @@ function runMountCallback(callback, hookName, element) {
     registerDisposer(element, cleanup);
   }
 }
+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(() => runMountCallback(callback, "onMount", element));
+      queueMicrotask(() => {
+        if (disposed) return;
+        runMountCallback(callback, "onMount", element);
+      });
       return;
     }
-    const observer = new MutationObserver(() => {
-      if (element.isConnected) {
-        observer.disconnect();
-        runMountCallback(callback, "onMount", element);
-      }
-    });
-    registerDisposer(element, () => observer.disconnect());
     queueMicrotask(() => {
+      if (disposed) return;
       if (element.isConnected) {
         runMountCallback(callback, "onMount", element);
-      } else {
-        observer.observe(document.body, { childList: true, subtree: true });
+        return;
       }
+      const unregister = registerMountWatcher(element, () => {
+        if (disposed) return;
+        runMountCallback(callback, "onMount", element);
+      });
+      registerDisposer(element, unregister);
     });
   } else {
     queueMicrotask(() => {
@@ -1741,22 +2011,24 @@ function onMount(callback, element) {
   }
 }
 function onUnmount(callback, element) {
-  registerDisposer(element, () => safeCall(callback, "onUnmount"));
-  const startObserving = () => {
-    const observer = new MutationObserver(() => {
-      if (!element.isConnected) {
-        observer.disconnect();
-        safeCall(callback, "onUnmount");
-      }
-    });
-    observer.observe(document.body, { childList: true, subtree: true });
-    registerDisposer(element, () => observer.disconnect());
+  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);
   }
@@ -1773,7 +2045,7 @@ function strict(fn) {
       try {
         fn();
       } catch (err) {
-        console.warn("[Sibu strict] second run threw:", err);
+        console.warn("[SibuJS strict] second run threw:", err);
       }
     });
   }
@@ -1789,7 +2061,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 () => {
@@ -1815,9 +2087,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 = () => {
@@ -1831,11 +2105,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) {
@@ -1876,6 +2156,32 @@ 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() {
@@ -1892,14 +2198,14 @@ function lazy(importFn) {
     }).catch((err) => {
       if (disposed) return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
-      container.replaceChildren(div("sibu-lazy-error", `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..."));
-    const origRemove = container.remove.bind(container);
-    container.remove = () => {
+    registerDisposer(container, () => {
       disposed = true;
-      origRemove();
-    };
+    });
     return container;
   };
 }
@@ -1907,32 +2213,48 @@ 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/components/ErrorDisplay.ts
-var _isDev2 = isDev();
+var _isDev3 = isDev();
 var STYLES = `
   .sibu-error-display {
     border: 1px solid var(--sibu-err-border, #e5484d);
@@ -2018,20 +2340,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 {
@@ -2156,21 +2479,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("");
@@ -2180,9 +2507,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");
 }
@@ -2234,7 +2565,7 @@ function ErrorDisplay(props) {
   injectStyles();
   const severity = props.severity ?? "error";
   const normalized = normalizeError(props.error);
-  const showDetails = props.alwaysShowDetails ?? _isDev2;
+  const showDetails = props.alwaysShowDetails ?? _isDev3;
   const headline = props.title ?? normalized.message;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
   const [copyLabel, setCopyLabel] = signal("Copy");
@@ -2243,7 +2574,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(
             () => {
@@ -2264,6 +2595,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 })
     ]
   });
@@ -2275,25 +2607,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));
@@ -2309,37 +2628,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(
@@ -2534,6 +2822,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);
@@ -2542,27 +2831,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) {
@@ -2575,7 +2879,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) => {
@@ -2627,7 +2939,7 @@ function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
       }
     }
   });
-  container.addEventListener("sibu:error-propagate", (e) => {
+  const propagateListener = (e) => {
     if (error()) return;
     e.stopPropagation();
     const customEvent = e;
@@ -2635,6 +2947,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;
 }
@@ -2770,6 +3106,7 @@ export {
   nextTick,
   defer,
   transition,
+  takePendingError,
   lazy,
   Suspense,
   ErrorDisplay,