sibujs 3.0.0 → 3.2.0

package/dist/extras.cjs

@@ -164,6 +164,7 @@ __export(extras_exports, {
   inspectSignal: () => inspectSignal,
   intersection: () => intersection,
   invalidateQueries: () => invalidateQueries,
+  isDangerousMetaRefresh: () => isDangerousMetaRefresh,
   isDebugEnabled: () => isDebugEnabled,
   isHMRAvailable: () => isHMRAvailable,
   isWasmCached: () => isWasmCached,
@@ -459,7 +460,7 @@ function retrack(effectFn, subscriber) {
   }
 }
 function track(effectFn, subscriber) {
-  if (!subscriber) subscriber = effectFn;
+  if (!subscriber) return reactiveBinding(effectFn);
   cleanup(subscriber);
   const prev = currentSubscriber;
   currentSubscriber = subscriber;
@@ -477,6 +478,32 @@ function track(effectFn, subscriber) {
   const sub2 = subscriber;
   return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
+function reactiveBinding(commit) {
+  const run = () => {
+    const s2 = subscriber;
+    if (s2._disposed || s2._reentrant) return;
+    s2._reentrant = true;
+    try {
+      retrack(commit, subscriber);
+    } finally {
+      s2._reentrant = false;
+    }
+  };
+  const subscriber = run;
+  subscriber.depsHead = null;
+  subscriber.depsTail = null;
+  subscriber._epoch = 0;
+  subscriber._structDirty = false;
+  subscriber._runEpoch = 0;
+  subscriber._runs = 0;
+  subscriber._reentrant = false;
+  subscriber._disposed = false;
+  run();
+  return subscriber._dispose ?? (subscriber._dispose = () => {
+    subscriber._disposed = true;
+    cleanup(subscriber);
+  });
+}
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub2 = currentSubscriber;
@@ -686,6 +713,7 @@ function derived(getter, options) {
   const equals = options?.equals;
   const cs = {};
   cs._d = false;
+  cs._init = false;
   cs._g = getter;
   cs.__v = 0;
   const markDirty = () => {
@@ -694,11 +722,18 @@ function derived(getter, options) {
   };
   markDirty._c = 1;
   markDirty._sig = cs;
+  const recompute = () => {
+    const next = getter();
+    cs._v = equals && cs._init ? equals(cs._v, next) ? cs._v : next : next;
+    cs._d = false;
+    cs._init = true;
+  };
   track(() => {
     let threw = true;
     try {
       cs._v = getter();
       cs._d = false;
+      cs._init = true;
       threw = false;
     } finally {
       if (threw) cs._d = true;
@@ -714,20 +749,13 @@ function derived(getter, options) {
     }
     if (trackingSuspended) {
       if (cs._d) {
+        const prev = cs._v;
         evaluating = true;
-        let threw = true;
         try {
-          const prev = cs._v;
-          retrack(() => {
-            const next = getter();
-            cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
-            cs._d = false;
-            threw = false;
-          }, markDirty);
+          retrack(recompute, markDirty);
           if (!Object.is(prev, cs._v)) cs.__v++;
         } finally {
           evaluating = false;
-          if (threw) cs._d = true;
         }
       }
       return cs._v;
@@ -736,18 +764,11 @@ function derived(getter, options) {
     if (cs._d) {
       const oldValue = cs._v;
       evaluating = true;
-      let threw = true;
       try {
-        retrack(() => {
-          const next = getter();
-          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
-          cs._d = false;
-          threw = false;
-        }, markDirty);
+        retrack(recompute, markDirty);
         if (!Object.is(oldValue, cs._v)) cs.__v++;
       } finally {
         evaluating = false;
-        if (threw) cs._d = true;
       }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
@@ -768,11 +789,15 @@ function derived(getter, options) {
 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();
+    let mod = null;
+    const getBuiltin = process.getBuiltinModule;
+    if (typeof getBuiltin === "function") {
+      mod = getBuiltin("node:async_hooks");
+    } else {
+      const req = Function("return typeof require==='function'?require:null")();
+      if (req) mod = req("node:async_hooks");
     }
+    if (mod) als = new mod.AsyncLocalStorage();
   }
 } catch {
   als = null;
@@ -788,6 +813,17 @@ function getSSRStore() {
 function isSSR() {
   return getSSRStore().ssr;
 }
+function getRequestScopedCache(name) {
+  if (!isSSR()) return null;
+  const store = getSSRStore();
+  const caches = store.caches ?? (store.caches = /* @__PURE__ */ new Map());
+  let c = caches.get(name);
+  if (!c) {
+    c = /* @__PURE__ */ new Map();
+    caches.set(name, c);
+  }
+  return c;
+}
 
 // src/core/signals/effect.ts
 var _g = globalThis;
@@ -874,6 +910,7 @@ function effect(effectFn, options) {
     ctx.fn(ctx.onCleanup);
   };
   const sub2 = (() => {
+    if (ctx.disposed) return;
     if (ctx.running) {
       ctx.rerunPending = true;
       return;
@@ -1070,9 +1107,12 @@ async function withRetry(fn, options, onRetry, signal2) {
 }
 
 // src/data/query.ts
-var queryCache = /* @__PURE__ */ new Map();
-function getOrCreateEntry(key, initialData) {
-  let entry = queryCache.get(key);
+var globalQueryCache = /* @__PURE__ */ new Map();
+function getActiveQueryCache() {
+  return getRequestScopedCache("query") ?? globalQueryCache;
+}
+function getOrCreateEntry(cache, key, initialData) {
+  let entry = cache.get(key);
   if (!entry) {
     entry = {
       data: initialData,
@@ -1084,7 +1124,7 @@ function getOrCreateEntry(key, initialData) {
       listeners: /* @__PURE__ */ new Set(),
       refetchers: /* @__PURE__ */ new Set()
     };
-    queryCache.set(key, entry);
+    cache.set(key, entry);
   }
   return entry;
 }
@@ -1104,6 +1144,7 @@ function query(key, fetcher, options = {}) {
     select: select3
   } = options;
   const resolveKey = typeof key === "function" ? key : () => key;
+  const cache = getActiveQueryCache();
   const [data2, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
@@ -1115,16 +1156,16 @@ function query(key, fetcher, options = {}) {
   const isStale = derived(() => {
     data2();
     if (!currentKey) return true;
-    const entry = queryCache.get(currentKey);
+    const entry = cache.get(currentKey);
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
   async function doFetch() {
     if (disposed || !currentKey || !enabled) return;
     const key2 = currentKey;
-    let entry = queryCache.get(key2);
+    let entry = cache.get(key2);
     if (!entry) {
-      entry = getOrCreateEntry(key2);
+      entry = getOrCreateEntry(cache, key2);
       entry.listeners.add(onCacheUpdate);
       entry.refetchers.add(doFetch);
     }
@@ -1199,7 +1240,7 @@ function query(key, fetcher, options = {}) {
   }
   function onCacheUpdate() {
     if (disposed || !currentKey) return;
-    const entry = queryCache.get(currentKey);
+    const entry = cache.get(currentKey);
     if (!entry) {
       batch(() => {
         setData(void 0);
@@ -1219,7 +1260,7 @@ function query(key, fetcher, options = {}) {
   const effectCleanup = effect(() => {
     const key2 = resolveKey();
     if (currentKey !== null && currentKey !== key2) {
-      const oldEntry = queryCache.get(currentKey);
+      const oldEntry = cache.get(currentKey);
       if (oldEntry) {
         oldEntry.listeners.delete(onCacheUpdate);
         oldEntry.refetchers.delete(doFetch);
@@ -1227,13 +1268,13 @@ function query(key, fetcher, options = {}) {
         if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
           const oldKey = currentKey;
           if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
-          oldEntry.gcTimer = setTimeout(() => queryCache.delete(oldKey), cacheTime);
+          oldEntry.gcTimer = setTimeout(() => cache.delete(oldKey), cacheTime);
         }
       }
     }
     const keyChanged = currentKey !== key2;
     currentKey = key2;
-    const entry = getOrCreateEntry(key2, initialData);
+    const entry = getOrCreateEntry(cache, key2, initialData);
     if (keyChanged) entry.subscribers++;
     if (entry.gcTimer !== null) {
       clearTimeout(entry.gcTimer);
@@ -1287,7 +1328,7 @@ function query(key, fetcher, options = {}) {
     effectCleanup();
     if (intervalTimer) clearInterval(intervalTimer);
     if (currentKey) {
-      const entry = queryCache.get(currentKey);
+      const entry = cache.get(currentKey);
       if (entry) {
         entry.listeners.delete(onCacheUpdate);
         entry.refetchers.delete(doFetch);
@@ -1295,7 +1336,7 @@ function query(key, fetcher, options = {}) {
         if (entry.subscribers <= 0 && cacheTime >= 0) {
           const key2 = currentKey;
           if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
-          entry.gcTimer = setTimeout(() => queryCache.delete(key2), cacheTime);
+          entry.gcTimer = setTimeout(() => cache.delete(key2), cacheTime);
         }
       }
     }
@@ -1318,7 +1359,7 @@ function query(key, fetcher, options = {}) {
 }
 function invalidateQueries(keyOrPredicate) {
   const predicate = typeof keyOrPredicate === "function" ? keyOrPredicate : (k) => k === keyOrPredicate;
-  for (const [key, entry] of queryCache.entries()) {
+  for (const [key, entry] of getActiveQueryCache().entries()) {
     if (predicate(key)) {
       entry.dataUpdatedAt = 0;
       for (const refetcher of entry.refetchers) refetcher();
@@ -1326,10 +1367,10 @@ function invalidateQueries(keyOrPredicate) {
   }
 }
 function getQueryData(key) {
-  return queryCache.get(key)?.data;
+  return getActiveQueryCache().get(key)?.data;
 }
 function setQueryData(key, data2) {
-  const entry = queryCache.get(key);
+  const entry = getActiveQueryCache().get(key);
   if (!entry) return;
   const newData = typeof data2 === "function" ? data2(entry.data) : data2;
   entry.data = newData;
@@ -1339,14 +1380,15 @@ function setQueryData(key, data2) {
 function clearQueryCache() {
   const activeListeners = [];
   const activeRefetchers = [];
-  for (const entry of queryCache.values()) {
+  const activeCache = getActiveQueryCache();
+  for (const entry of activeCache.values()) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
     if (entry.subscribers > 0) {
       for (const listener of entry.listeners) activeListeners.push(listener);
       for (const refetcher of entry.refetchers) activeRefetchers.push(refetcher);
     }
   }
-  queryCache.clear();
+  activeCache.clear();
   for (const listener of activeListeners) listener();
   for (const refetcher of activeRefetchers) {
     refetcher().catch((err) => {
@@ -1357,10 +1399,11 @@ function clearQueryCache() {
   }
 }
 function __resetQueryCache() {
-  for (const entry of queryCache.values()) {
+  const activeCache = getActiveQueryCache();
+  for (const entry of activeCache.values()) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
   }
-  queryCache.clear();
+  activeCache.clear();
 }
 
 // src/data/mutation.ts
@@ -1372,7 +1415,11 @@ function mutation(mutationFn, options = {}) {
   const isSuccess = derived(() => status() === "success");
   const isIdle = derived(() => status() === "idle");
   let runId = 0;
+  let abortController = null;
   async function execute(variables) {
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal2 = abortController.signal;
     const myRun = ++runId;
     let context2;
     batch(() => {
@@ -1384,7 +1431,7 @@ function mutation(mutationFn, options = {}) {
       if (options.onMutate) {
         context2 = await options.onMutate(variables);
       }
-      const result = await withRetry(() => mutationFn(variables), options.retry);
+      const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
       batch(() => {
         setData(result);
@@ -1396,6 +1443,7 @@ function mutation(mutationFn, options = {}) {
       return result;
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
+      if (errorObj instanceof DOMException && errorObj.name === "AbortError") throw errorObj;
       if (myRun !== runId) throw errorObj;
       batch(() => {
         setError(errorObj);
@@ -1409,6 +1457,8 @@ function mutation(mutationFn, options = {}) {
   }
   function reset() {
     runId++;
+    abortController?.abort();
+    abortController = null;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -1424,6 +1474,7 @@ function mutation(mutationFn, options = {}) {
     isIdle,
     mutate: (variables) => {
       execute(variables).catch((err) => {
+        if (err instanceof DOMException && err.name === "AbortError") return;
         if (typeof console !== "undefined") {
           console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
         }
@@ -1440,6 +1491,7 @@ function infiniteQuery(key, fetcher, options) {
     getNextPageParam,
     getPreviousPageParam,
     initialPageParam = 0,
+    maxPages,
     enabled = true,
     retry: retryOptions,
     onSuccess,
@@ -1463,8 +1515,9 @@ function infiniteQuery(key, fetcher, options) {
   let abortController = null;
   let disposed = false;
   let runId = 0;
-  async function fetchPage(pageParam, direction) {
-    if (disposed) return;
+  let inFlight = null;
+  function fetchPage(pageParam, direction) {
+    if (disposed) return Promise.resolve();
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
@@ -1475,39 +1528,44 @@ function infiniteQuery(key, fetcher, options) {
       if (direction === "prev") setIsFetchingPrev(true);
       setError(void 0);
     });
-    try {
-      const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
-      if (disposed || myRun !== runId) return;
-      const currentPages = pages();
-      let newPages;
-      if (direction === "prev") {
-        newPages = [page, ...currentPages];
-      } else {
-        newPages = [...currentPages, page];
+    const promise = (async () => {
+      try {
+        const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
+        if (disposed || myRun !== runId) return;
+        const currentPages = pages();
+        let newPages = direction === "prev" ? [page, ...currentPages] : [...currentPages, page];
+        if (maxPages != null && maxPages > 0 && newPages.length > maxPages) {
+          newPages = direction === "prev" ? newPages.slice(0, maxPages) : newPages.slice(newPages.length - maxPages);
+        }
+        const nextParam = getNextPageParam(newPages[newPages.length - 1], newPages);
+        const prevParam = getPreviousPageParam?.(newPages[0], newPages);
+        batch(() => {
+          setPages(newPages);
+          setNextPageParam(nextParam);
+          setPrevPageParam(prevParam);
+          setIsFetching(false);
+          setIsFetchingNext(false);
+          setIsFetchingPrev(false);
+        });
+        onSuccess?.(newPages);
+      } catch (err) {
+        if (disposed || myRun !== runId) return;
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        batch(() => {
+          setError(errorObj);
+          setIsFetching(false);
+          setIsFetchingNext(false);
+          setIsFetchingPrev(false);
+        });
+        onError?.(errorObj);
       }
-      const nextParam = getNextPageParam(page, newPages);
-      const prevParam = getPreviousPageParam?.(newPages[0], newPages);
-      batch(() => {
-        setPages(newPages);
-        setNextPageParam(nextParam);
-        setPrevPageParam(prevParam);
-        setIsFetching(false);
-        setIsFetchingNext(false);
-        setIsFetchingPrev(false);
-      });
-      onSuccess?.(newPages);
-    } catch (err) {
-      if (disposed || myRun !== runId) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      batch(() => {
-        setError(errorObj);
-        setIsFetching(false);
-        setIsFetchingNext(false);
-        setIsFetchingPrev(false);
-      });
-      onError?.(errorObj);
-    }
+    })();
+    inFlight = promise;
+    void promise.finally(() => {
+      if (inFlight === promise) inFlight = null;
+    });
+    return promise;
   }
   const effectCleanup = effect(() => {
     resolveKey();
@@ -1522,11 +1580,13 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (inFlight) return inFlight;
     const param2 = nextPageParam();
     if (param2 === void 0) return Promise.resolve();
     return fetchPage(param2, "next");
   }
   function fetchPreviousPage() {
+    if (inFlight) return inFlight;
     const param2 = prevPageParam();
     if (param2 === void 0) return Promise.resolve();
     return fetchPage(param2, "prev");
@@ -1565,13 +1625,17 @@ function infiniteQuery(key, fetcher, options) {
 function previous(getter) {
   const [previous2, setPrevious] = signal(void 0);
   let current = getter();
-  effect(() => {
+  const stop2 = effect(() => {
     const next = getter();
     if (!Object.is(next, current)) {
       setPrevious(current);
       current = next;
     }
   });
+  Object.defineProperty(previous2, "dispose", {
+    value: stop2,
+    enumerable: false
+  });
   return previous2;
 }
 
@@ -1579,7 +1643,7 @@ function previous(getter) {
 function debounce(getter, delay) {
   const [debounced, setDebounced] = signal(getter());
   let timer = null;
-  effect(() => {
+  const stop2 = effect(() => {
     const value = getter();
     if (timer !== null) clearTimeout(timer);
     timer = setTimeout(() => {
@@ -1587,6 +1651,16 @@ function debounce(getter, delay) {
       timer = null;
     }, delay);
   });
+  Object.defineProperty(debounced, "dispose", {
+    value: () => {
+      stop2();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    enumerable: false
+  });
   return debounced;
 }
 
@@ -1596,7 +1670,8 @@ function throttle(getter, interval) {
   let cooldown = false;
   let pending = null;
   let lastEmitted = getter();
-  effect(() => {
+  let timer = null;
+  const stop2 = effect(() => {
     const value = getter();
     if (!cooldown) {
       if (!Object.is(value, lastEmitted)) {
@@ -1604,7 +1679,8 @@ function throttle(getter, interval) {
         lastEmitted = value;
         cooldown = true;
         pending = null;
-        setTimeout(() => {
+        timer = setTimeout(() => {
+          timer = null;
           cooldown = false;
           if (pending !== null) {
             const trailingValue = pending.value;
@@ -1618,6 +1694,16 @@ function throttle(getter, interval) {
       pending = { value };
     }
   });
+  Object.defineProperty(throttled, "dispose", {
+    value: () => {
+      stop2();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    enumerable: false
+  });
   return throttled;
 }
 
@@ -1746,28 +1832,45 @@ function idbGet(db, store, key) {
     req.onerror = () => reject(req.error);
   });
 }
-function idbPut(db, store, item) {
+function idbPut(db, store, item, key) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).put(item);
+    if (key !== void 0) tx.objectStore(store).put(item, key);
+    else tx.objectStore(store).put(item);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbPutWithChange(db, item, change) {
+function coalesceAndAddChange(tx, change, keyPath) {
+  const store = tx.objectStore("_changes");
+  const targetKey = change.item[keyPath];
+  const cursorReq = store.openCursor();
+  cursorReq.onsuccess = () => {
+    const cursor = cursorReq.result;
+    if (cursor) {
+      const existing = cursor.value;
+      const k = existing.item[keyPath];
+      if (targetKey != null && k === targetKey) cursor.delete();
+      cursor.continue();
+    } else {
+      store.put(change);
+    }
+  };
+}
+function idbPutWithChange(db, item, change, keyPath) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(["items", "_changes"], "readwrite");
     tx.objectStore("items").put(item);
-    tx.objectStore("_changes").put(change);
+    coalesceAndAddChange(tx, change, keyPath);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbDeleteWithChange(db, key, change) {
+function idbDeleteWithChange(db, key, change, keyPath) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(["items", "_changes"], "readwrite");
     tx.objectStore("items").delete(key);
-    tx.objectStore("_changes").put(change);
+    coalesceAndAddChange(tx, change, keyPath);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
@@ -1827,13 +1930,18 @@ async function offlineStore(options) {
     setPendingCount(changes.length);
   }
   async function put(item) {
-    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() });
+    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() }, keyPath);
     await refreshData();
   }
   async function remove(key) {
     const existing = await idbGet(db, "items", key);
     if (existing) {
-      await idbDeleteWithChange(db, key, { type: "delete", item: existing, timestamp: Date.now() });
+      await idbDeleteWithChange(
+        db,
+        key,
+        { type: "delete", item: existing, timestamp: Date.now() },
+        keyPath
+      );
       await refreshData();
     }
   }
@@ -1859,6 +1967,8 @@ async function offlineStore(options) {
             snapshot.map((e) => e.key)
           );
           if (closed) return;
+        } else if (typeof console !== "undefined") {
+          console.warn(`[offlineStore] push rejected by adapter${result.error ? `: ${result.error}` : ""}`);
         }
       }
       const remoteItems = await adapter.pull(lastSynced());
@@ -1877,7 +1987,7 @@ async function offlineStore(options) {
       await idbPutMany(db, "items", safeRemote);
       if (closed) return;
       const now = Date.now();
-      await idbPut(db, "_meta", now);
+      await idbPut(db, "_meta", now, "lastSynced");
       if (closed) return;
       setLastSynced(now);
       await refreshData();
@@ -1976,14 +2086,20 @@ function loaderData() {
 async function preloadRoute(route, context2, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
+  let onAbort = null;
   if (callerSignal) {
     if (callerSignal.aborted) {
       controller.abort();
     } else {
-      callerSignal.addEventListener("abort", () => controller.abort(), { once: true });
+      onAbort = () => controller.abort();
+      callerSignal.addEventListener("abort", onAbort, { once: true });
     }
   }
-  return route.loader(context2, { signal: controller.signal });
+  try {
+    return await route.loader(context2, { signal: controller.signal });
+  } finally {
+    if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
+  }
 }
 
 // src/ui/socket.ts
@@ -2089,9 +2205,17 @@ function socket(url, options) {
 }
 
 // src/utils/sanitize.ts
+function stripControlChars(value) {
+  return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
+}
+function isEventHandlerAttr(name) {
+  if (name.length < 3) return false;
+  const lower = name.toLowerCase();
+  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
+}
 var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
 function sanitizeUrl(url) {
-  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  const trimmed = stripControlChars(url).trim();
   if (!trimmed) return "";
   const lower = trimmed.toLowerCase();
   let schemeEnd = -1;
@@ -2140,7 +2264,20 @@ function sanitizeCSSValue(value) {
   return value;
 }
 function stripHtml(html2) {
-  return String(html2).replace(/<[^>]*>/g, "");
+  const input2 = String(html2);
+  if (typeof DOMParser !== "undefined") {
+    try {
+      return new DOMParser().parseFromString(input2, "text/html").body.textContent ?? "";
+    } catch {
+    }
+  }
+  let prev;
+  let out = input2;
+  do {
+    prev = out;
+    out = out.replace(/<[^>]*>/g, "");
+  } while (out !== prev);
+  return out.replace(/<[^>]*$/, "");
 }
 var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "href",
@@ -2157,7 +2294,7 @@ var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "data"
 ]);
 function isUrlAttribute(attr) {
-  return URL_ATTRIBUTES.has(attr);
+  return URL_ATTRIBUTES.has(attr.toLowerCase());
 }
 
 // src/ui/stream.ts
@@ -2540,6 +2677,19 @@ function clipboard() {
   return { text: text2, copy, copied, dispose: dispose2 };
 }
 
+// src/utils/guards.ts
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isUnsafeKey(key) {
+  return UNSAFE_KEYS.has(key);
+}
+function stripUnsafeKeys(obj) {
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    if (!isUnsafeKey(k)) out[k] = obj[k];
+  }
+  return out;
+}
+
 // src/browser/dragDrop.ts
 function resolveTarget2(target) {
   return typeof target === "function" ? target : () => target.current;
@@ -2625,10 +2775,7 @@ function dropZone(element, options) {
         const raw = e.dataTransfer.getData("application/json");
         if (raw) {
           try {
-            transferData = JSON.parse(
-              raw,
-              (k, v) => k === "__proto__" || k === "constructor" || k === "prototype" ? void 0 : v
-            );
+            transferData = JSON.parse(raw, (k, v) => isUnsafeKey(k) ? void 0 : v);
           } catch {
             transferData = raw;
           }
@@ -3561,11 +3708,7 @@ function machine(config) {
     }
     if (action) {
       const rawPatch = action(ctx);
-      const next = { ...ctx };
-      for (const key of Object.keys(rawPatch)) {
-        if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-        next[key] = rawPatch[key];
-      }
+      const next = { ...ctx, ...stripUnsafeKeys(rawPatch) };
       setContext(next);
     }
     setState(target);
@@ -3596,10 +3739,7 @@ function machine(config) {
 function persisted(key, initial, options = {}) {
   const storage = options.session ? sessionStorage : localStorage;
   const serialize = options.serialize || JSON.stringify;
-  const safeReviver = (k, v) => {
-    if (k === "__proto__" || k === "constructor" || k === "prototype") return void 0;
-    return v;
-  };
+  const safeReviver = (k, v) => isUnsafeKey(k) ? void 0 : v;
   const deserialize = options.deserialize || ((raw) => JSON.parse(raw, safeReviver));
   const encrypt = options.encrypt;
   const decrypt = options.decrypt;
@@ -3889,6 +4029,7 @@ function deepClone(value) {
     if (Array.isArray(v)) return v.map(clone);
     const out = {};
     for (const k of Object.keys(v)) {
+      if (k === "__proto__") continue;
       out[k] = clone(v[k]);
     }
     return out;
@@ -3906,12 +4047,7 @@ function globalStore(config) {
     const execute = () => {
       const current = getState();
       const rawPatch = actionFn(current, payload);
-      const patch = {};
-      for (const key of Object.keys(rawPatch)) {
-        if (key !== "__proto__" && key !== "constructor" && key !== "prototype") {
-          patch[key] = rawPatch[key];
-        }
-      }
+      const patch = stripUnsafeKeys(rawPatch);
       setState({ ...current, ...patch });
       const newState = getState();
       for (const listener of listeners) {
@@ -3984,7 +4120,7 @@ function withBoundary(name, component) {
 function createSlots(slots) {
   return {
     renderSlot(name, fallback) {
-      const slotFn = slots[name];
+      const slotFn = Object.hasOwn(slots, name) ? slots[name] : void 0;
       if (slotFn) {
         const result = slotFn();
         if (Array.isArray(result)) {
@@ -3998,7 +4134,7 @@ function createSlots(slots) {
       return fallback ? fallback() : null;
     },
     hasSlot(name) {
-      return name in slots;
+      return Object.hasOwn(slots, name);
     }
   };
 }
@@ -4126,11 +4262,17 @@ function transition(element, options = {}) {
   } = options;
   const transitionValue = `${property} ${duration}ms ${easing} ${delay}ms`;
   let activeTimer = null;
+  let pendingResolve = null;
   function cancelPending() {
     if (activeTimer !== null) {
       clearTimeout(activeTimer);
       activeTimer = null;
     }
+    if (pendingResolve !== null) {
+      const resolvePrev = pendingResolve;
+      pendingResolve = null;
+      resolvePrev();
+    }
   }
   function enter() {
     return new Promise((resolve) => {
@@ -4142,11 +4284,13 @@ function transition(element, options = {}) {
       if (activeClass) element.classList.add(activeClass);
       const done = () => {
         activeTimer = null;
+        pendingResolve = null;
         if (enterClass) element.classList.remove(enterClass);
         onEnterDone?.();
         resolve();
       };
       if (duration > 0) {
+        pendingResolve = resolve;
         activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
@@ -4162,11 +4306,13 @@ function transition(element, options = {}) {
       if (enterClass) element.classList.remove(enterClass);
       const done = () => {
         activeTimer = null;
+        pendingResolve = null;
         if (leaveClass) element.classList.remove(leaveClass);
         onLeaveDone?.();
         resolve();
       };
       if (duration > 0) {
+        pendingResolve = resolve;
         activeTimer = setTimeout(done, duration + delay);
       } else {
         done();
@@ -4794,7 +4940,10 @@ function VirtualList(props) {
     const visibleCount = Math.ceil(props.containerHeight / props.itemHeight) + 2 * overscan;
     const endIndex = Math.min(items.length, startIndex + visibleCount);
     content.style.top = `${startIndex * props.itemHeight}px`;
-    content.innerHTML = "";
+    while (content.firstChild) {
+      dispose(content.firstChild);
+      content.removeChild(content.firstChild);
+    }
     for (let i2 = startIndex; i2 < endIndex; i2++) {
       const itemEl = props.renderItem(items[i2], i2);
       itemEl.style.height = `${props.itemHeight}px`;
@@ -4802,7 +4951,7 @@ function VirtualList(props) {
       content.appendChild(itemEl);
     }
   };
-  effect(update);
+  registerDisposer(container, effect(update));
   return container;
 }
 
@@ -4943,7 +5092,10 @@ function inputMask(options) {
           }
         }
       }
-      input2.setSelectionRange(newCursor, newCursor);
+      try {
+        input2.setSelectionRange(newCursor, newCursor);
+      } catch {
+      }
     };
     const onFocus = () => {
       if (!input2.value) {
@@ -4985,9 +5137,12 @@ function aria(element, attrs) {
     const ariaKey = key.startsWith("aria-") ? key : `aria-${key}`;
     if (typeof value === "function") {
       const getter = value;
-      track(() => {
-        element.setAttribute(ariaKey, String(getter()));
-      });
+      registerDisposer(
+        element,
+        track(() => {
+          element.setAttribute(ariaKey, String(getter()));
+        })
+      );
     } else {
       element.setAttribute(ariaKey, String(value));
     }
@@ -5261,11 +5416,6 @@ var _isDev5 = isDev();
 function setProp(el, key, val) {
   el[key] = val;
 }
-function isEventHandlerAttr(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
 function bindAttribute(el, attr, getter) {
   if (isEventHandlerAttr(attr)) {
     if (_isDev5)
@@ -5301,8 +5451,7 @@ function bindAttribute(el, attr, getter) {
       el.setAttribute(attr, isUrlAttribute(attr) ? sanitizeUrl(str) : str);
     }
   }
-  const teardown = track(commit);
-  return teardown;
+  return reactiveBinding(commit);
 }
 
 // src/ui/reactiveAttr.ts
@@ -5662,11 +5811,26 @@ function processQueue() {
     scheduleFrame();
   }
 }
+var TIER_SPEED = { microtask: 0, frame: 1, timeout: 2, idle: 3 };
+function cancelScheduled() {
+  if (scheduledHandle !== null) {
+    if (scheduledKind === "frame") cancelAnimationFrame(scheduledHandle);
+    else if (scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined") cancelIdleCallback(scheduledHandle);
+    else if (scheduledKind === "timeout") clearTimeout(scheduledHandle);
+  }
+  scheduledHandle = null;
+  scheduledKind = null;
+}
 function scheduleFrame() {
-  if (scheduledKind !== null || microtaskScheduled) return;
   const nextTask = taskQueue.find((t) => !t.cancelled);
   if (!nextTask) return;
-  if (nextTask.priority <= Priority.USER_BLOCKING) {
+  const desired = nextTask.priority <= Priority.USER_BLOCKING ? "microtask" : nextTask.priority === Priority.IDLE ? typeof requestIdleCallback !== "undefined" ? "idle" : "timeout" : "frame";
+  if (microtaskScheduled) return;
+  if (scheduledKind !== null) {
+    if (TIER_SPEED[scheduledKind] <= TIER_SPEED[desired]) return;
+    cancelScheduled();
+  }
+  if (desired === "microtask") {
     microtaskScheduled = true;
     scheduledKind = "microtask";
     queueMicrotask(() => {
@@ -5674,22 +5838,20 @@ function scheduleFrame() {
       scheduledKind = null;
       processQueue();
     });
-  } else if (nextTask.priority === Priority.IDLE) {
-    if (typeof requestIdleCallback !== "undefined") {
-      scheduledKind = "idle";
-      scheduledHandle = requestIdleCallback(() => {
-        scheduledKind = null;
-        scheduledHandle = null;
-        processQueue();
-      });
-    } else {
-      scheduledKind = "timeout";
-      scheduledHandle = setTimeout(() => {
-        scheduledKind = null;
-        scheduledHandle = null;
-        processQueue();
-      }, 50);
-    }
+  } else if (desired === "idle") {
+    scheduledKind = "idle";
+    scheduledHandle = requestIdleCallback(() => {
+      scheduledKind = null;
+      scheduledHandle = null;
+      processQueue();
+    });
+  } else if (desired === "timeout") {
+    scheduledKind = "timeout";
+    scheduledHandle = setTimeout(() => {
+      scheduledKind = null;
+      scheduledHandle = null;
+      processQueue();
+    }, 50);
   } else {
     scheduledKind = "frame";
     scheduledHandle = requestAnimationFrame(() => {
@@ -5754,7 +5916,7 @@ function yieldToMain() {
 async function processInChunks(items, processor, chunkSize = 50) {
   for (let i2 = 0; i2 < items.length; i2++) {
     processor(items[i2], i2);
-    if (i2 > 0 && i2 % chunkSize === 0) {
+    if ((i2 + 1) % chunkSize === 0 && i2 + 1 < items.length) {
       await yieldToMain();
     }
   }
@@ -5935,16 +6097,14 @@ function noSideEffect(fn) {
 }
 
 // src/platform/ssr.ts
+function sanitizeUrlAttr(name, value) {
+  return name === "srcset" ? sanitizeSrcset(value) : sanitizeUrl(value);
+}
 var _isDev7 = isDev();
 var SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
 function isSafeAttrName(name) {
   return SAFE_ATTR_NAME.test(name);
 }
-function isEventHandlerAttr2(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
 var URL_ATTRS = /* @__PURE__ */ new Set([
   "href",
   "src",
@@ -6015,11 +6175,11 @@ function renderToString(element) {
   for (const attr of Array.from(element.attributes)) {
     const rawName = attr.name;
     if (!isSafeAttrName(rawName)) continue;
-    if (isEventHandlerAttr2(rawName)) continue;
+    if (isEventHandlerAttr(rawName)) continue;
     const lowerName = rawName.toLowerCase();
     let value = attr.value;
     if (URL_ATTRS.has(lowerName)) {
-      value = sanitizeUrl(value);
+      value = sanitizeUrlAttr(lowerName, value);
       if (!value) continue;
     }
     html2 += ` ${rawName}="${escapeAttr(value)}"`;
@@ -6156,11 +6316,11 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
   for (const rawKey of Object.keys(attrs)) {
     if (!Object.hasOwn(attrs, rawKey)) continue;
     if (!isSafeAttrName(rawKey)) continue;
-    if (!allowEventHandlers && isEventHandlerAttr2(rawKey)) continue;
+    if (!allowEventHandlers && isEventHandlerAttr(rawKey)) continue;
     const lowerKey = rawKey.toLowerCase();
     let value = String(attrs[rawKey]);
     if (URL_ATTRS.has(lowerKey)) {
-      value = sanitizeUrl(value);
+      value = sanitizeUrlAttr(lowerKey, value);
       if (!value) continue;
     }
     out.push(`${rawKey}="${escapeAttr(value)}"`);
@@ -6168,12 +6328,17 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
   return out.join(" ");
 }
 function isDangerousMetaRefresh(metaProps) {
-  const httpEquiv = metaProps["http-equiv"];
+  let httpEquiv;
+  let content;
+  for (const k in metaProps) {
+    const lk = k.toLowerCase();
+    if (lk === "http-equiv") httpEquiv = metaProps[k];
+    else if (lk === "content") content = metaProps[k];
+  }
   if (typeof httpEquiv !== "string") return false;
   if (httpEquiv.toLowerCase() !== "refresh") return false;
-  const content = metaProps.content;
   if (typeof content !== "string") return false;
-  const normalized = content.replace(/[\x00-\x20\x7f-\x9f]+/g, "").toLowerCase();
+  const normalized = stripControlChars(content).toLowerCase();
   return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
 }
 function renderToDocument(component, options = {}) {
@@ -6251,11 +6416,11 @@ async function* renderToStream(element) {
   for (const attr of Array.from(element.attributes)) {
     const rawName = attr.name;
     if (!isSafeAttrName(rawName)) continue;
-    if (isEventHandlerAttr2(rawName)) continue;
+    if (isEventHandlerAttr(rawName)) continue;
     const lowerName = rawName.toLowerCase();
     let value = attr.value;
     if (URL_ATTRS.has(lowerName)) {
-      value = sanitizeUrl(value);
+      value = sanitizeUrlAttr(lowerName, value);
       if (!value) continue;
     }
     openTag += ` ${rawName}="${escapeAttr(value)}"`;
@@ -6332,11 +6497,11 @@ function hydrateProgressively(container, islands, options) {
       (entries) => {
         for (const entry of entries) {
           if (entry.isIntersecting) {
+            observer.disconnect();
             const clientTree = factory();
             clientTree.setAttribute("data-sibu-island", id);
             clientTree.setAttribute("data-sibu-hydrated", "true");
             marker2.replaceWith(clientTree);
-            observer.disconnect();
             break;
           }
         }
@@ -6593,6 +6758,12 @@ function denormalize(id, entities, schema) {
 }
 
 // src/performance/chunkLoader.ts
+function clearChildren(el) {
+  while (el.firstChild) {
+    dispose(el.firstChild);
+    el.removeChild(el.firstChild);
+  }
+}
 function createChunkRegistry(config = {}) {
   const {
     maxCacheSize = 50,
@@ -6757,10 +6928,10 @@ function lazyChunk(id, loader, registry, fallback) {
       const mod = await loader();
       return typeof mod === "function" ? mod : mod.default;
     }).then((component) => {
-      container.innerHTML = "";
+      clearChildren(container);
       container.appendChild(component());
     }).catch((err) => {
-      container.innerHTML = "";
+      clearChildren(container);
       const errorEl = document.createElement("div");
       errorEl.textContent = `Failed to load chunk '${id}': ${err.message}`;
       container.appendChild(errorEl);
@@ -6787,24 +6958,28 @@ function sanitizeHeadAttr(key, value) {
   if (HEAD_URL_ATTRS.has(key)) return sanitizeUrl(value);
   return value;
 }
+function isDangerousRefreshContent(content) {
+  const normalized = stripControlChars(content).toLowerCase();
+  return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
+}
+function getMetaAttr(metaProps, name) {
+  for (const k in metaProps) {
+    if (k.toLowerCase() === name) return metaProps[k];
+  }
+  return void 0;
+}
 function isDangerousMetaRefresh2(metaProps) {
-  const httpEquiv = metaProps["http-equiv"];
+  const httpEquiv = getMetaAttr(metaProps, "http-equiv");
   if (typeof httpEquiv !== "string") return false;
   if (httpEquiv.toLowerCase() !== "refresh") return false;
-  const content = metaProps.content;
+  const content = getMetaAttr(metaProps, "content");
   if (typeof content !== "string") return false;
-  const normalized = content.replace(/[\x00-\x20\x7f-\x9f]+/g, "").toLowerCase();
-  return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
+  return isDangerousRefreshContent(content);
 }
 var SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-function isEventHandlerAttr3(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
 function isSafeHeadAttr(name) {
   if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
-  if (isEventHandlerAttr3(name)) return false;
+  if (isEventHandlerAttr(name)) return false;
   return true;
 }
 function escapeScriptJsonLocal(json) {
@@ -6837,15 +7012,27 @@ function Head(props) {
     if (props.meta) {
       for (const metaProps of props.meta) {
         if (isDangerousMetaRefresh2(metaProps)) continue;
+        const httpEquiv = getMetaAttr(metaProps, "http-equiv");
+        const isRefreshNow = () => {
+          const eq = typeof httpEquiv === "function" ? httpEquiv() : httpEquiv;
+          return typeof eq === "string" && eq.toLowerCase() === "refresh";
+        };
         const el = document.createElement("meta");
         for (const [key, value] of Object.entries(metaProps)) {
           if (!isSafeHeadAttr(key)) continue;
+          const isContent = key.toLowerCase() === "content";
           if (typeof value === "function") {
             const cleanupFn = effect(() => {
-              el.setAttribute(key, sanitizeHeadAttr(key, value()));
+              const resolved = value();
+              if (isContent && isRefreshNow() && isDangerousRefreshContent(resolved)) {
+                el.removeAttribute(key);
+                return;
+              }
+              el.setAttribute(key, sanitizeHeadAttr(key, resolved));
             });
             effectCleanups.push(cleanupFn);
           } else {
+            if (isContent && isRefreshNow() && isDangerousRefreshContent(value)) continue;
             el.setAttribute(key, sanitizeHeadAttr(key, value));
           }
         }
@@ -7379,6 +7566,7 @@ function bindChildNode(placeholder, getter) {
     if (result == null || typeof result === "boolean") {
       for (let i2 = 0; i2 < lastNodes.length; i2++) {
         const node = lastNodes[i2];
+        dispose(node);
         if (node.parentNode) node.parentNode.removeChild(node);
       }
       lastNodes.length = 0;
@@ -7420,22 +7608,20 @@ function bindChildNode(placeholder, getter) {
     for (let i2 = 0; i2 < lastNodes.length; i2++) {
       const node = lastNodes[i2];
       if (reused?.has(node)) continue;
+      dispose(node);
       if (node.parentNode) node.parentNode.removeChild(node);
     }
-    const anchor = placeholder.nextSibling;
+    let prev = placeholder;
     for (let i2 = 0; i2 < newNodes.length; i2++) {
       const node = newNodes[i2];
-      if (reused?.has(node) && node.parentNode === parent) {
-        if (node.nextSibling !== anchor) {
-          parent.insertBefore(node, anchor);
-        }
-      } else {
-        parent.insertBefore(node, anchor);
+      if (prev.nextSibling !== node) {
+        parent.insertBefore(node, prev.nextSibling);
       }
+      prev = node;
     }
     lastNodes = newNodes;
   }
-  return track(commit);
+  return reactiveBinding(commit);
 }
 
 // src/core/rendering/tagFactory.ts
@@ -7464,6 +7650,18 @@ var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
 function setProp2(el, key, val) {
   el[key] = val;
 }
+function looksLikeClassList(s2) {
+  const t = s2.trim();
+  if (!t) return false;
+  const tokens = t.split(/\s+/);
+  let sawClassish = false;
+  for (let i2 = 0; i2 < tokens.length; i2++) {
+    const tok = tokens[i2];
+    if (!/^-?[A-Za-z_][A-Za-z0-9_:/.-]*$/.test(tok)) return false;
+    if (/[-:/0-9]/.test(tok)) sawClassish = true;
+  }
+  return sawClassish;
+}
 var kebabCache = /* @__PURE__ */ new Map();
 function toKebab(prop) {
   let cached = kebabCache.get(prop);
@@ -7599,6 +7797,11 @@ var tagFactory = (tag, ns) => {
         appendChildren(el, second);
         return el;
       }
+      if (_isDev9 && looksLikeClassList(first)) {
+        devWarn(
+          `tagFactory: lone string "${first}" looks like a class list but is being rendered as TEXT. For a class, use ${tag}({ class: "${first}" }) \u2014 or ${tag}("${first}", children) to set the class AND add children.`
+        );
+      }
       el.textContent = first;
       return el;
     }
@@ -7656,7 +7859,7 @@ var tagFactory = (tag, ns) => {
           const value = props[key];
           if (value == null) continue;
           const lkey = key.toLowerCase();
-          if (lkey[0] === "o" && lkey[1] === "n") continue;
+          if (isEventHandlerAttr(key)) continue;
           if (typeof value === "function") {
             registerDisposer(el, bindAttribute(el, key, value));
           } else if (typeof value === "boolean") {
@@ -9011,6 +9214,7 @@ function createBootSequence() {
 // src/devtools/debug.ts
 var debugEnabled = false;
 var perfMarks = /* @__PURE__ */ new Map();
+var MAX_PERF_SAMPLES = 1e3;
 function enableDebug() {
   debugEnabled = true;
   console.log("[SibuJS] Debug mode enabled");
@@ -9035,7 +9239,11 @@ function perfTracker(label2) {
   }
   function endMeasure() {
     const elapsed = globalThis.performance.now() - startTime;
-    perfMarks.get(label2)?.push(elapsed);
+    const marks = perfMarks.get(label2);
+    if (marks) {
+      marks.push(elapsed);
+      if (marks.length > MAX_PERF_SAMPLES) marks.shift();
+    }
     if (debugEnabled) {
       debugLog("Perf", `${label2}: ${elapsed.toFixed(2)}ms`);
     }
@@ -9989,7 +10197,7 @@ function withErrorTracking(name, component, reporter) {
     }
   };
 }
-function formatError(error, context2) {
+function formatError(error, context2, seen = /* @__PURE__ */ new Set([error])) {
   const lines = [];
   const componentLabel = context2?.component ?? (error instanceof SibuError ? error.component : void 0);
   if (componentLabel) {
@@ -10014,10 +10222,11 @@ function formatError(error, context2) {
     lines.push(stackBody);
   }
   const cause = error.cause;
-  if (cause instanceof Error) {
+  if (cause instanceof Error && !seen.has(cause)) {
+    seen.add(cause);
     lines.push("");
     lines.push("Caused by:");
-    lines.push(formatError(cause));
+    lines.push(formatError(cause, context2, seen));
   }
   return lines.join("\n");
 }
@@ -10031,7 +10240,11 @@ function debugValue(value, formatter) {
   const dispose2 = effect(() => {
     const resolved = value();
     entry.value = resolved;
-    entry.label = format(resolved);
+    try {
+      entry.label = format(resolved);
+    } catch (err) {
+      entry.label = `<format error: ${err instanceof Error ? err.message : String(err)}>`;
+    }
   });
   return () => {
     dispose2();
@@ -11495,6 +11708,18 @@ function mobXAdapter(options) {
   return createPlugin("sibu-mobx", (ctx) => {
     const { autorun } = options;
     const disposers = [];
+    function trackDisposer(rawDispose) {
+      let done = false;
+      const wrapped = () => {
+        if (done) return;
+        done = true;
+        const i2 = disposers.indexOf(wrapped);
+        if (i2 >= 0) disposers.splice(i2, 1);
+        rawDispose();
+      };
+      disposers.push(wrapped);
+      return wrapped;
+    }
     function fromMobX(expression) {
       const [getValue, setValue] = signal(void 0);
       const disposer = autorun(() => {
@@ -11503,22 +11728,18 @@ function mobXAdapter(options) {
           setValue(newValue);
         });
       });
-      disposers.push(disposer);
       const getter = (() => getValue());
-      getter.dispose = () => {
-        const i2 = disposers.indexOf(disposer);
-        if (i2 >= 0) disposers.splice(i2, 1);
-        disposer();
-      };
+      getter.dispose = trackDisposer(disposer);
       return getter;
     }
     function toMobX(sibuGetter, callback) {
-      return effect(() => {
+      const stop2 = effect(() => {
         callback(sibuGetter());
       });
+      return trackDisposer(stop2);
     }
     function destroy() {
-      for (const disposer of disposers) {
+      for (const disposer of [...disposers]) {
         disposer();
       }
       disposers.length = 0;
@@ -11979,6 +12200,7 @@ var materialAdapter = componentAdapter(materialConfig);
   inspectSignal,
   intersection,
   invalidateQueries,
+  isDangerousMetaRefresh,
   isDebugEnabled,
   isHMRAvailable,
   isWasmCached,