sibujs 3.4.0 → 4.0.0

package/dist/{chunk-APFRCIRI.js → chunk-GCSGGA3Q.js}

@@ -135,45 +135,40 @@ import {
   use,
   var_,
   video
-} from "./chunk-3Z2NGWQI.js";
+} from "./chunk-ES2GERY2.js";
+import {
+  trustHTML
+} from "./chunk-HYCCIYNS.js";
 import {
   watch
-} from "./chunk-H5FI5WDP.js";
+} from "./chunk-RRIDJQ5C.js";
 import {
   __resetIdCounter,
   createId
 } from "./chunk-CCSJMTRN.js";
-import {
-  trustHTML
-} from "./chunk-EX77FXTT.js";
 import {
   context
-} from "./chunk-RT3IYFN2.js";
+} from "./chunk-O3QQ3XOL.js";
 import {
   SVG_NS,
   bindChildNode,
   tagFactory
-} from "./chunk-JNGGM2XE.js";
+} from "./chunk-DQVUBVNX.js";
 import {
   bindAttribute,
-  bindDynamic
-} from "./chunk-K35BAR4P.js";
+  bindDynamic,
+  setSafeAttribute
+} from "./chunk-4MFZMLUU.js";
 import {
   derived
-} from "./chunk-ITWCTZYH.js";
+} from "./chunk-Z2CE42DB.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
-import {
-  isEventHandlerAttr,
-  isUrlAttribute,
-  sanitizeSrcset,
-  sanitizeUrl
-} from "./chunk-L3GAGWCC.js";
 import {
   effect,
   on
-} from "./chunk-BUKYCWHX.js";
+} from "./chunk-PBQEW5VW.js";
 import {
   disableSSR,
   enableSSR,
@@ -182,18 +177,22 @@ import {
   isSSR,
   runInSSRContext,
   withSSR
-} from "./chunk-S3NFJO6L.js";
+} from "./chunk-TIRZCERI.js";
 import {
+  MAX_DRAIN_TEARDOWNS,
   checkLeaks,
   dispose,
-  registerDisposer
-} from "./chunk-5VGSK6D2.js";
+  registerDisposer,
+  replaceChildrenSafely,
+  reportDrainRunaway,
+  unregisterDisposer
+} from "./chunk-DHDZ7IVN.js";
 import {
   batch,
   enqueueBatchedSignal,
   isBatching,
   signal
-} from "./chunk-KZBEVFXZ.js";
+} from "./chunk-W55YHPEP.js";
 import {
   notifySubscribers,
   recordDependency,
@@ -203,13 +202,17 @@ import {
   suspendTracking,
   track,
   untracked
-} from "./chunk-OOUQUCNN.js";
+} from "./chunk-ACBT6UZS.js";
 import {
   __export,
   devAssert,
   devWarn,
-  isDev
-} from "./chunk-COY6PUD2.js";
+  getRuntimeErrorHandler,
+  isDev,
+  normalizeError,
+  reportError,
+  setRuntimeErrorHandler
+} from "./chunk-VPP2FONR.js";
 
 // index.ts
 var index_exports = {};
@@ -220,6 +223,7 @@ __export(index_exports, {
   Fragment: () => Fragment,
   KeepAlive: () => KeepAlive,
   Loading: () => Loading,
+  MAX_DRAIN_TEARDOWNS: () => MAX_DRAIN_TEARDOWNS,
   Portal: () => Portal,
   SVG_NS: () => SVG_NS,
   Suspense: () => Suspense,
@@ -297,6 +301,7 @@ __export(index_exports, {
   g: () => g,
   getAction: () => getAction,
   getRequestScopedCache: () => getRequestScopedCache,
+  getRuntimeErrorHandler: () => getRuntimeErrorHandler,
   getSSRStore: () => getSSRStore,
   getSlot: () => getSlot,
   h1: () => h1,
@@ -370,6 +375,9 @@ __export(index_exports, {
   registerComponent: () => registerComponent,
   registerDisposer: () => registerDisposer,
   registerIsland: () => registerIsland,
+  replaceChildrenSafely: () => replaceChildrenSafely,
+  reportDrainRunaway: () => reportDrainRunaway,
+  reportError: () => reportError,
   resolveComponent: () => resolveComponent,
   retrack: () => retrack,
   rp: () => rp,
@@ -383,6 +391,7 @@ __export(index_exports, {
   select: () => select,
   setGlobalErrorHandler: () => setGlobalErrorHandler,
   setMaxDrainIterations: () => setMaxDrainIterations,
+  setRuntimeErrorHandler: () => setRuntimeErrorHandler,
   show: () => show,
   signal: () => signal,
   slot: () => slot,
@@ -422,6 +431,7 @@ __export(index_exports, {
   u: () => u,
   ul: () => ul,
   unregisterComponent: () => unregisterComponent,
+  unregisterDisposer: () => unregisterDisposer,
   unregisterIsland: () => unregisterIsland,
   untracked: () => untracked,
   use: () => use,
@@ -436,18 +446,14 @@ __export(index_exports, {
 // 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;
-    }
+  const report = () => {
+    if (!node.parentNode) return false;
+    reportError(error, { phase: "render", name: "lazy", node });
+    return true;
   };
-  if (node.parentNode && fire()) return;
+  if (report()) return;
   queueMicrotask(() => {
-    if (fire()) return;
+    if (report()) return;
     node[PENDING_ERROR] = error;
   });
 }
@@ -472,12 +478,14 @@ function lazy(importFn) {
       if (disposed) return;
       cached = mod.default;
       const rendered = cached();
-      container.replaceChildren(rendered);
+      replaceChildrenSafely(container, rendered);
     }).catch((err) => {
       if (disposed) return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
-      devWarn(`[SibuJS] lazy() failed to load component: ${errorObj.message}`);
-      container.replaceChildren(div({ class: "sibu-lazy-error" }, `Failed to load component: ${errorObj.message}`));
+      replaceChildrenSafely(
+        container,
+        div({ class: "sibu-lazy-error" }, `Failed to load component: ${errorObj.message}`)
+      );
       dispatchPropagate(container, errorObj);
     });
     container.appendChild(span("sibu-lazy-loading", "Loading..."));
@@ -509,7 +517,7 @@ function Suspense({ nodes, fallback }) {
       childEl = el;
       if (el.classList.contains("sibu-lazy")) {
         if (!el.querySelector(".sibu-lazy-loading")) {
-          container.replaceChildren(el);
+          replaceChildrenSafely(container, el);
           return;
         }
         observer = new MutationObserver(() => {
@@ -518,16 +526,15 @@ function Suspense({ nodes, fallback }) {
           if (!loading) {
             observer?.disconnect();
             observer = null;
-            container.replaceChildren(el);
+            replaceChildrenSafely(container, el);
           }
         });
         observer.observe(el, { childList: true, subtree: true });
       } else {
-        container.replaceChildren(el);
+        replaceChildrenSafely(container, el);
       }
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
-      devWarn(`[SibuJS] Suspense nodes() threw: ${errorObj.message}`);
       dispatchPropagate(container, errorObj);
     }
   });
@@ -539,7 +546,8 @@ function safeCall(cb, hookName) {
   try {
     return cb();
   } catch (err) {
-    devWarn(`${hookName}: callback threw: ${err instanceof Error ? err.message : String(err)}`);
+    const phase = hookName.toLowerCase().includes("unmount") ? "cleanup" : "effect";
+    reportError(err, { phase, name: hookName });
     return void 0;
   }
 }
@@ -970,14 +978,14 @@ function parseStack(stack) {
   }
   return frames;
 }
-function normalizeError(err) {
+function normalizeError2(err) {
   if (err instanceof Error) {
     const code2 = err.code ?? err.name ?? "ERROR";
     const message = err.message || "Unknown error";
     const stack = err.stack ?? "";
     const frames = parseStack(stack);
     const rawCause = err.cause;
-    const cause = rawCause != null ? normalizeError(rawCause) : null;
+    const cause = rawCause != null ? normalizeError2(rawCause) : null;
     return { code: code2, message, stack, frames, cause };
   }
   return {
@@ -1073,7 +1081,7 @@ function renderMetadata(meta2) {
 function ErrorDisplay(props) {
   injectStyles();
   const severity = props.severity ?? "error";
-  const normalized = normalizeError(props.error);
+  const normalized = normalizeError2(props.error);
   const showDetails = props.alwaysShowDetails ?? isDev();
   const headline = props.title ?? normalized.message;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
@@ -1323,6 +1331,7 @@ var errorBoundaryStyles = `
     background: #3a3a4e;
   }
 `;
+var RESET_KEY_THREW = /* @__PURE__ */ Symbol("sibujs.ErrorBoundary.resetKeyThrew");
 var stylesInjected = false;
 function injectStyles2() {
   if (!stylesInjected && typeof document !== "undefined") {
@@ -1331,29 +1340,6 @@ function injectStyles2() {
     stylesInjected = true;
   }
 }
-var FALLBACK_CACHE_MAX = 50;
-var fallbackCache = /* @__PURE__ */ new WeakMap();
-function getMemoizedFallback(fallbackFn, error, retry) {
-  let cache2 = fallbackCache.get(fallbackFn);
-  if (!cache2) {
-    cache2 = /* @__PURE__ */ new Map();
-    fallbackCache.set(fallbackFn, cache2);
-  }
-  const key = error.message;
-  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 factory();
-}
 function ErrorBoundary(optionsOrChildren, maybeChildren) {
   const children = typeof optionsOrChildren === "function" ? optionsOrChildren : maybeChildren;
   const options = typeof optionsOrChildren === "function" ? {} : optionsOrChildren;
@@ -1361,43 +1347,61 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
   injectStyles2();
   const [error, setError] = signal(null);
   const retry = () => {
-    if (fallback) {
-      const cur = error();
-      const inner = fallbackCache.get(fallback);
-      if (cur && inner) inner.delete(cur.message);
-    }
+    stopResetKeysWatcher();
     setError(null);
   };
   let resetKeysTeardown = null;
-  if (resetKeys && resetKeys.length > 0) {
-    let initialized = false;
+  const stopResetKeysWatcher = () => {
+    if (!resetKeysTeardown) return;
+    const teardown = resetKeysTeardown;
+    resetKeysTeardown = null;
+    teardown();
+  };
+  const readResetKeyValues = (keys) => {
+    const values = new Array(keys.length);
+    for (let i2 = 0; i2 < keys.length; i2++) {
+      try {
+        values[i2] = keys[i2]();
+      } catch (err) {
+        reportError(err, { phase: "effect", name: "ErrorBoundary.resetKeys" });
+        values[i2] = RESET_KEY_THREW;
+      }
+    }
+    return values;
+  };
+  const startResetKeysWatcher = () => {
+    const keys = resetKeys;
+    if (!keys || keys.length === 0) return;
+    stopResetKeysWatcher();
+    let baseline = null;
     resetKeysTeardown = effect(() => {
-      for (const k of resetKeys) {
-        try {
-          k();
-        } catch (err) {
-          if (typeof console !== "undefined") {
-            console.warn("[SibuJS ErrorBoundary] resetKeys getter threw:", err);
+      const current = readResetKeyValues(keys);
+      if (baseline === null) {
+        baseline = current;
+        return;
+      }
+      let changed = current.length !== baseline.length;
+      if (!changed) {
+        for (let i2 = 0; i2 < current.length; i2++) {
+          if (!Object.is(current[i2], baseline[i2])) {
+            changed = true;
+            break;
           }
         }
       }
-      if (!initialized) {
-        initialized = true;
-        return;
-      }
-      if (error() !== null) retry();
+      baseline = current;
+      if (changed) retry();
     });
-  }
+  };
   const handleError = (e) => {
-    const errorObj = e instanceof Error ? e : new Error(String(e));
+    const errorObj = normalizeError(e);
     setError(errorObj);
+    startResetKeysWatcher();
     if (onError) {
       try {
         onError(errorObj);
       } catch (cbErr) {
-        if (typeof console !== "undefined") {
-          console.error("[SibuJS ErrorBoundary] onError callback threw:", cbErr);
-        }
+        reportError(cbErr, { phase: "render", name: "ErrorBoundary onError callback" });
       }
     }
     return errorObj;
@@ -1408,18 +1412,14 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
   const tryRenderFallback = (err) => {
     const fn = fallback || defaultFallback;
     try {
-      return getMemoizedFallback(fn, err, retry);
+      return fn(err, retry);
     } catch (fallbackError) {
-      const propagateError = fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError));
       queueMicrotask(() => {
-        if (container.parentNode) {
-          container.dispatchEvent(
-            new CustomEvent("sibu:error-propagate", {
-              bubbles: true,
-              detail: { error: propagateError }
-            })
-          );
-        }
+        reportError(fallbackError, {
+          phase: "render",
+          name: "ErrorBoundary fallback",
+          node: container.parentNode ? container : void 0
+        });
       });
       return document.createComment("error-boundary-failed");
     }
@@ -1436,11 +1436,20 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
         if (result && typeof result.then === "function") {
           const asyncContainer = div({ class: "sibu-error-async" });
           asyncContainer.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));
+          let asyncDisposed = false;
+          registerDisposer(asyncContainer, () => {
+            asyncDisposed = true;
+          });
           result.then((el) => {
-            asyncContainer.replaceChildren(el);
+            if (asyncDisposed) {
+              dispose(el);
+              return;
+            }
+            replaceChildrenSafely(asyncContainer, el);
           }).catch((e) => {
+            if (asyncDisposed) return;
             const err = handleError(e);
-            asyncContainer.replaceChildren(tryRenderFallback(err));
+            replaceChildrenSafely(asyncContainer, tryRenderFallback(err));
           });
           return asyncContainer;
         }
@@ -1453,12 +1462,12 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
   });
   const propagateListener = (e) => {
     if (error()) return;
-    e.stopPropagation();
     const customEvent = e;
     const propagatedError = customEvent.detail?.error;
-    if (propagatedError) {
-      handleError(propagatedError);
-    }
+    if (!propagatedError) return;
+    e.preventDefault();
+    e.stopPropagation();
+    handleError(propagatedError);
   };
   container.addEventListener("sibu:error-propagate", propagateListener);
   onMount(() => {
@@ -1486,7 +1495,7 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
     return void 0;
   }, container);
   registerDisposer(container, () => {
-    if (resetKeysTeardown) resetKeysTeardown();
+    stopResetKeysWatcher();
     container.removeEventListener("sibu:error-propagate", propagateListener);
   });
   return container;
@@ -1836,10 +1845,7 @@ function DynamicComponent(is) {
     } else {
       el = resolveComponent(target);
     }
-    for (const child of Array.from(container.childNodes)) {
-      dispose(child);
-    }
-    container.replaceChildren(el);
+    replaceChildrenSafely(container, el);
   }
   const untrack = track(render);
   registerDisposer(container, untrack);
@@ -1900,6 +1906,10 @@ function each(getArray, render, options) {
   let oldLen = 0;
   let nodeMap = /* @__PURE__ */ new Map();
   let workMap = /* @__PURE__ */ new Map();
+  const pendingRows = [];
+  const pendingItems = [];
+  const pendingIndices = [];
+  let pendingCount = 0;
   let newNodes = [];
   let newKeysBuf = [];
   let isStableBuf = new Uint8Array(0);
@@ -1909,8 +1919,10 @@ function each(getArray, render, options) {
   const keyIndexMap = /* @__PURE__ */ new Map();
   let initialized = false;
   let sentinelInserted = false;
+  let rangeDisposed = false;
   const keyFn = options.key;
   const update = () => {
+    if (rangeDisposed) return;
     const arr = getArray();
     const newLen = arr.length;
     const parent = anchor.parentNode;
@@ -1939,49 +1951,44 @@ function each(getArray, render, options) {
       }
       keyIndexMap.set(newKeys[i2], i2);
     }
+    pendingCount = 0;
     for (let i2 = 0; i2 < newLen; i2++) {
       const key = newKeys[i2];
       const existing = nodeMap.get(key);
-      let node;
+      let row;
       if (existing !== void 0) {
-        node = existing;
+        row = existing;
+        pendingRows[pendingCount] = row;
+        pendingItems[pendingCount] = arr[i2];
+        pendingIndices[pendingCount] = i2;
+        pendingCount++;
       } else {
-        const itemKey = key;
-        const itemGetter = () => untracked(() => getArray()[keyIndexMap.get(itemKey)]);
-        const indexGetter = () => keyIndexMap.get(itemKey);
+        const [itemGetter, setItem] = signal(arr[i2]);
+        const [indexGetter, setIndex] = signal(i2);
+        let node;
         try {
           node = resolveNodeChild(render(itemGetter, indexGetter));
         } catch (err) {
-          if (_isDev) {
-            devWarn(
-              `each: render threw for item at index ${i2} (key="${newKeys[i2]}"): ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
+          const key2 = newKeys[i2];
           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 (_isDev) {
-                devWarn(`each: error not surfaced \u2014 anchor detached: ${errorObj.message}`);
-              }
-            } catch {
-            }
+            reportError(err, {
+              phase: "render",
+              name: `each row (key="${String(key2)}")`,
+              node: anchor.parentNode ? anchor : void 0
+            });
           });
         }
+        row = { node, item: itemGetter, setItem, index: indexGetter, setIndex };
       }
-      workMap.set(key, node);
-      newNodes[i2] = node;
+      workMap.set(key, row);
+      newNodes[i2] = row.node;
     }
-    for (const [key, node] of nodeMap) {
+    for (const [key, row] of nodeMap) {
       if (!workMap.has(key)) {
-        dispose(node);
-        if (node.parentNode) {
-          parent.removeChild(node);
+        dispose(row.node);
+        if (row.node.parentNode) {
+          parent.removeChild(row.node);
         }
       }
     }
@@ -1990,6 +1997,8 @@ function each(getArray, render, options) {
       const tmp2 = nodeMap;
       nodeMap = workMap;
       workMap = tmp2;
+      initialized = true;
+      pendingCount = 0;
       return;
     }
     oldKeyIndex.clear();
@@ -2039,12 +2048,47 @@ function each(getArray, render, options) {
     nodeMap = workMap;
     workMap = tmp;
     initialized = true;
+    flushRowCells();
   };
+  function flushRowCells() {
+    if (pendingCount === 0) return;
+    const count = pendingCount;
+    pendingCount = 0;
+    batch(() => {
+      for (let i2 = 0; i2 < count; i2++) {
+        const row = pendingRows[i2];
+        row.setItem(pendingItems[i2]);
+        row.setIndex(pendingIndices[i2]);
+        pendingRows[i2] = void 0;
+        pendingItems[i2] = void 0;
+      }
+    });
+  }
   const untrack = track(update);
-  registerDisposer(anchor, untrack);
+  const disposeRange = () => {
+    if (rangeDisposed) return;
+    rangeDisposed = true;
+    untrack();
+    for (const row of nodeMap.values()) {
+      dispose(row.node);
+      row.node.parentNode?.removeChild(row.node);
+    }
+    if (end.parentNode) end.parentNode.removeChild(end);
+    sentinelInserted = false;
+    nodeMap.clear();
+    workMap.clear();
+    keyIndexMap.clear();
+    oldKeyIndex.clear();
+    oldLen = 0;
+    pendingRows.length = 0;
+    pendingItems.length = 0;
+    pendingIndices.length = 0;
+    pendingCount = 0;
+  };
+  registerDisposer(anchor, disposeRange);
   if (!initialized) {
     queueMicrotask(() => {
-      if (!initialized && anchor.parentNode) {
+      if (!initialized && !rangeDisposed && anchor.parentNode) {
         update();
       }
     });
@@ -2343,20 +2387,11 @@ function executeElement(tmpl, values) {
         break;
       case 1: {
         const name = attr.name;
-        const lname = name.toLowerCase();
-        if (isEventHandlerAttr(name)) break;
         const val = values[attr.idx];
         if (typeof val === "function") {
           registerDisposer(el, bindAttribute(el, name, val));
-        } else if (val != null) {
-          const str = String(val);
-          if (lname === "srcset") {
-            el.setAttribute(name, sanitizeSrcset(str));
-          } else if (isUrlAttribute(lname)) {
-            el.setAttribute(name, sanitizeUrl(str));
-          } else {
-            el.setAttribute(name, str);
-          }
+        } else {
+          setSafeAttribute(el, name, val, { syncValueProperty: false, label: "html" });
         }
         break;
       }
@@ -2366,14 +2401,7 @@ function executeElement(tmpl, values) {
           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);
-        }
+        setSafeAttribute(el, attr.name, val, { syncValueProperty: false, label: "html" });
         break;
       }
       case 3: {
@@ -2599,20 +2627,12 @@ function Portal(nodes, target) {
       portalContent = nodes();
       container.appendChild(portalContent);
     } catch (err) {
-      if (typeof console !== "undefined") {
-        console.error("[Portal] Render error:", err);
-      }
-      const errorObj = err instanceof Error ? err : new Error(String(err));
       queueMicrotask(() => {
-        try {
-          const target2 = anchor.parentNode;
-          if (target2?.dispatchEvent) {
-            target2.dispatchEvent(
-              new CustomEvent("sibu:error-propagate", { bubbles: true, detail: { error: errorObj } })
-            );
-          }
-        } catch {
-        }
+        reportError(err, {
+          phase: "render",
+          name: "Portal",
+          node: anchor.parentNode ? anchor : void 0
+        });
       });
     }
   });
@@ -2709,9 +2729,10 @@ function array(initial = []) {
 function reactiveArray(initial = []) {
   let data2 = [...initial];
   let snapshot = null;
-  const signal2 = {};
+  const signal2 = { __v: 0 };
   function notify() {
     snapshot = null;
+    signal2.__v++;
     if (!enqueueBatchedSignal(signal2)) {
       notifySubscribers(signal2);
     }
@@ -2831,17 +2852,34 @@ function asyncDerived(factory, initial) {
   const [error, setError] = signal(null);
   const [tick, setTick] = signal(0);
   let runId = 0;
-  effect(() => {
+  let disposed = false;
+  let controller = null;
+  const abortInFlight = () => {
+    if (controller === null) return;
+    const c = controller;
+    controller = null;
+    try {
+      c.abort();
+    } catch {
+    }
+  };
+  const stopEffect = effect(() => {
     tick();
+    if (disposed) return;
+    abortInFlight();
     const currentRun = ++runId;
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    controller = ac;
     batch(() => {
       setLoading(true);
       setError(null);
     });
+    const stale = () => disposed || currentRun !== runId;
     let promise;
     try {
-      promise = factory();
+      promise = factory({ signal: ac ? ac.signal : void 0 });
     } catch (err) {
+      if (stale()) return;
       batch(() => {
         setError(err);
         setLoading(false);
@@ -2850,14 +2888,16 @@ function asyncDerived(factory, initial) {
     }
     promise.then(
       (result) => {
-        if (currentRun !== runId) return;
+        if (stale()) return;
+        controller = null;
         batch(() => {
           setValue(result);
           setLoading(false);
         });
       },
       (err) => {
-        if (currentRun !== runId) return;
+        if (stale()) return;
+        controller = null;
         batch(() => {
           setError(err);
           setLoading(false);
@@ -2869,7 +2909,16 @@ function asyncDerived(factory, initial) {
     value,
     loading,
     error,
-    refresh: () => setTick((n) => n + 1)
+    refresh: () => {
+      if (disposed) return;
+      setTick((n) => n + 1);
+    },
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      stopEffect();
+      abortInFlight();
+    }
   };
 }
 
@@ -3102,6 +3151,28 @@ function strictEffect(fn) {
 }
 
 // src/platform/enhance.ts
+var ENHANCED_ATTR = "data-sibu-enhanced";
+var enhancementOwner = /* @__PURE__ */ new WeakMap();
+function drainTeardowns(teardowns, label2) {
+  let executed = 0;
+  while (teardowns.length > 0) {
+    const batch2 = teardowns.splice(0);
+    for (let i2 = 0; i2 < batch2.length; i2++) {
+      if (executed >= MAX_DRAIN_TEARDOWNS) {
+        const remaining = batch2.length - i2 + teardowns.length;
+        teardowns.length = 0;
+        reportDrainRunaway(label2, executed, remaining);
+        return;
+      }
+      executed++;
+      try {
+        batch2[i2]();
+      } catch (err) {
+        if (typeof console !== "undefined") console.error(`[SibuJS ${label2}] teardown error:`, err);
+      }
+    }
+  }
+}
 function resolveTarget(root, target) {
   if (target == null) return root;
   if (typeof target !== "string") return target;
@@ -3144,7 +3215,7 @@ function enhance(target, setup) {
     return () => {
     };
   }
-  if (root.getAttribute("data-sibu-enhanced") === "true") {
+  if (root.getAttribute(ENHANCED_ATTR) === "true") {
     if (isDev() && typeof console !== "undefined") {
       console.warn("[SibuJS enhance] element is already enhanced; ignoring re-enhance.", root);
     }
@@ -3152,6 +3223,7 @@ function enhance(target, setup) {
     };
   }
   const teardowns = [];
+  const owner = /* @__PURE__ */ Symbol("sibujs.enhance");
   let disposed = false;
   const bind = (target_, fn) => {
     const el = resolveTarget(root, target_);
@@ -3198,11 +3270,7 @@ function enhance(target, setup) {
           effect(() => {
             const v = value();
             const next = v == null ? null : String(v);
-            if (next === null) {
-              if (el.hasAttribute(name)) el.removeAttribute(name);
-            } else if (el.getAttribute(name) !== next) {
-              el.setAttribute(name, next);
-            }
+            setSafeAttribute(el, name, next, { syncValueProperty: false, label: "enhance attr()" });
           })
         );
       });
@@ -3248,29 +3316,50 @@ function enhance(target, setup) {
       teardowns.push(fn);
     }
   };
-  const extra = setup(ctx);
+  let extra;
+  try {
+    extra = setup(ctx);
+  } catch (err) {
+    drainTeardowns(teardowns, "enhance");
+    throw err;
+  }
   if (typeof extra === "function") teardowns.push(extra);
   const dispose2 = () => {
     if (disposed) return;
     disposed = true;
-    for (const fn of teardowns.splice(0)) {
-      try {
-        fn();
-      } catch (err) {
-        if (typeof console !== "undefined") console.error("[SibuJS enhance] teardown error:", err);
-      }
+    if (enhancementOwner.get(root) === owner) {
+      enhancementOwner.delete(root);
+      root.removeAttribute(ENHANCED_ATTR);
     }
+    unregisterDisposer(root, dispose2);
+    drainTeardowns(teardowns, "enhance");
   };
   registerDisposer(root, dispose2);
-  root.setAttribute("data-sibu-enhanced", "true");
+  enhancementOwner.set(root, owner);
+  root.setAttribute(ENHANCED_ATTR, "true");
   return dispose2;
 }
 function enhanceAll(selector, setup) {
   if (typeof document === "undefined") return () => {
   };
-  const disposers = Array.from(document.querySelectorAll(selector)).map((el) => enhance(el, setup));
+  const disposers = [];
+  try {
+    for (const el of Array.from(document.querySelectorAll(selector))) {
+      disposers.push(enhance(el, setup));
+    }
+  } catch (err) {
+    for (let i2 = disposers.length - 1; i2 >= 0; i2--) {
+      try {
+        disposers[i2]();
+      } catch (rollbackErr) {
+        if (typeof console !== "undefined") console.error("[SibuJS enhanceAll] rollback error:", rollbackErr);
+      }
+    }
+    disposers.length = 0;
+    throw err;
+  }
   return () => {
-    for (const d of disposers) d();
+    for (const d of disposers.splice(0)) d();
   };
 }
 
@@ -3304,6 +3393,7 @@ function mountIslands(root = typeof document !== "undefined" ? document : null,
   };
   const cancels = [];
   const disposers = [];
+  let torndown = false;
   for (const el of Array.from(root.querySelectorAll("[data-sibu-island]"))) {
     if (el.getAttribute("data-sibu-enhanced") === "true") continue;
     const name = el.getAttribute("data-sibu-island") ?? "";
@@ -3317,17 +3407,23 @@ function mountIslands(root = typeof document !== "undefined" ? document : null,
     }
     let activated = false;
     const activate = () => {
-      if (activated) return;
+      if (activated || torndown) return;
       activated = true;
       const reg = registry.get(name);
       if (!reg) return;
       resolveSetup(reg).then((setup) => {
+        if (torndown) return;
         if (!setup) {
           if (typeof console !== "undefined") console.warn(`[SibuJS islands] "${name}" loader produced no setup.`);
           return;
         }
         try {
-          disposers.push(enhance(el, setup));
+          const disposeIsland = enhance(el, setup);
+          if (torndown) {
+            disposeIsland();
+            return;
+          }
+          disposers.push(disposeIsland);
           el.setAttribute("data-sibu-hydrated", "true");
         } catch (err) {
           if (typeof console !== "undefined") console.error(`[SibuJS islands] "${name}" failed to mount:`, err);
@@ -3340,6 +3436,7 @@ function mountIslands(root = typeof document !== "undefined" ? document : null,
     cancels.push(schedule(strategy, el, activate, options));
   }
   return () => {
+    torndown = true;
     for (const c of cancels.splice(0)) c();
     for (const d of disposers.splice(0)) d();
   };