sibujs 3.4.0 → 4.0.0

package/dist/build.cjs

@@ -1063,8 +1063,9 @@ __export(index_exports, {
   Fragment: () => Fragment,
   KeepAlive: () => KeepAlive,
   Loading: () => Loading,
+  MAX_DRAIN_TEARDOWNS: () => MAX_DRAIN_TEARDOWNS,
   Portal: () => Portal,
-  SVG_NS: () => SVG_NS,
+  SVG_NS: () => SVG_NS2,
   Suspense: () => Suspense,
   __resetIdCounter: () => __resetIdCounter,
   a: () => a,
@@ -1140,6 +1141,7 @@ __export(index_exports, {
   g: () => g,
   getAction: () => getAction,
   getRequestScopedCache: () => getRequestScopedCache,
+  getRuntimeErrorHandler: () => getRuntimeErrorHandler,
   getSSRStore: () => getSSRStore,
   getSlot: () => getSlot,
   h1: () => h1,
@@ -1213,6 +1215,9 @@ __export(index_exports, {
   registerComponent: () => registerComponent,
   registerDisposer: () => registerDisposer,
   registerIsland: () => registerIsland,
+  replaceChildrenSafely: () => replaceChildrenSafely,
+  reportDrainRunaway: () => reportDrainRunaway,
+  reportError: () => reportError,
   resolveComponent: () => resolveComponent,
   retrack: () => retrack2,
   rp: () => rp,
@@ -1226,6 +1231,7 @@ __export(index_exports, {
   select: () => select,
   setGlobalErrorHandler: () => setGlobalErrorHandler,
   setMaxDrainIterations: () => setMaxDrainIterations2,
+  setRuntimeErrorHandler: () => setRuntimeErrorHandler,
   show: () => show,
   signal: () => signal,
   slot: () => slot,
@@ -1265,6 +1271,7 @@ __export(index_exports, {
   u: () => u,
   ul: () => ul,
   unregisterComponent: () => unregisterComponent,
+  unregisterDisposer: () => unregisterDisposer,
   unregisterIsland: () => unregisterIsland,
   untracked: () => untracked2,
   use: () => use,
@@ -1276,6 +1283,103 @@ __export(index_exports, {
   writable: () => writable
 });
 
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g2 = globalThis;
+  const existing = g2[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g2[ERROR_STATE_KEY] = created;
+  return created;
+}
+function setRuntimeErrorHandler(handler) {
+  const s2 = state();
+  const prev = s2.handler;
+  s2.handler = handler;
+  return prev;
+}
+function getRuntimeErrorHandler() {
+  return state().handler;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context2) {
+  return context2.name ? `${context2.phase} "${context2.name}"` : context2.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context2) {
+  const raw = context2.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context: context2 }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self = node;
+  return typeof self.dispatchEvent === "function" ? self : null;
+}
+function defaultReport(error, context2) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context2)}: ${error.message}`, error);
+}
+function reportError(error, context2) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context2)) return;
+    const s2 = state();
+    const handler = s2.handler;
+    if (handler && s2.handlerDepth === 0) {
+      s2.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context2);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s2.handlerDepth--;
+      }
+    }
+    defaultReport(err, context2);
+  });
+}
+
 // src/core/dev.ts
 function isDev() {
   return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
@@ -1300,6 +1404,14 @@ function devWarn(message) {
 
 // src/core/rendering/dispose.ts
 var elementDisposers = /* @__PURE__ */ new WeakMap();
+var MAX_DRAIN_TEARDOWNS = 1e4;
+function reportDrainRunaway(label2, executed, remaining) {
+  if (typeof console === "undefined") return;
+  console.error(
+    `[SibuJS ${label2}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
+    { executed, remaining }
+  );
+}
 var _isDev2 = isDev();
 var activeBindingCount = 0;
 function registerDisposer(node, teardown) {
@@ -1311,6 +1423,15 @@ function registerDisposer(node, teardown) {
   disposers.push(teardown);
   if (_isDev2) activeBindingCount++;
 }
+function unregisterDisposer(node, teardown) {
+  const disposers = elementDisposers.get(node);
+  if (!disposers) return;
+  const index = disposers.indexOf(teardown);
+  if (index === -1) return;
+  disposers.splice(index, 1);
+  if (_isDev2) activeBindingCount--;
+  if (disposers.length === 0) elementDisposers.delete(node);
+}
 function dispose(node) {
   const stack = [node];
   const order = [];
@@ -1324,40 +1445,47 @@ function dispose(node) {
   }
   for (let i2 = order.length - 1; i2 >= 0; i2--) {
     const current = order[i2];
-    const disposers = elementDisposers.get(current);
-    if (disposers) {
-      const snapshot = disposers.slice();
-      elementDisposers.delete(current);
-      if (_isDev2) activeBindingCount -= snapshot.length;
-      for (const d of snapshot) {
-        try {
-          d();
-        } catch (err) {
-          if (_isDev2 && typeof console !== "undefined") {
-            console.warn("[SibuJS] Disposer threw during cleanup:", err);
-          }
-        }
-      }
-      let extraPasses = 0;
-      while (extraPasses++ < 8) {
-        const added = elementDisposers.get(current);
-        if (!added || added.length === 0) break;
-        const moreSnapshot = added.slice();
+    if (elementDisposers.has(current)) {
+      let executed = 0;
+      let runaway = false;
+      while (!runaway) {
+        const pending = elementDisposers.get(current);
+        if (!pending || pending.length === 0) break;
+        const snapshot = pending.slice();
         elementDisposers.delete(current);
-        if (_isDev2) activeBindingCount -= moreSnapshot.length;
-        for (const d of moreSnapshot) {
+        if (_isDev2) activeBindingCount -= snapshot.length;
+        for (let i3 = 0; i3 < snapshot.length; i3++) {
+          if (executed >= MAX_DRAIN_TEARDOWNS) {
+            const rest = snapshot.slice(i3);
+            const added = elementDisposers.get(current);
+            elementDisposers.set(current, added ? rest.concat(added) : rest);
+            if (_isDev2) activeBindingCount += rest.length;
+            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+            runaway = true;
+            break;
+          }
+          executed++;
           try {
-            d();
+            snapshot[i3]();
           } catch (err) {
-            if (_isDev2 && typeof console !== "undefined") {
-              console.warn("[SibuJS] Disposer threw during cleanup:", err);
-            }
+            reportError(err, { phase: "cleanup", name: "disposer" });
           }
         }
       }
     }
   }
 }
+function replaceChildrenSafely(parent, ...next) {
+  for (let i2 = 0; i2 < next.length; i2++) {
+    const node = next[i2];
+    node.parentNode?.removeChild(node);
+  }
+  const current = Array.from(parent.childNodes);
+  for (let i2 = 0; i2 < current.length; i2++) {
+    dispose(current[i2]);
+  }
+  parent.replaceChildren(...next);
+}
 function checkLeaks(warnThreshold = 0) {
   if (!_isDev2) return 0;
   if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
@@ -1378,10 +1506,12 @@ function isEventHandlerAttr(name) {
   return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
 }
 var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
+var OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
 function sanitizeUrl(url) {
-  const trimmed = stripControlChars(url).trim();
-  if (!trimmed) return "";
-  const lower = trimmed.toLowerCase();
+  const probe = stripControlChars(url).trim();
+  if (!probe) return "";
+  const output2 = url.replace(OUTER_TRIM, "");
+  const lower = probe.toLowerCase();
   let schemeEnd = -1;
   for (let i2 = 0; i2 < lower.length; i2++) {
     const ch = lower.charCodeAt(i2);
@@ -1391,12 +1521,13 @@ function sanitizeUrl(url) {
     }
     if (ch === 47 || ch === 63 || ch === 35) break;
   }
-  if (schemeEnd === -1) return trimmed;
+  if (schemeEnd === -1) return output2;
   const scheme = lower.slice(0, schemeEnd + 1);
-  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return trimmed;
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output2;
   if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
-  return trimmed;
+  return output2;
 }
+var SRCSET_DESCRIPTOR = /^\s+\d+(\.\d+)?[wx]$/;
 function sanitizeSrcset(value) {
   const parts = value.split(",");
   const out = [];
@@ -1405,6 +1536,7 @@ function sanitizeSrcset(value) {
     if (!part) continue;
     const m = part.match(/^(\S+)(\s+.+)?$/);
     if (!m) continue;
+    if (m[2] !== void 0 && !SRCSET_DESCRIPTOR.test(m[2])) continue;
     const safe = sanitizeUrl(m[1]);
     if (!safe) continue;
     out.push(m[2] ? `${safe}${m[2]}` : safe);
@@ -1412,23 +1544,83 @@ function sanitizeSrcset(value) {
   return out.join(", ");
 }
 var CSS_DANGER_GATE = /[(:@\\]/;
+function isCssWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function isHexDigit(ch) {
+  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+}
+function decodeCssEscapes(value) {
+  let out = "";
+  for (let i2 = 0; i2 < value.length; i2++) {
+    const ch = value[i2];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    if (i2 + 1 >= value.length) break;
+    const next = value[i2 + 1];
+    if (next === "\n" || next === "\f") {
+      i2 += 1;
+      continue;
+    }
+    if (next === "\r") {
+      i2 += value[i2 + 2] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (isHexDigit(next)) {
+      let hex = "";
+      let j = i2 + 1;
+      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
+        hex += value[j];
+        j++;
+      }
+      if (j < value.length && isCssWhitespace(value[j])) {
+        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
+      }
+      const code2 = Number.parseInt(hex, 16);
+      const invalid = code2 === 0 || code2 > 1114111 || code2 >= 55296 && code2 <= 57343;
+      out += invalid ? "\uFFFD" : String.fromCodePoint(code2);
+      i2 = j - 1;
+      continue;
+    }
+    out += next;
+    i2 += 1;
+  }
+  return out;
+}
 function sanitizeCSSValue(value) {
   if (!CSS_DANGER_GATE.test(value)) return value;
-  const decoded = value.replace(/\\([0-9a-fA-F]{1,6})\s?/g, (_m, hex) => {
-    const code2 = Number.parseInt(hex, 16);
-    if (!Number.isFinite(code2) || code2 < 0 || code2 > 1114111) return "";
-    try {
-      return String.fromCodePoint(code2);
-    } catch {
-      return "";
-    }
-  });
-  const lower = decoded.toLowerCase().replace(/\s+/g, "");
+  const normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
+  const lower = normalized.toLowerCase().replace(/\s+/g, "");
   if (lower.includes("url(") || lower.includes("expression(") || lower.includes("javascript:") || lower.includes("vbscript:") || lower.includes("-moz-binding") || lower.includes("behavior:") || lower.includes("@import") || lower.includes("image-set(") || lower.includes("filter:progid")) {
     return "";
   }
   return value;
 }
+function sanitizeStyleAttribute(cssText) {
+  const input2 = String(cssText);
+  if (input2.trim() === "") return "";
+  if (typeof document === "undefined") {
+    return sanitizeCSSValue(input2) === "" ? "" : input2;
+  }
+  const probe = document.createElement("div");
+  try {
+    probe.style.cssText = input2;
+  } catch {
+    return "";
+  }
+  const declarations = [];
+  for (let i2 = 0; i2 < probe.style.length; i2++) {
+    const property = probe.style[i2];
+    const value = probe.style.getPropertyValue(property);
+    if (sanitizeCSSValue(value) === "") continue;
+    if (sanitizeCSSValue(`${property}:${value}`) === "") continue;
+    const priority = probe.style.getPropertyPriority(property);
+    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
+  }
+  return declarations.join("; ");
+}
 var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "href",
   "xlink:href",
@@ -1441,20 +1633,101 @@ var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "background",
   "srcset",
   "ping",
-  "data"
+  "data",
+  // `<html manifest>` is a URL sink too. It was carried only by the SSR
+  // serializers' private copy of this set; folding that copy into this one would
+  // otherwise have silently dropped its coverage.
+  "manifest"
 ]);
-function isUrlAttribute(attr) {
-  return URL_ATTRIBUTES.has(attr.toLowerCase());
+var HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
+function isHtmlContentAttribute(name) {
+  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
 }
 function sanitizeAttributeString(attr, value) {
   const lower = attr.toLowerCase();
   if (lower === "srcset") return sanitizeSrcset(value);
   if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
+  if (lower === "style") return sanitizeStyleAttribute(value);
   return value;
 }
 
-// src/reactivity/track-core.ts
+// src/utils/setSafeAttribute.ts
 var _isDev3 = isDev();
+var HTML_NS = "http://www.w3.org/1999/xhtml";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
+function isHtmlElement(el) {
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS;
+}
+function setProp(el, key, val) {
+  el[key] = val;
+}
+function namespaceFor(el, name) {
+  if (el.namespaceURI !== SVG_NS) return null;
+  const lower = name.toLowerCase();
+  if (lower.startsWith("xlink:")) return XLINK_NS;
+  if (lower.startsWith("xml:")) return XML_NS;
+  return null;
+}
+function setSafeAttribute(el, name, value, options = {}) {
+  const ns = namespaceFor(el, name);
+  const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
+  if (isEventHandlerAttr(name)) {
+    if (_isDev3) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set event-handler attribute "${name}". Its value would be evaluated as JavaScript. Use on:{ ${name.slice(2)}: fn } instead.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  if (value == null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
+  if (isHtmlContentAttribute(name)) {
+    if (_isDev3) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set "${name}". The browser parses this attribute as a nested HTML document, so a generic string value cannot be made safe \u2014 attribute escaping is undone before the parse. Build the frame's content another way.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  const html3 = isHtmlElement(el);
+  const idlName = html3 ? name.toLowerCase() : name;
+  if (typeof value === "boolean") {
+    if (html3 && BOOLEAN_IDL_ATTRS.has(idlName) && idlName in el) {
+      setProp(el, idlName, value);
+    } else if (value) {
+      if (ns) el.setAttributeNS(ns, name, "");
+      else el.setAttribute(name, "");
+    } else if (ns) {
+      el.removeAttributeNS(ns, localName);
+    } else {
+      el.removeAttribute(name);
+    }
+    return true;
+  }
+  const str = String(value);
+  if (options.syncValueProperty !== false && html3 && (idlName === "value" || idlName === "checked") && idlName in el) {
+    setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
+    return true;
+  }
+  const safe = sanitizeAttributeString(name, str);
+  const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
+  if (current === safe) return true;
+  if (ns) el.setAttributeNS(ns, name, safe);
+  else el.setAttribute(name, safe);
+  return true;
+}
+
+// src/reactivity/track-core.ts
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -1462,6 +1735,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -1546,8 +1820,27 @@ function safeInvoke(sub2) {
   try {
     sub2();
   } catch (err) {
-    if (_isDev3) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s2 = sub2;
+    reportError(err, { phase: s2._errorPhase ?? "effect", name: s2.__name, node: s2._errorNode });
+  }
+}
+function depsChanged(sub2) {
+  let node = sub2.depsHead ?? null;
+  if (node === null) return true;
+  while (node !== null) {
+    const sig = node.sig;
+    if (sig === null) return true;
+    if (sig._d === true && sig._validate !== void 0) {
+      try {
+        sig._validate();
+      } catch {
+        return true;
+      }
+    }
+    if (node.depVersion !== sig.__v) return true;
+    node = node.subNext;
   }
+  return false;
 }
 var suspendDepth = 0;
 var trackingSuspended = false;
@@ -1629,7 +1922,7 @@ function track(effectFn, subscriber) {
   const sub2 = subscriber;
   return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s2 = subscriber;
     if (s2._disposed || s2._reentrant) return;
@@ -1645,13 +1938,17 @@ function reactiveBinding(commit) {
   subscriber.depsTail = null;
   subscriber._epoch = 0;
   subscriber._structDirty = false;
+  subscriber._hasComputedDep = false;
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
   subscriber._disposed = false;
+  subscriber._errorPhase = "binding";
+  subscriber._errorNode = ownerNode;
   run();
   return subscriber._dispose ?? (subscriber._dispose = () => {
     subscriber._disposed = true;
+    subscriber._errorNode = void 0;
     cleanup(subscriber);
   });
 }
@@ -1663,9 +1960,12 @@ function recordDependency(signal2) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub2) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub2._hasComputedDep = true;
   const node = allocNode(signal2, sub2, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub2, node);
@@ -1684,9 +1984,10 @@ function cleanup(subscriber) {
     node = next;
   }
 }
-var maxSubscriberRepeats = 50;
+var maxSubscriberRepeats = 1e3;
 var maxDrainIterations = 1e6;
 var drainEpoch = 0;
+var quarantined = /* @__PURE__ */ new Set();
 function setMaxSubscriberRepeats(n) {
   const prev = maxSubscriberRepeats;
   if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
@@ -1708,19 +2009,21 @@ function tickRepeat(sub2) {
   return s2._runs > maxSubscriberRepeats;
 }
 function cycleError(sub2) {
-  if (typeof console !== "undefined") {
-    const name = sub2.__name ?? "<unnamed>";
-    console.error(
-      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
-    );
-  }
+  const name = sub2.__name ?? "<unnamed>";
+  reportError(
+    new Error(
+      `subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. This subscriber is quarantined for the rest of this update; other pending work still runs.`
+    ),
+    { phase: "scheduler", name }
+  );
 }
 function absoluteDrainError() {
-  if (typeof console !== "undefined") {
-    console.error(
-      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
-    );
-  }
+  reportError(
+    new Error(
+      `Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    ),
+    { phase: "scheduler" }
+  );
 }
 function drainQueue() {
   let i2 = 0;
@@ -1730,11 +2033,14 @@ function drainQueue() {
       break;
     }
     const sub2 = pendingQueue[i2++];
+    pendingSet.delete(sub2);
+    if (quarantined.size > 0 && quarantined.has(sub2)) continue;
+    if (sub2._hasComputedDep === true && !depsChanged(sub2)) continue;
     if (tickRepeat(sub2)) {
       cycleError(sub2);
-      break;
+      quarantined.add(sub2);
+      continue;
     }
-    pendingSet.delete(sub2);
     safeInvoke(sub2);
   }
 }
@@ -1749,6 +2055,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -1842,6 +2149,7 @@ function notifySubscribers(signal2) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -1869,7 +2177,7 @@ function forEachSubscriber(signal2, visit) {
 
 // src/reactivity/track.ts
 var _isDev4 = isDev();
-var _runtimeVersion = true ? "3.4.0" : "dev";
+var _runtimeVersion = true ? "4.0.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -1926,16 +2234,9 @@ var getSubscriberDeps2 = API.getSubscriberDeps;
 var forEachSubscriber2 = API.forEachSubscriber;
 
 // src/reactivity/bindAttribute.ts
-var _isDev5 = isDev();
-function setProp(el, key, val) {
-  el[key] = val;
-}
 function bindAttribute(el, attr, getter) {
   if (isEventHandlerAttr(attr)) {
-    if (_isDev5)
-      devWarn(
-        `bindAttribute: refusing to bind event-handler attribute "${attr}". Use on:{ ${attr.slice(2)}: fn } instead.`
-      );
+    setSafeAttribute(el, attr, "", { label: `bindAttribute("${attr}")` });
     return () => {
     };
   }
@@ -1944,28 +2245,12 @@ function bindAttribute(el, attr, getter) {
     try {
       value = getter();
     } catch (err) {
-      if (_isDev5)
-        devWarn(`bindAttribute: getter for "${attr}" threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
       return;
     }
-    if (typeof value === "boolean") {
-      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
-        setProp(el, attr, value);
-      } else if (value) {
-        el.setAttribute(attr, "");
-      } else {
-        el.removeAttribute(attr);
-      }
-      return;
-    }
-    const str = String(value);
-    if ((attr === "value" || attr === "checked") && attr in el) {
-      setProp(el, attr, attr === "checked" ? Boolean(value) : str);
-    } else {
-      el.setAttribute(attr, sanitizeAttributeString(attr, str));
-    }
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
   }
-  return reactiveBinding2(commit);
+  return reactiveBinding2(commit, el);
 }
 function bindDynamic(el, nameGetter, valueGetter) {
   let prevName = null;
@@ -1974,29 +2259,24 @@ function bindDynamic(el, nameGetter, valueGetter) {
     try {
       name = typeof nameGetter === "function" ? nameGetter() : nameGetter;
     } catch (err) {
-      if (_isDev5) devWarn(`bindDynamic: name getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: "bindDynamic (name getter)", node: el });
       return;
     }
     let value;
     try {
       value = typeof valueGetter === "function" ? valueGetter() : valueGetter;
     } catch (err) {
-      if (_isDev5) devWarn(`bindDynamic: value getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: "bindDynamic (value getter)", node: el });
       return;
     }
-    if (isEventHandlerAttr(name)) return;
     if (prevName !== null && prevName !== name) {
       el.removeAttribute(prevName);
+      prevName = null;
     }
-    const str = String(value);
-    if ((name === "value" || name === "checked") && name in el) {
-      setProp(el, name, name === "checked" ? Boolean(value) : str);
-    } else {
-      el.setAttribute(name, sanitizeAttributeString(name, str));
-    }
+    if (!setSafeAttribute(el, name, value, { label: "bindDynamic" })) return;
     prevName = name;
   }
-  const teardown = reactiveBinding2(commit);
+  const teardown = reactiveBinding2(commit, el);
   return () => {
     teardown();
     if (prevName !== null) {
@@ -2006,7 +2286,7 @@ function bindDynamic(el, nameGetter, valueGetter) {
 }
 
 // src/reactivity/bindChildNode.ts
-var _isDev6 = isDev();
+var _isDev5 = isDev();
 function bindChildNode(placeholder, getter) {
   let lastNodes = [];
   function commit() {
@@ -2014,7 +2294,7 @@ function bindChildNode(placeholder, getter) {
     try {
       result = getter();
     } catch (err) {
-      if (_isDev6) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: "bindChildNode", node: placeholder });
       return;
     }
     if (result == null || typeof result === "boolean") {
@@ -2040,7 +2320,7 @@ function bindChildNode(placeholder, getter) {
         if (item == null || typeof item === "boolean") continue;
         const node = item instanceof Node ? item : document.createTextNode(String(item));
         if (seen.has(node)) {
-          if (_isDev6)
+          if (_isDev5)
             devWarn("bindChildNode: duplicate node reference in array \u2014 only the first occurrence is rendered.");
           continue;
         }
@@ -2075,12 +2355,12 @@ function bindChildNode(placeholder, getter) {
     }
     lastNodes = newNodes;
   }
-  return reactiveBinding2(commit);
+  return reactiveBinding2(commit, placeholder);
 }
 
 // src/core/rendering/tagFactory.ts
-var SVG_NS = "http://www.w3.org/2000/svg";
-var _isDev7 = isDev();
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+var _isDev6 = isDev();
 var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
 function isBlockedTag(tag) {
   return BLOCKED_TAGS.has(tag.toLowerCase());
@@ -2098,9 +2378,6 @@ var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "self",
   "frames"
 ]);
-function setProp2(el, key, val) {
-  el[key] = val;
-}
 function looksLikeClassList(s2) {
   const t = s2.trim();
   if (!t) return false;
@@ -2124,13 +2401,13 @@ function toKebab(prop) {
 function applyStyle(el, style2) {
   if (typeof style2 === "function") {
     const teardown = track2(() => {
-      el.setAttribute("style", style2());
+      el.setAttribute("style", sanitizeStyleAttribute(String(style2())));
     });
     registerDisposer(el, teardown);
     return;
   }
   if (typeof style2 === "string") {
-    el.setAttribute("style", style2);
+    el.setAttribute("style", sanitizeStyleAttribute(style2));
     return;
   }
   const htmlEl = el;
@@ -2251,7 +2528,7 @@ var tagFactory = (tag, ns) => {
         appendChildren(el, second);
         return el;
       }
-      if (_isDev7 && looksLikeClassList(first)) {
+      if (_isDev6 && 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.`
         );
@@ -2272,7 +2549,7 @@ var tagFactory = (tag, ns) => {
     if (pClass != null) applyClass(el, pClass);
     const pId = props.id;
     if (pId != null) {
-      if (_isDev7 && typeof pId === "string" && CLOBBER_RISKY_IDS.has(pId.toLowerCase())) {
+      if (_isDev6 && typeof pId === "string" && CLOBBER_RISKY_IDS.has(pId.toLowerCase())) {
         devWarn(
           `tagFactory: element id="${pId}" matches a common global and may cause DOM clobbering. Avoid setting ids from untrusted input.`
         );
@@ -2287,7 +2564,7 @@ var tagFactory = (tag, ns) => {
         const handler = pOn[ev];
         if (typeof handler === "function") {
           el.addEventListener(ev, handler);
-        } else if (_isDev7) {
+        } else if (_isDev6) {
           devWarn(
             `tagFactory: on.${ev} handler is not a function (got ${typeof handler}). Event listener was not attached.`
           );
@@ -2315,16 +2592,8 @@ var tagFactory = (tag, ns) => {
           if (isEventHandlerAttr(key)) continue;
           if (typeof value === "function") {
             registerDisposer(el, bindAttribute(el, key, value));
-          } else if (typeof value === "boolean") {
-            if (key in el && (key === "checked" || key === "disabled" || key === "selected")) {
-              setProp2(el, key, value);
-            } else if (value) {
-              el.setAttribute(key, "");
-            } else {
-              el.removeAttribute(key);
-            }
           } else {
-            el.setAttribute(key, sanitizeAttributeString(key, String(value)));
+            setSafeAttribute(el, key, value, { syncValueProperty: false, label: "tagFactory" });
           }
         }
       }
@@ -2409,7 +2678,7 @@ var param = tagFactory("param");
 var picture = tagFactory("picture");
 var portal = tagFactory("portal");
 var source = tagFactory("source");
-var svg = tagFactory("svg", SVG_NS);
+var svg = tagFactory("svg", SVG_NS2);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -2450,26 +2719,26 @@ var base = tagFactory("base");
 var link = tagFactory("link");
 var meta = tagFactory("meta");
 var style = tagFactory("style");
-var circle = tagFactory("circle", SVG_NS);
-var ellipse = tagFactory("ellipse", SVG_NS);
-var g = tagFactory("g", SVG_NS);
-var line = tagFactory("line", SVG_NS);
-var path = tagFactory("path", SVG_NS);
-var polygon = tagFactory("polygon", SVG_NS);
-var polyline = tagFactory("polyline", SVG_NS);
-var rect = tagFactory("rect", SVG_NS);
-var text = tagFactory("text", SVG_NS);
-var tspan = tagFactory("tspan", SVG_NS);
-var defs = tagFactory("defs", SVG_NS);
-var clipPath = tagFactory("clipPath", SVG_NS);
-var mask = tagFactory("mask", SVG_NS);
-var pattern = tagFactory("pattern", SVG_NS);
-var linearGradient = tagFactory("linearGradient", SVG_NS);
-var radialGradient = tagFactory("radialGradient", SVG_NS);
-var stop = tagFactory("stop", SVG_NS);
-var use = tagFactory("use", SVG_NS);
-var symbol = tagFactory("symbol", SVG_NS);
-var marker = tagFactory("marker", SVG_NS);
+var circle = tagFactory("circle", SVG_NS2);
+var ellipse = tagFactory("ellipse", SVG_NS2);
+var g = tagFactory("g", SVG_NS2);
+var line = tagFactory("line", SVG_NS2);
+var path = tagFactory("path", SVG_NS2);
+var polygon = tagFactory("polygon", SVG_NS2);
+var polyline = tagFactory("polyline", SVG_NS2);
+var rect = tagFactory("rect", SVG_NS2);
+var text = tagFactory("text", SVG_NS2);
+var tspan = tagFactory("tspan", SVG_NS2);
+var defs = tagFactory("defs", SVG_NS2);
+var clipPath = tagFactory("clipPath", SVG_NS2);
+var mask = tagFactory("mask", SVG_NS2);
+var pattern = tagFactory("pattern", SVG_NS2);
+var linearGradient = tagFactory("linearGradient", SVG_NS2);
+var radialGradient = tagFactory("radialGradient", SVG_NS2);
+var stop = tagFactory("stop", SVG_NS2);
+var use = tagFactory("use", SVG_NS2);
+var symbol = tagFactory("symbol", SVG_NS2);
+var marker = tagFactory("marker", SVG_NS2);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -2478,18 +2747,14 @@ var customElement = (tagName) => tagFactory(tagName);
 // 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;
   });
 }
@@ -2514,12 +2779,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..."));
@@ -2551,7 +2818,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(() => {
@@ -2560,16 +2827,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);
     }
   });
@@ -2581,7 +2847,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;
   }
 }
@@ -2815,20 +3082,35 @@ function detectSSRShared() {
       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");
+      } else if (typeof require === "function") {
+        mod = require("async_hooks");
       }
       if (mod) detected = new mod.AsyncLocalStorage();
     }
   } catch {
     detected = null;
   }
-  return { als: detected, fallbackStore: { ssr: false, suspenseIdCounter: 0 } };
+  return {
+    als: detected,
+    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
+    fallbackDepth: 0
+  };
 }
 var _shared = globalThis[SSR_KEY] ?? (globalThis[SSR_KEY] = detectSSRShared());
 var als = _shared.als;
 var fallbackStore = _shared.fallbackStore;
+_shared.fallbackDepth ?? (_shared.fallbackDepth = 0);
+var _alsWarned = false;
+function warnMissingAsyncLocalStorage() {
+  if (_alsWarned || als) return;
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  if (!isNode) return;
+  _alsWarned = true;
+  const version = process.versions.node;
+  devWarn(
+    `SSR request isolation is UNAVAILABLE on this runtime (Node ${version}). AsyncLocalStorage could not be loaded, so concurrent requests share one SSR store: request state and the query cache can bleed between them. Node >= 22.3 is required for isolated SSR under ESM; the CommonJS build works on older versions. A fully synchronous render is unaffected.`
+  );
+}
 function getSSRStore() {
   if (als) {
     const s2 = als.getStore();
@@ -2857,19 +3139,25 @@ function disableSSR() {
   getSSRStore().ssr = false;
 }
 function runInSSRContext(fn) {
-  const store2 = { ssr: true, suspenseIdCounter: 0 };
+  const store2 = { ssr: true, suspenseIdCounter: 0, locale: void 0 };
   if (als) {
     return als.run(store2, fn);
   }
+  warnMissingAsyncLocalStorage();
   const prevSSR = fallbackStore.ssr;
   const prevCounter = fallbackStore.suspenseIdCounter;
+  const prevLocale = fallbackStore.locale;
   fallbackStore.ssr = true;
   fallbackStore.suspenseIdCounter = 0;
+  fallbackStore.locale = void 0;
+  _shared.fallbackDepth++;
   try {
     return fn();
   } finally {
+    _shared.fallbackDepth--;
     fallbackStore.ssr = prevSSR;
     fallbackStore.suspenseIdCounter = prevCounter;
+    fallbackStore.locale = prevLocale;
   }
 }
 function withSSR(fn) {
@@ -2910,7 +3198,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i2]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -2923,11 +3211,12 @@ function drainReruns(ctx) {
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
-    if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-      console.error(
-        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-      );
-    }
+    reportError(
+      new Error(
+        `effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      ),
+      { phase: "effect" }
+    );
   }
 }
 function disposeEffect(ctx) {
@@ -3004,6 +3293,8 @@ function effect(effectFn, options) {
   sub2.depsTail = null;
   sub2._epoch = 0;
   sub2._structDirty = false;
+  sub2._hasComputedDep = false;
+  sub2._errorPhase = "effect";
   sub2._runEpoch = 0;
   sub2._runs = 0;
   ctx.subscriber = sub2;
@@ -3072,70 +3363,72 @@ var isBatching = API2.isBatching;
 
 // src/core/signals/signal.ts
 var _g2 = globalThis;
-var _isDev8 = isDev();
+var _isDev7 = isDev();
 function signal(initial, options) {
-  const state = {
+  const state2 = {
     value: initial,
     __v: 0,
     __sc: 0,
     subsHead: null,
     subsTail: null,
     __activeNode: null,
-    __name: void 0
+    __name: void 0,
+    _d: false,
+    _validate: void 0
   };
-  const debugName = _isDev8 ? options?.name : void 0;
+  const debugName = _isDev7 ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state.__name = debugName;
+  if (debugName) state2.__name = debugName;
   function get() {
-    recordDependency2(state);
-    return state.value;
+    recordDependency2(state2);
+    return state2.value;
   }
-  get.__signal = state;
+  get.__signal = state2;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state.value = newValue;
-      state.__v++;
-      if (_isDev8) {
+      state2.value = newValue;
+      state2.__v++;
+      if (_isDev7) {
         const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+        if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
-  } else if (_isDev8) {
+  } else if (_isDev7) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
+      state2.value = newValue;
+      state2.__v++;
       const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   } else {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      state2.value = newValue;
+      state2.__v++;
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   }
-  if (_isDev8) {
+  if (_isDev7) {
     const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+    if (hook) hook.emit("signal:create", { signal: state2, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -3347,14 +3640,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 {
@@ -3450,7 +3743,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);
@@ -3700,6 +3993,7 @@ var errorBoundaryStyles = `
     background: #3a3a4e;
   }
 `;
+var RESET_KEY_THREW = /* @__PURE__ */ Symbol("sibujs.ErrorBoundary.resetKeyThrew");
 var stylesInjected = false;
 function injectStyles2() {
   if (!stylesInjected && typeof document !== "undefined") {
@@ -3708,29 +4002,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;
@@ -3738,43 +4009,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;
@@ -3785,18 +4074,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");
     }
@@ -3813,11 +4098,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;
         }
@@ -3830,12 +4124,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(() => {
@@ -3863,7 +4157,7 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
     return void 0;
   }, container);
   registerDisposer(container, () => {
-    if (resetKeysTeardown) resetKeysTeardown();
+    stopResetKeysWatcher();
     container.removeEventListener("sibu:error-propagate", propagateListener);
   });
   return container;
@@ -4113,10 +4407,18 @@ function setGlobalErrorHandler(handler) {
 }
 
 // src/core/rendering/context.ts
+var _isDev8 = isDev();
 function context(defaultValue) {
   const [getValue, setValue] = signal(defaultValue);
+  const warnIfSSR = (method) => {
+    if (!_isDev8 || !isSSR()) return;
+    devWarn(
+      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
+    );
+  };
   const ctx = {
     provide(value) {
+      warnIfSSR("provide");
       const previous = getValue();
       setValue(value);
       return () => setValue(previous);
@@ -4128,13 +4430,21 @@ function context(defaultValue) {
       return getValue();
     },
     set(value) {
+      warnIfSSR("set");
       setValue(value);
     },
     withContext(value, fn) {
+      warnIfSSR("withContext");
       const previous = getValue();
       setValue(value);
       try {
-        return fn();
+        const result = fn();
+        if (_isDev8 && result !== null && typeof result?.then === "function") {
+          devWarn(
+            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
+          );
+        }
+        return result;
       } finally {
         setValue(previous);
       }
@@ -4255,10 +4565,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 = track2(render);
   registerDisposer(container, untrack);
@@ -4319,6 +4626,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);
@@ -4328,8 +4639,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;
@@ -4358,49 +4671,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 = () => untracked2(() => 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 (_isDev9) {
-            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 (_isDev9) {
-                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);
         }
       }
     }
@@ -4409,6 +4717,8 @@ function each(getArray, render, options) {
       const tmp2 = nodeMap;
       nodeMap = workMap;
       workMap = tmp2;
+      initialized = true;
+      pendingCount = 0;
       return;
     }
     oldKeyIndex.clear();
@@ -4458,12 +4768,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 = track2(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();
       }
     });
@@ -4753,7 +5098,7 @@ function parseTemplate(strings) {
   return parseChildren();
 }
 function executeElement(tmpl, values) {
-  const el = tmpl.svg ? document.createElementNS(SVG_NS, tmpl.tag) : document.createElement(tmpl.tag);
+  const el = tmpl.svg ? document.createElementNS(SVG_NS2, tmpl.tag) : document.createElement(tmpl.tag);
   for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
     const attr = tmpl.attrs[i2];
     switch (attr.t) {
@@ -4762,20 +5107,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;
       }
@@ -4785,14 +5121,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: {
@@ -5018,20 +5347,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
+        });
       });
     }
   });
@@ -5128,9 +5449,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)) {
       notifySubscribers2(signal2);
     }
@@ -5250,17 +5572,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);
@@ -5269,14 +5608,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);
@@ -5288,7 +5629,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();
+    }
   };
 }
 
@@ -5408,6 +5758,21 @@ function derived(getter, options) {
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   let evaluating = false;
+  const validate = () => {
+    if (!cs._d) return;
+    const oldValue = cs._v;
+    evaluating = true;
+    try {
+      retrack2(recompute, markDirty);
+      if (!Object.is(oldValue, cs._v)) cs.__v++;
+    } finally {
+      evaluating = false;
+    }
+    if (hook && !Object.is(oldValue, cs._v)) {
+      hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+    }
+  };
+  cs._validate = validate;
   function computedGetter() {
     if (evaluating) {
       throw new Error(
@@ -5415,32 +5780,11 @@ function derived(getter, options) {
       );
     }
     if (isTrackingSuspended2()) {
-      if (cs._d) {
-        const prev = cs._v;
-        evaluating = true;
-        try {
-          retrack2(recompute, markDirty);
-          if (!Object.is(prev, cs._v)) cs.__v++;
-        } finally {
-          evaluating = false;
-        }
-      }
+      if (cs._d) validate();
       return cs._v;
     }
+    if (cs._d) validate();
     recordDependency2(cs);
-    if (cs._d) {
-      const oldValue = cs._v;
-      evaluating = true;
-      try {
-        retrack2(recompute, markDirty);
-        if (!Object.is(oldValue, cs._v)) cs.__v++;
-      } finally {
-        evaluating = false;
-      }
-      if (hook && oldValue !== cs._v) {
-        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
-      }
-    }
     return cs._v;
   }
   if (debugName) {
@@ -5630,6 +5974,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;
@@ -5672,7 +6038,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);
     }
@@ -5680,6 +6046,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_);
@@ -5726,11 +6093,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()" });
           })
         );
       });
@@ -5757,10 +6120,10 @@ function enhance(target, setup) {
         });
       });
     },
-    model: (t, state, options) => {
+    model: (t, state2, options) => {
       bind(t, (el) => {
         const control = el;
-        const [get, set] = state;
+        const [get, set] = state2;
         const evt = options?.event ?? (control instanceof HTMLSelectElement || control instanceof HTMLInputElement && (control.type === "checkbox" || control.type === "radio") ? "change" : "input");
         teardowns.push(
           effect(() => {
@@ -5776,29 +6139,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();
   };
 }
 
@@ -5838,6 +6222,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") ?? "";
@@ -5851,17 +6236,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);
@@ -5874,6 +6265,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();
   };