sibujs 1.4.0 → 1.5.0

package/dist/extras.cjs

@@ -403,12 +403,21 @@ function queueSignalNotification(signal2) {
     }
   }
 }
+var MAX_DRAIN_ITERATIONS = 1e3;
 function drainNotificationQueue() {
   if (notifyDepth > 0) return;
   notifyDepth++;
   try {
     let i2 = 0;
     while (i2 < pendingQueue.length) {
+      if (i2 >= MAX_DRAIN_ITERATIONS) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
       safeInvoke(pendingQueue[i2]);
       i2++;
     }
@@ -575,21 +584,37 @@ function derived(getter, options) {
     cs._v = getter();
   }, 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;
+        try {
+          cs._d = false;
+          cs._v = getter();
+        } finally {
+          evaluating = false;
+        }
       }
       return cs._v;
     }
     recordDependency(cs);
     if (cs._d) {
       const oldValue = cs._v;
-      track(() => {
-        cs._d = false;
-        cs._v = getter();
-      }, markDirty);
+      evaluating = true;
+      try {
+        track(() => {
+          cs._d = false;
+          cs._v = getter();
+        }, markDirty);
+      } finally {
+        evaluating = false;
+      }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
       }
@@ -745,9 +770,13 @@ async function withRetry(fn, options, onRetry, signal2) {
       const delay = calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter);
       onRetry?.(error, attempt, delay);
       await new Promise((resolve, reject) => {
-        const timer = setTimeout(resolve, delay);
+        let onAbort = null;
+        const timer = setTimeout(() => {
+          if (onAbort && signal2) signal2.removeEventListener("abort", onAbort);
+          resolve();
+        }, delay);
         if (signal2) {
-          const onAbort = () => {
+          onAbort = () => {
             clearTimeout(timer);
             reject(new DOMException("Aborted", "AbortError"));
           };
@@ -898,9 +927,10 @@ function query(key, fetcher, options = {}) {
         }
       }
     }
+    const keyChanged = currentKey !== key2;
     currentKey = key2;
     const entry = getOrCreateEntry(key2, initialData);
-    entry.subscribers++;
+    if (keyChanged || entry.subscribers === 0) entry.subscribers++;
     if (entry.gcTimer !== null) {
       clearTimeout(entry.gcTimer);
       entry.gcTimer = null;
@@ -1014,7 +1044,9 @@ function mutation(mutationFn, options = {}) {
   const [status, setStatus] = signal("idle");
   const isSuccess = derived(() => status() === "success");
   const isIdle = derived(() => status() === "idle");
+  let runId = 0;
   async function execute(variables) {
+    const myRun = ++runId;
     let context2;
     batch(() => {
       setLoading(true);
@@ -1026,6 +1058,7 @@ function mutation(mutationFn, options = {}) {
         context2 = await options.onMutate(variables);
       }
       const result = await withRetry(() => mutationFn(variables), options.retry);
+      if (myRun !== runId) return result;
       batch(() => {
         setData(result);
         setLoading(false);
@@ -1036,6 +1069,7 @@ function mutation(mutationFn, options = {}) {
       return result;
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
+      if (myRun !== runId) throw errorObj;
       batch(() => {
         setError(errorObj);
         setLoading(false);
@@ -1047,6 +1081,7 @@ function mutation(mutationFn, options = {}) {
     }
   }
   function reset() {
+    runId++;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -1296,7 +1331,10 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       options.onSuccess?.(result);
     } catch (err) {
       if (version !== fetchVersion || disposed) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
+      if (err instanceof DOMException && err.name === "AbortError") {
+        if (version === fetchVersion) setLoading(false);
+        return;
+      }
       const errorObj = err instanceof Error ? err : new Error(String(err));
       batch(() => {
         setError(errorObj);
@@ -1550,6 +1588,7 @@ function socket(url, options) {
   let reconnectTimer = null;
   let heartbeatTimer = null;
   let disposed = false;
+  let manuallyClosed = false;
   function getUrl() {
     return typeof url === "function" ? url() : url;
   }
@@ -1573,12 +1612,13 @@ function socket(url, options) {
     ws.onclose = () => {
       setStatus("closed");
       stopHeartbeat();
-      if (autoReconnect && !disposed && reconnectCount < maxReconnects) {
+      if (autoReconnect && !disposed && !manuallyClosed && reconnectCount < maxReconnects) {
         reconnectCount++;
         reconnectTimer = setTimeout(() => {
           connect();
         }, reconnectDelay);
       }
+      manuallyClosed = false;
     };
     ws.onerror = () => {
     };
@@ -1604,6 +1644,7 @@ function socket(url, options) {
     }
   }
   function close() {
+    manuallyClosed = true;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
@@ -1774,6 +1815,8 @@ function scroll(target) {
   const [y, setY] = signal(0);
   const [isScrolling, setIsScrolling] = signal(false);
   let scrollTimer = null;
+  let currentTarget = null;
+  let effectCleanup = null;
   if (typeof window === "undefined") {
     return { x, y, isScrolling, dispose: () => {
     } };
@@ -1796,11 +1839,26 @@ function scroll(target) {
       scrollTimer = null;
     }, 150);
   };
-  const scrollTarget = target ? target() : null;
-  const eventTarget = scrollTarget || window;
-  eventTarget.addEventListener("scroll", handler, { passive: true });
+  function attachListener(eventTarget) {
+    if (currentTarget === eventTarget) return;
+    if (currentTarget) currentTarget.removeEventListener("scroll", handler);
+    currentTarget = eventTarget;
+    currentTarget.addEventListener("scroll", handler, { passive: true });
+  }
+  if (target) {
+    effectCleanup = effect(() => {
+      const el = target();
+      attachListener(el || window);
+    });
+  } else {
+    attachListener(window);
+  }
   function dispose() {
-    eventTarget.removeEventListener("scroll", handler);
+    effectCleanup?.();
+    if (currentTarget) {
+      currentTarget.removeEventListener("scroll", handler);
+      currentTarget = null;
+    }
     if (scrollTimer !== null) {
       clearTimeout(scrollTimer);
       scrollTimer = null;
@@ -2319,31 +2377,44 @@ function urlState() {
       }
     };
   }
-  const [params, setParamsSignal] = signal(new URLSearchParams(window.location.search));
-  const [hash, setHashSignal] = signal(window.location.hash);
-  const syncFromLocation = () => {
-    setParamsSignal(new URLSearchParams(window.location.search));
-    setHashSignal(window.location.hash);
-  };
-  const onPopState = () => syncFromLocation();
-  window.addEventListener("popstate", onPopState);
+  let lastSearch = window.location.search;
+  let lastHash = window.location.hash;
+  const [params, setParamsSignal] = signal(new URLSearchParams(lastSearch));
+  const [hash, setHashSignal] = signal(lastHash);
+  function syncFromLocation() {
+    const currentSearch = window.location.search;
+    const currentHash = window.location.hash;
+    if (currentSearch !== lastSearch) {
+      lastSearch = currentSearch;
+      setParamsSignal(new URLSearchParams(currentSearch));
+    }
+    if (currentHash !== lastHash) {
+      lastHash = currentHash;
+      setHashSignal(currentHash);
+    }
+  }
+  window.addEventListener("popstate", syncFromLocation);
+  window.addEventListener("hashchange", syncFromLocation);
   function setParams(next, opts = {}) {
     const p2 = next instanceof URLSearchParams ? next : new URLSearchParams(next);
     const query2 = p2.toString();
     const newUrl = `${window.location.pathname}${query2 ? `?${query2}` : ""}${window.location.hash}`;
     if (opts.replace) window.history.replaceState(null, "", newUrl);
     else window.history.pushState(null, "", newUrl);
+    lastSearch = window.location.search;
     setParamsSignal(new URLSearchParams(p2));
   }
   function setHash(next, opts = {}) {
-    const normalized = next.startsWith("#") ? next : next ? `#${next}` : "";
+    const normalized = next && next !== "#" ? next.startsWith("#") ? next : `#${next}` : "";
     const newUrl = `${window.location.pathname}${window.location.search}${normalized}`;
     if (opts.replace) window.history.replaceState(null, "", newUrl);
     else window.history.pushState(null, "", newUrl);
+    lastHash = normalized;
     setHashSignal(normalized);
   }
   function dispose() {
-    window.removeEventListener("popstate", onPopState);
+    window.removeEventListener("popstate", syncFromLocation);
+    window.removeEventListener("hashchange", syncFromLocation);
   }
   return { params, hash, setParams, setHash, dispose };
 }
@@ -3007,7 +3078,7 @@ function persisted(key, initial, options = {}) {
   }
   const [value, setValue] = signal(restored);
   let applyingFromStorage = false;
-  effect(() => {
+  const stopPersistEffect = effect(() => {
     const current = value();
     if (applyingFromStorage) return;
     try {
@@ -3047,6 +3118,7 @@ function persisted(key, initial, options = {}) {
     window.addEventListener("storage", storageListener);
   }
   const dispose = () => {
+    stopPersistEffect();
     if (storageListener && typeof window !== "undefined") {
       window.removeEventListener("storage", storageListener);
       storageListener = null;
@@ -3064,27 +3136,53 @@ function persisted(key, initial, options = {}) {
 // src/patterns/optimistic.ts
 function optimistic(initialValue) {
   const [value, setValue] = signal(initialValue);
-  const [_pending, setPending] = signal(false);
-  async function addOptimistic(optimisticValue, asyncAction) {
+  const [pending, setPending] = signal(false);
+  let inflightCount = 0;
+  let version = 0;
+  async function update(optimisticValue, asyncAction) {
+    const myVersion = ++version;
     const previousValue = value();
     setValue(optimisticValue);
+    inflightCount++;
     setPending(true);
     try {
       const result = await asyncAction();
-      setValue(result);
+      if (version === myVersion) {
+        setValue(result);
+      }
     } catch {
-      setValue(previousValue);
+      if (version === myVersion) {
+        setValue(previousValue);
+      }
     } finally {
-      setPending(false);
+      inflightCount--;
+      if (inflightCount === 0) setPending(false);
     }
   }
-  return [value, addOptimistic];
+  return { value, pending, update };
 }
 function optimisticList(initialValue) {
   const [items, setItems] = signal([...initialValue]);
-  async function addOptimistic(item, asyncAction) {
+  const [pending, setPending] = signal(false);
+  let inflightCount = 0;
+  let version = 0;
+  function begin() {
+    const v = ++version;
+    inflightCount++;
+    setPending(true);
+    return v;
+  }
+  function end(myVersion, revertFn) {
+    if (revertFn && version === myVersion) {
+      revertFn();
+    }
+    inflightCount--;
+    if (inflightCount === 0) setPending(false);
+  }
+  async function add(item, asyncAction) {
     const prev = items();
     setItems([...prev, item]);
+    const myVersion = begin();
     try {
       const result = await asyncAction();
       setItems((current) => {
@@ -3094,32 +3192,56 @@ function optimisticList(initialValue) {
           next[idx] = result;
           return next;
         }
-        return [...current.filter((i2) => i2 !== item), result];
+        return [...current, result];
       });
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  async function removeOptimistic(predicate, asyncAction) {
+  async function remove(predicate, asyncAction) {
     const prev = items();
     setItems(prev.filter((item) => !predicate(item)));
+    const myVersion = begin();
     try {
       await asyncAction();
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  async function updateOptimistic(predicate, update, asyncAction) {
+  async function updateItem(predicate, patch, asyncAction) {
     const prev = items();
-    setItems(prev.map((item) => predicate(item) ? { ...item, ...update } : item));
+    const patchedRefs = [];
+    setItems(
+      prev.map((item) => {
+        if (predicate(item)) {
+          const patched = { ...item, ...patch };
+          patchedRefs.push(patched);
+          return patched;
+        }
+        return item;
+      })
+    );
+    const myVersion = begin();
     try {
       const result = await asyncAction();
-      setItems((current) => current.map((item) => predicate(item) ? result : item));
+      setItems((current) => current.map((item) => patchedRefs.includes(item) ? result : item));
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  return { items, addOptimistic, removeOptimistic, updateOptimistic };
+  return {
+    items,
+    pending,
+    add,
+    remove,
+    update: updateItem,
+    addOptimistic: add,
+    removeOptimistic: remove,
+    updateOptimistic: updateItem
+  };
 }
 
 // src/patterns/timeTravel.ts
@@ -3171,7 +3293,7 @@ function timeline(initial, maxHistory = 100) {
 
 // src/patterns/globalStore.ts
 function globalStore(config) {
-  const initialState = { ...config.state };
+  const initialState = JSON.parse(JSON.stringify(config.state));
   const [getState, setState] = signal({ ...initialState });
   const listeners = /* @__PURE__ */ new Set();
   const middlewares = config.middleware || [];
@@ -3400,20 +3522,29 @@ function transition(element, options = {}) {
     onLeaveDone
   } = options;
   const transitionValue = `${property} ${duration}ms ${easing} ${delay}ms`;
+  let activeTimer = null;
+  function cancelPending() {
+    if (activeTimer !== null) {
+      clearTimeout(activeTimer);
+      activeTimer = null;
+    }
+  }
   function enter() {
     return new Promise((resolve) => {
+      cancelPending();
       element.style.transition = transitionValue;
       if (enterClass) element.classList.add(enterClass);
       if (leaveClass) element.classList.remove(leaveClass);
       void element.offsetHeight;
       if (activeClass) element.classList.add(activeClass);
       const done = () => {
+        activeTimer = null;
         if (enterClass) element.classList.remove(enterClass);
         onEnterDone?.();
         resolve();
       };
       if (duration > 0) {
-        setTimeout(done, duration + delay);
+        activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
       }
@@ -3421,17 +3552,19 @@ function transition(element, options = {}) {
   }
   function leave() {
     return new Promise((resolve) => {
+      cancelPending();
       element.style.transition = transitionValue;
       if (activeClass) element.classList.remove(activeClass);
       if (leaveClass) element.classList.add(leaveClass);
       if (enterClass) element.classList.remove(enterClass);
       const done = () => {
+        activeTimer = null;
         if (leaveClass) element.classList.remove(leaveClass);
         onLeaveDone?.();
         resolve();
       };
       if (duration > 0) {
-        setTimeout(done, duration + delay);
+        activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
       }
@@ -3834,7 +3967,7 @@ function bindField(field, extras) {
     blur: () => field.touch()
   };
   const { on: extraOn, value: _ignoreValue, ...restExtras } = extras ?? {};
-  const mergedOn = extraOn && typeof extraOn === "object" ? { ...fieldOn, ...extraOn } : fieldOn;
+  const mergedOn = extraOn && typeof extraOn === "object" ? { ...extraOn, ...fieldOn } : fieldOn;
   return {
     value: field.value,
     on: mergedOn,
@@ -3905,14 +4038,23 @@ function form(config) {
     }
     return result;
   });
+  const [submitting, setSubmitting] = signal(false);
   function handleSubmit(onSubmit) {
     return (e) => {
       if (e) e.preventDefault();
+      if (submitting()) return;
       for (const field of Object.values(fieldMap)) {
         field.touch();
       }
       if (isValid()) {
-        onSubmit(values());
+        const result = onSubmit(values());
+        if (result && typeof result.then === "function") {
+          setSubmitting(true);
+          result.then(
+            () => setSubmitting(false),
+            () => setSubmitting(false)
+          );
+        }
       }
     };
   }
@@ -3929,6 +4071,7 @@ function form(config) {
     errors,
     isValid,
     isDirty,
+    submitting,
     touched: touchedState,
     values,
     handleSubmit,
@@ -3937,6 +4080,20 @@ function form(config) {
   };
 }
 
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var _isDev4 = isDev();
+var activeBindingCount = 0;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  if (_isDev4) activeBindingCount++;
+}
+
 // src/ui/virtualList.ts
 function VirtualList(props) {
   const overscan = props.overscan ?? 3;
@@ -3954,9 +4111,9 @@ function VirtualList(props) {
   content.style.right = "0";
   spacer.appendChild(content);
   container.appendChild(spacer);
-  container.addEventListener("scroll", () => {
-    setScrollTop(container.scrollTop);
-  });
+  const onScroll = () => setScrollTop(container.scrollTop);
+  container.addEventListener("scroll", onScroll);
+  registerDisposer(container, () => container.removeEventListener("scroll", onScroll));
   const update = () => {
     const items = props.items();
     const totalHeight = items.length * props.itemHeight;
@@ -4064,13 +4221,52 @@ function inputMask(options) {
     }
     return raw;
   }
+  function isSlot(c) {
+    return c === "9" || c === "A" || c === "*";
+  }
+  function buildStripRegex() {
+    const hasDigit = options.pattern.includes("9");
+    const hasLetter = options.pattern.includes("A");
+    const hasAny = options.pattern.includes("*");
+    if (hasAny) {
+      const literals = /* @__PURE__ */ new Set();
+      for (const c of options.pattern) {
+        if (!isSlot(c)) literals.add(c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      }
+      return literals.size > 0 ? new RegExp(`[${Array.from(literals).join("")}]`, "g") : /(?!)/g;
+    }
+    if (hasDigit && hasLetter) return /[^a-zA-Z0-9]/g;
+    if (hasDigit) return /[^0-9]/g;
+    if (hasLetter) return /[^a-zA-Z]/g;
+    return /[^a-zA-Z0-9]/g;
+  }
+  const stripRegex = buildStripRegex();
+  const rawCharTest = options.pattern.includes("*") ? () => true : (c) => /[a-zA-Z0-9]/.test(c);
   function bind(input2) {
     input2.addEventListener("input", () => {
-      const raw = input2.value.replace(/[^a-zA-Z0-9]/g, "");
+      const cursorBefore = input2.selectionStart ?? input2.value.length;
+      const oldValue = input2.value;
+      const raw = oldValue.replace(stripRegex, "");
       const masked = applyMask(raw);
       setValue(masked);
       setRawValue(extractRaw(masked));
       input2.value = masked;
+      let rawBefore = 0;
+      for (let i2 = 0; i2 < cursorBefore && i2 < oldValue.length; i2++) {
+        if (rawCharTest(oldValue[i2])) rawBefore++;
+      }
+      let newCursor = 0;
+      let counted = 0;
+      for (; newCursor < masked.length; newCursor++) {
+        if (newCursor < options.pattern.length && isSlot(options.pattern[newCursor])) {
+          counted++;
+          if (counted >= rawBefore) {
+            newCursor++;
+            break;
+          }
+        }
+      }
+      input2.setSelectionRange(newCursor, newCursor);
     });
     input2.addEventListener("focus", () => {
       if (!input2.value) {
@@ -4140,7 +4336,10 @@ function FocusTrap(nodes, options = {}) {
     const focusable = container.querySelectorAll(
       'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
     );
-    if (focusable.length === 0) return;
+    if (focusable.length === 0) {
+      e.preventDefault();
+      return;
+    }
     const first = focusable[0];
     const last = focusable[focusable.length - 1];
     if (e.shiftKey) {
@@ -4163,24 +4362,27 @@ function FocusTrap(nodes, options = {}) {
       first?.focus();
     });
   }
+  let trapObserver = null;
+  function restoreFocusAndCleanup() {
+    if (options.restoreFocus !== false) previouslyFocused?.focus();
+    if (trapObserver) {
+      trapObserver.disconnect();
+      trapObserver = null;
+    }
+  }
   if (options.restoreFocus !== false) {
-    const observer = new MutationObserver((mutations) => {
-      for (const mutation2 of mutations) {
-        for (const removed of Array.from(mutation2.removedNodes)) {
-          if (removed === container || removed.contains(container)) {
-            previouslyFocused?.focus();
-            observer.disconnect();
-            return;
-          }
-        }
+    trapObserver = new MutationObserver(() => {
+      if (!container.isConnected) {
+        restoreFocusAndCleanup();
       }
     });
     queueMicrotask(() => {
-      if (container.parentNode) {
-        observer.observe(container.parentNode, { childList: true });
+      if (container.isConnected) {
+        trapObserver.observe(document.body, { childList: true, subtree: true });
       }
     });
   }
+  registerDisposer(container, restoreFocusAndCleanup);
   return container;
 }
 function hotkey(combo, handler, options = {}) {
@@ -4266,6 +4468,10 @@ function scopedStyle(css) {
     if (trimmed.startsWith("@") || trimmed.startsWith("from") || trimmed.startsWith("to") || /^\d+%$/.test(trimmed)) {
       return match;
     }
+    const pseudoIdx = trimmed.indexOf("::");
+    if (pseudoIdx >= 0) {
+      return `${trimmed.slice(0, pseudoIdx)}[${attr}]${trimmed.slice(pseudoIdx)}${delimiter}`;
+    }
     return `${trimmed}[${attr}]${delimiter}`;
   });
   if (typeof document !== "undefined") {
@@ -4301,7 +4507,7 @@ function removeScopedStyle(scopeId) {
 }
 
 // src/reactivity/bindAttribute.ts
-var _isDev4 = isDev();
+var _isDev5 = isDev();
 function isEventHandlerAttr(name) {
   if (name.length < 3) return false;
   const lower = name.toLowerCase();
@@ -4309,7 +4515,7 @@ function isEventHandlerAttr(name) {
 }
 function bindAttribute(el, attr, getter) {
   if (isEventHandlerAttr(attr)) {
-    if (_isDev4)
+    if (_isDev5)
       devWarn(
         `bindAttribute: refusing to bind event-handler attribute "${attr}". Use on:{ ${attr.slice(2)}: fn } instead.`
       );
@@ -4321,7 +4527,7 @@ function bindAttribute(el, attr, getter) {
     try {
       value = getter();
     } catch (err) {
-      if (_isDev4)
+      if (_isDev5)
         devWarn(`bindAttribute: getter for "${attr}" threw: ${err instanceof Error ? err.message : String(err)}`);
       return;
     }
@@ -4415,28 +4621,35 @@ function dialog() {
       close();
     }
   }
-  function open() {
-    setIsOpen(true);
+  function attachListener() {
     if (typeof window !== "undefined" && !listenerAttached) {
       window.addEventListener("keydown", handleKeydown);
       listenerAttached = true;
     }
   }
-  function close() {
-    setIsOpen(false);
+  function detachListener() {
     if (typeof window !== "undefined" && listenerAttached) {
       window.removeEventListener("keydown", handleKeydown);
       listenerAttached = false;
     }
   }
+  function open() {
+    setIsOpen(true);
+    attachListener();
+  }
+  function close() {
+    setIsOpen(false);
+    detachListener();
+  }
   function toggle() {
-    if (isOpen()) {
-      close();
-    } else {
-      open();
-    }
+    if (isOpen()) close();
+    else open();
   }
-  return { open, close, isOpen, toggle };
+  function dispose() {
+    detachListener();
+    setIsOpen(false);
+  }
+  return { open, close, isOpen, toggle, dispose };
 }
 
 // src/ui/toast.ts
@@ -4757,15 +4970,12 @@ function startTransition(callback) {
 }
 function deferredValue(getter) {
   const [deferred, setDeferred] = signal(getter());
-  const sync = () => {
-    const current = getter();
-    setDeferred(current);
-  };
-  scheduleUpdate(Priority.LOW, sync);
-  return () => {
-    scheduleUpdate(Priority.LOW, sync);
-    return deferred();
-  };
+  let latest = deferred();
+  effect(() => {
+    latest = getter();
+    scheduleUpdate(Priority.LOW, () => setDeferred(latest));
+  });
+  return deferred;
 }
 function transitionState() {
   const [isPending, setIsPending] = signal(false);
@@ -5368,7 +5578,7 @@ function setCanonical(url) {
 }
 
 // src/platform/ssr.ts
-var _isDev5 = isDev();
+var _isDev6 = isDev();
 var SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
 function isSafeAttrName(name) {
   return SAFE_ATTR_NAME.test(name);
@@ -5393,7 +5603,7 @@ var URL_ATTRS = /* @__PURE__ */ new Set([
   "xlink:href"
 ]);
 function ssrErrorComment(err) {
-  if (_isDev5) {
+  if (_isDev6) {
     const msg = escapeHtml(err instanceof Error ? err.message : String(err));
     return `<!--SSR error: ${safeCommentText(msg)}-->`;
   }
@@ -5439,10 +5649,10 @@ function renderToString(element) {
   }
   const tag = element.tagName.toLowerCase();
   if (tag === "script" || tag === "style") {
-    return _isDev5 ? `<!--ssr:${tag}-stripped-->` : "";
+    return _isDev6 ? `<!--ssr:${tag}-stripped-->` : "";
   }
   if (!/^[a-z][a-z0-9-]*$/i.test(tag)) {
-    return _isDev5 ? "<!--ssr:invalid-tag-->" : "";
+    return _isDev6 ? "<!--ssr:invalid-tag-->" : "";
   }
   let html2 = `<${tag}`;
   for (const attr of Array.from(element.attributes)) {
@@ -5483,7 +5693,7 @@ function hydrate(component, container, options = {}) {
       const first = mismatches[0];
       if (options.onMismatch) {
         options.onMismatch(first);
-      } else if (_isDev5) {
+      } else if (_isDev6) {
         console.warn(
           `[Sibu hydration] ${first.message}
   at ${first.path}
@@ -5681,11 +5891,11 @@ async function* renderToStream(element) {
   }
   const tag = element.tagName.toLowerCase();
   if (tag === "script" || tag === "style") {
-    if (_isDev5) yield `<!--ssr:${tag}-stripped-->`;
+    if (_isDev6) yield `<!--ssr:${tag}-stripped-->`;
     return;
   }
   if (!/^[a-z][a-z0-9-]*$/i.test(tag)) {
-    if (_isDev5) yield "<!--ssr:invalid-tag-->";
+    if (_isDev6) yield "<!--ssr:invalid-tag-->";
     return;
   }
   let openTag = `<${tag}`;
@@ -6187,7 +6397,7 @@ function isWasmCached(key) {
 }
 
 // src/reactivity/bindChildNode.ts
-var _isDev6 = isDev();
+var _isDev7 = isDev();
 function bindChildNode(placeholder, getter) {
   let lastNodes = [];
   function commit() {
@@ -6195,7 +6405,7 @@ function bindChildNode(placeholder, getter) {
     try {
       result = getter();
     } catch (err) {
-      if (_isDev6) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      if (_isDev7) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
       return;
     }
     if (result == null || typeof result === "boolean") {
@@ -6255,20 +6465,6 @@ function bindChildNode(placeholder, getter) {
   return track(commit);
 }
 
-// src/core/rendering/dispose.ts
-var elementDisposers = /* @__PURE__ */ new WeakMap();
-var _isDev7 = isDev();
-var activeBindingCount = 0;
-function registerDisposer(node, teardown) {
-  let disposers = elementDisposers.get(node);
-  if (!disposers) {
-    disposers = [];
-    elementDisposers.set(node, disposers);
-  }
-  disposers.push(teardown);
-  if (_isDev7) activeBindingCount++;
-}
-
 // src/core/rendering/tagFactory.ts
 var SVG_NS = "http://www.w3.org/2000/svg";
 var kebabCache = /* @__PURE__ */ new Map();