sibujs 1.5.0 → 2.1.0

package/dist/ui.cjs

@@ -23,6 +23,7 @@ __export(ui_exports, {
   FocusTrap: () => FocusTrap,
   RenderProp: () => RenderProp,
   VirtualList: () => VirtualList,
+  __resetDialogStack: () => __resetDialogStack,
   announce: () => announce,
   aria: () => aria,
   assertType: () => assertType,
@@ -91,26 +92,39 @@ 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/reactivity/track.ts
 var _isDev2 = isDev();
-var subscriberStack = new Array(32);
-var stackCapacity = 32;
+var STACK_INITIAL = 32;
+var STACK_SHRINK_THRESHOLD = 128;
+var subscriberStack = new Array(STACK_INITIAL);
+var stackCapacity = STACK_INITIAL;
 var stackTop = -1;
 var currentSubscriber = null;
-var signalSubscribers = /* @__PURE__ */ new WeakMap();
 var SUBS = "__s";
+function syncFastPath(signal2, subs) {
+  const size = subs.size;
+  if (size === 0) {
+    signal2.__f = void 0;
+    delete signal2[SUBS];
+  } else if (size === 1) {
+    signal2.__f = subs.values().next().value;
+  } else {
+    signal2.__f = void 0;
+  }
+}
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
 function safeInvoke(sub) {
   try {
     sub();
@@ -119,6 +133,47 @@ function safeInvoke(sub) {
   }
 }
 var trackingSuspended = false;
+var subscriberEpochCounter = 0;
+function retrack(effectFn, subscriber) {
+  const prev = currentSubscriber;
+  currentSubscriber = subscriber;
+  const sub = subscriber;
+  const epoch = ++subscriberEpochCounter;
+  sub._epoch = epoch;
+  try {
+    effectFn();
+  } finally {
+    currentSubscriber = prev;
+    pruneStaleDeps(sub, epoch);
+  }
+}
+function pruneStaleDeps(sub, currentEpoch) {
+  if (sub._dep !== void 0) {
+    if (sub._depEpoch !== currentEpoch) {
+      const sig = sub._dep;
+      const subs = sig[SUBS];
+      if (subs?.delete(sub)) syncFastPath(sig, subs);
+      sub._dep = void 0;
+      sub._depEpoch = void 0;
+    }
+    return;
+  }
+  const deps = sub._deps;
+  if (!deps || deps.size === 0) return;
+  let stales;
+  for (const [signal2, epoch] of deps) {
+    if (epoch !== currentEpoch) {
+      (stales ?? (stales = [])).push(signal2);
+    }
+  }
+  if (!stales) return;
+  for (const signal2 of stales) {
+    deps.delete(signal2);
+    const sig = signal2;
+    const subs = sig[SUBS];
+    if (subs?.delete(sub)) syncFastPath(sig, subs);
+  }
+}
 function track(effectFn, subscriber) {
   if (!subscriber) subscriber = effectFn;
   cleanup(subscriber);
@@ -134,75 +189,133 @@ function track(effectFn, subscriber) {
   } finally {
     stackTop--;
     currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+    if (stackTop < 0 && stackCapacity > STACK_SHRINK_THRESHOLD) {
+      stackCapacity = Math.max(STACK_INITIAL, stackCapacity >>> 1);
+      subscriberStack.length = stackCapacity;
+    }
   }
   return () => cleanup(subscriber);
 }
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub = currentSubscriber;
-  if (sub._dep === signal2) return;
+  const epoch = sub._epoch;
+  if (sub._dep === signal2) {
+    sub._depEpoch = epoch;
+    return;
+  }
   const deps = sub._deps;
   if (deps) {
-    if (deps.has(signal2)) return;
-    deps.add(signal2);
+    deps.set(signal2, epoch);
   } else if (sub._dep !== void 0) {
-    const set = /* @__PURE__ */ new Set();
-    set.add(sub._dep);
-    set.add(signal2);
-    sub._deps = set;
+    const map = /* @__PURE__ */ new Map();
+    map.set(sub._dep, sub._depEpoch);
+    map.set(signal2, epoch);
+    sub._deps = map;
     sub._dep = void 0;
+    sub._depEpoch = void 0;
   } else {
     sub._dep = signal2;
+    sub._depEpoch = epoch;
   }
-  let subs = signal2[SUBS];
+  const sig = signal2;
+  let subs = sig[SUBS];
   if (!subs) {
     subs = /* @__PURE__ */ new Set();
-    signalSubscribers.set(signal2, subs);
-    signal2[SUBS] = subs;
+    sig[SUBS] = subs;
   }
+  const prevSize = subs.size;
   subs.add(currentSubscriber);
-  if (subs.size === 1) {
-    signal2.__f = currentSubscriber;
-  } else if (signal2.__f !== void 0) {
-    signal2.__f = void 0;
+  if (subs.size !== prevSize) {
+    if (subs.size === 1) {
+      sig.__f = currentSubscriber;
+    } else if (sig.__f !== void 0) {
+      sig.__f = void 0;
+    }
+  }
+}
+var maxSubscriberRepeats = 50;
+var maxDrainIterations = 1e6;
+var drainEpoch = 0;
+function tickRepeat(sub) {
+  const s = sub;
+  if (s._runEpoch !== drainEpoch) {
+    s._runEpoch = drainEpoch;
+    s._runs = 1;
+    return false;
+  }
+  return ++s._runs > maxSubscriberRepeats;
+}
+function cycleError(sub) {
+  if (typeof console !== "undefined") {
+    const name = sub.__name ?? "<unnamed>";
+    console.error(
+      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
+    );
+  }
+}
+function absoluteDrainError() {
+  if (typeof console !== "undefined") {
+    console.error(
+      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    );
+  }
+}
+function drainQueue() {
+  let i = 0;
+  while (i < pendingQueue.length) {
+    if (i >= maxDrainIterations) {
+      absoluteDrainError();
+      break;
+    }
+    const sub = pendingQueue[i++];
+    if (tickRepeat(sub)) {
+      cycleError(sub);
+      break;
+    }
+    pendingSet.delete(sub);
+    safeInvoke(sub);
   }
 }
 function propagateDirty(sub) {
   sub();
-  let sig = sub._sig;
-  while (sig) {
+  const rootSig = sub._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 s of subs) {
       if (s._c) {
-        s();
         const nSig = s._sig;
-        if (nSig && !nextSig) {
-          nextSig = nSig;
-        } else if (nSig) {
-          propagateDirty(s);
+        if (nSig && !nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        } else if (!nSig) {
+          s();
         }
       } else if (!pendingSet.has(s)) {
         pendingSet.add(s);
         pendingQueue.push(s);
       }
     }
-    sig = nextSig;
   }
 }
 function notifySubscribers(signal2) {
@@ -218,21 +331,22 @@ function notifySubscribers(signal2) {
       return;
     }
     notifyDepth++;
+    drainEpoch++;
     try {
       if (first._c) {
         propagateDirty(first);
+      } else if (tickRepeat(first)) {
+        cycleError(first);
       } else {
         safeInvoke(first);
       }
-      let i = 0;
-      while (i < pendingQueue.length) {
-        safeInvoke(pendingQueue[i]);
-        i++;
-      }
+      drainQueue();
     } finally {
-      pendingQueue.length = 0;
-      pendingSet.clear();
       notifyDepth--;
+      if (notifyDepth === 0) {
+        pendingQueue.length = 0;
+        pendingSet.clear();
+      }
     }
     return;
   }
@@ -250,57 +364,45 @@ function notifySubscribers(signal2) {
     return;
   }
   notifyDepth++;
+  drainEpoch++;
   try {
-    let directCount = 0;
     for (const sub of subs) {
-      pendingQueue[directCount++] = sub;
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (pendingQueue[i2]._c) {
-        propagateDirty(pendingQueue[i2]);
-      }
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (!pendingQueue[i2]._c) {
-        if (!pendingSet.has(pendingQueue[i2])) {
-          safeInvoke(pendingQueue[i2]);
-        }
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
       }
     }
-    let i = directCount;
-    while (i < pendingQueue.length) {
-      safeInvoke(pendingQueue[i]);
-      i++;
-    }
+    drainQueue();
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
 function cleanup(subscriber) {
   const sub = subscriber;
   const singleDep = sub._dep;
   if (singleDep !== void 0) {
-    const subs = singleDep[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (singleDep.__f === subscriber) {
-        singleDep.__f = void 0;
-      }
+    const sig = singleDep;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
     sub._dep = void 0;
+    sub._depEpoch = void 0;
     return;
   }
   const deps = sub._deps;
   if (!deps || deps.size === 0) return;
-  for (const signal2 of deps) {
-    const subs = signal2[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (signal2.__f === subscriber) {
-        signal2.__f = void 0;
-      }
+  for (const signal2 of deps.keys()) {
+    const sig = signal2;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
   }
   deps.clear();
@@ -310,6 +412,7 @@ function cleanup(subscriber) {
 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;
@@ -320,8 +423,14 @@ 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;
@@ -334,11 +443,16 @@ function derived(getter, options) {
     if (trackingSuspended) {
       if (cs._d) {
         evaluating = true;
+        let threw = true;
         try {
-          cs._d = false;
-          cs._v = getter();
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
         } finally {
           evaluating = false;
+          if (threw) cs._d = true;
         }
       }
       return cs._v;
@@ -347,13 +461,17 @@ function derived(getter, options) {
     if (cs._d) {
       const oldValue = cs._v;
       evaluating = true;
+      let threw = true;
       try {
-        track(() => {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
           cs._d = false;
-          cs._v = getter();
+          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 });
@@ -518,9 +636,18 @@ function form(config) {
       }
       return null;
     });
+    const wrappedSet = (next) => {
+      setValue(next);
+      setManualErrors((prev) => {
+        if (!(name in prev) || prev[name] == null) return prev;
+        const copy = { ...prev };
+        copy[name] = null;
+        return copy;
+      });
+    };
     fieldMap[name] = {
       value,
-      set: setValue,
+      set: wrappedSet,
       error,
       touched: isTouched,
       touch: () => setTouched(true),
@@ -654,11 +781,77 @@ function registerDisposer(node, teardown) {
   disposers.push(teardown);
   if (_isDev4) activeBindingCount++;
 }
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i = 0; i < children.length; i++) {
+      stack.push(children[i]);
+    }
+  }
+  for (let i = order.length - 1; i >= 0; i--) {
+    const current = order[i];
+    const disposers = elementDisposers.get(current);
+    if (disposers) {
+      const snapshot = disposers.slice();
+      elementDisposers.delete(current);
+      if (_isDev4) activeBindingCount -= snapshot.length;
+      for (const d of snapshot) {
+        try {
+          d();
+        } catch (err) {
+          if (_isDev4 && 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 (_isDev4) activeBindingCount -= moreSnapshot.length;
+        for (const d of moreSnapshot) {
+          try {
+            d();
+          } catch (err) {
+            if (_isDev4 && typeof console !== "undefined") {
+              console.warn("[SibuJS] Disposer threw during cleanup:", err);
+            }
+          }
+        }
+      }
+    }
+  }
+}
 
 // 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 s = als.getStore();
+    if (s) return s;
+  }
+  return fallbackStore;
+}
 function isSSR() {
-  return ssrMode;
+  return getSSRStore().ssr;
 }
 
 // src/core/signals/effect.ts
@@ -668,26 +861,114 @@ function effect(effectFn, options) {
   if (isSSR()) return () => {
   };
   const onError = options?.onError;
+  let userCleanups = [];
+  const onCleanup = (fn) => {
+    userCleanups.push(fn);
+  };
+  const runUserCleanups = () => {
+    if (userCleanups.length === 0) return;
+    const list = userCleanups;
+    userCleanups = [];
+    for (let i = list.length - 1; i >= 0; i--) {
+      try {
+        list[i]();
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS effect] onCleanup threw:", err);
+        }
+      }
+    }
+  };
+  const invokeBody = () => effectFn(onCleanup);
   const wrappedFn = onError ? () => {
     try {
-      effectFn();
+      invokeBody();
     } catch (err) {
       onError(err);
     }
-  } : effectFn;
+  } : invokeBody;
   let cleanupHandle = () => {
   };
+  let running = false;
+  let rerunPending = false;
+  const MAX_RERUNS = 100;
   const subscriber = () => {
-    cleanupHandle();
-    cleanupHandle = track(wrappedFn, subscriber);
+    if (running) {
+      rerunPending = true;
+      return;
+    }
+    running = true;
+    try {
+      let reruns = 0;
+      do {
+        rerunPending = false;
+        runUserCleanups();
+        cleanupHandle();
+        cleanupHandle = track(wrappedFn, subscriber);
+        if (++reruns > MAX_RERUNS) {
+          if (_g2.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+            console.error(
+              `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+            );
+          }
+          rerunPending = false;
+          break;
+        }
+      } while (rerunPending);
+    } finally {
+      running = false;
+      rerunPending = false;
+    }
   };
-  cleanupHandle = track(wrappedFn, subscriber);
+  running = true;
+  try {
+    let reruns = 0;
+    do {
+      rerunPending = false;
+      runUserCleanups();
+      cleanupHandle();
+      cleanupHandle = track(wrappedFn, subscriber);
+      if (++reruns > MAX_RERUNS) {
+        if (_g2.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times on initial run \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+          );
+        }
+        rerunPending = false;
+        break;
+      }
+    } while (rerunPending);
+  } finally {
+    running = false;
+    rerunPending = 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);
+      }
+    }
   };
 }
 
@@ -739,6 +1020,7 @@ function intersection(options) {
   let observer = null;
   let currentElement = null;
   function observe(element) {
+    if (typeof IntersectionObserver === "undefined") return;
     unobserve();
     currentElement = element;
     observer = new IntersectionObserver((entries) => {
@@ -766,6 +1048,11 @@ function intersection(options) {
   };
 }
 function lazyLoad(element, loader, options) {
+  if (typeof IntersectionObserver === "undefined") {
+    loader();
+    return () => {
+    };
+  }
   const observer = new IntersectionObserver((entries) => {
     for (const entry of entries) {
       if (entry.isIntersecting) {
@@ -840,7 +1127,7 @@ function inputMask(options) {
   const stripRegex = buildStripRegex();
   const rawCharTest = options.pattern.includes("*") ? () => true : (c) => /[a-zA-Z0-9]/.test(c);
   function bind(input) {
-    input.addEventListener("input", () => {
+    const onInput = () => {
       const cursorBefore = input.selectionStart ?? input.value.length;
       const oldValue = input.value;
       const raw = oldValue.replace(stripRegex, "");
@@ -864,13 +1151,19 @@ function inputMask(options) {
         }
       }
       input.setSelectionRange(newCursor, newCursor);
-    });
-    input.addEventListener("focus", () => {
+    };
+    const onFocus = () => {
       if (!input.value) {
         const display = options.pattern.replace(/9/g, placeholder).replace(/A/g, placeholder).replace(/\*/g, placeholder);
         input.placeholder = display;
       }
-    });
+    };
+    input.addEventListener("input", onInput);
+    input.addEventListener("focus", onFocus);
+    return () => {
+      input.removeEventListener("input", onInput);
+      input.removeEventListener("focus", onFocus);
+    };
   }
   return { value, rawValue, bind };
 }
@@ -912,8 +1205,20 @@ function focus() {
   let currentElement = null;
   function bind(element) {
     currentElement = element;
-    element.addEventListener("focus", () => setIsFocused(true));
-    element.addEventListener("blur", () => setIsFocused(false));
+    const onFocus = () => setIsFocused(true);
+    const onBlur = () => setIsFocused(false);
+    element.addEventListener("focus", onFocus);
+    element.addEventListener("blur", onBlur);
+    let disposed = false;
+    const dispose2 = () => {
+      if (disposed) return;
+      disposed = true;
+      element.removeEventListener("focus", onFocus);
+      element.removeEventListener("blur", onBlur);
+      if (currentElement === element) currentElement = null;
+    };
+    registerDisposer(element, dispose2);
+    return dispose2;
   }
   function focus2() {
     currentElement?.focus();
@@ -928,11 +1233,35 @@ function FocusTrap(nodes, options = {}) {
   container.setAttribute("data-sibu-focus-trap", "true");
   container.appendChild(nodes);
   const previouslyFocused = document.activeElement;
-  container.addEventListener("keydown", (e) => {
+  const FOCUSABLE_SELECTOR = 'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"]), [contenteditable]';
+  function isEffectivelyVisible(el) {
+    let node = el;
+    while (node) {
+      if (node.hasAttribute("inert")) return false;
+      if (node.getAttribute("aria-hidden") === "true") return false;
+      if (node.hidden) return false;
+      node = node.parentElement;
+    }
+    if (el.offsetParent === null && el.getClientRects().length === 0) return false;
+    return true;
+  }
+  function getFocusable() {
+    const raw = Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR));
+    const out = [];
+    for (const el of raw) {
+      if (el.hasAttribute("disabled")) continue;
+      if (el.getAttribute("aria-hidden") === "true") continue;
+      if (el.hasAttribute("inert")) continue;
+      const ce = el.getAttribute("contenteditable");
+      if (ce !== null && ce === "false") continue;
+      if (!isEffectivelyVisible(el)) continue;
+      out.push(el);
+    }
+    return out;
+  }
+  const onTrapKeydown = (e) => {
     if (e.key !== "Tab") return;
-    const focusable = container.querySelectorAll(
-      'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
-    );
+    const focusable = getFocusable();
     if (focusable.length === 0) {
       e.preventDefault();
       return;
@@ -950,18 +1279,18 @@ function FocusTrap(nodes, options = {}) {
         first.focus();
       }
     }
-  });
+  };
+  container.addEventListener("keydown", onTrapKeydown);
   if (options.autoFocus !== false) {
     queueMicrotask(() => {
-      const first = container.querySelector(
-        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
-      );
+      const first = getFocusable()[0];
       first?.focus();
     });
   }
   let trapObserver = null;
   function restoreFocusAndCleanup() {
     if (options.restoreFocus !== false) previouslyFocused?.focus();
+    container.removeEventListener("keydown", onTrapKeydown);
     if (trapObserver) {
       trapObserver.disconnect();
       trapObserver = null;
@@ -975,7 +1304,7 @@ function FocusTrap(nodes, options = {}) {
     });
     queueMicrotask(() => {
       if (container.isConnected) {
-        trapObserver.observe(document.body, { childList: true, subtree: true });
+        trapObserver.observe(container, { childList: true, subtree: true });
       }
     });
   }
@@ -1012,7 +1341,16 @@ function hotkey(combo, handler, options = {}) {
   document.addEventListener("keydown", listener);
   return () => document.removeEventListener("keydown", listener);
 }
-function announce(message, priority = "polite") {
+var announceQueues = {
+  polite: [],
+  assertive: []
+};
+var announceDraining = {
+  polite: false,
+  assertive: false
+};
+var ANNOUNCE_INTERVAL_MS = 150;
+function ensureLiveRegion(priority) {
   let region = document.getElementById(`sibu-announce-${priority}`);
   if (!region) {
     region = document.createElement("div");
@@ -1023,11 +1361,33 @@ function announce(message, priority = "polite") {
     region.style.cssText = "position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; border: 0;";
     document.body.appendChild(region);
   }
+  return region;
+}
+function drainAnnounceQueue(priority) {
+  if (announceDraining[priority]) return;
+  const queue = announceQueues[priority];
+  if (queue.length === 0) return;
+  announceDraining[priority] = true;
+  const region = ensureLiveRegion(priority);
+  const next = queue.shift();
   region.textContent = "";
   requestAnimationFrame(() => {
-    if (region) region.textContent = message;
+    if (!region.isConnected) {
+      announceDraining[priority] = false;
+      return;
+    }
+    region.textContent = next;
+    setTimeout(() => {
+      announceDraining[priority] = false;
+      drainAnnounceQueue(priority);
+    }, ANNOUNCE_INTERVAL_MS);
   });
 }
+function announce(message, priority = "polite") {
+  if (typeof document === "undefined") return;
+  announceQueues[priority].push(message);
+  drainAnnounceQueue(priority);
+}
 
 // src/core/rendering/createId.ts
 var idCounter = 0;
@@ -1121,22 +1481,22 @@ function createListbox(container, options = {}) {
     }
   }
   function select(value) {
+    const previous = selectedValue();
+    let nextSelectedSet;
     if (multiple) {
-      const current2 = selectedValue();
-      const set = new Set((current2 ?? "").split(",").filter(Boolean));
-      if (set.has(value)) set.delete(value);
-      else set.add(value);
-      setSelectedValue(Array.from(set).join(","));
+      nextSelectedSet = new Set((previous ?? "").split(",").filter(Boolean));
+      if (nextSelectedSet.has(value)) nextSelectedSet.delete(value);
+      else nextSelectedSet.add(value);
+      setSelectedValue(Array.from(nextSelectedSet).join(","));
     } else {
+      nextSelectedSet = /* @__PURE__ */ new Set([value]);
       setSelectedValue(value);
     }
     options.onSelect?.(value);
     const opts = getOptions();
-    const current = selectedValue();
-    const selected = new Set((current ?? "").split(",").filter(Boolean));
     for (const opt of opts) {
       const ov = opt.dataset.value ?? "";
-      opt.setAttribute("aria-selected", selected.has(ov) ? "true" : "false");
+      opt.setAttribute("aria-selected", nextSelectedSet.has(ov) ? "true" : "false");
     }
   }
   function moveActive(delta) {
@@ -1194,12 +1554,12 @@ function createListbox(container, options = {}) {
   }
   container.addEventListener("keydown", onKeyDown);
   container.addEventListener("click", onClick);
-  function dispose() {
+  function dispose2() {
     container.removeEventListener("keydown", onKeyDown);
     container.removeEventListener("click", onClick);
   }
-  registerDisposer(container, dispose);
-  return { activeValue, selectedValue, activeDescendantId, dispose };
+  registerDisposer(container, dispose2);
+  return { activeValue, selectedValue, activeDescendantId, dispose: dispose2 };
 }
 function createDialogAria(element, options = {}) {
   const titleId = options.labelledBy ?? createId("dialog-title");
@@ -1287,22 +1647,49 @@ function removeScopedStyle(scopeId) {
 }
 
 // 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 i = 0; i < lower.length; i++) {
+    const ch = lower.charCodeAt(i);
+    if (ch === 58) {
+      schemeEnd = i;
+      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;
 }
-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);
 }
 
 // src/reactivity/bindAttribute.ts
 var _isDev5 = isDev();
+function setProp(el, key, val) {
+  el[key] = val;
+}
 function isEventHandlerAttr(name) {
   if (name.length < 3) return false;
   const lower = name.toLowerCase();
@@ -1328,7 +1715,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 {
@@ -1338,7 +1725,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);
     }
@@ -1408,66 +1795,91 @@ function bindData(el, key, getter) {
 }
 
 // src/ui/dialog.ts
+var dialogStack = [];
+var globalListenerAttached = false;
+function __resetDialogStack() {
+  while (dialogStack.length > 0) dialogStack.pop();
+  if (typeof window !== "undefined" && globalListenerAttached) {
+    window.removeEventListener("keydown", handleGlobalKeydown);
+    globalListenerAttached = false;
+  }
+}
+function handleGlobalKeydown(event) {
+  if (event.key !== "Escape") return;
+  const top = dialogStack[dialogStack.length - 1];
+  if (top) top.close();
+}
+function ensureGlobalListener() {
+  if (typeof window === "undefined" || globalListenerAttached) return;
+  window.addEventListener("keydown", handleGlobalKeydown);
+  globalListenerAttached = true;
+}
+function removeGlobalListenerIfIdle() {
+  if (typeof window === "undefined") return;
+  if (!globalListenerAttached) return;
+  if (dialogStack.length > 0) return;
+  window.removeEventListener("keydown", handleGlobalKeydown);
+  globalListenerAttached = false;
+}
 function dialog() {
   const [isOpen, setIsOpen] = signal(false);
-  let listenerAttached = false;
-  function handleKeydown(event) {
-    if (event.key === "Escape") {
-      close();
-    }
+  const entry = { close: () => close() };
+  function pushOnStack() {
+    if (dialogStack.indexOf(entry) !== -1) return;
+    dialogStack.push(entry);
+    ensureGlobalListener();
   }
-  function attachListener() {
-    if (typeof window !== "undefined" && !listenerAttached) {
-      window.addEventListener("keydown", handleKeydown);
-      listenerAttached = true;
-    }
-  }
-  function detachListener() {
-    if (typeof window !== "undefined" && listenerAttached) {
-      window.removeEventListener("keydown", handleKeydown);
-      listenerAttached = false;
-    }
+  function removeFromStack() {
+    const idx = dialogStack.indexOf(entry);
+    if (idx !== -1) dialogStack.splice(idx, 1);
+    removeGlobalListenerIfIdle();
   }
   function open() {
+    if (isOpen()) return;
     setIsOpen(true);
-    attachListener();
+    pushOnStack();
   }
   function close() {
+    if (!isOpen()) {
+      removeFromStack();
+      return;
+    }
     setIsOpen(false);
-    detachListener();
+    removeFromStack();
   }
   function toggle() {
     if (isOpen()) close();
     else open();
   }
-  function dispose() {
-    detachListener();
+  function dispose2() {
+    removeFromStack();
     setIsOpen(false);
   }
-  return { open, close, isOpen, toggle, dispose };
+  return { open, close, isOpen, toggle, dispose: dispose2 };
 }
 
 // src/ui/toast.ts
-var toastCounter = 0;
 function toast(options) {
   const duration = options?.duration ?? 3e3;
   const maxToasts = options?.maxToasts ?? Infinity;
   const [toasts, setToasts] = signal([]);
   const timers = /* @__PURE__ */ new Map();
+  let toastCounter = 0;
   function show(message, type) {
     const id = `toast-${++toastCounter}`;
     const toast2 = { id, message, type };
+    const trimmedIds = [];
     setToasts((prev) => {
       const next = [...prev, toast2];
       if (next.length > maxToasts) {
         const removed = next.splice(0, next.length - maxToasts);
-        for (const r of removed) {
-          clearTimerForToast(r.id);
-        }
+        for (const r of removed) trimmedIds.push(r.id);
       }
       return next;
     });
-    if (duration > 0) {
+    for (const tid of trimmedIds) clearTimerForToast(tid);
+    const wasTrimmed = trimmedIds.indexOf(id) !== -1;
+    if (duration > 0 && !wasTrimmed) {
       const timer = setTimeout(() => {
         dismiss(id);
       }, duration);
@@ -1553,14 +1965,14 @@ function infiniteScroll(options) {
     },
     configurable: true
   });
-  function dispose() {
+  function dispose2() {
     disposed = true;
     if (observer) {
       observer.disconnect();
       observer = null;
     }
   }
-  return { sentinelRef: originalRef, loading, dispose };
+  return { sentinelRef: originalRef, loading, dispose: dispose2 };
 }
 
 // src/ui/pagination.ts
@@ -1635,21 +2047,21 @@ function eventBus() {
 // src/ui/lazyEffect.ts
 function lazyEffect(element, effectFn, options) {
   if (typeof IntersectionObserver === "undefined") {
-    const dispose2 = effect(effectFn);
-    return dispose2;
+    const dispose3 = effect(effectFn);
+    return dispose3;
   }
-  let dispose = null;
+  let dispose2 = null;
   let disposed = false;
   const observer = new IntersectionObserver(
     (entries) => {
       if (disposed) return;
       const entry = entries[0];
       if (!entry) return;
-      if (entry.isIntersecting && !dispose) {
-        dispose = effect(effectFn);
-      } else if (!entry.isIntersecting && dispose) {
-        dispose();
-        dispose = null;
+      if (entry.isIntersecting && !dispose2) {
+        dispose2 = effect(effectFn);
+      } else if (!entry.isIntersecting && dispose2) {
+        dispose2();
+        dispose2 = null;
       }
     },
     { threshold: 0, ...options }
@@ -1658,9 +2070,9 @@ function lazyEffect(element, effectFn, options) {
   return () => {
     disposed = true;
     observer.disconnect();
-    if (dispose) {
-      dispose();
-      dispose = null;
+    if (dispose2) {
+      dispose2();
+      dispose2 = null;
     }
   };
 }
@@ -1717,11 +2129,11 @@ function hover(target) {
   const onLeave = () => setHovered(false);
   target.addEventListener("pointerenter", onEnter);
   target.addEventListener("pointerleave", onLeave);
-  function dispose() {
+  function dispose2() {
     target.removeEventListener("pointerenter", onEnter);
     target.removeEventListener("pointerleave", onLeave);
   }
-  return { hovered, dispose };
+  return { hovered, dispose: dispose2 };
 }
 
 // src/ui/scrollLock.ts
@@ -1765,7 +2177,7 @@ function defineElement(name, component, options = {}) {
   class SibuElement extends HTMLElement {
     constructor() {
       super();
-      this._rendered = false;
+      this._rendered = null;
       if (options.shadow !== false) {
         this._root = this.attachShadow({ mode: options.mode || "open" });
       } else {
@@ -1779,25 +2191,23 @@ function defineElement(name, component, options = {}) {
       this._render();
     }
     disconnectedCallback() {
-      if (this._root instanceof ShadowRoot) {
-        this._root.innerHTML = "";
-      }
-      this._rendered = false;
+      this._teardown();
     }
     attributeChangedCallback() {
       if (this._rendered) {
         this._render();
       }
     }
+    _teardown() {
+      if (this._rendered) {
+        dispose(this._rendered);
+        this._rendered = null;
+      }
+      this._root.replaceChildren();
+    }
     _render() {
+      this._teardown();
       const props = this._getProps();
-      if (this._root instanceof ShadowRoot) {
-        this._root.innerHTML = "";
-      } else {
-        while (this._root.firstChild) {
-          this._root.removeChild(this._root.firstChild);
-        }
-      }
       if (options.styles && this._root instanceof ShadowRoot) {
         const styleEl = document.createElement("style");
         styleEl.textContent = options.styles;
@@ -1805,7 +2215,7 @@ function defineElement(name, component, options = {}) {
       }
       const el = component(props, this);
       this._root.appendChild(el);
-      this._rendered = true;
+      this._rendered = el;
     }
     _getProps() {
       const props = {};
@@ -2004,6 +2414,7 @@ function createGuard(validator) {
   FocusTrap,
   RenderProp,
   VirtualList,
+  __resetDialogStack,
   announce,
   aria,
   assertType,