sibujs 4.5.0 → 4.6.0

package/dist/extras.cjs

@@ -24,6 +24,8 @@ __export(extras_exports, {
   Features: () => Features,
   FocusTrap: () => FocusTrap,
   Head: () => Head,
+  MigrationStorageError: () => MigrationStorageError,
+  PluginInstallCancelledError: () => PluginInstallCancelledError,
   Priority: () => Priority,
   RenderProp: () => RenderProp,
   SibuError: () => SibuError,
@@ -32,6 +34,7 @@ __export(extras_exports, {
   VirtualList: () => VirtualList,
   __resetDialogStack: () => __resetDialogStack,
   __resetQueryCache: () => __resetQueryCache,
+  __resetSpeechCoordinator: () => __resetSpeechCoordinator,
   accordion: () => accordion,
   animate: () => animate,
   animationFrame: () => animationFrame,
@@ -167,6 +170,7 @@ __export(extras_exports, {
   isDangerousMetaRefresh: () => isDangerousMetaRefresh,
   isDebugEnabled: () => isDebugEnabled,
   isHMRAvailable: () => isHMRAvailable,
+  isPluginInstallCancelledError: () => isPluginInstallCancelledError,
   isWasmCached: () => isWasmCached,
   island: () => island,
   keyboard: () => keyboard,
@@ -234,6 +238,7 @@ __export(extras_exports, {
   renderToStream: () => renderToStream,
   renderToString: () => renderToString,
   renderToSuspenseStream: () => renderToSuspenseStream,
+  renderWithLoader: () => renderWithLoader,
   required: () => required,
   resetIdCounter: () => resetIdCounter,
   resetPlugins: () => resetPlugins,
@@ -305,6 +310,7 @@ __export(extras_exports, {
   withBoundary: () => withBoundary,
   withDefaults: () => withDefaults,
   withErrorTracking: () => withErrorTracking,
+  withLoader: () => withLoader,
   withProps: () => withProps,
   withRetry: () => withRetry,
   withScopedStyle: () => withScopedStyle,
@@ -367,8 +373,8 @@ function safeStringify(value) {
     return Object.prototype.toString.call(value);
   }
 }
-function describe(context2) {
-  return context2.name ? `${context2.phase} "${context2.name}"` : context2.phase;
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
 }
 var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function untrackedRun(fn) {
@@ -376,8 +382,8 @@ function untrackedRun(fn) {
   return api?.untracked ? api.untracked(fn) : fn();
 }
 var PROPAGATE_EVENT = "sibu:error-propagate";
-function claimedByBoundary(error, context2) {
-  const raw = context2.node;
+function claimedByBoundary(error, context) {
+  const raw = context.node;
   if (!raw || typeof CustomEvent === "undefined") return false;
   const target = resolveEventTarget(raw);
   if (!target) return false;
@@ -385,7 +391,7 @@ function claimedByBoundary(error, context2) {
     const event = new CustomEvent(PROPAGATE_EVENT, {
       bubbles: true,
       cancelable: true,
-      detail: { error, context: context2 }
+      detail: { error, context }
     });
     return target.dispatchEvent(event) === false;
   } catch {
@@ -404,20 +410,20 @@ function resolveEventTarget(node) {
   const self2 = node;
   return typeof self2.dispatchEvent === "function" ? self2 : null;
 }
-function defaultReport(error, context2) {
+function defaultReport(error, context) {
   if (typeof console === "undefined") return;
-  console.error(`[SibuJS] Uncaught error during ${describe(context2)}: ${error.message}`, error);
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
 }
-function reportError(error, context2) {
+function reportError(error, context) {
   const err = normalizeError(error);
   untrackedRun(() => {
-    if (claimedByBoundary(err, context2)) return;
+    if (claimedByBoundary(err, context)) return;
     const s2 = state();
     const handler = s2.handler;
     if (handler && s2.handlerDepth === 0) {
       s2.handlerDepth++;
       try {
-        handler(error instanceof Error ? error : err, context2);
+        handler(error instanceof Error ? error : err, context);
         return;
       } catch (handlerError) {
         if (typeof console !== "undefined") {
@@ -428,10 +434,158 @@ function reportError(error, context2) {
         s2.handlerDepth--;
       }
     }
-    defaultReport(err, context2);
+    defaultReport(err, context);
   });
 }
 
+// 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 activeBindingCount = 0;
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  if (DEV) activeBindingCount++;
+  const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (capture) capture.entries.push([node, teardown]);
+}
+function withDisposerRollback(build) {
+  const frame = { entries: [], closed: false };
+  const captured = frame.entries;
+  registrationCaptures.push(frame);
+  let result;
+  try {
+    result = build();
+  } catch (err) {
+    let executed = 0;
+    try {
+      while (captured.length > 0) {
+        if (executed >= MAX_DRAIN_TEARDOWNS) {
+          reportDrainRunaway("rollback", executed, captured.length);
+          break;
+        }
+        const [node, teardown] = captured.pop();
+        if (!unregisterDisposer(node, teardown)) continue;
+        executed++;
+        try {
+          teardown();
+        } catch (cleanupErr) {
+          reportError(cleanupErr, { phase: "cleanup", name: "disposer" });
+        }
+      }
+    } finally {
+      frame.closed = true;
+      captured.length = 0;
+      registrationCaptures.pop();
+    }
+    throw err;
+  }
+  frame.closed = true;
+  registrationCaptures.pop();
+  const parent = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (parent) {
+    for (const entry of captured) {
+      if (elementDisposers.get(entry[0])?.includes(entry[1])) parent.entries.push(entry);
+    }
+    frame.forwardTo = parent;
+  }
+  captured.length = 0;
+  return result;
+}
+function unregisterDisposer(node, teardown) {
+  const disposers = elementDisposers.get(node);
+  if (!disposers) return false;
+  const index = disposers.indexOf(teardown);
+  if (index === -1) return false;
+  disposers.splice(index, 1);
+  if (DEV) activeBindingCount--;
+  if (disposers.length === 0) elementDisposers.delete(node);
+  return true;
+}
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i2 = 0; i2 < children.length; i2++) {
+      stack.push(children[i2]);
+    }
+  }
+  for (let i2 = order.length - 1; i2 >= 0; i2--) {
+    disposeNodeOwn(order[i2]);
+  }
+}
+function disposeNodeOwn(node) {
+  if (!elementDisposers.has(node)) return;
+  let executed = 0;
+  let runaway = false;
+  while (!runaway) {
+    const pending = elementDisposers.get(node);
+    if (!pending || pending.length === 0) break;
+    const snapshot = pending.slice();
+    elementDisposers.delete(node);
+    if (DEV) activeBindingCount -= snapshot.length;
+    for (let i2 = 0; i2 < snapshot.length; i2++) {
+      if (executed >= MAX_DRAIN_TEARDOWNS) {
+        const rest = snapshot.slice(i2);
+        const added = elementDisposers.get(node);
+        elementDisposers.set(node, added ? rest.concat(added) : rest);
+        if (DEV) activeBindingCount += rest.length;
+        reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+        runaway = true;
+        break;
+      }
+      executed++;
+      try {
+        snapshot[i2]();
+      } catch (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);
+}
+
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
 var nodePool = [];
@@ -590,6 +744,7 @@ function retrack(effectFn, subscriber) {
   }
   currentSubscriber = subscriber;
   const sub2 = subscriber;
+  if (sub2._cap === void 0) sub2._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub2._epoch = epoch;
   sub2._structDirty = false;
@@ -781,7 +936,12 @@ function drainQueue() {
       quarantined.add(sub2);
       continue;
     }
-    safeInvoke(sub2);
+    const pushed = beginDisposerCapture(sub2._cap ?? null);
+    try {
+      safeInvoke(sub2);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -917,7 +1077,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.5.0" : "dev";
+var _runtimeVersion = true ? "4.6.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -1118,6 +1278,10 @@ function getSSRStore() {
   }
   return fallbackStore;
 }
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
 function isSSR() {
   return getSSRStore().ssr;
 }
@@ -1839,7 +2003,7 @@ function mutation(mutationFn, options = {}) {
     abortController = new AbortController();
     const signal2 = abortController.signal;
     const myRun = ++runId;
-    let context2;
+    let context;
     batch(() => {
       setLoading(true);
       setError(void 0);
@@ -1847,7 +2011,7 @@ function mutation(mutationFn, options = {}) {
     });
     try {
       if (options.onMutate) {
-        context2 = await options.onMutate(variables);
+        context = await options.onMutate(variables);
       }
       const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
@@ -1858,8 +2022,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("success");
       });
-      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context2));
+      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context));
       return result;
     } catch (err) {
       if (isAbortError(err)) {
@@ -1881,8 +2045,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("error");
       });
-      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context2));
+      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context));
       throw errorObj;
     }
   }
@@ -2020,18 +2184,21 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param2 = nextPageParam();
     if (param2 === void 0) return Promise.resolve();
     return fetchPage(param2, "next");
   }
   function fetchPreviousPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param2 = prevPageParam();
     if (param2 === void 0) return Promise.resolve();
     return fetchPage(param2, "prev");
   }
   async function refetch() {
+    if (disposed) return;
     batch(() => {
       setPages([]);
       setNextPageParam(initialPageParam);
@@ -2115,25 +2282,26 @@ function throttle(getter, interval) {
   let pending = null;
   let lastEmitted = getter();
   let timer = null;
+  function emit(value) {
+    setThrottled(value);
+    lastEmitted = value;
+    cooldown = true;
+    pending = null;
+    timer = setTimeout(endWindow, interval);
+  }
+  function endWindow() {
+    timer = null;
+    if (pending !== null && !Object.is(pending.value, lastEmitted)) {
+      emit(pending.value);
+      return;
+    }
+    pending = null;
+    cooldown = false;
+  }
   const stop2 = effect(() => {
     const value = getter();
     if (!cooldown) {
-      if (!Object.is(value, lastEmitted)) {
-        setThrottled(value);
-        lastEmitted = value;
-        cooldown = true;
-        pending = null;
-        timer = setTimeout(() => {
-          timer = null;
-          cooldown = false;
-          if (pending !== null) {
-            const trailingValue = pending.value;
-            pending = null;
-            setThrottled(trailingValue);
-            lastEmitted = trailingValue;
-          }
-        }, interval);
-      }
+      if (!Object.is(value, lastEmitted)) emit(value);
     } else {
       pending = { value };
     }
@@ -2207,7 +2375,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       });
       runCallback("resource onError", () => options.onError?.(errorObj));
     } finally {
-      if (version === fetchVersion) {
+      if (!disposed && version === fetchVersion) {
         runCallback("resource onSettled", () => options.onSettled?.());
       }
     }
@@ -2513,62 +2681,55 @@ function syncAdapter(config) {
   return config;
 }
 
-// src/core/rendering/context.ts
-function context(defaultValue) {
-  const [getValue, setValue] = signal(defaultValue);
-  const warnIfSSR = (method) => {
-    if (!DEV || !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 previous2 = getValue();
-      setValue(value);
-      return () => setValue(previous2);
-    },
-    use() {
-      return getValue;
-    },
-    get() {
-      return getValue();
-    },
-    set(value) {
-      warnIfSSR("set");
-      setValue(value);
-    },
-    withContext(value, fn) {
-      warnIfSSR("withContext");
-      const previous2 = getValue();
-      setValue(value);
-      try {
-        const result = fn();
-        if (DEV && 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(previous2);
-      }
-    }
-  };
-  return ctx;
-}
-
 // src/data/routeLoader.ts
-var LoaderContext = context(null);
-function executeLoader(loader, context2, options) {
-  const res = resource(({ signal: signal2 }) => loader(context2, { signal: signal2 }), options);
-  LoaderContext.provide(res);
+var _clientScope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.v2"), () => ({ stack: [] }));
+var _disposed = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.disposed.v1"), () => /* @__PURE__ */ new WeakSet());
+function currentScope() {
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return _clientScope;
+  let scope = cache.get("scope");
+  if (!scope) {
+    scope = { stack: [] };
+    cache.set("scope", scope);
+  }
+  return scope;
+}
+function executeLoader(loader, context, options) {
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const disposeResource = res.dispose;
+  res.dispose = () => {
+    _disposed.add(res);
+    disposeResource();
+  };
   return res;
 }
+function renderWithLoader(loader, render) {
+  if (_disposed.has(loader)) {
+    throw new Error("renderWithLoader: the loader resource has been disposed");
+  }
+  const scope = currentScope();
+  const entry = loader;
+  scope.stack.push(entry);
+  try {
+    return render();
+  } finally {
+    const index = scope.stack.lastIndexOf(entry);
+    if (index !== -1) scope.stack.splice(index, 1);
+  }
+}
+function withLoader(loader, context, render, options) {
+  const res = executeLoader(loader, context, options);
+  try {
+    return { view: renderWithLoader(res, render), resource: res };
+  } catch (err) {
+    res.dispose();
+    throw err;
+  }
+}
 function loaderData() {
-  const resource2 = LoaderContext.get();
-  if (!resource2) {
+  const scope = currentScope();
+  const resource2 = scope.stack[scope.stack.length - 1];
+  if (!resource2 || _disposed.has(resource2)) {
     throw new Error("loaderData must be used inside a route with a loader");
   }
   return {
@@ -2577,7 +2738,7 @@ function loaderData() {
     error: resource2.error
   };
 }
-async function preloadRoute(route, context2, callerSignal) {
+async function preloadRoute(route, context, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
   let onAbort = null;
@@ -2590,7 +2751,7 @@ async function preloadRoute(route, context2, callerSignal) {
     }
   }
   try {
-    return await route.loader(context2, { signal: controller.signal });
+    return await route.loader(context, { signal: controller.signal });
   } finally {
     if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
   }
@@ -2618,34 +2779,73 @@ function socket(url, options) {
   let heartbeatTimer = null;
   let disposed = false;
   let manuallyClosed = false;
+  let lifecycle = 0;
   function getUrl() {
     return typeof url === "function" ? url() : url;
   }
   function connect() {
     if (disposed) return;
+    const generation = lifecycle;
+    const invalidated = () => disposed || generation !== lifecycle;
     if (typeof WebSocket === "undefined") {
       setStatus("closed");
       return;
     }
-    const safeUrl = validateWsUrl(getUrl());
+    let rawUrl;
+    try {
+      rawUrl = getUrl();
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    const safeUrl = validateWsUrl(rawUrl);
     if (safeUrl === null) {
       setStatus("closed");
       return;
     }
     setStatus("connecting");
-    ws = new WebSocket(safeUrl, protocols);
-    ws.onopen = () => {
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    let instance;
+    try {
+      instance = new WebSocket(safeUrl, protocols);
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      instance.close();
+      setStatus("closed");
+      return;
+    }
+    ws = instance;
+    instance.onopen = () => {
+      if (ws !== instance) return;
+      const openGeneration = lifecycle;
       setStatus("open");
+      if (disposed || openGeneration !== lifecycle || ws !== instance) return;
       reconnectCount = 0;
       startHeartbeat();
     };
-    ws.onmessage = (event) => {
+    instance.onmessage = (event) => {
+      if (ws !== instance) return;
       setData(event.data);
     };
-    ws.onclose = () => {
+    instance.onclose = () => {
+      if (ws !== instance) return;
+      ws = null;
+      const closeGeneration = lifecycle;
       setStatus("closed");
       stopHeartbeat();
-      const wasManual = manuallyClosed;
+      const wasManual = manuallyClosed || closeGeneration !== lifecycle;
       manuallyClosed = false;
       if (autoReconnect && !disposed && !wasManual && reconnectCount < maxReconnects) {
         const cap = 3e4;
@@ -2659,7 +2859,7 @@ function socket(url, options) {
         }, jittered);
       }
     };
-    ws.onerror = () => {
+    instance.onerror = () => {
     };
   }
   function startHeartbeat() {
@@ -2683,13 +2883,23 @@ function socket(url, options) {
     }
   }
   function close() {
+    lifecycle++;
     manuallyClosed = true;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
     stopHeartbeat();
-    if (ws) {
+    if (!ws) {
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState === WebSocket.CLOSED) {
+      ws = null;
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState !== WebSocket.CLOSING) {
       setStatus("closing");
       ws.close();
     }
@@ -2856,17 +3066,17 @@ function blockedCssReason(value) {
   }
   return -1;
 }
-function sanitizeCSSValue(value, context2) {
+function sanitizeCSSValue(value, context) {
   const reason = blockedCssReason(value);
   if (reason === -1) return value;
-  warnDroppedDeclaration(value, reason, context2);
+  warnDroppedDeclaration(value, reason, context);
   return "";
 }
-function sanitizeStyleAttribute(cssText, context2) {
+function sanitizeStyleAttribute(cssText, context) {
   const input2 = String(cssText);
   if (input2.trim() === "") return "";
   if (typeof document === "undefined") {
-    return sanitizeCSSValue(input2, context2) === "" ? "" : input2;
+    return sanitizeCSSValue(input2, context) === "" ? "" : input2;
   }
   const probe = document.createElement("div");
   try {
@@ -2881,7 +3091,7 @@ function sanitizeStyleAttribute(cssText, context2) {
     let reason = blockedCssReason(value);
     if (reason === -1) reason = blockedCssReason(`${property}:${value}`);
     if (reason !== -1) {
-      warnDroppedDeclaration(value, reason, { property, element: context2?.element });
+      warnDroppedDeclaration(value, reason, { property, element: context?.element });
       continue;
     }
     const priority = probe.style.getPropertyPriority(property);
@@ -2931,11 +3141,11 @@ function isPolicyAttribute(name) {
   const lower = name.toLowerCase();
   return lower === "style" || URL_ATTRIBUTES.has(lower);
 }
-function sanitizeAttributeString(attr, value, context2) {
+function sanitizeAttributeString(attr, value, context) {
   const lower = attr.toLowerCase();
   if (lower === "srcset") return sanitizeSrcset(value);
   if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
-  if (lower === "style") return sanitizeStyleAttribute(value, context2);
+  if (lower === "style") return sanitizeStyleAttribute(value, context);
   return value;
 }
 
@@ -2957,6 +3167,7 @@ function stream(url, options) {
   let disposed = false;
   let reconnectTimer = null;
   let attempts = 0;
+  let closeGeneration = 0;
   function connect() {
     if (disposed) return;
     if (typeof EventSource === "undefined") {
@@ -2968,44 +3179,64 @@ function stream(url, options) {
       setStatus("closed");
       return;
     }
+    const generation = closeGeneration;
     setStatus("connecting");
-    source2 = new EventSource(safeUrl, {
+    if (disposed || generation !== closeGeneration) return;
+    const instance = new EventSource(safeUrl, {
       withCredentials: options?.withCredentials ?? false
     });
-    source2.onopen = () => {
+    if (disposed || generation !== closeGeneration) {
+      instance.close();
+      return;
+    }
+    source2 = instance;
+    const live = () => !disposed && source2 === instance;
+    instance.onopen = () => {
+      if (!live()) return;
       setStatus("open");
       attempts = 0;
     };
-    source2.onmessage = (evt) => {
+    instance.onmessage = (evt) => {
+      if (!live()) return;
       setData(evt.data);
       setEvent(evt.type);
     };
-    source2.onerror = () => {
-      if (source2 && source2.readyState === EventSource.CLOSED) {
-        setStatus("closed");
-        source2 = null;
-        if (autoReconnect && !disposed && attempts < maxReconnects) {
-          const delay = Math.min(maxMs, baseMs * 2 ** attempts);
-          const jittered = delay * (0.5 + Math.random() * 0.5);
-          attempts++;
-          reconnectTimer = setTimeout(() => {
-            reconnectTimer = null;
-            connect();
-          }, jittered);
-        }
+    instance.onerror = () => {
+      if (!live() || instance.readyState !== EventSource.CLOSED) return;
+      detach(instance);
+      source2 = null;
+      const generation2 = closeGeneration;
+      setStatus("closed");
+      if (disposed || generation2 !== closeGeneration) return;
+      if (autoReconnect && attempts < maxReconnects) {
+        const delay = Math.min(maxMs, baseMs * 2 ** attempts);
+        const jittered = delay * (0.5 + Math.random() * 0.5);
+        attempts++;
+        reconnectTimer = setTimeout(() => {
+          reconnectTimer = null;
+          connect();
+        }, jittered);
       }
     };
   }
+  function detach(instance) {
+    instance.onopen = null;
+    instance.onmessage = null;
+    instance.onerror = null;
+  }
   function close() {
+    closeGeneration++;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
-    if (source2) {
-      source2.close();
-      setStatus("closed");
+    const instance = source2;
+    if (instance) {
       source2 = null;
+      detach(instance);
+      instance.close();
     }
+    setStatus("closed");
   }
   function dispose2() {
     disposed = true;
@@ -3306,13 +3537,15 @@ function clipboard() {
   const [copied, setCopied] = signal(false);
   let copiedTimer = null;
   let disposed = false;
+  let generation = 0;
   async function copy(value) {
     if (disposed) return;
     if (typeof navigator === "undefined" || !navigator.clipboard) {
       return;
     }
+    const mine = ++generation;
     await navigator.clipboard.writeText(value);
-    if (disposed) return;
+    if (disposed || mine !== generation) return;
     setText(value);
     setCopied(true);
     if (copiedTimer !== null) clearTimeout(copiedTimer);
@@ -3324,6 +3557,7 @@ function clipboard() {
   }
   function dispose2() {
     disposed = true;
+    generation++;
     if (copiedTimer !== null) {
       clearTimeout(copiedTimer);
       copiedTimer = null;
@@ -3358,15 +3592,26 @@ function draggable(element, data2) {
   let currentEl = null;
   let onDragStart = null;
   let onDragEnd = null;
+  let prevDraggableAttr = null;
+  function detach() {
+    if (!currentEl) return;
+    if (onDragStart) currentEl.removeEventListener("dragstart", onDragStart);
+    if (onDragEnd) currentEl.removeEventListener("dragend", onDragEnd);
+    if (prevDraggableAttr === null) currentEl.removeAttribute("draggable");
+    else currentEl.setAttribute("draggable", prevDraggableAttr);
+    currentEl = null;
+    onDragStart = null;
+    onDragEnd = null;
+    setIsDragging(false);
+  }
   const getter = resolveTarget2(element);
   const cleanup3 = effect(() => {
-    if (currentEl && onDragStart && onDragEnd) {
-      currentEl.removeEventListener("dragstart", onDragStart);
-      currentEl.removeEventListener("dragend", onDragEnd);
-    }
     const el = getter();
-    currentEl = el;
+    if (el === currentEl) return;
+    detach();
     if (!el) return;
+    currentEl = el;
+    prevDraggableAttr = el.getAttribute("draggable");
     el.draggable = true;
     onDragStart = (e) => {
       setIsDragging(true);
@@ -3380,16 +3625,16 @@ function draggable(element, data2) {
     el.addEventListener("dragstart", onDragStart);
     el.addEventListener("dragend", onDragEnd);
   });
+  let disposed = false;
   function dispose2() {
+    if (disposed) return;
+    disposed = true;
     cleanup3();
-    if (currentEl && onDragStart && onDragEnd) {
-      currentEl.removeEventListener("dragstart", onDragStart);
-      currentEl.removeEventListener("dragend", onDragEnd);
-      currentEl = null;
-    }
+    detach();
   }
   return { isDragging, dispose: dispose2 };
 }
+var DROP_ZONE_EXIT_GRACE_MS = 600;
 function dropZone(element, options) {
   const [isOver, setIsOver] = signal(false);
   if (typeof window === "undefined") {
@@ -3401,30 +3646,66 @@ function dropZone(element, options) {
   let onDragEnter = null;
   let onDragLeave = null;
   let onDrop = null;
-  const getter = resolveTarget2(element);
-  const cleanup3 = effect(() => {
+  let depth = 0;
+  let exitTimer = null;
+  function cancelPendingExit() {
+    if (exitTimer !== null) {
+      clearTimeout(exitTimer);
+      exitTimer = null;
+    }
+  }
+  function resetOver() {
+    cancelPendingExit();
+    depth = 0;
+    setIsOver(false);
+  }
+  function detach() {
     if (currentEl && onDragOver && onDragEnter && onDragLeave && onDrop) {
       currentEl.removeEventListener("dragover", onDragOver);
       currentEl.removeEventListener("dragenter", onDragEnter);
       currentEl.removeEventListener("dragleave", onDragLeave);
       currentEl.removeEventListener("drop", onDrop);
     }
+    currentEl = null;
+    resetOver();
+  }
+  const getter = resolveTarget2(element);
+  const cleanup3 = effect(() => {
     const el = getter();
-    currentEl = el;
+    if (el === currentEl) return;
+    detach();
     if (!el) return;
+    currentEl = el;
     onDragOver = (e) => {
       e.preventDefault();
+      cancelPendingExit();
     };
     onDragEnter = (e) => {
       e.preventDefault();
+      cancelPendingExit();
+      depth++;
       setIsOver(true);
     };
-    onDragLeave = () => {
-      setIsOver(false);
+    onDragLeave = (e) => {
+      depth = Math.max(0, depth - 1);
+      if (depth === 0) {
+        resetOver();
+        return;
+      }
+      const to = e.relatedTarget;
+      if (to != null && typeof to.nodeType === "number") {
+        if (!el.contains(to)) resetOver();
+        return;
+      }
+      cancelPendingExit();
+      exitTimer = setTimeout(() => {
+        exitTimer = null;
+        resetOver();
+      }, DROP_ZONE_EXIT_GRACE_MS);
     };
     onDrop = (e) => {
       e.preventDefault();
-      setIsOver(false);
+      resetOver();
       let transferData = null;
       if (e.dataTransfer) {
         const raw = e.dataTransfer.getData("application/json");
@@ -3445,13 +3726,7 @@ function dropZone(element, options) {
   });
   function dispose2() {
     cleanup3();
-    if (currentEl && onDragOver && onDragEnter && onDragLeave && onDrop) {
-      currentEl.removeEventListener("dragover", onDragOver);
-      currentEl.removeEventListener("dragenter", onDragEnter);
-      currentEl.removeEventListener("dragleave", onDragLeave);
-      currentEl.removeEventListener("drop", onDrop);
-      currentEl = null;
-    }
+    detach();
   }
   return { isOver, dispose: dispose2 };
 }
@@ -3620,9 +3895,9 @@ function formatNumber(value, options) {
 function formatCurrency(value, currency, options) {
   const { locale, ...formatOptions } = options ?? {};
   return new Intl.NumberFormat(locale, {
+    ...formatOptions,
     style: "currency",
-    currency,
-    ...formatOptions
+    currency
   }).format(value);
 }
 
@@ -3708,18 +3983,36 @@ function swipe(target, options = {}) {
   }
   let startX = 0;
   let startY = 0;
-  let tracking = false;
+  let trackedId = null;
+  const idOf = (t) => t.identifier ?? 0;
+  const findTracked = (list) => {
+    if (!list) return null;
+    for (let i2 = 0; i2 < list.length; i2++) {
+      const t = list[i2];
+      if (idOf(t) === trackedId) return t;
+    }
+    return null;
+  };
   const onStart = (e) => {
-    if (e.touches.length === 0) return;
-    startX = e.touches[0].clientX;
-    startY = e.touches[0].clientY;
-    tracking = true;
+    const onTarget = e.targetTouches ?? e.touches;
+    if (onTarget.length > 1) {
+      trackedId = null;
+      return;
+    }
+    const touch = e.changedTouches?.[0] ?? e.touches[0];
+    if (!touch) return;
+    trackedId = idOf(touch);
+    startX = touch.clientX;
+    startY = touch.clientY;
+  };
+  const onCancel = (e) => {
+    if (trackedId !== null && findTracked(e.changedTouches)) trackedId = null;
   };
   const onEnd = (e) => {
-    if (!tracking) return;
-    tracking = false;
-    const touch = e.changedTouches[0];
+    if (trackedId === null) return;
+    const touch = findTracked(e.changedTouches);
     if (!touch) return;
+    trackedId = null;
     const dx = touch.clientX - startX;
     const dy = touch.clientY - startY;
     const absX = Math.abs(dx);
@@ -3736,9 +4029,12 @@ function swipe(target, options = {}) {
   };
   target.addEventListener("touchstart", onStart, { passive: true });
   target.addEventListener("touchend", onEnd, { passive: true });
+  target.addEventListener("touchcancel", onCancel, { passive: true });
   function dispose2() {
     target.removeEventListener("touchstart", onStart);
     target.removeEventListener("touchend", onEnd);
+    target.removeEventListener("touchcancel", onCancel);
+    trackedId = null;
   }
   return { direction, dispose: dispose2 };
 }
@@ -3765,6 +4061,18 @@ function windowSize() {
 }
 
 // src/browser/urlState.ts
+var _url = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.urlState.v1"), () => ({
+  instances: /* @__PURE__ */ new Set()
+}));
+function notifyUrlWrite() {
+  for (const sync of Array.from(_url.instances)) sync();
+}
+var SCROLL_ENTRY_KEY = "__sibuScrollKey";
+function withoutEntryIdentity(state2) {
+  if (state2 === null || typeof state2 !== "object" || !Object.hasOwn(state2, SCROLL_ENTRY_KEY)) return state2;
+  const { [SCROLL_ENTRY_KEY]: _identity, ...rest } = state2;
+  return rest;
+}
 function urlState() {
   if (typeof window === "undefined") {
     const [params2] = signal(new URLSearchParams());
@@ -3798,26 +4106,36 @@ function urlState() {
   }
   window.addEventListener("popstate", syncFromLocation);
   window.addEventListener("hashchange", syncFromLocation);
+  _url.instances.add(syncFromLocation);
+  function writeHistory(newUrl, opts) {
+    const state2 = "state" in opts ? opts.state : window.history.state;
+    if (opts.replace) window.history.replaceState(state2, "", newUrl);
+    else window.history.pushState("state" in opts ? state2 : withoutEntryIdentity(state2), "", newUrl);
+  }
   function setParams(next, opts = {}) {
     const p2 = next instanceof URLSearchParams ? next : new URLSearchParams(next);
     const query2 = p2.toString();
     const newUrl = `${window.location.pathname}${query2 ? `?${query2}` : ""}${window.location.hash}`;
-    if (opts.replace) window.history.replaceState(null, "", newUrl);
-    else window.history.pushState(null, "", newUrl);
+    writeHistory(newUrl, opts);
     lastSearch = window.location.search;
     setParamsSignal(new URLSearchParams(p2));
+    notifyUrlWrite();
   }
   function setHash(next, opts = {}) {
     const normalized = next && next !== "#" ? next.startsWith("#") ? next : `#${next}` : "";
     const newUrl = `${window.location.pathname}${window.location.search}${normalized}`;
-    if (opts.replace) window.history.replaceState(null, "", newUrl);
-    else window.history.pushState(null, "", newUrl);
+    writeHistory(newUrl, opts);
     lastHash = normalized;
     setHashSignal(normalized);
+    notifyUrlWrite();
   }
+  let disposed = false;
   function dispose2() {
+    if (disposed) return;
+    disposed = true;
     window.removeEventListener("popstate", syncFromLocation);
     window.removeEventListener("hashchange", syncFromLocation);
+    _url.instances.delete(syncFromLocation);
   }
   return { params, hash, setParams, setHash, dispose: dispose2 };
 }
@@ -3834,10 +4152,14 @@ function broadcast(channelName) {
   const channel = new BroadcastChannel(channelName);
   const handler = (ev) => setLast(ev.data);
   channel.addEventListener("message", handler);
+  let disposed = false;
   function post(message) {
+    if (disposed) return;
     channel.postMessage(message);
   }
   function dispose2() {
+    if (disposed) return;
+    disposed = true;
     channel.removeEventListener("message", handler);
     channel.close();
   }
@@ -4036,31 +4358,42 @@ function animationFrame(options = {}) {
   let prev = -1;
   let start = -1;
   let disposed = false;
+  let active = false;
+  let generation = 0;
   const minFrameMs = options.fpsLimit ? 1e3 / options.fpsLimit : 0;
   const step = (now) => {
+    id = null;
+    if (!active) return;
+    const frameGeneration = generation;
     if (start < 0) start = now;
     const firstTick = prev < 0;
     const dt2 = firstTick ? 0 : now - prev;
     if (firstTick || dt2 >= minFrameMs) {
-      setDelta(dt2);
-      setElapsed(now - start);
       prev = now;
+      const elapsedValue = now - start;
+      setDelta(dt2);
+      if (!active || generation !== frameGeneration) return;
+      setElapsed(elapsedValue);
+      if (!active || generation !== frameGeneration) return;
     }
-    id = requestAnimationFrame(step);
+    if (id === null) id = requestAnimationFrame(step);
   };
   function resume() {
-    if (disposed || id !== null) return;
-    setRunning(true);
+    if (disposed || active) return;
+    active = true;
     id = requestAnimationFrame(step);
+    setRunning(true);
   }
   function pause() {
+    generation++;
+    active = false;
     if (id !== null) {
       cancelAnimationFrame(id);
       id = null;
     }
-    setRunning(false);
     prev = -1;
     start = -1;
+    setRunning(false);
   }
   function dispose2() {
     disposed = true;
@@ -4190,6 +4523,35 @@ function keyboard(options = {}) {
 }
 
 // src/browser/speech.ts
+var _speech = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.speech.v1"), () => ({
+  queue: [],
+  active: null,
+  owners: /* @__PURE__ */ new Set()
+}));
+function syncOwners() {
+  for (const owner of Array.from(_speech.owners)) owner.sync();
+}
+function pump(synth) {
+  if (_speech.active) return;
+  const index = _speech.queue.findIndex((entry2) => !entry2.owner.paused);
+  if (index === -1) return;
+  const [entry] = _speech.queue.splice(index, 1);
+  _speech.active = entry;
+  const finish = () => {
+    if (_speech.active !== entry) return;
+    _speech.active = null;
+    pump(synth);
+    syncOwners();
+  };
+  entry.utterance.addEventListener("end", finish, { once: true });
+  entry.utterance.addEventListener("error", finish, { once: true });
+  synth.speak(entry.utterance);
+}
+function __resetSpeechCoordinator() {
+  _speech.queue.length = 0;
+  _speech.active = null;
+  _speech.owners.clear();
+}
 function speech() {
   const [speaking, setSpeaking] = signal(false);
   const [paused, setPaused] = signal(false);
@@ -4210,19 +4572,16 @@ function speech() {
     };
   }
   const synth = window.speechSynthesis;
-  let interval = null;
-  function startPolling() {
-    if (interval !== null) return;
-    interval = setInterval(() => {
-      setSpeaking(synth.speaking);
-      setPaused(synth.paused);
-      if (!synth.speaking && !synth.paused) {
-        clearInterval(interval);
-        interval = null;
-      }
-    }, 200);
-  }
   let disposed = false;
+  const owner = {
+    paused: false,
+    sync: () => {
+      const mine = _speech.active?.owner === owner || _speech.queue.some((entry) => entry.owner === owner);
+      setSpeaking(mine);
+      setPaused(owner.paused);
+    }
+  };
+  _speech.owners.add(owner);
   function speak(text2, options = {}) {
     if (disposed) return;
     const u2 = new SpeechSynthesisUtterance(text2);
@@ -4235,52 +4594,48 @@ function speech() {
       const match = voices.find((v) => v.name === options.voice);
       if (match) u2.voice = match;
     }
-    u2.addEventListener(
-      "start",
-      () => {
-        if (!disposed) setSpeaking(true);
-      },
-      { once: true }
-    );
-    u2.addEventListener(
-      "end",
-      () => {
-        if (disposed) return;
-        setSpeaking(false);
-        setPaused(false);
-      },
-      { once: true }
-    );
-    u2.addEventListener(
-      "error",
-      () => {
-        if (disposed) return;
-        setSpeaking(false);
-        setPaused(false);
-      },
-      { once: true }
-    );
-    synth.speak(u2);
-    setSpeaking(true);
-    startPolling();
+    _speech.queue.push({ owner, utterance: u2 });
+    pump(synth);
+    syncOwners();
+  }
+  function pause() {
+    if (disposed || owner.paused) return;
+    owner.paused = true;
+    if (_speech.active?.owner === owner) synth.pause();
+    syncOwners();
+  }
+  function resume() {
+    if (disposed || !owner.paused) return;
+    owner.paused = false;
+    if (_speech.active?.owner === owner) synth.resume();
+    else pump(synth);
+    syncOwners();
+  }
+  function cancel() {
+    if (disposed) return;
+    cancelOwned();
+    syncOwners();
+  }
+  function cancelOwned() {
+    for (let i2 = _speech.queue.length - 1; i2 >= 0; i2--) {
+      if (_speech.queue[i2].owner === owner) _speech.queue.splice(i2, 1);
+    }
+    owner.paused = false;
+    if (_speech.active?.owner === owner) {
+      _speech.active = null;
+      if (synth.paused) synth.resume();
+      synth.cancel();
+      pump(synth);
+    }
   }
   function dispose2() {
+    if (disposed) return;
+    cancelOwned();
     disposed = true;
-    if (interval !== null) {
-      clearInterval(interval);
-      interval = null;
-    }
-    synth.cancel();
+    syncOwners();
+    _speech.owners.delete(owner);
   }
-  return {
-    speaking,
-    paused,
-    speak,
-    pause: () => synth.pause(),
-    resume: () => synth.resume(),
-    cancel: () => synth.cancel(),
-    dispose: dispose2
-  };
+  return { speaking, paused, speak, pause, resume, cancel, dispose: dispose2 };
 }
 
 // src/browser/gamepad.ts
@@ -4291,6 +4646,7 @@ function gamepad() {
     } };
   }
   let rafId = null;
+  let disposed = false;
   function snapshot(pad) {
     return {
       index: pad.index,
@@ -4305,7 +4661,7 @@ function gamepad() {
     for (let i2 = 0; i2 < a2.length; i2++) {
       const pa = a2[i2];
       const pb = b2[i2];
-      if (pa.index !== pb.index || pa.connected !== pb.connected) return false;
+      if (pa.index !== pb.index || pa.id !== pb.id || pa.connected !== pb.connected) return false;
       if (pa.buttons.length !== pb.buttons.length) return false;
       for (let j = 0; j < pa.buttons.length; j++) {
         if (pa.buttons[j].pressed !== pb.buttons[j].pressed) return false;
@@ -4318,15 +4674,19 @@ function gamepad() {
     }
     return true;
   }
+  function publish() {
+    const snap = Array.from(navigator.getGamepads()).filter((g2) => g2 !== null).map(snapshot);
+    if (!equal(pads(), snap)) setPads(snap);
+    return snap;
+  }
   function poll() {
-    const raw = navigator.getGamepads();
-    const snap = Array.from(raw).filter((g2) => g2 !== null).map(snapshot);
-    const current = pads();
-    if (!equal(current, snap)) setPads(snap);
-    rafId = requestAnimationFrame(poll);
+    rafId = null;
+    if (disposed) return;
+    publish();
+    if (!disposed && rafId === null) rafId = requestAnimationFrame(poll);
   }
   function startPolling() {
-    if (rafId === null) poll();
+    if (!disposed && rafId === null) poll();
   }
   function stopPolling() {
     if (rafId !== null) {
@@ -4336,15 +4696,14 @@ function gamepad() {
   }
   const onConnect = () => startPolling();
   const onDisconnect = () => {
-    const raw = navigator.getGamepads();
-    const hasAny = Array.from(raw).some((g2) => g2 !== null);
-    if (!hasAny) stopPolling();
+    if (publish().length === 0) stopPolling();
   };
   window.addEventListener("gamepadconnected", onConnect);
   window.addEventListener("gamepaddisconnected", onDisconnect);
   const initial = Array.from(navigator.getGamepads()).some((g2) => g2 !== null);
   if (initial) startPolling();
   function dispose2() {
+    disposed = true;
     stopPolling();
     window.removeEventListener("gamepadconnected", onConnect);
     window.removeEventListener("gamepaddisconnected", onDisconnect);
@@ -4358,8 +4717,7 @@ function pointerLock() {
   if (typeof document === "undefined") {
     return {
       locked,
-      request: () => {
-      },
+      request: () => Promise.resolve(),
       exit: () => {
       },
       dispose: () => {
@@ -4371,8 +4729,14 @@ function pointerLock() {
   };
   document.addEventListener("pointerlockchange", handler);
   function request(element) {
-    if (typeof element.requestPointerLock === "function") {
-      element.requestPointerLock();
+    if (typeof element.requestPointerLock !== "function") {
+      return Promise.resolve();
+    }
+    try {
+      const result = element.requestPointerLock();
+      return Promise.resolve(result).then(() => void 0);
+    } catch (err) {
+      return Promise.reject(err);
     }
   }
   function exit() {
@@ -4475,25 +4839,46 @@ function imageLoader(src) {
     };
   }
   let current = null;
+  let currentSettled = false;
   let disposed = false;
+  let startToken = 0;
+  function resetState() {
+    batch(() => {
+      setStatus("pending");
+      setImage(null);
+      setWidth(0);
+      setHeight(0);
+    });
+  }
+  function abandonCurrent() {
+    if (!current) return;
+    const prev = current;
+    current = null;
+    prev.onload = null;
+    prev.onerror = null;
+    if (!currentSettled) prev.src = "";
+  }
   function start(url) {
-    if (current) {
-      current.onload = null;
-      current.onerror = null;
-    }
-    setStatus("pending");
-    setImage(null);
+    const token = ++startToken;
+    abandonCurrent();
+    resetState();
+    if (disposed || token !== startToken) return;
     const img2 = new Image();
     current = img2;
+    currentSettled = false;
     img2.onload = () => {
       if (disposed || current !== img2) return;
-      setImage(img2);
-      setWidth(img2.naturalWidth);
-      setHeight(img2.naturalHeight);
-      setStatus("loaded");
-    };
+      currentSettled = true;
+      batch(() => {
+        setImage(img2);
+        setWidth(img2.naturalWidth);
+        setHeight(img2.naturalHeight);
+        setStatus("loaded");
+      });
+    };
     img2.onerror = () => {
       if (disposed || current !== img2) return;
+      currentSettled = true;
       setStatus("error");
     };
     img2.src = url;
@@ -4508,16 +4893,15 @@ function imageLoader(src) {
     start(src);
   }
   function dispose2() {
+    if (disposed) return;
     disposed = true;
+    startToken++;
     if (srcEffectTeardown) {
       srcEffectTeardown();
       srcEffectTeardown = null;
     }
-    if (current) {
-      current.onload = null;
-      current.onerror = null;
-      current = null;
-    }
+    abandonCurrent();
+    resetState();
   }
   return { status, image, width, height, dispose: dispose2 };
 }
@@ -4525,13 +4909,25 @@ function imageLoader(src) {
 // src/patterns/machine.ts
 function machine(config) {
   const [state2, setState] = signal(config.initial);
-  const [context2, setContext] = signal(config.context || {});
-  const initialDef = config.states[config.initial];
-  if (initialDef?.entry) {
-    initialDef.entry(context2());
+  const [context, setContext] = signal(config.context || {});
+  let currentState = config.initial;
+  let currentContext = context();
+  const queue = [];
+  let processing = false;
+  function drain() {
+    processing = true;
+    try {
+      while (queue.length > 0) {
+        step(queue.shift());
+      }
+    } catch (err) {
+      queue.length = 0;
+      throw err;
+    } finally {
+      processing = false;
+    }
   }
-  function send(event) {
-    const currentState = state2();
+  function step(event) {
     const stateDef = config.states[currentState];
     if (!stateDef?.on) return;
     const transition2 = stateDef.on[event];
@@ -4546,38 +4942,61 @@ function machine(config) {
       guard = transition2.guard;
       action = transition2.action;
     }
-    const ctx = context2();
+    const ctx = currentContext;
     if (guard && !guard(ctx)) return;
     if (stateDef.exit) {
       stateDef.exit(ctx);
     }
+    let nextContext = ctx;
     if (action) {
       const rawPatch = action(ctx);
-      const next = { ...ctx, ...stripUnsafeKeys(rawPatch) };
-      setContext(next);
+      nextContext = { ...ctx, ...stripUnsafeKeys(rawPatch) };
     }
-    setState(target);
+    currentState = target;
+    currentContext = nextContext;
+    batch(() => {
+      if (action) setContext(nextContext);
+      setState(target);
+    });
     const targetDef = config.states[target];
     if (targetDef?.entry) {
-      targetDef.entry(context2());
+      targetDef.entry(currentContext);
     }
   }
+  function send(event) {
+    queue.push(event);
+    if (processing) return;
+    drain();
+  }
+  const initialDef = config.states[config.initial];
+  if (initialDef?.entry) {
+    processing = true;
+    try {
+      initialDef.entry(currentContext);
+    } catch (err) {
+      queue.length = 0;
+      throw err;
+    } finally {
+      processing = false;
+    }
+    if (queue.length > 0) drain();
+  }
   function matches(s2) {
     return state2() === s2;
   }
   function can(event) {
-    const currentState = state2();
-    const stateDef = config.states[currentState];
+    const currentState2 = state2();
+    const stateDef = config.states[currentState2];
     if (!stateDef?.on) return false;
     const transition2 = stateDef.on[event];
     if (!transition2) return false;
     if (typeof transition2 === "string") return true;
     if (transition2.guard) {
-      return transition2.guard(context2());
+      return transition2.guard(context());
     }
     return true;
   }
-  return { state: state2, context: context2, send, matches, can };
+  return { state: state2, context, send, matches, can };
 }
 
 // src/patterns/persist.ts
@@ -4950,6 +5369,9 @@ function optimisticList(initialValue) {
 
 // src/patterns/timeTravel.ts
 function timeline(initial, maxHistory = 100) {
+  if (!Number.isSafeInteger(maxHistory) || maxHistory < 1) {
+    throw new RangeError(`[timeline] maxHistory must be a positive safe integer, got ${maxHistory}`);
+  }
   const [history2, setHistory] = signal([initial]);
   const [index, setIndex] = signal(0);
   const value = derived(() => history2()[index()]);
@@ -5004,6 +5426,120 @@ function timeline(initial, maxHistory = 100) {
   return { value, set, undo, redo, canUndo, canRedo, history: history2, index, reset, jumpTo, dispose: dispose2 };
 }
 
+// src/utils/adoption.ts
+var nativeThen = Promise.prototype.then;
+function probeNative(target, onRejected, onOpen) {
+  let decided = false;
+  const decide = (rejected) => {
+    if (decided) return;
+    decided = true;
+    (rejected ? onRejected : onOpen)();
+  };
+  try {
+    Reflect.apply(nativeThen, target, [void 0, () => decide(true)]);
+  } catch {
+    queueMicrotask(() => decide(true));
+    return;
+  }
+  queueMicrotask(() => decide(false));
+}
+function adopt(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return {
+      promise: Promise.reject(error),
+      failedEarly: true,
+      probe: (onRejected) => queueMicrotask(onRejected)
+    };
+  }
+  if (typeof then !== "function") return null;
+  let resolvePromise;
+  let rejectPromise;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  let state2 = "invoking";
+  let nativeTarget;
+  const waiters = [];
+  const transition2 = (next) => {
+    state2 = next;
+    if (next === "invoking") return;
+    for (const waiter of waiters.splice(0)) waiter();
+  };
+  const fulfil = (result) => {
+    resolvePromise(result);
+    transition2("fulfilled");
+  };
+  const fail = (error) => {
+    rejectPromise(error);
+    transition2("rejected");
+  };
+  const follow = (result) => {
+    if (result === promise) {
+      fail(new TypeError("adopt: a thenable resolved to its own adoption"));
+      return;
+    }
+    if (result === null || typeof result !== "object" && typeof result !== "function") {
+      fulfil(result);
+      return;
+    }
+    let nextThen;
+    try {
+      nextThen = result.then;
+    } catch (error) {
+      fail(error);
+      return;
+    }
+    if (typeof nextThen !== "function") {
+      fulfil(result);
+      return;
+    }
+    invokeLater(result, nextThen);
+  };
+  const invokeLater = (target, targetThen) => {
+    if (targetThen === nativeThen) {
+      nativeTarget = target;
+      transition2("native");
+    } else {
+      transition2("invoking");
+    }
+    queueMicrotask(() => {
+      let done = false;
+      const onResolve = (result) => {
+        if (done) return;
+        done = true;
+        follow(result);
+      };
+      const onReject = (error) => {
+        if (done) return;
+        done = true;
+        fail(error);
+      };
+      try {
+        Reflect.apply(targetThen, target, [onResolve, onReject]);
+      } catch (error) {
+        onReject(error);
+      }
+      if (!done && state2 === "invoking") transition2("pending");
+    });
+  };
+  invokeLater(value, then);
+  const probe = (onRejected, onOpen) => {
+    const decide = () => {
+      if (state2 === "native") probeNative(nativeTarget, onRejected, onOpen);
+      else (state2 === "rejected" ? onRejected : onOpen)();
+    };
+    if (state2 === "native") probeNative(nativeTarget, onRejected, onOpen);
+    else if (state2 === "invoking") waiters.push(decide);
+    else queueMicrotask(state2 === "rejected" ? onRejected : onOpen);
+  };
+  return { promise, failedEarly: false, probe };
+}
+
 // src/patterns/globalStore.ts
 function deepClone(value) {
   if (typeof structuredClone === "function") {
@@ -5038,8 +5574,51 @@ function deepClone(value) {
 function globalStore(config) {
   const initialState = deepClone(config.state);
   const [getState, setState] = signal({ ...initialState });
-  const listeners = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
   const middlewares = config.middleware || [];
+  function notifyListeners2(state2) {
+    if (subscriptions.size === 0) return;
+    for (const subscription of Array.from(subscriptions.values())) {
+      if (!subscription.active) continue;
+      try {
+        subscription.callback(state2);
+      } catch (err) {
+        reportError(err, { phase: "event", name: "globalStore(subscribe)" });
+      }
+    }
+  }
+  const operations = [];
+  let running = false;
+  function perform(operation, rethrowOwn = true) {
+    operations.push(operation);
+    if (running) return;
+    running = true;
+    let callerError;
+    let callerFailed = false;
+    try {
+      let first = true;
+      let cursor = 0;
+      while (cursor < operations.length) {
+        const next = operations[cursor];
+        operations[cursor++] = void 0;
+        try {
+          next();
+        } catch (err) {
+          if (first && rethrowOwn) {
+            callerFailed = true;
+            callerError = err;
+          } else {
+            reportError(err, { phase: "event", name: "globalStore(dispatch)" });
+          }
+        }
+        first = false;
+      }
+    } finally {
+      operations.length = 0;
+      running = false;
+    }
+    if (callerFailed) throw callerError;
+  }
   function dispatch(action, payload) {
     const actionFn = config.actions[action];
     if (!actionFn) throw new Error(`Unknown action: ${String(action)}`);
@@ -5048,38 +5627,96 @@ function globalStore(config) {
       const rawPatch = actionFn(current, payload);
       const patch = stripUnsafeKeys(rawPatch);
       setState({ ...current, ...patch });
-      const newState = getState();
-      for (const listener of listeners) {
-        listener(newState);
-      }
+      notifyListeners2(getState());
     };
-    if (middlewares.length === 0) {
-      execute();
-      return;
-    }
-    let index = 0;
-    const next = () => {
-      if (index < middlewares.length) {
-        const mw = middlewares[index++];
-        mw(getState(), String(action), payload, next);
-      } else {
+    perform(() => {
+      if (middlewares.length === 0) {
         execute();
+        return;
       }
-    };
-    next();
+      const runFrom = (index) => {
+        if (index >= middlewares.length) {
+          execute();
+          return;
+        }
+        let called = false;
+        let failed = false;
+        let synchronous = true;
+        const next = () => {
+          if (failed && !called) {
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called after it failed for "${String(action)}"; ignored.`
+              );
+            called = true;
+            return;
+          }
+          if (called) {
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called more than once for "${String(action)}"; ignored.`
+              );
+            return;
+          }
+          called = true;
+          if (synchronous) {
+            runFrom(index + 1);
+            return;
+          }
+          const proceed = () => perform(() => runFrom(index + 1), false);
+          if (!adoption) {
+            proceed();
+            return;
+          }
+          adoption.probe(() => {
+            failed = true;
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called after it failed for "${String(action)}"; ignored.`
+              );
+          }, proceed);
+        };
+        let adoption = null;
+        try {
+          adoption = adopt(middlewares[index](getState(), String(action), payload, next));
+        } catch (err) {
+          failed = true;
+          throw err;
+        } finally {
+          synchronous = false;
+        }
+        if (adoption) {
+          if (adoption.failedEarly) failed = true;
+          adoption.promise.then(void 0, (err) => {
+            failed = true;
+            reportError(err, { phase: "async", name: "globalStore(middleware)" });
+          });
+        }
+      };
+      runFrom(0);
+    });
   }
   function select3(selector) {
     return () => selector(getState());
   }
   function subscribe(callback) {
-    listeners.add(callback);
-    return () => listeners.delete(callback);
+    let subscription = subscriptions.get(callback);
+    if (!subscription) {
+      subscription = { callback, active: true };
+      subscriptions.set(callback, subscription);
+    }
+    const own = subscription;
+    return () => {
+      if (subscriptions.get(callback) !== own) return;
+      own.active = false;
+      subscriptions.delete(callback);
+    };
   }
   function reset() {
-    setState({ ...initialState });
-    for (const listener of listeners) {
-      listener(getState());
-    }
+    perform(() => {
+      setState({ ...initialState });
+      notifyListeners2(getState());
+    });
   }
   return { getState, select: select3, dispatch, subscribe, reset };
 }
@@ -5203,7 +5840,7 @@ function validateProps(props, schema) {
     const errors = [];
     for (const [key, def] of Object.entries(schema)) {
       const propDef = typeof def === "function" ? { type: def } : def;
-      if (result[key] == null && propDef.default !== void 0) {
+      if (result[key] === void 0 && propDef.default !== void 0) {
         result[key] = typeof propDef.default === "function" ? propDef.default() : propDef.default;
       }
       if (propDef.required && result[key] == null) {
@@ -5229,7 +5866,7 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   for (const [key, def] of Object.entries(schema)) {
     if (typeof def === "function") continue;
     const fallback = def.default;
-    if (result[key] == null && fallback !== void 0) {
+    if (result[key] === void 0 && fallback !== void 0) {
       result[key] = typeof fallback === "function" ? fallback() : fallback;
     }
   }
@@ -5255,81 +5892,6 @@ function createGuard(validator) {
   };
 }
 
-// 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 activeBindingCount = 0;
-function registerDisposer(node, teardown) {
-  let disposers = elementDisposers.get(node);
-  if (!disposers) {
-    disposers = [];
-    elementDisposers.set(node, disposers);
-  }
-  disposers.push(teardown);
-  if (DEV) activeBindingCount++;
-}
-function dispose(node) {
-  const stack = [node];
-  const order = [];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    order.push(current);
-    const children = Array.from(current.childNodes);
-    for (let i2 = 0; i2 < children.length; i2++) {
-      stack.push(children[i2]);
-    }
-  }
-  for (let i2 = order.length - 1; i2 >= 0; i2--) {
-    const current = order[i2];
-    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 (DEV) 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 (DEV) activeBindingCount += rest.length;
-            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
-            runaway = true;
-            break;
-          }
-          executed++;
-          try {
-            snapshot[i3]();
-          } catch (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);
-}
-
 // src/ui/transition.ts
 function transition(element, options = {}) {
   const {
@@ -5357,6 +5919,15 @@ function transition(element, options = {}) {
       resolvePrev();
     }
   }
+  function complete(callback, name, resolve) {
+    try {
+      callback?.();
+    } catch (error) {
+      reportError(error, { phase: "async", name, node: element });
+    } finally {
+      resolve();
+    }
+  }
   function enter() {
     return new Promise((resolve) => {
       cancelPending();
@@ -5369,8 +5940,7 @@ function transition(element, options = {}) {
         activeTimer = null;
         pendingResolve = null;
         if (enterClass) element.classList.remove(enterClass);
-        onEnterDone?.();
-        resolve();
+        complete(onEnterDone, "transition(onEnterDone)", resolve);
       };
       if (duration > 0) {
         pendingResolve = resolve;
@@ -5391,8 +5961,7 @@ function transition(element, options = {}) {
         activeTimer = null;
         pendingResolve = null;
         if (leaveClass) element.classList.remove(leaveClass);
-        onLeaveDone?.();
-        resolve();
+        complete(onLeaveDone, "transition(onLeaveDone)", resolve);
       };
       if (duration > 0) {
         pendingResolve = resolve;
@@ -5595,22 +6164,54 @@ async function sequence(steps) {
   }
 }
 
+// src/utils/adoptThenable.ts
+function adoptThenable(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (typeof then !== "function") return null;
+  return new Promise((resolve, reject) => {
+    queueMicrotask(() => {
+      try {
+        Reflect.apply(then, value, [resolve, reject]);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
 // src/ui/TransitionGroup.ts
 function TransitionGroup(options) {
   const [elements, setElements] = signal([]);
   const positions = /* @__PURE__ */ new Map();
+  function runCallback2(name, callback, el) {
+    const report = (error) => reportError(error, { phase: "async", name: `TransitionGroup.${name}`, node: el });
+    try {
+      adoptThenable(callback(el))?.then(void 0, report);
+    } catch (error) {
+      report(error);
+    }
+  }
   function add(el) {
     setElements((prev) => [...prev, el]);
-    if (options.enter) {
-      options.enter(el);
-    }
+    if (options.enter) runCallback2("enter", options.enter, el);
   }
   async function remove(el) {
-    if (options.leave) {
-      await options.leave(el);
+    try {
+      if (options.leave) {
+        await adoptThenable(options.leave(el));
+      }
+    } catch (error) {
+      reportError(error, { phase: "async", name: "TransitionGroup.leave", node: el });
+    } finally {
+      positions.delete(el);
+      setElements((prev) => prev.filter((e) => e !== el));
     }
-    positions.delete(el);
-    setElements((prev) => prev.filter((e) => e !== el));
   }
   function track4(newElements) {
     const oldPositions = /* @__PURE__ */ new Map();
@@ -5622,17 +6223,13 @@ function TransitionGroup(options) {
     const currentSet = new Set(elements());
     for (const el of newElements) {
       if (!currentSet.has(el)) {
-        if (options.enter) {
-          options.enter(el);
-        }
+        if (options.enter) runCallback2("enter", options.enter, el);
       }
     }
     const newSet = new Set(newElements);
     for (const el of elements()) {
       if (!newSet.has(el)) {
-        if (options.leave) {
-          options.leave(el);
-        }
+        if (options.leave) runCallback2("leave", options.leave, el);
       }
     }
     setElements(newElements);
@@ -5642,7 +6239,7 @@ function TransitionGroup(options) {
         if (oldRect && typeof el.getBoundingClientRect === "function") {
           const newRect = el.getBoundingClientRect();
           if (oldRect.left !== newRect.left || oldRect.top !== newRect.top) {
-            options.move(el);
+            runCallback2("move", options.move, el);
           }
         }
       }
@@ -5693,9 +6290,13 @@ function springSignal(initial, options) {
   let target = initial;
   let rafId = null;
   let lastTime = 0;
+  let disposed = false;
+  const canAnimate = () => typeof requestAnimationFrame === "function";
   const REF_DT_MS = 1e3 / 60;
   const MAX_STEP_RATIO = 4;
   function tick(now) {
+    rafId = null;
+    if (disposed) return;
     if (lastTime === 0) lastTime = now;
     const rawDt = now - lastTime;
     lastTime = now;
@@ -5708,23 +6309,27 @@ function springSignal(initial, options) {
     if (Math.abs(current - target) < precision && Math.abs(velocity) < precision) {
       current = target;
       velocity = 0;
-      rafId = null;
       lastTime = 0;
       setValue(current);
       return;
     }
     setValue(current);
+    if (disposed || rafId !== null) return;
     rafId = requestAnimationFrame(tick);
   }
+  function cancelFrame() {
+    if (rafId !== null) {
+      if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+  }
   function set(newTarget) {
+    if (disposed) return;
     target = newTarget;
-    if (prefersReducedMotion()) {
+    if (!canAnimate() || prefersReducedMotion()) {
       current = newTarget;
       velocity = 0;
-      if (rafId !== null) {
-        cancelAnimationFrame(rafId);
-        rafId = null;
-      }
+      cancelFrame();
       lastTime = 0;
       setValue(current);
       return;
@@ -5735,15 +6340,20 @@ function springSignal(initial, options) {
     }
   }
   function dispose2() {
-    if (rafId !== null) {
-      cancelAnimationFrame(rafId);
-      rafId = null;
-    }
+    disposed = true;
+    cancelFrame();
     lastTime = 0;
   }
   return [value, set, dispose2];
 }
 
+// src/reactivity/domBinding.ts
+function domBinding(commit, ownerNode) {
+  if (isSSR()) return () => {
+  };
+  return reactiveBinding2(commit, ownerNode);
+}
+
 // src/ui/form.ts
 function required(message = "This field is required") {
   return (value) => {
@@ -5771,10 +6381,14 @@ function maxLength(max2, message) {
 }
 function matchesPattern(regex, message = "Invalid format") {
   return (value) => {
-    if (value && !regex.test(value)) {
-      return message;
+    if (!value) return null;
+    const savedLastIndex = regex.lastIndex;
+    regex.lastIndex = 0;
+    try {
+      return regex.test(value) ? null : message;
+    } finally {
+      regex.lastIndex = savedLastIndex;
     }
-    return null;
   };
 }
 function email(message = "Invalid email address") {
@@ -5823,13 +6437,13 @@ function bindField(field, extras) {
   const mergedOn = extraOn && typeof extraOn === "object" ? { ...extraOn, ...fieldOn } : fieldOn;
   const onElement = (el) => {
     if (el instanceof HTMLSelectElement && el.multiple) {
-      const stop2 = effect(() => {
+      const stop2 = domBinding(() => {
         const v = field.value();
         const selected = Array.isArray(v) ? v.map(String) : [];
         for (const opt of Array.from(el.options)) {
           opt.selected = selected.includes(opt.value);
         }
-      });
+      }, el);
       registerDisposer(el, stop2);
     }
     if (typeof extraOnElement === "function") {
@@ -5849,6 +6463,7 @@ function form(config) {
   const fieldEntries = Object.entries(config);
   const fieldMap = {};
   const [manualErrors, setManualErrors] = signal({});
+  const fieldErrors = [];
   for (const [name, cfg] of fieldEntries) {
     const [value, setValue] = signal(cfg.initial);
     const [isTouched, setTouched] = signal(false);
@@ -5863,6 +6478,7 @@ function form(config) {
       }
       return null;
     });
+    fieldErrors.push(error);
     const wrappedSet = (next) => {
       setValue(next);
       setManualErrors((prev) => {
@@ -5939,12 +6555,22 @@ function form(config) {
         field.touch();
       }
       if (isValid()) {
-        const result = onSubmit(values());
-        if (result && typeof result.then === "function") {
+        const report = (error) => reportError(error, { phase: "async", name: "form.handleSubmit" });
+        let pending;
+        try {
+          pending = adoptThenable(onSubmit(values()));
+        } catch (error) {
+          report(error);
+          return;
+        }
+        if (pending) {
           setSubmitting(true);
-          result.then(
+          pending.then(
             () => setSubmitting(false),
-            () => setSubmitting(false)
+            (error) => {
+              setSubmitting(false);
+              report(error);
+            }
           );
         }
       }
@@ -5958,6 +6584,17 @@ function form(config) {
   function setError(field, message) {
     setManualErrors((prev) => ({ ...prev, [field]: message }));
   }
+  let disposed = false;
+  function dispose2() {
+    if (disposed) return;
+    disposed = true;
+    errors.dispose();
+    isValid.dispose();
+    isDirty.dispose();
+    touchedState.dispose();
+    values.dispose();
+    for (const error of fieldErrors) error.dispose();
+  }
   return {
     fields: fieldMap,
     errors,
@@ -5968,7 +6605,8 @@ function form(config) {
     values,
     handleSubmit,
     reset,
-    setError
+    setError,
+    dispose: dispose2
   };
 }
 
@@ -6012,7 +6650,7 @@ function VirtualList(props) {
       content.appendChild(itemEl);
     }
   };
-  registerDisposer(container, effect(update));
+  registerDisposer(container, domBinding(update, container));
   return container;
 }
 
@@ -6022,11 +6660,14 @@ function intersection(options) {
   const [ratio, setRatio] = signal(0);
   let observer = null;
   let currentElement = null;
+  let generation = 0;
   function observe(element) {
     if (typeof IntersectionObserver === "undefined") return;
     unobserve();
     currentElement = element;
+    const observation = ++generation;
     observer = new IntersectionObserver((entries) => {
+      if (observation !== generation) return;
       const entry = entries[0];
       if (entry) {
         setIsIntersecting(entry.isIntersecting);
@@ -6036,8 +6677,10 @@ function intersection(options) {
     observer.observe(element);
   }
   function unobserve() {
+    generation++;
     if (observer) {
       if (currentElement) observer.unobserve(currentElement);
+      observer.takeRecords();
       observer.disconnect();
       observer = null;
       currentElement = null;
@@ -6056,17 +6699,26 @@ function lazyLoad(element, loader, options) {
     return () => {
     };
   }
+  let done = false;
+  const stop2 = () => {
+    done = true;
+    observer.takeRecords();
+    observer.disconnect();
+  };
   const observer = new IntersectionObserver((entries) => {
+    if (done) return;
     for (const entry of entries) {
       if (entry.isIntersecting) {
+        stop2();
         loader();
-        observer.disconnect();
         break;
       }
     }
   }, options);
   observer.observe(element);
-  return () => observer.disconnect();
+  return () => {
+    if (!done) stop2();
+  };
 }
 
 // src/ui/inputMask.ts
@@ -6215,6 +6867,7 @@ function focus() {
     const dispose2 = () => {
       if (disposed) return;
       disposed = true;
+      unregisterDisposer(element, dispose2);
       element.removeEventListener("focus", onFocus);
       element.removeEventListener("blur", onBlur);
       if (currentElement === element) currentElement = null;
@@ -6283,14 +6936,19 @@ function FocusTrap(nodes, options = {}) {
     }
   };
   container.addEventListener("keydown", onTrapKeydown);
+  let disposed = false;
   if (options.autoFocus !== false) {
     queueMicrotask(() => {
+      if (disposed || !container.isConnected) return;
       const first = getFocusable()[0];
       first?.focus();
     });
   }
   let trapObserver = null;
   function restoreFocusAndCleanup() {
+    if (disposed) return;
+    disposed = true;
+    unregisterDisposer(container, restoreFocusAndCleanup);
     if (options.restoreFocus !== false) previouslyFocused?.focus();
     container.removeEventListener("keydown", onTrapKeydown);
     if (trapObserver) {
@@ -6305,29 +6963,45 @@ function FocusTrap(nodes, options = {}) {
       }
     });
     queueMicrotask(() => {
-      if (container.isConnected) {
-        trapObserver.observe(container, { childList: true, subtree: true });
-      }
+      const observer = trapObserver;
+      if (disposed || !container.isConnected || !observer) return;
+      observer.observe(container, { childList: true, subtree: true });
     });
   }
   registerDisposer(container, restoreFocusAndCleanup);
   return container;
 }
+function isApplePlatform() {
+  if (typeof navigator === "undefined") return false;
+  const nav2 = navigator;
+  return /mac|iphone|ipad|ipod/i.test(nav2.userAgentData?.platform || nav2.platform || "");
+}
 function hotkey(combo, handler, options = {}) {
   let key = combo;
   let needCtrl = options.ctrl ?? false;
   let needShift = options.shift ?? false;
   let needAlt = options.alt ?? false;
   let needMeta = options.meta ?? false;
-  if (combo.includes("+")) {
-    const parts = combo.toLowerCase().split("+");
+  if (combo === "+") {
+    key = "+";
+  } else if (combo.includes("+")) {
+    const literalPlus = combo.endsWith("++");
+    const parts = (literalPlus ? combo.slice(0, -2) : combo).toLowerCase().split("+");
+    if (literalPlus) parts.push("+");
     key = parts[parts.length - 1];
+    if (key === "") throw new Error(`hotkey("${combo}"): missing key`);
     for (let i2 = 0; i2 < parts.length - 1; i2++) {
       const mod = parts[i2];
       if (mod === "ctrl" || mod === "control") needCtrl = true;
       else if (mod === "shift") needShift = true;
-      else if (mod === "alt") needAlt = true;
+      else if (mod === "alt" || mod === "option") needAlt = true;
       else if (mod === "meta" || mod === "cmd" || mod === "command") needMeta = true;
+      else if (mod === "mod") {
+        if (isApplePlatform()) needMeta = true;
+        else needCtrl = true;
+      } else {
+        throw new Error(`hotkey("${combo}"): unknown modifier "${mod}"`);
+      }
     }
   }
   const listener = (e) => {
@@ -6785,6 +7459,8 @@ function removeGlobalListenerIfIdle() {
 function dialog() {
   const [isOpen, setIsOpen] = signal(false);
   const entry = { close: () => close() };
+  let opened = false;
+  let disposed = false;
   function pushOnStack() {
     if (dialogStack.indexOf(entry) !== -1) return;
     dialogStack.push(entry);
@@ -6796,23 +7472,27 @@ function dialog() {
     removeGlobalListenerIfIdle();
   }
   function open() {
-    if (isOpen()) return;
-    setIsOpen(true);
+    if (disposed || opened) return;
+    opened = true;
     pushOnStack();
+    setIsOpen(true);
   }
   function close() {
-    if (!isOpen()) {
+    if (!opened) {
       removeFromStack();
       return;
     }
-    setIsOpen(false);
+    opened = false;
     removeFromStack();
+    setIsOpen(false);
   }
   function toggle() {
-    if (isOpen()) close();
+    if (opened) close();
     else open();
   }
   function dispose2() {
+    disposed = true;
+    opened = false;
     removeFromStack();
     setIsOpen(false);
   }
@@ -7017,32 +7697,49 @@ function pagination(options) {
 function eventBus() {
   const listeners = /* @__PURE__ */ new Map();
   function on(event, handler) {
-    let set = listeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      listeners.set(event, set);
+    let subs = listeners.get(event);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Map();
+      listeners.set(event, subs);
+    }
+    let subscription = subs.get(handler);
+    if (!subscription) {
+      subscription = { handler, active: true };
+      subs.set(handler, subscription);
     }
-    set.add(handler);
-    return () => off(event, handler);
+    const own = subscription;
+    return () => {
+      if (listeners.get(event)?.get(handler) !== own) return;
+      off(event, handler);
+    };
   }
   function emit(event, data2) {
-    const set = listeners.get(event);
-    if (set) {
-      for (const handler of set) {
-        handler(data2);
+    const subs = listeners.get(event);
+    if (!subs || subs.size === 0) return;
+    for (const subscription of Array.from(subs.values())) {
+      if (!subscription.active) continue;
+      try {
+        subscription.handler(data2);
+      } catch (err) {
+        reportError(err, { phase: "event", name: `eventBus(${String(event)})` });
       }
     }
   }
   function off(event, handler) {
-    const set = listeners.get(event);
-    if (set) {
-      set.delete(handler);
-      if (set.size === 0) {
-        listeners.delete(event);
-      }
+    const subs = listeners.get(event);
+    if (!subs) return;
+    const subscription = subs.get(handler);
+    if (!subscription) return;
+    subscription.active = false;
+    subs.delete(handler);
+    if (subs.size === 0) {
+      listeners.delete(event);
     }
   }
   function clear() {
+    for (const subs of listeners.values()) {
+      for (const subscription of subs.values()) subscription.active = false;
+    }
     listeners.clear();
   }
   return { on, emit, off, clear };
@@ -7072,28 +7769,34 @@ function insertTask(task) {
   }
   taskQueue.splice(i2, 0, task);
 }
+function runTask(callback) {
+  try {
+    callback();
+  } catch (err) {
+    reportError(err, { phase: "scheduler", name: "scheduleUpdate" });
+  }
+}
 function processQueue() {
   if (_sched.isProcessing || taskQueue.length === 0) return;
   _sched.isProcessing = true;
   const startTime = performance.now();
   const timeSlice = 5;
-  while (taskQueue.length > 0) {
-    const task = taskQueue[0];
-    if (task.cancelled) {
+  try {
+    while (taskQueue.length > 0) {
+      const task = taskQueue[0];
+      if (task.cancelled) {
+        taskQueue.shift();
+        continue;
+      }
+      if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
+        break;
+      }
       taskQueue.shift();
-      continue;
-    }
-    if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
-      break;
-    }
-    taskQueue.shift();
-    try {
-      task.callback();
-    } catch (e) {
-      console.error("[Scheduler] Task error:", e);
+      runTask(task.callback);
     }
+  } finally {
+    _sched.isProcessing = false;
   }
-  _sched.isProcessing = false;
   if (taskQueue.length > 0) {
     scheduleFrame();
   }
@@ -7161,11 +7864,7 @@ function scheduleUpdate(priority, callback) {
     cancelled: false
   };
   if (priority === Priority.IMMEDIATE) {
-    try {
-      callback();
-    } catch (e) {
-      console.error("[Scheduler] Immediate task error:", e);
-    }
+    runTask(callback);
     return () => {
     };
   }
@@ -7185,14 +7884,15 @@ function flushScheduler() {
   _sched.scheduledHandle = null;
   _sched.scheduledKind = null;
   _sched.microtaskScheduled = false;
-  while (taskQueue.length > 0) {
-    const task = taskQueue.shift();
-    if (!task) break;
-    if (!task.cancelled) {
-      task.callback();
+  try {
+    while (taskQueue.length > 0) {
+      const task = taskQueue.shift();
+      if (!task) break;
+      if (!task.cancelled) runTask(task.callback);
     }
+  } finally {
+    _sched.isProcessing = false;
   }
-  _sched.isProcessing = false;
 }
 function pendingTasks() {
   return taskQueue.filter((t) => !t.cancelled).length;
@@ -7328,11 +8028,16 @@ function getDOMPool() {
   return _defaultPool;
 }
 var preloadedResources = /* @__PURE__ */ new Set();
+function hintKey(rel, as, crossorigin, href) {
+  return `${rel}\0${as}\0${crossorigin}\0${href}`;
+}
 function preloadResource(url, type = "fetch") {
   const safe = sanitizeUrl(url);
   if (!safe) return;
-  if (preloadedResources.has(safe)) return;
-  preloadedResources.add(safe);
+  const as = type === "script" || type === "style" || type === "image" ? type : "fetch";
+  const key = hintKey("preload", as, as === "fetch" ? "anonymous" : "", safe);
+  if (preloadedResources.has(key)) return;
+  preloadedResources.add(key);
   const link2 = document.createElement("link");
   link2.rel = "preload";
   link2.href = safe;
@@ -7355,8 +8060,9 @@ function preloadResource(url, type = "fetch") {
 function prefetch(url) {
   const safe = sanitizeUrl(url);
   if (!safe) return;
-  if (preloadedResources.has(safe)) return;
-  preloadedResources.add(safe);
+  const key = hintKey("prefetch", "", "", safe);
+  if (preloadedResources.has(key)) return;
+  preloadedResources.add(key);
   const link2 = document.createElement("link");
   link2.rel = "prefetch";
   link2.href = safe;
@@ -7821,7 +8527,7 @@ function renderToDocument(component, options = {}) {
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${options.title ? `<title>${escapeHtml(options.title)}</title>` : ""}
+    ${options.title != null ? `<title>${escapeHtml(options.title)}</title>` : ""}
     ${metaTags}
     ${linkTags}
     ${options.headExtra || ""}
@@ -7996,16 +8702,32 @@ function ssrSuspense(props) {
   const timeoutPromise = new Promise((_, reject) => {
     timer = setTimeout(() => reject(new Error(`[SibuJS SSR] ssrSuspense timed out after ${timeoutMs}ms`)), timeoutMs);
   });
-  const raced = Promise.race([props.content(), timeoutPromise]);
+  let contentPromise;
+  try {
+    contentPromise = Promise.resolve(props.content());
+  } catch (err) {
+    contentPromise = Promise.reject(err);
+  }
+  const toFallback = (err) => {
+    if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
+    return { id, html: fallbackHtml };
+  };
+  const clearTimer = () => {
+    if (timer !== void 0) clearTimeout(timer);
+  };
+  const raced = Promise.race([contentPromise, timeoutPromise]);
   const promise = raced.then(
     (resolvedEl) => {
-      if (timer) clearTimeout(timer);
-      return { id, html: renderToString(resolvedEl) };
+      clearTimer();
+      try {
+        return { id, html: renderToString(resolvedEl) };
+      } catch (err) {
+        return toFallback(err);
+      }
     },
     (err) => {
-      if (timer) clearTimeout(timer);
-      if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
-      return { id, html: fallbackHtml };
+      clearTimer();
+      return toFallback(err);
     }
   );
   promise.catch(noop);
@@ -8094,65 +8816,92 @@ function block(factory) {
 }
 
 // src/performance/normalize.ts
+function dict(source2) {
+  const out = /* @__PURE__ */ Object.create(null);
+  if (source2) {
+    for (const key of Object.keys(source2)) defineOwn(out, key, source2[key]);
+  }
+  return out;
+}
+function ownGet(obj, key) {
+  return obj !== void 0 && Object.hasOwn(obj, key) ? obj[key] : void 0;
+}
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function readEntityId(entity, idKey, typeName) {
+  const raw = entity !== null && typeof entity === "object" && Object.hasOwn(entity, idKey) ? entity[idKey] : void 0;
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  throw new TypeError(
+    `[normalize] "${typeName}" entity has no valid "${idKey}" (expected a string or finite number, got ${raw === null ? "null" : typeof raw})`
+  );
+}
 function normalizedStore(schema) {
   const idKey = schema.idKey || "id";
   const [getState, setState] = signal({
     ids: [],
-    entities: {}
+    entities: dict()
   });
-  const idOf = (entity) => String(entity[idKey]);
+  const idOf = (entity) => readEntityId(entity, idKey, schema.name);
   function add(entity) {
     const id = idOf(entity);
     setState((prev) => {
-      const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
-      return {
-        ids,
-        entities: { ...prev.entities, [id]: entity }
-      };
+      const ids = Object.hasOwn(prev.entities, id) ? prev.ids : [...prev.ids, id];
+      const entities = dict(prev.entities);
+      defineOwn(entities, id, entity);
+      return { ids, entities };
     });
   }
   function addMany(entities) {
+    const ids = entities.map(idOf);
     setState((prev) => {
       const nextIds = [...prev.ids];
-      const nextEntities = { ...prev.entities };
-      for (const entity of entities) {
-        const id = idOf(entity);
-        if (!nextIds.includes(id)) {
+      const nextEntities = dict(prev.entities);
+      entities.forEach((entity, i2) => {
+        const id = ids[i2];
+        if (!Object.hasOwn(nextEntities, id)) {
           nextIds.push(id);
         }
-        nextEntities[id] = entity;
-      }
+        defineOwn(nextEntities, id, entity);
+      });
       return { ids: nextIds, entities: nextEntities };
     });
   }
   function get(id) {
-    const state2 = getState();
-    return state2.entities[id];
+    return ownGet(getState().entities, id);
   }
   function getAll() {
     const state2 = getState();
     return state2.ids.map((id) => state2.entities[id]);
   }
   function update(id, partial) {
-    setState((prev) => {
-      const existing = prev.entities[id];
-      if (!existing) return prev;
-      return {
-        ids: prev.ids,
-        entities: {
-          ...prev.entities,
-          [id]: { ...existing, ...partial }
-        }
-      };
+    const prev = getState();
+    if (!Object.hasOwn(prev.entities, id)) return;
+    if (partial !== null && typeof partial === "object" && Object.hasOwn(partial, idKey)) {
+      const nextId = readEntityId(partial, idKey, schema.name);
+      if (nextId !== id) {
+        throw new Error(
+          `[normalizedStore] update("${id}") cannot change "${idKey}" to "${nextId}"; remove and re-add the entity instead.`
+        );
+      }
+    }
+    setState((current) => {
+      const existing = ownGet(current.entities, id);
+      if (!existing) return current;
+      const entities = dict(current.entities);
+      defineOwn(entities, id, { ...existing, ...partial });
+      return { ids: current.ids, entities };
     });
   }
   function remove(id) {
     setState((prev) => {
-      if (!prev.entities[id]) return prev;
-      const { [id]: _, ...remainingEntities } = prev.entities;
+      if (!Object.hasOwn(prev.entities, id)) return prev;
+      const entities = dict(prev.entities);
+      delete entities[id];
       return {
         ids: prev.ids.filter((existingId) => existingId !== id),
-        entities: remainingEntities
+        entities
       };
     });
   }
@@ -8163,31 +8912,37 @@ function normalizedStore(schema) {
   return { add, addMany, get, getAll, update, remove, select: select3, getState };
 }
 function normalize(data2, schema) {
-  const entities = {};
+  const entities = dict();
   function ensureTable(name) {
-    if (!entities[name]) {
-      entities[name] = {};
+    let table2 = ownGet(entities, name);
+    if (!table2) {
+      table2 = dict();
+      defineOwn(entities, name, table2);
     }
-    return entities[name];
+    return table2;
   }
   function normalizeEntity(entity, entitySchema) {
     const entityIdKey = entitySchema.idKey || "id";
-    const id = String(entity[entityIdKey]);
+    const id = readEntityId(entity, entityIdKey, entitySchema.name);
     const table2 = ensureTable(entitySchema.name);
     const flat = { ...entity };
     if (entitySchema.relations) {
       for (const [field, relationType] of Object.entries(entitySchema.relations)) {
-        const value = entity[field];
+        const value = Object.hasOwn(entity, field) ? entity[field] : void 0;
         if (value == null) continue;
         const relSchema = { name: relationType };
         if (Array.isArray(value)) {
-          flat[field] = value.map((item) => normalizeEntity(item, relSchema));
+          defineOwn(
+            flat,
+            field,
+            value.map((item) => normalizeEntity(item, relSchema))
+          );
         } else if (typeof value === "object") {
-          flat[field] = normalizeEntity(value, relSchema);
+          defineOwn(flat, field, normalizeEntity(value, relSchema));
         }
       }
     }
-    table2[id] = flat;
+    defineOwn(table2, id, flat);
     return id;
   }
   if (Array.isArray(data2)) {
@@ -8198,20 +8953,24 @@ function normalize(data2, schema) {
   return { result, entities };
 }
 function denormalize(id, entities, schema) {
-  const table2 = entities[schema.name];
+  const table2 = ownGet(entities, schema.name);
   if (!table2) return void 0;
-  const entity = table2[id];
+  const entity = ownGet(table2, id);
   if (!entity) return void 0;
   const result = { ...entity };
   if (schema.relations) {
     for (const [field, relationType] of Object.entries(schema.relations)) {
-      const value = entity[field];
+      const value = ownGet(entity, field);
       if (value == null) continue;
       const relSchema = { name: relationType };
       if (Array.isArray(value)) {
-        result[field] = value.map((relId) => denormalize(relId, entities, relSchema));
+        defineOwn(
+          result,
+          field,
+          value.map((relId) => denormalize(relId, entities, relSchema))
+        );
       } else if (typeof value === "string") {
-        result[field] = denormalize(value, entities, relSchema);
+        defineOwn(result, field, denormalize(value, entities, relSchema));
       }
     }
   }
@@ -8421,13 +9180,24 @@ function lazyChunk(id, loader, registry, fallback) {
     if (fallback) {
       container.appendChild(fallback());
     }
+    let disposed = false;
+    registerDisposer(container, () => {
+      disposed = true;
+    });
     registry.load(id, async () => {
       const mod = await loader();
       return typeof mod === "function" ? mod : mod.default;
     }).then((component) => {
+      if (disposed) return;
+      const node = component();
+      if (disposed) {
+        dispose(node);
+        return;
+      }
       clearChildren(container);
-      container.appendChild(component());
+      container.appendChild(node);
     }).catch((err) => {
+      if (disposed) return;
       clearChildren(container);
       const errorEl = document.createElement("div");
       errorEl.textContent = `Failed to load chunk '${id}': ${err.message}`;
@@ -8518,7 +9288,7 @@ function Head(props) {
   };
   const apply = () => {
     cleanup3();
-    if (props.title) {
+    if (props.title != null) {
       if (typeof props.title === "function") {
         const getter = props.title;
         let lease = null;
@@ -8573,13 +9343,14 @@ function Head(props) {
   return anchor;
 }
 function setStructuredData(data2) {
-  const existing = document.head.querySelector('script[type="application/ld+json"][data-sibu]');
-  if (existing) existing.remove();
+  const json = escapeScriptJsonLocal(JSON.stringify(data2));
   const script2 = document.createElement("script");
   script2.type = "application/ld+json";
   script2.setAttribute("data-sibu", "true");
-  script2.textContent = escapeScriptJsonLocal(JSON.stringify(data2));
-  document.head.appendChild(script2);
+  script2.textContent = json;
+  const existing = document.head.querySelector('script[type="application/ld+json"][data-sibu]');
+  if (existing) existing.replaceWith(script2);
+  else document.head.appendChild(script2);
 }
 function setCanonical(url) {
   let link2 = document.head.querySelector('link[rel="canonical"]');
@@ -8595,13 +9366,33 @@ function setCanonical(url) {
 
 // src/platform/customElement.ts
 var SVG_NS2 = "http://www.w3.org/2000/svg";
+var MAX_RENDER_PASSES = 10;
+var ABANDONED_RENDER = /* @__PURE__ */ Symbol("sibujs.defineElement.abandonedRender");
 function defineElement(name, component, options = {}) {
   if (customElements.get(name)) return;
   const observed = options.observedAttributes || [];
   class SibuElement extends HTMLElement {
     constructor() {
       super();
-      this._rendered = null;
+      // Re-rendering is keyed on connection, not on a previous render: a first render
+      // that throws leaves nothing rendered, and the element must still re-render
+      // when a later attribute change fixes the input.
+      this._connected = false;
+      // A render in progress, and whether an attribute changed during it. The
+      // component may write its host's observed attributes while rendering; with
+      // the old subtree kept during the build, rendering again from inside the
+      // callback recursed until the stack overflowed.
+      this._rendering = false;
+      this._dirty = false;
+      // How many teardowns are draining. A host teardown may reconnect the element
+      // (and a nested disconnect may run inside it), and rendering the next
+      // generation from inside that drain would let the drain tear down what the
+      // new render registers. A counter, not a flag: a nested teardown returning
+      // must not declare the outer one finished.
+      this._teardownDepth = 0;
+      // Disconnects so far. A render compares it across its old-subtree teardown
+      // to detect a disconnect that happened inside it.
+      this._disconnects = 0;
       if (options.shadow !== false) {
         this._root = this.attachShadow({ mode: options.mode || "open" });
       } else {
@@ -8611,32 +9402,106 @@ function defineElement(name, component, options = {}) {
     static get observedAttributes() {
       return observed;
     }
+    /** Whether rendering must wait for work already in progress. */
+    get _busy() {
+      return this._rendering || this._teardownDepth > 0;
+    }
     connectedCallback() {
+      this._connected = true;
+      if (this._busy) {
+        this._dirty = true;
+        return;
+      }
       this._render();
     }
     disconnectedCallback() {
-      this._teardown();
+      this._connected = false;
+      this._disconnects++;
+      this._teardownDepth++;
+      try {
+        this._teardown();
+      } finally {
+        this._teardownDepth--;
+        if (this._teardownDepth === 0 && this._connected && this._dirty) {
+          this._dirty = false;
+          if (!this._rendering) this._render();
+        }
+      }
     }
-    attributeChangedCallback() {
-      if (this._rendered) {
-        this._render();
+    attributeChangedCallback(_name, oldValue, newValue) {
+      if (oldValue === newValue || !this._connected) return;
+      if (this._busy) {
+        this._dirty = true;
+        return;
       }
+      this._render();
     }
     _teardown() {
-      this._rendered = null;
       replaceChildrenSafely(this._root);
+      disposeNodeOwn(this);
     }
+    /**
+     * Render as a transaction: build the replacement first, commit only if that
+     * succeeds. Tearing the current subtree down before calling the factory
+     * meant a throwing rerender (an invalid attribute, say) left the element
+     * blank with its live state already disposed. Now a failure keeps the
+     * working subtree, releases whatever the failed attempt registered, and is
+     * reported with this element as its node so an enclosing ErrorBoundary can
+     * claim it.
+     */
     _render() {
-      this._teardown();
+      this._rendering = true;
+      try {
+        let passes = 0;
+        do {
+          this._dirty = false;
+          if (++passes > MAX_RENDER_PASSES) {
+            reportError(
+              new Error(
+                `[SibuJS] defineElement(${name}): the component changed its own observed attributes on ${MAX_RENDER_PASSES} consecutive renders; stopped re-rendering.`
+              ),
+              { phase: "render", name: `defineElement(${name})`, node: this }
+            );
+            break;
+          }
+          this._renderOnce();
+        } while (this._dirty && this._connected);
+      } finally {
+        this._rendering = false;
+        this._dirty = false;
+      }
+    }
+    _renderOnce() {
       const props = this._getProps();
+      let el;
+      try {
+        el = withDisposerRollback(() => {
+          const built = component(props, this);
+          if (!this._connected) throw ABANDONED_RENDER;
+          return built;
+        });
+      } catch (err) {
+        if (err !== ABANDONED_RENDER) {
+          reportError(err, { phase: "render", name: `defineElement(${name})`, node: this });
+        }
+        return;
+      }
+      const next = [];
       if (options.styles && this._root instanceof ShadowRoot) {
         const styleEl = document.createElement("style");
         styleEl.textContent = options.styles;
-        this._root.appendChild(styleEl);
+        next.push(styleEl);
+      }
+      next.push(el);
+      const disconnects = this._disconnects;
+      for (const node of next) node.parentNode?.removeChild(node);
+      replaceChildrenSafely(this._root);
+      if (this._disconnects !== disconnects) {
+        for (const node of next) dispose(node);
+        if (this._connected) this._dirty = true;
+        return;
       }
-      const el = component(props, this);
-      this._root.appendChild(el);
-      this._rendered = el;
+      this._root.replaceChildren(...next);
     }
     _getProps() {
       const props = {};
@@ -8669,6 +9534,11 @@ function svgElement(tag, props = {}, ...nodes) {
 }
 
 // src/platform/worker.ts
+function toError(err) {
+  if (err instanceof Error) return err;
+  if (err !== null && typeof err === "object" && "name" in err && "message" in err) return err;
+  return new Error(String(err));
+}
 function worker(workerFn2) {
   const [result, setResult] = signal(null);
   const [error, setError] = signal(null);
@@ -8691,8 +9561,11 @@ function worker(workerFn2) {
     worker2 = new Worker(blobUrl);
     worker2.addEventListener("message", (e) => {
       revokeBlobUrl();
-      setResult(e.data);
-      setLoading(false);
+      batch(() => {
+        setResult(e.data);
+        setError(null);
+        setLoading(false);
+      });
     });
     worker2.addEventListener("error", (e) => {
       revokeBlobUrl();
@@ -8709,10 +9582,17 @@ function worker(workerFn2) {
   }
   function post(data2) {
     if (!worker2) return;
-    setLoading(true);
-    setError(null);
-    setResult(null);
-    worker2.postMessage(data2);
+    try {
+      worker2.postMessage(data2);
+    } catch (err) {
+      setError(toError(err));
+      return;
+    }
+    batch(() => {
+      setLoading(true);
+      setError(null);
+      setResult(null);
+    });
   }
   function terminate() {
     if (!worker2) return;
@@ -8776,9 +9656,14 @@ function workerFn(fn) {
         reject(new Error("Worker is not available"));
         return;
       }
-      setLoading(true);
+      try {
+        worker2.postMessage(args);
+      } catch (err) {
+        reject(toError(err));
+        return;
+      }
       queue.push({ resolve, reject });
-      worker2.postMessage(args);
+      setLoading(true);
     });
   }
   function terminate() {
@@ -8808,7 +9693,11 @@ function createWorkerPool(workerFn2, poolSize) {
     }
   };
   function dispatchNext(idx) {
-    if (!alive || inflight[idx] || queues[idx].length === 0) return;
+    while (alive && !inflight[idx] && queues[idx].length > 0) {
+      dispatchOne(idx);
+    }
+  }
+  function dispatchOne(idx) {
     const w = workers[idx];
     const slot2 = queues[idx].shift();
     const onMsg = (e) => {
@@ -8833,10 +9722,15 @@ function createWorkerPool(workerFn2, poolSize) {
       slot2.reject(new Error(e.message || "Worker error"));
       dispatchNext(idx);
     };
+    try {
+      w.postMessage(slot2.data);
+    } catch (err) {
+      slot2.reject(toError(err));
+      return;
+    }
     inflight[idx] = { ...slot2, onMsg, onErr };
     w.addEventListener("message", onMsg);
     w.addEventListener("error", onErr);
-    w.postMessage(slot2.data);
   }
   try {
     if (typeof Worker === "undefined") {
@@ -9723,13 +10617,13 @@ function createSharedScope(initialState) {
   for (const key of Object.keys(initialState)) {
     const [get2, set2] = signal(initialState[key]);
     signals.set(key, { get: get2, set: set2 });
-    subscribers.set(key, /* @__PURE__ */ new Set());
+    subscribers.set(key, /* @__PURE__ */ new Map());
   }
   function ensureSignal(key) {
     if (!signals.has(key)) {
       const [get2, set2] = signal(void 0);
       signals.set(key, { get: get2, set: set2 });
-      subscribers.set(key, /* @__PURE__ */ new Set());
+      subscribers.set(key, /* @__PURE__ */ new Map());
     }
   }
   function get(key) {
@@ -9740,9 +10634,14 @@ function createSharedScope(initialState) {
     ensureSignal(key);
     signals.get(key)?.set(value);
     const subs = subscribers.get(key);
-    if (subs) {
-      for (const cb of subs) {
-        cb(value);
+    if (subs && subs.size > 0) {
+      for (const subscription of Array.from(subs.values())) {
+        if (!subscription.active) continue;
+        try {
+          subscription.callback(value);
+        } catch (err) {
+          reportError(err, { phase: "event", name: `sharedScope(${String(key)})` });
+        }
       }
     }
   }
@@ -9753,9 +10652,17 @@ function createSharedScope(initialState) {
       return () => {
       };
     }
-    subs.add(callback);
+    const cb = callback;
+    let subscription = subs.get(cb);
+    if (!subscription) {
+      subscription = { callback: cb, active: true };
+      subs.set(cb, subscription);
+    }
+    const own = subscription;
     return () => {
-      subs.delete(callback);
+      if (subs.get(cb) !== own) return;
+      own.active = false;
+      subs.delete(cb);
     };
   }
   return { get, set, subscribe };
@@ -9822,7 +10729,7 @@ function serviceWorker(scriptUrl, options) {
       arrivedRegistration = null;
     }
   }
-  function adopt(reg) {
+  function adopt2(reg) {
     if (unregisterRequested) {
       arrivedRegistration = reg;
       return null;
@@ -9831,7 +10738,7 @@ function serviceWorker(scriptUrl, options) {
     return reg;
   }
   if (supported) {
-    registrationPromise = navigator.serviceWorker.register(scriptUrl, options).then(adopt).catch((err) => {
+    registrationPromise = navigator.serviceWorker.register(scriptUrl, options).then(adopt2).catch((err) => {
       if (!unregistered) {
         setError(err instanceof Error ? err : new Error(String(err)));
       }
@@ -9907,15 +10814,31 @@ async function generateStaticSite(options) {
 // src/platform/incrementalRegeneration.ts
 function createISR(options) {
   const { revalidateAfter, fetcher, initialData } = options;
+  if (!Number.isFinite(revalidateAfter) || revalidateAfter <= 0) {
+    throw new RangeError(`[SibuJS ISR] revalidateAfter must be a positive finite number, got ${revalidateAfter}`);
+  }
   const [data2, setData] = signal(initialData);
-  const [timestamp, setTimestamp] = signal(initialData !== void 0 ? Date.now() : 0);
+  const [stale, setStale] = signal(initialData === void 0);
   const controller = new AbortController();
   let inFlight = false;
   let disposed = false;
-  const isStale = () => {
-    const ts = timestamp();
-    if (ts === 0) return true;
-    return Date.now() - ts >= revalidateAfter;
+  let deadline;
+  const clearDeadline = () => {
+    if (deadline !== void 0) {
+      clearTimeout(deadline);
+      deadline = void 0;
+    }
+  };
+  const armDeadline = () => {
+    clearDeadline();
+    deadline = setTimeout(() => {
+      deadline = void 0;
+      if (disposed) return;
+      setStale(true);
+      revalidate().catch((err) => {
+        if (typeof console !== "undefined") console.warn("[SibuJS ISR] revalidate failed", err);
+      });
+    }, revalidateAfter);
   };
   const revalidate = async () => {
     if (disposed || inFlight) return;
@@ -9924,8 +10847,14 @@ function createISR(options) {
     try {
       const result = await fetcher({ signal: controller.signal });
       if (disposed || controller.signal.aborted) return;
-      setData(result);
-      setTimestamp(Date.now());
+      batch(() => {
+        setData(result);
+        setStale(false);
+      });
+      armDeadline();
+    } catch (err) {
+      if (!disposed && !controller.signal.aborted) armDeadline();
+      throw err;
     } finally {
       inFlight = false;
     }
@@ -9934,19 +10863,16 @@ function createISR(options) {
     revalidate().catch((err) => {
       if (typeof console !== "undefined") console.warn("[SibuJS ISR] initial fetch failed", err);
     });
+  } else {
+    armDeadline();
   }
-  const intervalId = setInterval(() => {
-    revalidate().catch((err) => {
-      if (typeof console !== "undefined") console.warn("[SibuJS ISR] revalidate failed", err);
-    });
-  }, revalidateAfter);
   const dispose2 = () => {
     if (disposed) return;
     disposed = true;
-    clearInterval(intervalId);
+    clearDeadline();
     controller.abort();
   };
-  return { data: data2, isStale, revalidate, dispose: dispose2 };
+  return { data: data2, isStale: stale, revalidate, dispose: dispose2 };
 }
 
 // src/platform/routeActions.ts
@@ -10071,7 +10997,7 @@ function scrollRestoration(options) {
 
 // src/platform/routeMiddleware.ts
 function composeMiddleware(...fns) {
-  return async (context2, next) => {
+  return async (context, next) => {
     let index = -1;
     const dispatch = async (i2) => {
       if (i2 <= index) {
@@ -10079,7 +11005,7 @@ function composeMiddleware(...fns) {
       }
       index = i2;
       if (i2 < fns.length) {
-        await fns[i2](context2, () => dispatch(i2 + 1));
+        await fns[i2](context, () => dispatch(i2 + 1));
       } else {
         await next();
       }
@@ -10092,46 +11018,136 @@ function createMiddlewareChain() {
   const use2 = (fn) => {
     middlewares.push(fn);
   };
-  const run = async (context2) => {
+  const run = async (context) => {
     const composed = composeMiddleware(...middlewares);
-    await composed(context2, () => {
+    await composed(context, () => {
     });
   };
   return { use: use2, run };
 }
 
 // src/plugins/plugin.ts
+var CANCELLED_BRAND = /* @__PURE__ */ Symbol.for("sibujs.plugins.installCancelled.v1");
+var _a;
+var PluginInstallCancelledError = class extends Error {
+  constructor(pluginName) {
+    super(`[Plugin] Installation of "${pluginName}" was cancelled before it was committed (registry reset).`);
+    /**
+     * Brand, not identity: the default registry is shared across duplicate copies
+     * of this module, so the error a caller receives may come from another copy's
+     * constructor. `instanceof` is taught to recognise the brand instead.
+     */
+    this[_a] = true;
+    this.name = "PluginInstallCancelledError";
+    this.pluginName = pluginName;
+  }
+  static [(_a = CANCELLED_BRAND, Symbol.hasInstance)](value) {
+    return isPluginInstallCancelledError(value);
+  }
+};
+function isPluginInstallCancelledError(value) {
+  return typeof value === "object" && value !== null && value[CANCELLED_BRAND] === true;
+}
 function createPluginRegistry() {
   const installedPlugins = /* @__PURE__ */ new Set();
   const hooks = { init: [], mount: [], unmount: [], error: [] };
   const provided = /* @__PURE__ */ new Map();
+  const installStack = /* @__PURE__ */ new Set();
+  const pendingInstalls = /* @__PURE__ */ new Map();
+  let generation = 0;
   const registry = {
     installedPlugins,
     hooks,
     provided,
+    /**
+     * Install a plugin as a transaction.
+     *
+     * Hooks and providers registered through `ctx` are staged and committed
+     * only if `install()` returns; a throwing install leaves the registry
+     * exactly as it found it (and can simply be retried). The plugin is marked
+     * installed at commit, before its init hooks run.
+     *
+     * Each `plugin()` call is its own transaction: a dependency installed by a
+     * nested `plugin()` call commits on its own and stays installed even if the
+     * outer installation later fails.
+     */
     plugin(p2, options) {
       if (installedPlugins.has(p2.name)) {
         console.warn(`[Plugin] "${p2.name}" is already installed.`);
         return;
       }
+      if (installStack.has(p2.name)) {
+        throw new Error(`[Plugin] "${p2.name}" is already being installed (recursive installation).`);
+      }
+      if (pendingInstalls.has(p2.name)) {
+        throw new Error(`[Plugin] "${p2.name}" is already being installed (asynchronous installation in flight).`);
+      }
+      const staged = { init: [], mount: [], unmount: [], error: [] };
+      const stagedProvided = /* @__PURE__ */ new Map();
+      let committed = false;
+      const myGeneration = generation;
+      const stale = () => {
+        if (myGeneration === generation) return false;
+        if (DEV) devWarn(`plugin: "${p2.name}" registered after the registry was reset; the registration was ignored.`);
+        return true;
+      };
+      const target = () => stale() ? null : committed ? hooks : staged;
       const ctx = {
-        onInit: (cb) => hooks.init.push(cb),
-        onMount: (cb) => hooks.mount.push(cb),
-        onUnmount: (cb) => hooks.unmount.push(cb),
-        onError: (cb) => hooks.error.push(cb),
-        provide: (key, value) => provided.set(key, value)
+        onInit: (cb) => void target()?.init.push(cb),
+        onMount: (cb) => void target()?.mount.push(cb),
+        onUnmount: (cb) => void target()?.unmount.push(cb),
+        onError: (cb) => void target()?.error.push(cb),
+        provide: (key, value) => {
+          if (stale()) return;
+          (committed ? provided : stagedProvided).set(key, value);
+        }
       };
-      const initHooksBefore = hooks.init.length;
-      p2.install(ctx, options);
-      installedPlugins.add(p2.name);
-      const justAdded = hooks.init.slice(initHooksBefore);
-      for (const cb of justAdded) {
-        try {
-          cb();
-        } catch (e) {
-          console.error(`[Plugin] "${p2.name}" init error:`, e);
+      const commit = () => {
+        if (myGeneration !== generation) return false;
+        hooks.init.push(...staged.init);
+        hooks.mount.push(...staged.mount);
+        hooks.unmount.push(...staged.unmount);
+        hooks.error.push(...staged.error);
+        for (const [key, value] of stagedProvided) provided.set(key, value);
+        installedPlugins.add(p2.name);
+        committed = true;
+        if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+        for (const cb of staged.init.slice()) {
+          try {
+            cb();
+          } catch (e) {
+            console.error(`[Plugin] "${p2.name}" init error:`, e);
+          }
         }
+        return true;
+      };
+      installStack.add(p2.name);
+      let pending;
+      try {
+        pending = adoptThenable(p2.install(ctx, options));
+      } finally {
+        installStack.delete(p2.name);
+      }
+      if (!pending) {
+        if (!commit()) throw new PluginInstallCancelledError(p2.name);
+        return;
       }
+      if (myGeneration === generation) pendingInstalls.set(p2.name, myGeneration);
+      const settled = pending.then(
+        () => {
+          if (commit()) return;
+          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+          throw new PluginInstallCancelledError(p2.name);
+        },
+        (err) => {
+          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+          reportError(err, { phase: "async", name: `plugin(${p2.name})` });
+          throw err;
+        }
+      );
+      settled.catch(() => {
+      });
+      return settled;
     },
     inject(key, defaultValue) {
       if (provided.has(key)) return provided.get(key);
@@ -10169,6 +11185,8 @@ function createPluginRegistry() {
       }
     },
     reset() {
+      generation++;
+      pendingInstalls.clear();
       installedPlugins.clear();
       hooks.init.length = 0;
       hooks.mount.length = 0;
@@ -10188,7 +11206,7 @@ function createPlugin(name, install) {
 }
 function plugin(plugin2, options) {
   _defaults.touched = true;
-  _defaults.registry.plugin(plugin2, options);
+  return _defaults.registry.plugin(plugin2, options);
 }
 function inject(key, defaultValue) {
   return _defaults.registry.inject(key, defaultValue);
@@ -10219,35 +11237,44 @@ function setDefaultPluginRegistry(registry) {
 // src/plugins/modular.ts
 function createModuleRegistry() {
   const modules = /* @__PURE__ */ new Map();
-  function resolveInternal(name, stack) {
+  const resolving = [];
+  function resolveInternal(name) {
     const entry = modules.get(name);
     if (!entry) {
       throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
     }
-    if (entry.loaded) {
+    if (entry.state === "loaded") {
       return entry.value;
     }
-    if (stack.has(name)) {
-      const cycle = [...stack, name].join(" -> ");
+    if (entry.state === "resolving") {
+      const cycle = [...resolving.slice(resolving.indexOf(name)), name].join(" -> ");
       throw new Error(`[ModuleRegistry] Circular dependency detected: ${cycle}`);
     }
-    stack.add(name);
-    for (const dep of entry.deps) {
-      resolveInternal(dep, stack);
+    entry.state = "resolving";
+    resolving.push(name);
+    try {
+      for (const dep of entry.deps) {
+        resolveInternal(dep);
+      }
+      entry.value = entry.factory();
+      entry.state = "loaded";
+      return entry.value;
+    } catch (err) {
+      entry.state = "unloaded";
+      entry.value = void 0;
+      throw err;
+    } finally {
+      resolving.pop();
     }
-    stack.delete(name);
-    entry.value = entry.factory();
-    entry.loaded = true;
-    return entry.value;
   }
   return {
     /** Register a module with its factory function and optional dependencies */
     register(name, factory, deps = []) {
-      modules.set(name, { factory, deps, loaded: false });
+      modules.set(name, { factory, deps, state: "unloaded" });
     },
     /** Resolve a module, loading its dependencies first */
     resolve(name) {
-      return resolveInternal(name, /* @__PURE__ */ new Set());
+      return resolveInternal(name);
     },
     /** Check if a module is registered */
     has(name) {
@@ -10282,7 +11309,7 @@ function createModuleRegistry() {
     /** Reset all loaded modules back to unloaded state (useful for testing) */
     reset() {
       for (const entry of modules.values()) {
-        entry.loaded = false;
+        entry.state = "unloaded";
         entry.value = void 0;
       }
     }
@@ -10310,46 +11337,83 @@ function createBundle(modules) {
 function lazyModule(loader) {
   let cached;
   let loadedFlag = false;
-  const handle = {
+  let inFlight = null;
+  return {
     get loaded() {
       return loadedFlag;
     },
-    async get() {
-      if (loadedFlag) return cached;
-      cached = await loader();
-      loadedFlag = true;
-      return cached;
-    }
-  };
-  return handle;
-}
+    get() {
+      if (loadedFlag) return Promise.resolve(cached);
+      if (inFlight) return inFlight;
+      let started;
+      try {
+        started = Promise.resolve(loader());
+      } catch (err) {
+        started = Promise.reject(err);
+      }
+      const attempt = started.then(
+        (value) => {
+          cached = value;
+          loadedFlag = true;
+          if (inFlight === attempt) inFlight = null;
+          return value;
+        },
+        (err) => {
+          if (inFlight === attempt) inFlight = null;
+          throw err;
+        }
+      );
+      inFlight = attempt;
+      return attempt;
+    }
+  };
+}
+var MODULE_ENTRY_POINTS = {
+  main: "./index.ts",
+  data: "./data.ts",
+  browser: "./browser.ts",
+  patterns: "./patterns.ts",
+  motion: "./motion.ts",
+  ui: "./ui.ts",
+  widgets: "./widgets.ts",
+  ssr: "./ssr.ts",
+  devtools: "./devtools.ts",
+  performance: "./performance.ts",
+  ecosystem: "./ecosystem.ts",
+  plugins: "./plugins.ts",
+  build: "./build.ts",
+  testing: "./testing.ts",
+  extras: "./extras.ts"
+};
+var CDN_ENTRY_POINTS = {
+  cdn: "./dist/cdn.global.js",
+  "cdn-dev": "./dist/cdn.dev.global.js",
+  "cdn-full": "./dist/cdn.full.global.js",
+  "cdn-full-dev": "./dist/cdn.full.dev.global.js"
+};
 var packageInfo = {
-  name: "sibu",
-  version: "1.0.0",
-  entryPoints: {
-    main: "./index.ts",
-    core: "./src/core/html.ts",
-    hooks: "./src/core/signals/signal.ts",
-    router: "./src/plugins/router.ts",
-    i18n: "./src/plugins/i18n.ts",
-    testing: "./src/testing/index.ts",
-    ssr: "./src/core/ssr.ts"
-  },
+  name: "sibujs",
+  version: true ? "4.6.0" : "dev",
+  entryPoints: MODULE_ENTRY_POINTS,
   /**
-   * Generate a package.json `exports` map for Node.js subpath exports.
-   * Maps each entry point to its import, require, and types paths.
+   * Generate the package.json `exports` map. Module entries resolve to the
+   * `.js` (ESM), `.cjs` and `.d.ts` files tsup emits into `dist/`; CDN entries
+   * resolve to their prebuilt global script.
    */
   generateExportsMap() {
     const exportsMap = {};
-    for (const [name, sourcePath] of Object.entries(this.entryPoints)) {
+    for (const [name, sourcePath] of Object.entries(MODULE_ENTRY_POINTS)) {
       const distPath = sourcePath.replace(/^\.\//, "./dist/").replace(/\.ts$/, "");
       const subpath = name === "main" ? "." : `./${name}`;
       exportsMap[subpath] = {
-        import: `${distPath}.mjs`,
-        require: `${distPath}.cjs`,
-        types: `${distPath}.d.ts`
+        types: `${distPath}.d.ts`,
+        import: `${distPath}.js`,
+        require: `${distPath}.cjs`
       };
     }
+    for (const [name, file] of Object.entries(CDN_ENTRY_POINTS)) {
+      exportsMap[`./${name}`] = { default: file };
+    }
     return exportsMap;
   }
 };
@@ -10474,29 +11538,26 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = "1.0.0";
+var VERSION = true ? "4.6.0" : "dev";
+var NUM = "(?:0|[1-9]\\d*)";
+var PRE_ID = `(?:${NUM}|\\d*[a-zA-Z-][0-9a-zA-Z-]*)`;
+var BUILD_ID = "[0-9a-zA-Z-]+";
+var SEMVER_PATTERN = new RegExp(
+  `^(${NUM})(?:\\.(${NUM})(?:\\.(${NUM})(?:-(${PRE_ID}(?:\\.${PRE_ID})*))?(?:\\+(${BUILD_ID}(?:\\.${BUILD_ID})*))?)?)?$`
+);
 function parseSemVer(version) {
-  const trimmed = version.trim().replace(/^v/i, "");
-  const prereleaseIndex = trimmed.indexOf("-");
-  let main2;
-  let prerelease;
-  if (prereleaseIndex !== -1) {
-    main2 = trimmed.slice(0, prereleaseIndex);
-    prerelease = trimmed.slice(prereleaseIndex + 1);
-  } else {
-    main2 = trimmed;
-  }
-  const parts = main2.split(".");
-  const major = parseInt(parts[0], 10);
-  const minor = parseInt(parts[1] || "0", 10);
-  const patch = parseInt(parts[2] || "0", 10);
-  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+  const trimmed = String(version).trim().replace(/^v/i, "");
+  const match = SEMVER_PATTERN.exec(trimmed);
+  if (!match) {
     throw new Error(`[Versioning] Invalid semver string: "${version}"`);
   }
-  const result = { major, minor, patch };
-  if (prerelease !== void 0) {
-    result.prerelease = prerelease;
-  }
+  const result = {
+    major: Number(match[1]),
+    minor: match[2] === void 0 ? 0 : Number(match[2]),
+    patch: match[3] === void 0 ? 0 : Number(match[3])
+  };
+  if (match[4] !== void 0) result.prerelease = match[4];
+  if (match[5] !== void 0) result.build = match[5];
   return result;
 }
 function compareSemVer(a2, b2) {
@@ -10579,82 +11640,154 @@ function satisfies(version, range) {
   const target = parseSemVer(exactStr);
   return compareSemVer(v, target) === 0;
 }
+var MigrationStorageError = class extends Error {
+  constructor(version, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(`[Versioning] Migration ${version} completed, but recording it in storage failed: ${reason}`);
+    this.name = "MigrationStorageError";
+    this.version = version;
+    this.cause = cause;
+  }
+};
+var _migrationQueues = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.migrationQueues.v1"),
+  () => /* @__PURE__ */ new WeakMap()
+);
+var NO_STORAGE = {};
 function createMigrationRunner(config) {
   const storageKey = config.storageKey || "__sibu_migration_version__";
   const sortedMigrations = [...config.migrations].sort((a2, b2) => compareSemVer(a2.version, b2.version));
   function getStorage() {
+    if (config.storage) return config.storage;
     try {
       return typeof localStorage !== "undefined" ? localStorage : null;
     } catch {
       return null;
     }
   }
+  function getAppliedVersion() {
+    const storage = getStorage();
+    if (!storage) return null;
+    return storage.getItem(storageKey);
+  }
+  function getPending() {
+    const appliedVersion = getAppliedVersion();
+    if (!appliedVersion) {
+      return sortedMigrations.filter((m) => compareSemVer(m.version, config.currentVersion) <= 0);
+    }
+    return sortedMigrations.filter(
+      (m) => compareSemVer(m.version, appliedVersion) > 0 && compareSemVer(m.version, config.currentVersion) <= 0
+    );
+  }
+  function writeApplied(version, migrationVersion) {
+    const storage = getStorage();
+    if (!storage) return;
+    try {
+      if (version === null) storage.removeItem(storageKey);
+      else storage.setItem(storageKey, version);
+    } catch (e) {
+      throw new MigrationStorageError(migrationVersion, e);
+    }
+  }
+  function serialize(operation) {
+    const identity = getStorage() ?? NO_STORAGE;
+    let queues = _migrationQueues.get(identity);
+    if (!queues) {
+      queues = /* @__PURE__ */ new Map();
+      _migrationQueues.set(identity, queues);
+    }
+    const run = (queues.get(storageKey) ?? Promise.resolve()).then(operation, operation);
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    queues.set(storageKey, tail);
+    const settled = queues;
+    tail.then(() => {
+      if (settled.get(storageKey) === tail) settled.delete(storageKey);
+    });
+    return run;
+  }
   return {
     /** Get the last applied migration version from storage */
-    getAppliedVersion() {
-      const storage = getStorage();
-      if (!storage) return null;
-      return storage.getItem(storageKey);
-    },
+    getAppliedVersion,
     /** Get pending migrations that haven't been applied */
-    getPending() {
-      const appliedVersion = this.getAppliedVersion();
-      if (!appliedVersion) {
-        return sortedMigrations.filter((m) => compareSemVer(m.version, config.currentVersion) <= 0);
-      }
-      return sortedMigrations.filter(
-        (m) => compareSemVer(m.version, appliedVersion) > 0 && compareSemVer(m.version, config.currentVersion) <= 0
-      );
-    },
-    /** Run all pending migrations in order */
-    async migrate() {
-      const pending = this.getPending();
-      const applied = [];
-      const errors = [];
-      for (const migration of pending) {
+    getPending,
+    /**
+     * Run all pending migrations in order. Concurrent calls (and calls racing
+     * `rollback()`) run one after another, each recomputing what is pending —
+     * on this runner and on every other runner in this realm sharing its
+     * storage and storage key.
+     */
+    migrate() {
+      return serialize(async () => {
+        const applied = [];
+        const errors = [];
+        let pending;
         try {
-          await migration.up();
-          applied.push(migration.version);
-          const storage = getStorage();
-          if (storage) {
-            storage.setItem(storageKey, migration.version);
-          }
+          pending = getPending();
         } catch (e) {
           errors.push({
-            version: migration.version,
+            version: getAppliedVersion() ?? "",
             error: e instanceof Error ? e : new Error(String(e))
           });
-          break;
+          return { applied, errors };
         }
-      }
-      return { applied, errors };
+        for (const migration of pending) {
+          try {
+            await migration.up();
+          } catch (e) {
+            errors.push({
+              version: migration.version,
+              error: e instanceof Error ? e : new Error(String(e))
+            });
+            break;
+          }
+          applied.push(migration.version);
+          try {
+            writeApplied(migration.version, migration.version);
+          } catch (e) {
+            errors.push({ version: migration.version, error: e });
+            break;
+          }
+        }
+        return { applied, errors };
+      });
     },
-    /** Rollback to a specific version */
-    async rollback(targetVersion) {
-      const appliedVersion = this.getAppliedVersion();
-      const rolledBack = [];
-      if (!appliedVersion) {
-        return { rolledBack };
-      }
-      const toRollback = sortedMigrations.filter((m) => compareSemVer(m.version, targetVersion) > 0 && compareSemVer(m.version, appliedVersion) <= 0).reverse();
-      for (const migration of toRollback) {
-        if (!migration.down) {
-          throw new Error(
-            `[Versioning] Migration ${migration.version} ("${migration.description}") does not have a down() function and cannot be rolled back.`
-          );
+    /**
+     * Rollback to a specific version.
+     *
+     * The applied version is checkpointed after EVERY successful `down()`, so a
+     * rollback that fails part-way leaves storage describing what is actually
+     * still applied, and a retry does not repeat completed `down()` steps.
+     * Throws the failing `down()`'s error, a missing-`down()` error, or a
+     * {@link MigrationStorageError} if a checkpoint cannot be written.
+     */
+    rollback(targetVersion) {
+      return serialize(async () => {
+        const appliedVersion = getAppliedVersion();
+        const rolledBack = [];
+        if (!appliedVersion) {
+          return { rolledBack };
         }
-        await migration.down();
-        rolledBack.push(migration.version);
-      }
-      const storage = getStorage();
-      if (storage) {
-        if (targetVersion === "0.0.0") {
-          storage.removeItem(storageKey);
-        } else {
-          storage.setItem(storageKey, targetVersion);
+        const toRollback = sortedMigrations.filter((m) => compareSemVer(m.version, targetVersion) > 0 && compareSemVer(m.version, appliedVersion) <= 0).reverse();
+        for (const migration of toRollback) {
+          if (!migration.down) {
+            throw new Error(
+              `[Versioning] Migration ${migration.version} ("${migration.description}") does not have a down() function and cannot be rolled back.`
+            );
+          }
         }
-      }
-      return { rolledBack };
+        for (const migration of toRollback) {
+          await migration.down();
+          rolledBack.push(migration.version);
+          const index = sortedMigrations.indexOf(migration);
+          const previous2 = index > 0 ? sortedMigrations[index - 1].version : null;
+          writeApplied(previous2, migration.version);
+        }
+        writeApplied(targetVersion === "0.0.0" ? null : targetVersion, targetVersion);
+        return { rolledBack };
+      });
     }
   };
 }
@@ -10704,28 +11837,43 @@ function preloadCritical(resources) {
     document.head.appendChild(link2);
   }
 }
-function prerenderRoutes(routes, options) {
-  const maxCacheSize = options?.maxCacheSize ?? 50;
-  const cacheTTL = options?.cacheTTL ?? 0;
-  const cache = /* @__PURE__ */ new Map();
-  function isValid(entry) {
-    if (cacheTTL === 0) return true;
-    return Date.now() - entry.timestamp < cacheTTL;
+function assertCacheSize(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`[Startup] ${name} must be a non-negative integer, got ${value}`);
+  }
+}
+function makeRoomFor(cache, key, maxSize, isValid) {
+  if (maxSize === 0) return false;
+  if (cache.has(key)) return true;
+  if (cache.size < maxSize) return true;
+  for (const [k, entry] of cache) {
+    if (!isValid(entry)) cache.delete(k);
   }
-  function evictOldest() {
-    if (cache.size < maxCacheSize) return;
+  while (cache.size >= maxSize) {
     let oldestKey = null;
     let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
+    for (const [k, entry] of cache) {
       if (entry.timestamp < oldestTime) {
         oldestTime = entry.timestamp;
-        oldestKey = key;
+        oldestKey = k;
       }
     }
-    if (oldestKey) cache.delete(oldestKey);
+    if (oldestKey === null) break;
+    cache.delete(oldestKey);
+  }
+  return true;
+}
+function prerenderRoutes(routes, options) {
+  const maxCacheSize = options?.maxCacheSize ?? 50;
+  const cacheTTL = options?.cacheTTL ?? 0;
+  assertCacheSize("maxCacheSize", maxCacheSize);
+  const cache = /* @__PURE__ */ new Map();
+  function isValid(entry) {
+    if (cacheTTL === 0) return true;
+    return Date.now() - entry.timestamp < cacheTTL;
   }
   for (const route of routes) {
-    evictOldest();
+    if (!makeRoomFor(cache, route.path, maxCacheSize, isValid)) break;
     const html2 = renderToString(route.component());
     cache.set(route.path, { html: html2, timestamp: Date.now() });
   }
@@ -10777,6 +11925,7 @@ function prerenderRoutes(routes, options) {
 function createSSRCache(config) {
   const maxSize = config?.maxSize ?? 100;
   const defaultTTL = config?.defaultTTL ?? 6e4;
+  assertCacheSize("maxSize", maxSize);
   const cache = /* @__PURE__ */ new Map();
   let hits = 0;
   let misses = 0;
@@ -10784,18 +11933,6 @@ function createSSRCache(config) {
     if (entry.ttl === 0) return true;
     return Date.now() - entry.timestamp < entry.ttl;
   }
-  function evictOldest() {
-    if (cache.size < maxSize) return;
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) cache.delete(oldestKey);
-  }
   return {
     /** Get cached HTML for a key, or undefined if not cached or expired */
     get(key) {
@@ -10814,7 +11951,7 @@ function createSSRCache(config) {
     },
     /** Cache an HTML string with an optional TTL override */
     set(key, html2, ttl) {
-      evictOldest();
+      if (!makeRoomFor(cache, key, maxSize, isValid)) return;
       cache.set(key, {
         html: html2,
         timestamp: Date.now(),
@@ -10847,25 +11984,30 @@ function createSSRCache(config) {
     }
   };
 }
+var DEFER_IDLE_TIMEOUT_MS = 2e3;
 function deferNonCritical(tasks) {
   if (tasks.length === 0) return;
-  const schedule = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : (cb) => setTimeout(cb, 1);
+  const schedule = typeof requestIdleCallback !== "undefined" ? (cb) => {
+    requestIdleCallback(cb, { timeout: DEFER_IDLE_TIMEOUT_MS });
+  } : (cb) => {
+    setTimeout(cb, 1);
+  };
   const queue = [...tasks];
   let index = 0;
   function processNext(deadline) {
+    let ranOne = false;
     while (index < queue.length) {
-      if (deadline && deadline.timeRemaining() < 1) {
+      if (ranOne && deadline && deadline.timeRemaining() < 1) {
         schedule(processNext);
         return;
       }
       try {
         queue[index]();
       } catch (e) {
-        if (typeof console !== "undefined") {
-          console.error("[Startup] Deferred task failed:", e);
-        }
+        reportError(e, { phase: "scheduler", name: "deferNonCritical" });
       }
       index++;
+      ranOne = true;
     }
   }
   schedule(processNext);
@@ -11886,20 +13028,20 @@ function createErrorReporter(options) {
   const logToConsole = options?.logToConsole ?? true;
   const maxErrors = options?.maxErrors ?? 500;
   const errors = [];
-  function report(error, context2) {
+  function report(error, context) {
     let sibuError;
     if (error instanceof SibuError) {
       sibuError = error;
-      if (context2?.component && !sibuError.component) {
-        sibuError.component = context2.component;
+      if (context?.component && !sibuError.component) {
+        sibuError.component = context.component;
       }
-      if (context2?.props && !sibuError.props) {
-        sibuError.props = context2.props;
+      if (context?.props && !sibuError.props) {
+        sibuError.props = context.props;
       }
     } else {
       sibuError = new SibuError(error.message, {
-        component: context2?.component,
-        props: context2?.props,
+        component: context?.component,
+        props: context?.props,
         cause: error
       });
       sibuError.stack = error.stack;
@@ -11955,9 +13097,9 @@ function withErrorTracking(name, component, reporter) {
     }
   };
 }
-function formatError(error, context2, seen = /* @__PURE__ */ new Set([error])) {
+function formatError(error, context, seen = /* @__PURE__ */ new Set([error])) {
   const lines = [];
-  const componentLabel = context2?.component ?? (error instanceof SibuError ? error.component : void 0);
+  const componentLabel = context?.component ?? (error instanceof SibuError ? error.component : void 0);
   if (componentLabel) {
     lines.push(`[SibuJS:${componentLabel}] ${error.name}: ${error.message}`);
   } else {
@@ -11984,7 +13126,7 @@ function formatError(error, context2, seen = /* @__PURE__ */ new Set([error])) {
     seen.add(cause);
     lines.push("");
     lines.push("Caused by:");
-    lines.push(formatError(cause, context2, seen));
+    lines.push(formatError(cause, context, seen));
   }
   return lines.join("\n");
 }
@@ -12142,9 +13284,21 @@ function createDevtoolsOverlay(options) {
 var COUNTER_KEY = /* @__PURE__ */ Symbol.for("sibujs.createId.v1");
 var _counter = globalThis[COUNTER_KEY] ?? (globalThis[COUNTER_KEY] = { n: 0 });
 function createId(prefix = "sibu") {
+  const request = getRequestStore();
+  if (request) {
+    request.idCounter = (request.idCounter ?? 0) + 1;
+    return `${prefix}-${request.idCounter}`;
+  }
   _counter.n++;
   return `${prefix}-${_counter.n}`;
 }
+function idSegment(key) {
+  let out = "";
+  for (const ch of String(key)) {
+    out += /[A-Za-z0-9-]/.test(ch) ? ch : `_${(ch.codePointAt(0) ?? 0).toString(16)}_`;
+  }
+  return out;
+}
 
 // src/core/signals/watch.ts
 function watch(getter, callback) {
@@ -12249,7 +13403,7 @@ function combobox(options) {
     els.input.setAttribute("role", "combobox");
     els.input.setAttribute("aria-autocomplete", "list");
     els.input.setAttribute("aria-controls", listboxId);
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       const open2 = isOpen();
       els.input.setAttribute("aria-expanded", open2 ? "true" : "false");
       els.listbox.hidden = !open2;
@@ -12267,7 +13421,7 @@ function combobox(options) {
       }
       if (activeId) els.input.setAttribute("aria-activedescendant", activeId);
       else els.input.removeAttribute("aria-activedescendant");
-    });
+    }, els.input);
     const onInput = () => {
       setQuery(els.input.value);
       open();
@@ -12315,8 +13469,11 @@ function combobox(options) {
     els.input.addEventListener("focus", onFocus);
     els.input.addEventListener("blur", onBlur);
     els.listbox.addEventListener("mousedown", onListboxPointerDown);
+    let tornDown = false;
     const teardown = () => {
-      boundComboboxes.delete(els.input);
+      if (tornDown) return;
+      tornDown = true;
+      if (boundComboboxes.get(els.input) === teardown) boundComboboxes.delete(els.input);
       fxTeardown();
       els.input.removeEventListener("input", onInput);
       els.input.removeEventListener("keydown", onKey);
@@ -12361,11 +13518,23 @@ function combobox(options) {
   };
 }
 
+// src/widgets/attributeSnapshot.ts
+function snapshotAttributes(el, names) {
+  const previous2 = names.map((name) => [name, el.getAttribute(name)]);
+  return () => {
+    for (const [name, value] of previous2) {
+      if (value === null) el.removeAttribute(name);
+      else el.setAttribute(name, value);
+    }
+  };
+}
+
 // src/widgets/Tabs.ts
 var boundTablists = /* @__PURE__ */ new WeakMap();
 function tabs(options) {
   const { tabs: tabDefs, defaultTab } = options;
-  const initialTab = defaultTab ?? tabDefs.find((t) => !t.disabled)?.id ?? tabDefs[0]?.id ?? "";
+  const firstEnabled = tabDefs.find((t) => !t.disabled)?.id ?? "";
+  const initialTab = defaultTab !== void 0 && tabDefs.some((t) => t.id === defaultTab && !t.disabled) ? defaultTab : firstEnabled;
   const [activeTab, setActiveTabState] = signal(initialTab);
   function setActiveTab(id) {
     const tab = tabDefs.find((t) => t.id === id);
@@ -12412,58 +13581,29 @@ function tabs(options) {
   function bind(els) {
     const existing = boundTablists.get(els.tablist);
     if (existing) return existing;
-    const restore = [];
-    const prevTablistRole = els.tablist.getAttribute("role");
+    const restore = [snapshotAttributes(els.tablist, ["role"])];
     els.tablist.setAttribute("role", "tablist");
-    restore.push(() => {
-      if (prevTablistRole === null) els.tablist.removeAttribute("role");
-      else els.tablist.setAttribute("role", prevTablistRole);
-    });
+    const idPrefix = createId("sibu-tabs");
     for (const def of tabDefs) {
       const tabEl = els.tabs[def.id];
       if (!tabEl) continue;
-      const prevRole = tabEl.getAttribute("role");
-      const prevId = tabEl.id;
-      const prevDisabled = tabEl.getAttribute("aria-disabled");
-      const prevControls = tabEl.getAttribute("aria-controls");
+      restore.push(
+        snapshotAttributes(tabEl, ["role", "id", "aria-disabled", "aria-controls", "aria-selected", "tabindex"])
+      );
       tabEl.setAttribute("role", "tab");
-      tabEl.setAttribute("id", `sibu-tab-${def.id}`);
+      if (!tabEl.id) tabEl.id = `${idPrefix}-tab-${idSegment(def.id)}`;
       if (def.disabled) tabEl.setAttribute("aria-disabled", "true");
+      else tabEl.removeAttribute("aria-disabled");
       const panelEl = els.panels?.[def.id];
-      let prevPanelRole = null;
-      let prevPanelId = "";
-      let prevPanelLabelledBy = null;
       if (panelEl) {
-        prevPanelRole = panelEl.getAttribute("role");
-        prevPanelId = panelEl.id;
-        prevPanelLabelledBy = panelEl.getAttribute("aria-labelledby");
+        restore.push(snapshotAttributes(panelEl, ["role", "id", "aria-labelledby", "hidden"]));
         panelEl.setAttribute("role", "tabpanel");
-        panelEl.setAttribute("id", `sibu-tabpanel-${def.id}`);
-        panelEl.setAttribute("aria-labelledby", `sibu-tab-${def.id}`);
-        tabEl.setAttribute("aria-controls", `sibu-tabpanel-${def.id}`);
+        if (!panelEl.id) panelEl.id = `${idPrefix}-panel-${idSegment(def.id)}`;
+        panelEl.setAttribute("aria-labelledby", tabEl.id);
+        tabEl.setAttribute("aria-controls", panelEl.id);
       }
-      restore.push(() => {
-        if (prevRole === null) tabEl.removeAttribute("role");
-        else tabEl.setAttribute("role", prevRole);
-        if (prevId === "") tabEl.removeAttribute("id");
-        else tabEl.id = prevId;
-        if (prevDisabled === null) tabEl.removeAttribute("aria-disabled");
-        else tabEl.setAttribute("aria-disabled", prevDisabled);
-        if (prevControls === null) tabEl.removeAttribute("aria-controls");
-        else tabEl.setAttribute("aria-controls", prevControls);
-        tabEl.removeAttribute("aria-selected");
-        tabEl.removeAttribute("tabindex");
-        if (panelEl) {
-          if (prevPanelRole === null) panelEl.removeAttribute("role");
-          else panelEl.setAttribute("role", prevPanelRole);
-          if (prevPanelId === "") panelEl.removeAttribute("id");
-          else panelEl.id = prevPanelId;
-          if (prevPanelLabelledBy === null) panelEl.removeAttribute("aria-labelledby");
-          else panelEl.setAttribute("aria-labelledby", prevPanelLabelledBy);
-        }
-      });
     }
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       const active = activeTab();
       for (const def of tabDefs) {
         const tabEl = els.tabs[def.id];
@@ -12474,7 +13614,7 @@ function tabs(options) {
         const panelEl = els.panels?.[def.id];
         if (panelEl) panelEl.hidden = !isAct;
       }
-    });
+    }, els.tablist);
     const onKey = (e) => {
       if (e.key === "ArrowRight" || e.key === "ArrowDown") {
         e.preventDefault();
@@ -12511,7 +13651,10 @@ function tabs(options) {
       tabEl.addEventListener("click", fn);
       clickHandlers.push({ el: tabEl, fn });
     }
+    let tornDown = false;
     const teardown = () => {
+      if (tornDown) return;
+      tornDown = true;
       boundTablists.delete(els.tablist);
       fxTeardown();
       els.tablist.removeEventListener("keydown", onKey);
@@ -12537,7 +13680,10 @@ function tabs(options) {
 var boundAccordions = /* @__PURE__ */ new WeakMap();
 function accordion(options) {
   const { items: itemDefs, multiple = false, defaultExpanded = [] } = options;
-  const [expandedIds, setExpandedIds] = signal(new Set(defaultExpanded));
+  const knownIds = new Set(itemDefs.map((item) => item.id));
+  const validDefaults = defaultExpanded.filter((id) => knownIds.has(id));
+  const initialExpanded = multiple ? validDefaults : validDefaults.slice(0, 1);
+  const [expandedIds, setExpandedIds] = signal(new Set(initialExpanded));
   const items = derived(
     () => itemDefs.map((item) => ({
       ...item,
@@ -12588,42 +13734,22 @@ function accordion(options) {
       if (existing) return existing;
     }
     const restore = [];
+    const idPrefix = createId("sibu-accordion");
     for (const item of itemDefs) {
       const trig = els.triggers[item.id];
       const panel = els.panels[item.id];
       if (!trig) continue;
-      const prevTrigId = trig.id;
-      const prevTrigControls = trig.getAttribute("aria-controls");
-      trig.id = `sibu-accordion-trigger-${item.id}`;
-      let prevPanelRole = null;
-      let prevPanelId = "";
-      let prevPanelLabelledBy = null;
+      restore.push(snapshotAttributes(trig, ["id", "aria-controls", "aria-expanded"]));
+      if (!trig.id) trig.id = `${idPrefix}-trigger-${idSegment(item.id)}`;
       if (panel) {
-        prevPanelRole = panel.getAttribute("role");
-        prevPanelId = panel.id;
-        prevPanelLabelledBy = panel.getAttribute("aria-labelledby");
+        restore.push(snapshotAttributes(panel, ["role", "id", "aria-labelledby", "hidden"]));
         panel.setAttribute("role", "region");
-        panel.id = `sibu-accordion-panel-${item.id}`;
+        if (!panel.id) panel.id = `${idPrefix}-panel-${idSegment(item.id)}`;
         panel.setAttribute("aria-labelledby", trig.id);
         trig.setAttribute("aria-controls", panel.id);
       }
-      restore.push(() => {
-        if (prevTrigId === "") trig.removeAttribute("id");
-        else trig.id = prevTrigId;
-        if (prevTrigControls === null) trig.removeAttribute("aria-controls");
-        else trig.setAttribute("aria-controls", prevTrigControls);
-        trig.removeAttribute("aria-expanded");
-        if (panel) {
-          if (prevPanelRole === null) panel.removeAttribute("role");
-          else panel.setAttribute("role", prevPanelRole);
-          if (prevPanelId === "") panel.removeAttribute("id");
-          else panel.id = prevPanelId;
-          if (prevPanelLabelledBy === null) panel.removeAttribute("aria-labelledby");
-          else panel.setAttribute("aria-labelledby", prevPanelLabelledBy);
-        }
-      });
     }
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       const ids = expandedIds();
       for (const item of itemDefs) {
         const trig = els.triggers[item.id];
@@ -12633,7 +13759,7 @@ function accordion(options) {
         trig.setAttribute("aria-expanded", expanded ? "true" : "false");
         if (panel) panel.hidden = !expanded;
       }
-    });
+    }, idempotencyKey);
     const handlers = [];
     for (const item of itemDefs) {
       const trig = els.triggers[item.id];
@@ -12649,7 +13775,10 @@ function accordion(options) {
       trig.addEventListener("keydown", key);
       handlers.push({ el: trig, click, key });
     }
+    let tornDown = false;
     const teardown = () => {
+      if (tornDown) return;
+      tornDown = true;
       if (idempotencyKey) boundAccordions.delete(idempotencyKey);
       fxTeardown();
       for (const { el, click, key } of handlers) {
@@ -12708,11 +13837,11 @@ function popover() {
       }
       els.popover.setAttribute("aria-labelledby", els.labelledBy.id);
     }
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       const open2 = isOpen();
       els.trigger.setAttribute("aria-expanded", open2 ? "true" : "false");
       els.popover.hidden = !open2;
-    });
+    }, els.trigger);
     const onTriggerClick = (e) => {
       e.preventDefault();
       toggle();
@@ -12735,8 +13864,11 @@ function popover() {
     els.popover.addEventListener("keydown", onKey);
     els.trigger.addEventListener("keydown", onKey);
     document.addEventListener("pointerdown", onDocPointer);
+    let tornDown = false;
     const teardown = () => {
-      boundPopovers.delete(els.trigger);
+      if (tornDown) return;
+      tornDown = true;
+      if (boundPopovers.get(els.trigger) === teardown) boundPopovers.delete(els.trigger);
       fxTeardown();
       els.trigger.removeEventListener("click", onTriggerClick);
       els.popover.removeEventListener("keydown", onKey);
@@ -12854,7 +13986,7 @@ function select2(options) {
     els.listbox.setAttribute("aria-multiselectable", multiple ? "true" : "false");
     if (els.listbox.tabIndex < 0) els.listbox.tabIndex = 0;
     const toStr = els.itemToString ?? itemToString ?? ((it) => String(it));
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       const idx = highlightedIndex();
       const sel = selectedItems();
       let activeId = "";
@@ -12864,13 +13996,14 @@ function select2(options) {
         if (!optEl.id) optEl.id = `${listboxId}-opt-${i2}`;
         optEl.setAttribute("role", "option");
         optEl.setAttribute("aria-selected", sel.includes(items[i2]) ? "true" : "false");
-        if (isItemDisabled(items[i2])) optEl.setAttribute("aria-disabled", "true");
+        const disabled = isItemDisabled(items[i2]);
+        if (disabled) optEl.setAttribute("aria-disabled", "true");
         else optEl.removeAttribute("aria-disabled");
-        if (i2 === idx) activeId = optEl.id;
+        if (i2 === idx && !disabled) activeId = optEl.id;
       }
       if (activeId) els.listbox.setAttribute("aria-activedescendant", activeId);
       else els.listbox.removeAttribute("aria-activedescendant");
-    });
+    }, els.listbox);
     let typeBuffer = "";
     let typeTimer = null;
     const onKey = (e) => {
@@ -12882,10 +14015,12 @@ function select2(options) {
         highlightPrev();
       } else if (e.key === "Home") {
         e.preventDefault();
-        if (items.length > 0) setHighlightedIndex(0);
+        const first = nextEnabled(-1, 1);
+        if (first !== -1) setHighlightedIndex(first);
       } else if (e.key === "End") {
         e.preventDefault();
-        if (items.length > 0) setHighlightedIndex(items.length - 1);
+        const last = nextEnabled(items.length, -1);
+        if (last !== -1) setHighlightedIndex(last);
       } else if (e.key === "Enter" || e.key === " ") {
         if (highlightedIndex() >= 0) {
           e.preventDefault();
@@ -12903,8 +14038,11 @@ function select2(options) {
       }
     };
     els.listbox.addEventListener("keydown", onKey);
+    let tornDown = false;
     const teardown = () => {
-      boundSelects.delete(els.listbox);
+      if (tornDown) return;
+      tornDown = true;
+      if (boundSelects.get(els.listbox) === teardown) boundSelects.delete(els.listbox);
       fxTeardown();
       els.listbox.removeEventListener("keydown", onKey);
       if (typeTimer !== null) clearTimeout(typeTimer);
@@ -12990,9 +14128,9 @@ function tooltip(options) {
     els.tooltip.id = id;
     const prevDescribedBy = els.trigger.getAttribute("aria-describedby");
     els.trigger.setAttribute("aria-describedby", prevDescribedBy ? `${prevDescribedBy} ${id}` : id);
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       els.tooltip.hidden = !isVisible();
-    });
+    }, els.trigger);
     const onTriggerEnter = () => show();
     const onTriggerLeave = () => scheduleHide();
     const onTooltipEnter = () => {
@@ -13017,8 +14155,11 @@ function tooltip(options) {
     els.trigger.addEventListener("keydown", onKey);
     els.tooltip.addEventListener("pointerenter", onTooltipEnter);
     els.tooltip.addEventListener("pointerleave", onTooltipLeave);
+    let tornDown = false;
     const teardown = () => {
-      boundTriggers.delete(els.trigger);
+      if (tornDown) return;
+      tornDown = true;
+      if (boundTriggers.get(els.trigger) === teardown) boundTriggers.delete(els.trigger);
       fxTeardown();
       els.trigger.removeEventListener("pointerenter", onTriggerEnter);
       els.trigger.removeEventListener("pointerleave", onTriggerLeave);
@@ -13056,7 +14197,8 @@ function fileUpload(options) {
   const [isDragOver, setDragOver] = signal(false);
   function isAccepted(file) {
     if (!accept) return true;
-    const acceptedTypes = accept.split(",").map((t) => t.trim().toLowerCase());
+    const acceptedTypes = accept.split(",").map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0);
+    if (acceptedTypes.length === 0) return true;
     const fileName = file.name.toLowerCase();
     const fileType = file.type.toLowerCase();
     return acceptedTypes.some((pattern2) => {
@@ -13085,16 +14227,17 @@ function fileUpload(options) {
       }
       validFiles.push(file);
     }
+    const committed = multiple ? validFiles : validFiles.slice(-1);
     batch(() => {
       setErrors(newErrors);
-      if (validFiles.length > 0) {
+      if (committed.length > 0) {
         if (multiple) {
-          setFiles((prev) => [...prev, ...validFiles]);
+          setFiles((prev) => [...prev, ...committed]);
         } else {
-          setFiles([validFiles[validFiles.length - 1]]);
+          setFiles(committed);
         }
         if (onFiles) {
-          onFiles(validFiles);
+          onFiles(committed);
         }
       }
     });
@@ -13118,8 +14261,15 @@ function fileUpload(options) {
     if (existing) return existing;
     const id = createId("sibu-fileupload");
     const restore = [];
+    const prevAccept = els.input.getAttribute("accept");
+    const prevMultiple = els.input.hasAttribute("multiple");
     if (accept) els.input.accept = accept;
     els.input.multiple = multiple;
+    restore.push(() => {
+      if (prevAccept === null) els.input.removeAttribute("accept");
+      else els.input.setAttribute("accept", prevAccept);
+      els.input.multiple = prevMultiple;
+    });
     let hintId = null;
     if (els.hint) {
       const assignedHintId = !els.hint.id;
@@ -13140,6 +14290,7 @@ function fileUpload(options) {
     if (els.errorRegion) {
       const prevRole = els.errorRegion.getAttribute("role");
       const prevLive = els.errorRegion.getAttribute("aria-live");
+      const prevText = els.errorRegion.textContent;
       els.errorRegion.setAttribute("role", "status");
       els.errorRegion.setAttribute("aria-live", "polite");
       restore.push(() => {
@@ -13147,12 +14298,14 @@ function fileUpload(options) {
         else els.errorRegion.setAttribute("role", prevRole);
         if (prevLive === null) els.errorRegion.removeAttribute("aria-live");
         else els.errorRegion.setAttribute("aria-live", prevLive);
+        els.errorRegion.textContent = prevText;
       });
     }
     if (els.dropZone) {
       const prevDzRole = els.dropZone.getAttribute("role");
       const prevDzLabel = els.dropZone.getAttribute("aria-label");
       const prevDzTabindex = els.dropZone.hasAttribute("tabindex") ? els.dropZone.getAttribute("tabindex") : null;
+      const prevDzDragOver = els.dropZone.getAttribute("data-drag-over");
       els.dropZone.setAttribute("role", "button");
       els.dropZone.setAttribute("aria-label", "File drop zone \u2014 click or press Enter to browse");
       if (els.dropZone.tabIndex < 0) els.dropZone.tabIndex = 0;
@@ -13163,13 +14316,15 @@ function fileUpload(options) {
         else els.dropZone.setAttribute("aria-label", prevDzLabel);
         if (prevDzTabindex === null) els.dropZone.removeAttribute("tabindex");
         else els.dropZone.setAttribute("tabindex", prevDzTabindex);
+        if (prevDzDragOver === null) els.dropZone.removeAttribute("data-drag-over");
+        else els.dropZone.setAttribute("data-drag-over", prevDzDragOver);
       });
     }
-    const fxTeardown = effect(() => {
+    const fxTeardown = domBinding(() => {
       const errs = errors();
       if (els.errorRegion) els.errorRegion.textContent = errs.join(". ");
       if (els.dropZone) els.dropZone.setAttribute("data-drag-over", isDragOver() ? "true" : "false");
-    });
+    }, els.input);
     const onChange = () => {
       if (els.input.files) addFiles(els.input.files);
     };
@@ -13198,7 +14353,10 @@ function fileUpload(options) {
       els.dropZone.addEventListener("dragleave", onDragLeave);
       els.dropZone.addEventListener("drop", onDrop);
     }
+    let tornDown = false;
     const teardown = () => {
+      if (tornDown) return;
+      tornDown = true;
       boundFileUploads.delete(els.input);
       fxTeardown();
       els.input.removeEventListener("change", onChange);
@@ -13227,12 +14385,15 @@ function fileUpload(options) {
 }
 
 // src/widgets/contentEditable.ts
+function toInertText(html2) {
+  return stripHtml(String(html2)).replace(/<(?=[a-z!/?])/gi, "&lt;");
+}
 function contentEditable(element) {
   const [content, setContentInternal] = signal("");
   const [isFocused, setFocused] = signal(false);
   function setContent(input2) {
     if (typeof input2 === "string") {
-      setContentInternal(input2);
+      setContentInternal(toInertText(input2));
       return;
     }
     if (typeof input2.text === "string") {
@@ -13241,7 +14402,7 @@ function contentEditable(element) {
     }
     if (typeof input2.html === "string") {
       const shouldSanitize = input2.sanitize !== false;
-      setContentInternal(shouldSanitize ? stripHtml(input2.html) : input2.html);
+      setContentInternal(shouldSanitize ? toInertText(input2.html) : input2.html);
       return;
     }
     setContentInternal("");
@@ -13253,7 +14414,7 @@ function contentEditable(element) {
     const range = selection.getRangeAt(0);
     if (element && !element.contains(range.commonAncestorContainer)) return;
     const ancestor = range.commonAncestorContainer;
-    const existingWrap = findAncestorByTag(
+    const existingWrap = findWrapperWithinEditor(
       ancestor instanceof HTMLElement ? ancestor : ancestor.parentElement,
       tagName
     );
@@ -13294,14 +14455,19 @@ function contentEditable(element) {
       selection.addRange(newRange);
     }
   }
-  function findAncestorByTag(el, tagName) {
+  function findWrapperWithinEditor(el, tagName) {
     const upper = tagName.toUpperCase();
     while (el) {
+      if (el === element || isEditingHost(el)) return null;
       if (el.tagName === upper) return el;
       el = el.parentElement;
     }
     return null;
   }
+  function isEditingHost(el) {
+    const attr = el.getAttribute("contenteditable");
+    return attr !== null && attr.toLowerCase() !== "false";
+  }
   function bold() {
     wrapSelection("strong");
   }
@@ -13437,15 +14603,36 @@ function datePicker(options) {
     els.grid.setAttribute("role", "grid");
     if (els.grid.tabIndex < 0) els.grid.tabIndex = 0;
     let pendingFocus = false;
-    const fxTeardown = effect(() => {
+    const touchedCells = /* @__PURE__ */ new Map();
+    const restoreAttr = (el, name, value) => {
+      if (value === null) el.removeAttribute(name);
+      else el.setAttribute(name, value);
+    };
+    const restoreCell = (cell, snap) => {
+      restoreAttr(cell, "role", snap.role);
+      restoreAttr(cell, "aria-selected", snap.selected);
+      restoreAttr(cell, "aria-disabled", snap.disabled);
+      restoreAttr(cell, "tabindex", snap.tabindex);
+    };
+    const fxTeardown = domBinding(() => {
       const sel = selectedDate();
       const view = viewDate();
       const days = daysInMonth();
       els.grid.setAttribute("aria-label", view.toLocaleDateString(void 0, { month: "long", year: "numeric" }));
       let viewCell = null;
+      const displayed = /* @__PURE__ */ new Set();
       for (const d of days) {
         const cell = els.cell(d.date);
         if (!cell) continue;
+        displayed.add(cell);
+        if (!touchedCells.has(cell)) {
+          touchedCells.set(cell, {
+            role: cell.getAttribute("role"),
+            selected: cell.getAttribute("aria-selected"),
+            disabled: cell.getAttribute("aria-disabled"),
+            tabindex: cell.getAttribute("tabindex")
+          });
+        }
         cell.setAttribute("role", "gridcell");
         cell.setAttribute("aria-selected", sel && isSameCalendarDay(sel, d.date) ? "true" : "false");
         if (d.isDisabled) cell.setAttribute("aria-disabled", "true");
@@ -13454,11 +14641,17 @@ function datePicker(options) {
         cell.tabIndex = isView ? 0 : -1;
         if (isView) viewCell = cell;
       }
+      for (const [cell, snap] of touchedCells) {
+        if (!displayed.has(cell)) {
+          restoreCell(cell, snap);
+          touchedCells.delete(cell);
+        }
+      }
       if (pendingFocus && viewCell && typeof viewCell.focus === "function") {
         pendingFocus = false;
         viewCell.focus();
       }
-    });
+    }, els.grid);
     function isSameCalendarDay(a2, b2) {
       return a2.getFullYear() === b2.getFullYear() && a2.getMonth() === b2.getMonth() && a2.getDate() === b2.getDate();
     }
@@ -13513,8 +14706,11 @@ function datePicker(options) {
       }
     };
     els.grid.addEventListener("keydown", onKey);
+    let tornDown = false;
     const teardown = () => {
-      boundDatePickers.delete(els.grid);
+      if (tornDown) return;
+      tornDown = true;
+      if (boundDatePickers.get(els.grid) === teardown) boundDatePickers.delete(els.grid);
       fxTeardown();
       els.grid.removeEventListener("keydown", onKey);
       if (prevGridRole === null) els.grid.removeAttribute("role");
@@ -13523,6 +14719,8 @@ function datePicker(options) {
       else els.grid.setAttribute("tabindex", prevGridTabIndex);
       if (prevGridLabel === null) els.grid.removeAttribute("aria-label");
       else els.grid.setAttribute("aria-label", prevGridLabel);
+      for (const [cell, snap] of touchedCells) restoreCell(cell, snap);
+      touchedCells.clear();
     };
     boundDatePickers.set(els.grid, teardown);
     return teardown;
@@ -13625,53 +14823,119 @@ function zustandAdapter(options) {
 }
 
 // src/ecosystem/ui/componentAdapter.ts
+var _themeLayers = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.themeLayers.v1"),
+  () => /* @__PURE__ */ new WeakMap()
+);
+function commitThemeProperty(root, name, record) {
+  const top = record.layers[record.layers.length - 1];
+  if (top) {
+    root.style.setProperty(name, top.value);
+    return;
+  }
+  _themeLayers.get(root)?.delete(name);
+  if (record.original.value === "") root.style.removeProperty(name);
+  else root.style.setProperty(name, record.original.value, record.original.priority);
+}
+function setThemeLayer(root, name, handle, value) {
+  let properties = _themeLayers.get(root);
+  if (!properties) _themeLayers.set(root, properties = /* @__PURE__ */ new Map());
+  let record = properties.get(name);
+  if (!record) {
+    record = {
+      original: { value: root.style.getPropertyValue(name), priority: root.style.getPropertyPriority(name) },
+      layers: []
+    };
+    properties.set(name, record);
+  }
+  const layer = record.layers.find((l) => l.handle === handle);
+  if (layer) layer.value = value;
+  else record.layers.push({ handle, value });
+  commitThemeProperty(root, name, record);
+}
+function removeThemeLayer(root, name, handle) {
+  const record = _themeLayers.get(root)?.get(name);
+  if (!record) return;
+  const index = record.layers.findIndex((l) => l.handle === handle);
+  if (index === -1) return;
+  record.layers.splice(index, 1);
+  commitThemeProperty(root, name, record);
+}
+function ownString(map2, key) {
+  if (!map2 || key === void 0 || !Object.hasOwn(map2, key)) return void 0;
+  const value = map2[key];
+  return typeof value === "string" ? value : void 0;
+}
 function createTheme(initial) {
   const [getConfig, setConfig] = signal(initial);
   function resolveClass(component, variant) {
     const config = getConfig();
     const overrideKey = variant ? `${component}-${variant}` : component;
-    if (config.classOverrides?.[overrideKey]) {
-      return config.classOverrides[overrideKey];
-    }
+    const override = ownString(config.classOverrides, overrideKey);
+    if (override) return override;
     const base2 = `${config.prefix}-${component}`;
     return variant ? `${base2} ${config.prefix}-${component}--${variant}` : base2;
   }
   function setTheme(partial) {
     setConfig((prev) => ({ ...prev, ...partial }));
   }
-  return { config: getConfig, setTheme, resolveClass };
+  function applyTo(root) {
+    const handle = {};
+    let applied = /* @__PURE__ */ new Set();
+    const stop2 = effect(() => {
+      const variables = getConfig().variables ?? {};
+      const next = new Set(Object.keys(variables));
+      for (const name of applied) {
+        if (!next.has(name)) removeThemeLayer(root, name, handle);
+      }
+      for (const [name, value] of Object.entries(variables)) setThemeLayer(root, name, handle, value);
+      applied = next;
+    });
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      stop2();
+      for (const name of applied) removeThemeLayer(root, name, handle);
+      applied.clear();
+    };
+  }
+  return { config: getConfig, setTheme, resolveClass, applyTo };
 }
 function componentAdapter(config) {
   const theme = createTheme({ prefix: config.prefix });
+  const reprefix = (cls, prefix) => prefix !== config.prefix && cls.startsWith(`${config.prefix}-`) ? `${prefix}-${cls.slice(config.prefix.length + 1)}` : cls;
   const components = {};
   for (const [name, mapping] of Object.entries(config.components)) {
     const factory = tagFactory(mapping.tag || "div");
-    components[name] = (props = {}) => {
+    components[name] = (props = {}, children) => {
       const { variant, size, class: userClass, ...rest } = props;
-      const classes = [mapping.baseClass];
-      if (variant && mapping.variants?.[variant]) {
-        classes.push(mapping.variants[variant]);
-      }
-      if (size && mapping.sizes?.[size]) {
-        classes.push(mapping.sizes[size]);
-      }
-      let finalClass;
-      if (typeof userClass === "function") {
-        finalClass = () => {
-          const extra = userClass();
-          return extra ? `${classes.join(" ")} ${extra}` : classes.join(" ");
-        };
-      } else if (typeof userClass === "string" && userClass) {
-        finalClass = `${classes.join(" ")} ${userClass}`;
-      } else {
-        finalClass = classes.join(" ");
-      }
+      const themeClasses = () => {
+        const current = theme.config();
+        const overrides = current.classOverrides ?? {};
+        const pick = (key, fallback) => Object.hasOwn(overrides, key) ? overrides[key] : reprefix(fallback, current.prefix);
+        const classes = [pick(name, mapping.baseClass)];
+        const variantClass = ownString(mapping.variants, variant);
+        if (variant && variantClass) {
+          classes.push(pick(`${name}-${variant}`, variantClass));
+        }
+        const sizeClass = ownString(mapping.sizes, size);
+        if (size && sizeClass) {
+          classes.push(pick(`${name}-${size}`, sizeClass));
+        }
+        return classes.filter(Boolean).join(" ");
+      };
+      const finalClass = () => {
+        const base2 = themeClasses();
+        const extra = typeof userClass === "function" ? userClass() : userClass;
+        return typeof extra === "string" && extra ? `${base2} ${extra}` : base2;
+      };
       const mergedProps = {
         ...mapping.defaultProps,
         ...rest,
         class: finalClass
       };
-      return factory(mergedProps);
+      return children === void 0 ? factory(mergedProps) : factory(mergedProps, children);
     };
   }
   return { name: config.name, components, theme };
@@ -13886,6 +15150,8 @@ var materialAdapter = componentAdapter(materialConfig);
   Features,
   FocusTrap,
   Head,
+  MigrationStorageError,
+  PluginInstallCancelledError,
   Priority,
   RenderProp,
   SibuError,
@@ -13894,6 +15160,7 @@ var materialAdapter = componentAdapter(materialConfig);
   VirtualList,
   __resetDialogStack,
   __resetQueryCache,
+  __resetSpeechCoordinator,
   accordion,
   animate,
   animationFrame,
@@ -14029,6 +15296,7 @@ var materialAdapter = componentAdapter(materialConfig);
   isDangerousMetaRefresh,
   isDebugEnabled,
   isHMRAvailable,
+  isPluginInstallCancelledError,
   isWasmCached,
   island,
   keyboard,
@@ -14096,6 +15364,7 @@ var materialAdapter = componentAdapter(materialConfig);
   renderToStream,
   renderToString,
   renderToSuspenseStream,
+  renderWithLoader,
   required,
   resetIdCounter,
   resetPlugins,
@@ -14167,6 +15436,7 @@ var materialAdapter = componentAdapter(materialConfig);
   withBoundary,
   withDefaults,
   withErrorTracking,
+  withLoader,
   withProps,
   withRetry,
   withScopedStyle,