diff --git a/CHANGELOG.md b/CHANGELOG.md
index d29ae69..e29797d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,47 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [3.3.3] — 2026-06-26
+
+A hardening pass across the non-core subsystems (`ui`, `widgets`, `components`, `plugins`, `data`, `platform`, `patterns`, `performance`, `devtools`): correctness fixes, memory-leak plugs, SSR-safety guards, and accessibility improvements. No breaking changes.
+
+### Added
+
+- **`bindField` reflects an array back to `<select multiple>`** — the field's array value is now written onto each option's `selected` state on render and on update. (3.3.2 added the read side; this completes the two-way binding.)
+- **`captureSignalGraph()` returns a real node inventory** — the devtools hook now implements `getSignalNodes()`, so the snapshot reports live signals/derived/effects (id, name, kind, current value) instead of always being empty. Dependency edges are not yet tracked.
+- **`prefersReducedMotion()`** is now exported from `reducedMotion` (the one-shot check was previously duplicated privately in the spring/preset helpers).
+- **`RouterLink` accepts positional children** — `RouterLink(props, children)` matches the framework's children convention; the `nodes` prop is kept as a deprecated alias.
+
+### Fixed
+
+- **Teardown-tied memory leaks** — `Head()`, the router's route outlets (`Route` / `KeepAliveRoute` / `Outlet`), `transition()`, and `hover()` now release their injected elements / cached subtrees / timers / listeners when their element or subtree is disposed, instead of living for the page's lifetime.
+- **SSR no longer crashes** in `persisted()`, the priority scheduler, `stream()` / `socket()`, the router constructor (`createMemoryRouter`), `scrollRestoration()`, and `battery()` — each guards the browser global it touches and degrades gracefully instead of throwing a `ReferenceError`.
+- **Devtools trace profiler** — `stop()` / `stopTrace()` no longer throw; the hook's `on()` now returns a working unsubscribe, so listeners are removed instead of leaking.
+- **`form().isDirty`** no longer reports a field as dirty when an array/object value is unchanged (e.g. a multi-select with `initial: []`).
+- **`createAction().submit`** — a slow earlier submission can no longer overwrite the result of a newer one (run-sequenced state updates).
+- **`inputMask`** caret restoration — fixed mis-counting of literal characters for `*` masks and patterns with a leading literal.
+- **`pagination`** clamps the current page reactively when the item count shrinks, so indices stay in bounds.
+- **`infiniteScroll`** re-checks intersection after loading, so it doesn't stall when appended content doesn't push the sentinel out of view.
+- **`lazyModule`** caches a loader that resolves to `undefined`/falsy instead of re-invoking it on every `get()`.
+- **`normalize`** — child relations default to `id` instead of inheriting the parent's custom `idKey` (which produced `String(undefined)` ids).
+- **Route matching is specificity-ordered** — a broad parameter route can no longer shadow a more specific route registered after it.
+- Smaller fixes: the test `mockFetch` tolerates non-JSON request bodies; the a11y checker no longer exempts the literal string `"undefined"` from ARIA value validation.
+
+### Accessibility
+
+- **`Loading`** exposes `role="status"` + `aria-live="polite"` and a default label, so it is announced to screen readers.
+- **`datePicker`** gives its grid an accessible name (the displayed month) and moves real focus to follow the roving tabindex during keyboard navigation.
+- **Widget `bind()` is reversible** — `Combobox`, `Select`, and `datePicker` restore the `role` / `aria-*` / `id` / `tabindex` they set when torn down (matching `Accordion` / `Tabs` / `Popover`).
+- **`Combobox`** no longer races a blur-close against an option click (a pointer-down inside the listbox keeps the input focused).
+- **`contentEditable`** can be scoped to an editor element so its formatting commands ignore selections elsewhere on the page.
+
+### Changed
+
+- Internal coordination state for several modules (the `plugin` default registry, the `devtools` session, and the WASM / microfrontend module caches) is now shared across duplicate runtime copies, extending the 3.3.1/3.3.2 first-copy-wins sweep.
+- `ErrorDisplay` reads dev-mode state at render time rather than at module load, so a runtime-configured dev flag is respected.
+
+---
+
 ## [3.3.2] — 2026-06-26
 
 Continues the duplicate-runtime hardening from 3.3.1, plus two small additive enhancements. No breaking changes.
diff --git a/package.json b/package.json
index 33001b6..2cbdf0a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "sibujs",
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "A lightweight, function-based frontend framework that combines the best of React, Svelte, and Vue — with zero VDOM and maximum simplicity. Designed for developers who want fine-grained reactivity and full control without compilation or magic.",
   "keywords": [
     "frontend",
diff --git a/src/browser/animationFrame.ts b/src/browser/animationFrame.ts
index bf087c5..04b51df 100644
--- a/src/browser/animationFrame.ts
+++ b/src/browser/animationFrame.ts
@@ -51,6 +51,7 @@ export function animationFrame(options: AnimationFrameOptions = {}): {
   let id: number | null = null;
   let prev = -1;
   let start = -1;
+  let disposed = false;
   const minFrameMs = options.fpsLimit ? 1000 / options.fpsLimit : 0;
 
   const step = (now: number) => {
@@ -66,7 +67,8 @@ export function animationFrame(options: AnimationFrameOptions = {}): {
   };
 
   function resume() {
-    if (id !== null) return;
+    // `disposed` makes dispose() permanent — resume() can't restart the loop.
+    if (disposed || id !== null) return;
     setRunning(true);
     id = requestAnimationFrame(step);
   }
@@ -82,6 +84,7 @@ export function animationFrame(options: AnimationFrameOptions = {}): {
   }
 
   function dispose() {
+    disposed = true;
     pause();
   }
 
diff --git a/src/browser/battery.ts b/src/browser/battery.ts
index 5ef1ed2..d77d05e 100644
--- a/src/browser/battery.ts
+++ b/src/browser/battery.ts
@@ -41,27 +41,34 @@ export function battery(): {
   if (typeof navigator !== "undefined" && "getBattery" in navigator) {
     setSupported(true);
 
-    (navigator as unknown as { getBattery(): Promise<BatteryManager> }).getBattery().then((bm: BatteryManager) => {
-      if (disposed) return;
+    const batteryPromise = (navigator as unknown as { getBattery(): Promise<BatteryManager> })
+      .getBattery()
+      .then((bm: BatteryManager) => {
+        if (disposed) return;
 
-      battery = bm;
+        battery = bm;
 
-      batch(() => {
-        setLevel(bm.level);
-        setCharging(bm.charging);
-        setChargingTime(bm.chargingTime);
-        setDischargingTime(bm.dischargingTime);
-      });
+        batch(() => {
+          setLevel(bm.level);
+          setCharging(bm.charging);
+          setChargingTime(bm.chargingTime);
+          setDischargingTime(bm.dischargingTime);
+        });
 
-      onLevelChange = () => setLevel(bm.level);
-      onChargingChange = () => setCharging(bm.charging);
-      onChargingTimeChange = () => setChargingTime(bm.chargingTime);
-      onDischargingTimeChange = () => setDischargingTime(bm.dischargingTime);
+        onLevelChange = () => setLevel(bm.level);
+        onChargingChange = () => setCharging(bm.charging);
+        onChargingTimeChange = () => setChargingTime(bm.chargingTime);
+        onDischargingTimeChange = () => setDischargingTime(bm.dischargingTime);
 
-      bm.addEventListener("levelchange", onLevelChange);
-      bm.addEventListener("chargingchange", onChargingChange);
-      bm.addEventListener("chargingtimechange", onChargingTimeChange);
-      bm.addEventListener("dischargingtimechange", onDischargingTimeChange);
+        bm.addEventListener("levelchange", onLevelChange);
+        bm.addEventListener("chargingchange", onChargingChange);
+        bm.addEventListener("chargingtimechange", onChargingTimeChange);
+        bm.addEventListener("dischargingtimechange", onDischargingTimeChange);
+      });
+    batteryPromise.catch(() => {
+      // getBattery() can reject (insecure context / permission denied) —
+      // degrade quietly instead of surfacing an unhandled rejection.
+      if (!disposed) setSupported(false);
     });
   }
 
diff --git a/src/browser/bounds.ts b/src/browser/bounds.ts
index 83cba34..2fb025b 100644
--- a/src/browser/bounds.ts
+++ b/src/browser/bounds.ts
@@ -70,7 +70,12 @@ export function bounds(target: Element): {
     };
   }
 
+  let disposed = false;
+
   function refresh() {
+    // A queued observer/scroll callback or a manual refresh() after dispose()
+    // must not write to the torn-down instance's signal.
+    if (disposed) return;
     setRect(readRect(target));
   }
 
@@ -86,6 +91,7 @@ export function bounds(target: Element): {
   window.addEventListener("scroll", onScroll, { passive: true, capture: true });
 
   function dispose() {
+    disposed = true;
     resizeObserver?.disconnect();
     window.removeEventListener("scroll", onScroll, { capture: true });
   }
diff --git a/src/browser/wakeLock.ts b/src/browser/wakeLock.ts
index 5410baf..14953f5 100644
--- a/src/browser/wakeLock.ts
+++ b/src/browser/wakeLock.ts
@@ -47,10 +47,19 @@ export function wakeLock(): {
 
   const api = (navigator as unknown as { wakeLock: WakeLockApi }).wakeLock;
   let sentinel: WakeLockSentinel | null = null;
+  let disposed = false;
 
   async function request(): Promise<void> {
+    if (disposed) return;
     try {
-      sentinel = await api.request("screen");
+      const s = await api.request("screen");
+      // If dispose() ran while the request was in flight, release the sentinel
+      // immediately and don't register it / its listener (which would leak).
+      if (disposed) {
+        s.release().catch(() => {});
+        return;
+      }
+      sentinel = s;
       setActive(true);
       sentinel.addEventListener("release", () => {
         setActive(false);
@@ -84,6 +93,7 @@ export function wakeLock(): {
   document.addEventListener("visibilitychange", onVisibility);
 
   function dispose(): void {
+    disposed = true;
     document.removeEventListener("visibilitychange", onVisibility);
     release().catch((err) => {
       if (typeof console !== "undefined") {
diff --git a/src/components/ErrorBoundary.ts b/src/components/ErrorBoundary.ts
index 0c66c6b..47d80d1 100644
--- a/src/components/ErrorBoundary.ts
+++ b/src/components/ErrorBoundary.ts
@@ -250,7 +250,10 @@ function getMemoizedFallback(
  *
  * Features:
  * - Catches sync errors thrown by children
- * - Catches async errors (Promise rejections) from children
+ * - Catches the rejection of a Promise *returned* by children (async components)
+ *   — it does NOT observe fire-and-forget async errors (rejections from timers,
+ *   event handlers, or detached/unawaited promises), which surface as global
+ *   `unhandledrejection` events instead.
  * - Supports nested ErrorBoundaries (inner catches first, outer catches propagation)
  * - Retry functionality to clear error and re-render children
  * - Memoized fallback to avoid re-creating fallback UI on every render
diff --git a/src/components/ErrorDisplay.ts b/src/components/ErrorDisplay.ts
index abfeef9..ea87d74 100644
--- a/src/components/ErrorDisplay.ts
+++ b/src/components/ErrorDisplay.ts
@@ -25,8 +25,6 @@ import { signal } from "../core/signals/signal";
 // No dependencies, no JSX, no compilation — every element is built
 // via the tag factories, and styles are injected once per page.
 
-const _isDev = isDev();
-
 export type ErrorSeverity = "error" | "warning" | "info";
 
 export interface ErrorDisplayProps {
@@ -427,7 +425,9 @@ export function ErrorDisplay(props: ErrorDisplayProps): Element {
 
   const severity = props.severity ?? "error";
   const normalized = normalizeError(props.error);
-  const showDetails = props.alwaysShowDetails ?? _isDev;
+  // Read dev state at render time, not module-eval — otherwise a runtime-set
+  // dev config (configured after this module is imported) would be ignored.
+  const showDetails = props.alwaysShowDetails ?? isDev();
   const headline = props.title ?? normalized.message;
   const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
 
diff --git a/src/components/Loading.ts b/src/components/Loading.ts
index 5fdf166..d3965f4 100644
--- a/src/components/Loading.ts
+++ b/src/components/Loading.ts
@@ -92,6 +92,11 @@ export function Loading(props: LoadingProps = {}): HTMLElement {
   if (variant === "dots") {
     return div({
       class: `sibu-loading${sizeClass}`,
+      role: "status",
+      "aria-live": "polite",
+      // When there's no visible text, give the live region an accessible name
+      // so it isn't announced as an empty status.
+      "aria-label": text ? undefined : "Loading",
       nodes: [
         div({
           class: "sibu-loading-dots",
@@ -108,6 +113,9 @@ export function Loading(props: LoadingProps = {}): HTMLElement {
 
   return div({
     class: `sibu-loading${sizeClass}`,
+    role: "status",
+    "aria-live": "polite",
+    "aria-label": text ? undefined : "Loading",
     nodes: [
       div({ class: "sibu-loading-spinner" }) as HTMLElement,
       text ? (span({ class: "sibu-loading-text", nodes: text }) as HTMLElement) : null,
diff --git a/src/data/query.ts b/src/data/query.ts
index b2f27ef..2c1c7d7 100644
--- a/src/data/query.ts
+++ b/src/data/query.ts
@@ -3,6 +3,7 @@ import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 import { getRequestScopedCache } from "../core/ssr-context";
 import { batch } from "../reactivity/batch";
+import { globalSingleton } from "../utils/globalSingleton";
 import type { RetryOptions } from "./retry";
 import { withRetry } from "./retry";
 
@@ -66,7 +67,10 @@ interface CacheEntry {
 // data (e.g. user A's profile under key "profile") bleeds into a concurrent
 // request for user B that resolves the same key. `getActiveQueryCache()`
 // returns the request-scoped map under SSR and this global otherwise.
-const globalQueryCache = new Map<string, CacheEntry>();
+//
+// Shared via globalSingleton so a bundler that duplicates this module doesn't
+// give `query()` and `invalidateQueries`/`setQueryData` two separate caches.
+const globalQueryCache = globalSingleton(Symbol.for("sibujs.query.cache.v1"), () => new Map<string, CacheEntry>());
 
 function getActiveQueryCache(): Map<string, CacheEntry> {
   return getRequestScopedCache<CacheEntry>("query") ?? globalQueryCache;
diff --git a/src/devtools/devtools.ts b/src/devtools/devtools.ts
index 7f1051c..a3daba5 100644
--- a/src/devtools/devtools.ts
+++ b/src/devtools/devtools.ts
@@ -25,6 +25,7 @@
 
 import { isDev } from "../core/dev";
 import { signal as _sbSignal } from "../core/signals/signal";
+import { globalSingleton } from "../utils/globalSingleton";
 import { stripHtml } from "../utils/sanitize";
 
 // ---------------------------------------------------------------------------
@@ -89,13 +90,29 @@ interface DevNode {
 // Global Hook
 // ---------------------------------------------------------------------------
 
+/** One entry of the reactive node inventory exposed by `getSignalNodes()`.
+ *  Mirrors `SignalNodeSnapshot` in signalGraph.ts structurally. */
+interface SignalNodeInventoryEntry {
+  id: string;
+  name: string | null;
+  kind: string;
+  value: string;
+  subscribers: string[];
+  dependencies: string[];
+  evalCount: number;
+}
+
 interface SibuGlobalHook {
   /** Register an event listener */
-  on: (event: string, fn: (...args: unknown[]) => void) => void;
+  on: (event: string, fn: (...args: unknown[]) => void) => () => void;
   /** Remove an event listener */
   off: (event: string, fn: (...args: unknown[]) => void) => void;
   /** Emit an event */
   emit: (event: string, payload: unknown) => void;
+  /** Snapshot the live reactive node inventory (id/name/kind/value). Edge data
+   *  (subscribers/dependencies/evalCount) is not tracked by this lightweight
+   *  registry — only a subscriber count is available — so those stay empty. */
+  getSignalNodes: () => SignalNodeInventoryEntry[];
   /** All registered nodes */
   nodes: Map<number, DevNode>;
   /** All registered components */
@@ -122,10 +139,53 @@ function createGlobalHook(): SibuGlobalHook {
         listeners.set(event, set);
       }
       set.add(fn);
+      // Return an unsubscribe fn — the trace profiler (and any consumer) relies
+      // on this to stop listening; previously `on()` returned void, so calling
+      // the result threw and the profiler's stop()/stopTrace() always failed.
+      return () => {
+        set?.delete(fn);
+      };
     },
     off(event, fn) {
       listeners.get(event)?.delete(fn);
     },
+    getSignalNodes() {
+      const out: SignalNodeInventoryEntry[] = [];
+      for (const [, node] of nodes) {
+        let value = "";
+        try {
+          const ref = node.ref as Record<string, unknown> | undefined;
+          let raw: unknown;
+          if (node.type === "effect") {
+            raw = undefined; // effects hold no value
+          } else if (node.type === "computed" && ref) {
+            raw = ref._v; // last cached value — don't force a re-eval in a snapshot
+          } else if (ref && "value" in ref) {
+            raw = ref.value;
+          }
+          if (raw === undefined) value = "undefined";
+          else if (raw === null) value = "null";
+          else if (typeof raw === "object") value = JSON.stringify(raw);
+          else value = String(raw);
+        } catch {
+          value = "?";
+        }
+        if (value.length > 200) value = `${value.slice(0, 200)}...`;
+        out.push({
+          id: String(node.id),
+          name: node.name || null,
+          kind: node.type === "computed" ? "derived" : node.type,
+          value,
+          // Edge identities aren't tracked by this registry (only a subscriber
+          // count, via node.ref.__sc) — left empty until the core exposes the
+          // dependency graph. The node inventory itself is real.
+          subscribers: [],
+          dependencies: [],
+          evalCount: 0,
+        });
+      }
+      return out;
+    },
     emit(event, payload) {
       // Buffer for late-connecting panels
       events.push({ event, payload, ts: Date.now() });
@@ -164,17 +224,18 @@ function getOrCreateHook(): SibuGlobalHook {
 // initDevTools
 // ---------------------------------------------------------------------------
 
-let activeDevTools: ReturnType<typeof initDevTools> | null = null;
-let nextNodeId = 0;
-/**
- * Gate for inferName(). Only `true` while devtools are initialized AND we
- * are in dev mode — otherwise we skip the Error-stack walk entirely so prod
- * hot paths don't allocate stacks.
- */
-let inferNameArmed = false;
+// Shared across duplicate module copies so one devtools session and one node-id
+// sequence are observed no matter which copy emitted the event.
+const _dt = globalSingleton(Symbol.for("sibujs.devtools.state.v1"), () => ({
+  active: null as ReturnType<typeof initDevTools> | null,
+  nextNodeId: 0,
+  // Gate for inferName(): only `true` while devtools are initialized AND in dev
+  // mode — otherwise skip the Error-stack walk so prod hot paths don't allocate.
+  inferNameArmed: false,
+}));
 
 export function getActiveDevTools(): ReturnType<typeof initDevTools> | null {
-  return activeDevTools;
+  return _dt.active;
 }
 
 /**
@@ -195,10 +256,10 @@ export function initDevTools(config?: DevToolsConfig) {
 
   // inferName() walks Error stacks — keep it gated so it never runs when
   // devtools are disabled (prod hot paths).
-  inferNameArmed = true;
+  _dt.inferNameArmed = true;
 
   const hook = getOrCreateHook();
-  nextNodeId = 0;
+  _dt.nextNodeId = 0;
 
   // Internal event log (serializable, no DOM refs)
   const eventLog: DevToolsEvent[] = [];
@@ -207,17 +268,17 @@ export function initDevTools(config?: DevToolsConfig) {
 
   hook.on("signal:create", (payload: unknown) => {
     const p = payload as { signal: object; getter: () => unknown; initial: unknown };
-    nextNodeId++;
+    _dt.nextNodeId++;
     const name = inferName();
     const node: DevNode = {
-      id: nextNodeId,
+      id: _dt.nextNodeId,
       type: "signal",
       name,
       ref: p.signal,
       getter: p.getter,
       createdAt: Date.now(),
     };
-    hook.nodes.set(nextNodeId, node);
+    hook.nodes.set(_dt.nextNodeId, node);
     emit();
   });
 
@@ -240,17 +301,17 @@ export function initDevTools(config?: DevToolsConfig) {
 
   hook.on("computed:create", (payload: unknown) => {
     const p = payload as { signal: object; getter: () => unknown };
-    nextNodeId++;
+    _dt.nextNodeId++;
     const name = inferName();
     const node: DevNode = {
-      id: nextNodeId,
+      id: _dt.nextNodeId,
       type: "computed",
       name,
       ref: p.signal,
       getter: p.getter,
       createdAt: Date.now(),
     };
-    hook.nodes.set(nextNodeId, node);
+    hook.nodes.set(_dt.nextNodeId, node);
     emit();
   });
 
@@ -269,11 +330,11 @@ export function initDevTools(config?: DevToolsConfig) {
   });
 
   hook.on("effect:create", (payload: unknown) => {
-    nextNodeId++;
+    _dt.nextNodeId++;
     const name = inferName();
     const p = payload as { effectFn: () => void };
-    const node: DevNode = { id: nextNodeId, type: "effect", name, ref: p.effectFn, createdAt: Date.now() };
-    hook.nodes.set(nextNodeId, node);
+    const node: DevNode = { id: _dt.nextNodeId, type: "effect", name, ref: p.effectFn, createdAt: Date.now() };
+    hook.nodes.set(_dt.nextNodeId, node);
     emit();
   });
 
@@ -461,8 +522,8 @@ export function initDevTools(config?: DevToolsConfig) {
     hook.components.clear();
     hook.events.length = 0;
     isActive = false;
-    inferNameArmed = false;
-    activeDevTools = null;
+    _dt.inferNameArmed = false;
+    _dt.active = null;
 
     const g = globalThis as unknown as {
       __SIBU__?: SibuNamespace;
@@ -687,7 +748,7 @@ export function initDevTools(config?: DevToolsConfig) {
     w.__SIBU_DEVTOOLS_DATA__ = buildData;
   }
 
-  activeDevTools = api;
+  _dt.active = api;
 
   // DOM component auto-discovery
   if (typeof document !== "undefined") {
@@ -777,7 +838,7 @@ export function initDevTools(config?: DevToolsConfig) {
 // ---------------------------------------------------------------------------
 
 function inferName(): string {
-  if (!inferNameArmed || !isDev()) return "anonymous";
+  if (!_dt.inferNameArmed || !isDev()) return "anonymous";
   try {
     const stack = new Error().stack || "";
     for (const line of stack.split("\n")) {
@@ -887,7 +948,7 @@ export function devState<T>(name: string, initial: T): [() => T, (value: T | ((p
     const newValue = get();
 
     // Record with proper component/key names
-    const dt = activeDevTools;
+    const dt = _dt.active;
     if (dt?.isEnabled() && !Object.is(oldValue, newValue)) {
       dt.record({ type: "state-change", component, key, oldValue, newValue, timestamp: Date.now() });
     }
diff --git a/src/devtools/signalGraph.ts b/src/devtools/signalGraph.ts
index e69183b..8a2d494 100644
--- a/src/devtools/signalGraph.ts
+++ b/src/devtools/signalGraph.ts
@@ -70,12 +70,19 @@ export interface SignalGraphSnapshot {
 }
 
 /**
- * Capture a synchronous snapshot of the reactive graph. The hook
- * provides a `getSignalNodes()` iterator that the core reactivity
- * layer populates; this function walks it and produces a serializable
- * view with dependency counts.
+ * Capture a synchronous snapshot of the reactive graph from the devtools hook's
+ * `getSignalNodes()`, producing a serializable view.
  *
- * Returns an empty snapshot when devtools are not enabled.
+ * Returns an empty snapshot when devtools are not enabled (`initDevTools()` has
+ * not run, so no hook / node registry exists).
+ *
+ * Coverage note: the default devtools hook reports the live node **inventory**
+ * (id / name / kind / current value) — useful for inspecting state and for
+ * leak-detection (how many signals/effects are alive). It does not yet report
+ * the dependency **edges**: the lightweight registry tracks only a subscriber
+ * *count*, not subscriber/dependency identities, so `subscribers`/`dependencies`
+ * are empty and `edgeCount` is 0 unless a richer hook supplies them. Wiring real
+ * edges requires the reactive core to expose its dependency sets.
  */
 export function captureSignalGraph(): SignalGraphSnapshot {
   const hook = getHook();
diff --git a/src/patterns/globalStore.ts b/src/patterns/globalStore.ts
index b87c927..411e3ee 100644
--- a/src/patterns/globalStore.ts
+++ b/src/patterns/globalStore.ts
@@ -1,4 +1,3 @@
-import { derived } from "../core/signals/derived";
 import { signal } from "../core/signals/signal";
 import { stripUnsafeKeys } from "../utils/guards";
 
@@ -111,7 +110,12 @@ export function globalStore<
   }
 
   function select<R>(selector: Selector<S, R>): () => R {
-    return derived(() => selector(getState()));
+    // Return a plain reactive getter, not a standalone derived(): a derived
+    // subscribes to the store for the app's lifetime, which leaks when select()
+    // is called per-component. Reading getState() inside the CALLER's own
+    // effect/derived ties the subscription to the caller's lifecycle instead,
+    // and stays fully reactive.
+    return () => selector(getState());
   }
 
   function subscribe(callback: (state: S) => void): () => void {
diff --git a/src/patterns/persist.ts b/src/patterns/persist.ts
index c71ad83..4619b1a 100644
--- a/src/patterns/persist.ts
+++ b/src/patterns/persist.ts
@@ -9,7 +9,10 @@ import { isUnsafeKey } from "../utils/guards";
  * @param key Storage key
  * @param initial Default value when no persisted value exists
  * @param options Storage options
- * @returns Same tuple as signal: [getter, setter]
+ * @returns The same `[getter, setter]` tuple as `signal()`. For localStorage
+ *   (cross-tab sync on), the setter additionally carries a non-enumerable
+ *   `dispose()` method — call `setter.dispose()` on unmount to remove the
+ *   `storage` event listener; otherwise it lives for the page's lifetime.
  *
  * @example
  * ```ts
@@ -70,7 +73,17 @@ export function persisted<T>(
   initial: T,
   options: PersistOptions<T> = {},
 ): [() => T, (next: T | ((prev: T) => T)) => void] {
-  const storage = options.session ? sessionStorage : localStorage;
+  // Resolve storage defensively: under SSR the globals don't exist
+  // (ReferenceError), and even in the browser access can throw in sandboxed /
+  // privacy contexts. When unavailable, persisted() degrades to a plain signal.
+  const storage: Storage | null = (() => {
+    try {
+      if (options.session) return typeof sessionStorage !== "undefined" ? sessionStorage : null;
+      return typeof localStorage !== "undefined" ? localStorage : null;
+    } catch {
+      return null;
+    }
+  })();
   const serialize = options.serialize || JSON.stringify;
   // Reject __proto__ / constructor / prototype keys at parse time to block
   // prototype pollution from a tampered storage entry (CWE-1321).
@@ -84,7 +97,7 @@ export function persisted<T>(
   // Try to restore persisted value
   let restored = initial;
   try {
-    let raw = storage.getItem(key);
+    let raw = storage ? storage.getItem(key) : null;
     if (raw !== null) {
       if (decrypt) raw = decrypt(raw);
       const parsed = deserialize(raw);
@@ -108,7 +121,7 @@ export function persisted<T>(
     try {
       let serialized = serialize(current);
       if (encrypt) serialized = encrypt(serialized);
-      storage.setItem(key, serialized);
+      storage?.setItem(key, serialized);
     } catch {
       // Storage full or unavailable
     }
@@ -120,7 +133,7 @@ export function persisted<T>(
   // that never dispose should be aware that the listener lives for the
   // lifetime of the page.
   let storageListener: ((e: StorageEvent) => void) | null = null;
-  if (syncTabs && typeof window !== "undefined") {
+  if (syncTabs && storage && typeof window !== "undefined") {
     storageListener = (e: StorageEvent) => {
       if (e.storageArea !== storage || e.key !== key) return;
       if (e.newValue === null) {
diff --git a/src/performance/concurrent.ts b/src/performance/concurrent.ts
index b86fe1d..1f7248b 100644
--- a/src/performance/concurrent.ts
+++ b/src/performance/concurrent.ts
@@ -4,6 +4,7 @@
 
 import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
+import { globalSingleton } from "../utils/globalSingleton";
 import { Priority, scheduleUpdate } from "./scheduler";
 
 /**
@@ -71,15 +72,20 @@ export function transitionState(): [isPending: () => boolean, startTransition: (
 // UNIQUE ID GENERATION
 // ============================================================================
 
-let idCounter = 0;
-let idPrefix = "sibu";
+// Counter + prefix shared via globalSingleton so a duplicated copy of this
+// module doesn't restart at 0 and mint colliding ids — which would desync
+// server/client during hydration (the exact thing resetIdCounter guards).
+const _ids = globalSingleton(Symbol.for("sibujs.uniqueId.v1"), () => ({
+  counter: 0,
+  prefix: "sibu",
+}));
 
 /**
  * Reset the ID counter. Call at the start of each SSR request
  * to ensure server and client produce matching IDs.
  */
 export function resetIdCounter(): void {
-  idCounter = 0;
+  _ids.counter = 0;
 }
 
 /**
@@ -87,7 +93,7 @@ export function resetIdCounter(): void {
  * Useful when multiple SibuJS apps coexist on the same page.
  */
 export function setIdPrefix(prefix: string): void {
-  idPrefix = prefix;
+  _ids.prefix = prefix;
 }
 
 /**
@@ -106,6 +112,6 @@ export function setIdPrefix(prefix: string): void {
  * ```
  */
 export function uniqueId(suffix?: string): string {
-  const id = `${idPrefix}-${idCounter++}`;
+  const id = `${_ids.prefix}-${_ids.counter++}`;
   return suffix ? `${id}-${suffix}` : id;
 }
diff --git a/src/performance/normalize.ts b/src/performance/normalize.ts
index ce3cab1..8e585e8 100644
--- a/src/performance/normalize.ts
+++ b/src/performance/normalize.ts
@@ -203,7 +203,6 @@ export interface NormalizeResult {
  */
 export function normalize<T extends Record<string, unknown>>(data: T | T[], schema: NormalizedSchema): NormalizeResult {
   const entities: NormalizedEntities = {};
-  const idKey = schema.idKey || "id";
 
   function ensureTable(name: string): Record<string, unknown> {
     if (!entities[name]) {
@@ -225,8 +224,10 @@ export function normalize<T extends Record<string, unknown>>(data: T | T[], sche
         const value = entity[field];
         if (value == null) continue;
 
-        // Relation schema: simple schema with just the type name
-        const relSchema: NormalizedSchema = { name: relationType, idKey };
+        // Relation schema: simple schema with just the type name. Children
+        // default to "id" — inheriting the parent's (possibly custom) idKey
+        // would read a missing field and produce `String(undefined)` ids.
+        const relSchema: NormalizedSchema = { name: relationType };
 
         if (Array.isArray(value)) {
           flat[field] = value.map((item) => normalizeEntity(item as Record<string, unknown>, relSchema));
@@ -276,7 +277,6 @@ export function denormalize<T extends Record<string, unknown>>(
   const entity = table[id];
   if (!entity) return undefined;
 
-  const idKey = schema.idKey || "id";
   const result: Record<string, unknown> = { ...(entity as Record<string, unknown>) };
 
   if (schema.relations) {
@@ -284,7 +284,8 @@ export function denormalize<T extends Record<string, unknown>>(
       const value = (entity as Record<string, unknown>)[field];
       if (value == null) continue;
 
-      const relSchema: NormalizedSchema = { name: relationType, idKey };
+      // Children default to "id"; see the matching note in normalize().
+      const relSchema: NormalizedSchema = { name: relationType };
 
       if (Array.isArray(value)) {
         result[field] = value.map((relId: string) => denormalize(relId, entities, relSchema));
diff --git a/src/performance/scheduler.ts b/src/performance/scheduler.ts
index 9c0dfe5..b632e24 100644
--- a/src/performance/scheduler.ts
+++ b/src/performance/scheduler.ts
@@ -2,6 +2,8 @@
 // PRIORITY-BASED UPDATE SCHEDULER
 // ============================================================================
 
+import { globalSingleton } from "../utils/globalSingleton";
+
 export const Priority = {
   IMMEDIATE: 0,
   USER_BLOCKING: 1,
@@ -19,15 +21,22 @@ interface ScheduledTask {
   cancelled: boolean;
 }
 
-let taskIdCounter = 0;
-const taskQueue: ScheduledTask[] = [];
-let isProcessing = false;
 // Distinguish scheduled work by type so we can cancel the right handle.
 // Microtasks cannot be cancelled — we only track they are scheduled.
 type ScheduledKind = "frame" | "idle" | "timeout" | "microtask";
-let scheduledKind: ScheduledKind | null = null;
-let scheduledHandle: number | null = null;
-let microtaskScheduled = false;
+
+// Scheduler state is shared via globalSingleton so tasks queued through one
+// (possibly duplicated) copy of this module are drained by the same rAF/idle
+// loop, instead of splitting into two independent queues that never flush.
+const _sched = globalSingleton(Symbol.for("sibujs.scheduler.v1"), () => ({
+  taskIdCounter: 0,
+  taskQueue: [] as ScheduledTask[],
+  isProcessing: false,
+  scheduledKind: null as ScheduledKind | null,
+  scheduledHandle: null as number | null,
+  microtaskScheduled: false,
+}));
+const taskQueue = _sched.taskQueue;
 
 function insertTask(task: ScheduledTask): void {
   // Insert in priority order (lower number = higher priority)
@@ -39,8 +48,8 @@ function insertTask(task: ScheduledTask): void {
 }
 
 function processQueue(): void {
-  if (isProcessing || taskQueue.length === 0) return;
-  isProcessing = true;
+  if (_sched.isProcessing || taskQueue.length === 0) return;
+  _sched.isProcessing = true;
 
   const startTime = performance.now();
   const timeSlice = 5; // 5ms time slice per frame
@@ -66,7 +75,7 @@ function processQueue(): void {
     }
   }
 
-  isProcessing = false;
+  _sched.isProcessing = false;
 
   // Schedule next frame if there are remaining tasks
   if (taskQueue.length > 0) {
@@ -79,13 +88,14 @@ function processQueue(): void {
 const TIER_SPEED: Record<ScheduledKind, number> = { microtask: 0, frame: 1, timeout: 2, idle: 3 };
 
 function cancelScheduled(): void {
-  if (scheduledHandle !== null) {
-    if (scheduledKind === "frame") cancelAnimationFrame(scheduledHandle);
-    else if (scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined") cancelIdleCallback(scheduledHandle);
-    else if (scheduledKind === "timeout") clearTimeout(scheduledHandle);
+  if (_sched.scheduledHandle !== null) {
+    if (_sched.scheduledKind === "frame") cancelAnimationFrame(_sched.scheduledHandle);
+    else if (_sched.scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined")
+      cancelIdleCallback(_sched.scheduledHandle);
+    else if (_sched.scheduledKind === "timeout") clearTimeout(_sched.scheduledHandle);
   }
-  scheduledHandle = null;
-  scheduledKind = null;
+  _sched.scheduledHandle = null;
+  _sched.scheduledKind = null;
 }
 
 function scheduleFrame(): void {
@@ -99,48 +109,52 @@ function scheduleFrame(): void {
         ? typeof requestIdleCallback !== "undefined"
           ? "idle"
           : "timeout"
-        : "frame";
+        : // NORMAL/LOW prefer a frame, but rAF is absent under SSR — fall back
+          // to a timeout so startTransition()/deferredValue() don't throw.
+          typeof requestAnimationFrame !== "undefined"
+          ? "frame"
+          : "timeout";
 
   // A microtask is the fastest tier — nothing to re-arm faster.
-  if (microtaskScheduled) return;
-  if (scheduledKind !== null) {
+  if (_sched.microtaskScheduled) return;
+  if (_sched.scheduledKind !== null) {
     // Keep the existing schedule only if it fires at least as soon as needed.
     // Otherwise a higher-priority task arrived (e.g. USER_BLOCKING behind a
     // pending rAF) — cancel the slower handle and re-arm at the faster tier,
     // instead of making the urgent task wait for the next frame.
-    if (TIER_SPEED[scheduledKind] <= TIER_SPEED[desired]) return;
+    if (TIER_SPEED[_sched.scheduledKind] <= TIER_SPEED[desired]) return;
     cancelScheduled();
   }
 
   if (desired === "microtask") {
     // Set flag BEFORE queueing to avoid races where another scheduleFrame()
     // call slips through.
-    microtaskScheduled = true;
-    scheduledKind = "microtask";
+    _sched.microtaskScheduled = true;
+    _sched.scheduledKind = "microtask";
     queueMicrotask(() => {
-      microtaskScheduled = false;
-      scheduledKind = null;
+      _sched.microtaskScheduled = false;
+      _sched.scheduledKind = null;
       processQueue();
     });
   } else if (desired === "idle") {
-    scheduledKind = "idle";
-    scheduledHandle = requestIdleCallback(() => {
-      scheduledKind = null;
-      scheduledHandle = null;
+    _sched.scheduledKind = "idle";
+    _sched.scheduledHandle = requestIdleCallback(() => {
+      _sched.scheduledKind = null;
+      _sched.scheduledHandle = null;
       processQueue();
     }) as unknown as number;
   } else if (desired === "timeout") {
-    scheduledKind = "timeout";
-    scheduledHandle = setTimeout(() => {
-      scheduledKind = null;
-      scheduledHandle = null;
+    _sched.scheduledKind = "timeout";
+    _sched.scheduledHandle = setTimeout(() => {
+      _sched.scheduledKind = null;
+      _sched.scheduledHandle = null;
       processQueue();
     }, 50) as unknown as number;
   } else {
-    scheduledKind = "frame";
-    scheduledHandle = requestAnimationFrame(() => {
-      scheduledKind = null;
-      scheduledHandle = null;
+    _sched.scheduledKind = "frame";
+    _sched.scheduledHandle = requestAnimationFrame(() => {
+      _sched.scheduledKind = null;
+      _sched.scheduledHandle = null;
       processQueue();
     });
   }
@@ -152,7 +166,7 @@ function scheduleFrame(): void {
  */
 export function scheduleUpdate(priority: PriorityLevel, callback: () => void): () => void {
   const task: ScheduledTask = {
-    id: taskIdCounter++,
+    id: _sched.taskIdCounter++,
     priority,
     callback,
     cancelled: false,
@@ -182,15 +196,15 @@ export function scheduleUpdate(priority: PriorityLevel, callback: () => void): (
 export function flushScheduler(): void {
   // Cancel any pending scheduled work. Microtasks are not cancellable, but
   // the callback becomes a no-op once the queue drains.
-  if (scheduledHandle !== null) {
-    if (scheduledKind === "frame") cancelAnimationFrame(scheduledHandle);
-    else if (scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined") {
-      cancelIdleCallback(scheduledHandle);
-    } else if (scheduledKind === "timeout") clearTimeout(scheduledHandle);
+  if (_sched.scheduledHandle !== null) {
+    if (_sched.scheduledKind === "frame") cancelAnimationFrame(_sched.scheduledHandle);
+    else if (_sched.scheduledKind === "idle" && typeof cancelIdleCallback !== "undefined") {
+      cancelIdleCallback(_sched.scheduledHandle);
+    } else if (_sched.scheduledKind === "timeout") clearTimeout(_sched.scheduledHandle);
   }
-  scheduledHandle = null;
-  scheduledKind = null;
-  microtaskScheduled = false;
+  _sched.scheduledHandle = null;
+  _sched.scheduledKind = null;
+  _sched.microtaskScheduled = false;
 
   while (taskQueue.length > 0) {
     const task = taskQueue.shift();
@@ -199,7 +213,7 @@ export function flushScheduler(): void {
       task.callback();
     }
   }
-  isProcessing = false;
+  _sched.isProcessing = false;
 }
 
 /**
diff --git a/src/platform/head.ts b/src/platform/head.ts
index 28e70d4..fed363e 100644
--- a/src/platform/head.ts
+++ b/src/platform/head.ts
@@ -1,3 +1,4 @@
+import { registerDisposer } from "../core/rendering/dispose";
 import { effect } from "../core/signals/effect";
 import { isEventHandlerAttr, sanitizeUrl, stripControlChars } from "../utils/sanitize";
 
@@ -211,6 +212,11 @@ export function Head(props: HeadProps): Comment {
 
   apply();
 
+  // Tie cleanup to the anchor so disposing the enclosing subtree (`dispose()`)
+  // removes this instance's injected <head> elements and stops its title/meta
+  // effects. Without this, every Head() leaked its elements + effects forever.
+  registerDisposer(anchor, cleanup);
+
   return anchor;
 }
 
diff --git a/src/platform/microfrontend.ts b/src/platform/microfrontend.ts
index 1fa8cbb..d88368f 100644
--- a/src/platform/microfrontend.ts
+++ b/src/platform/microfrontend.ts
@@ -1,5 +1,6 @@
 import { div, span } from "../core/rendering/html";
 import { signal } from "../core/signals/signal";
+import { globalSingleton } from "../utils/globalSingleton";
 
 // ============================================================================
 // MICRO-FRONTEND / MODULE FEDERATION
@@ -40,7 +41,12 @@ export interface SharedScope<T extends Record<string, unknown>> {
 // Module cache for loadRemoteModule
 // --------------------------------------------------------------------------
 
-const moduleCache = new Map<string, Promise<unknown>>();
+// Shared across duplicate module copies so a double-loaded bundle dedups the
+// in-flight import of the same remote URL instead of fetching it twice.
+const moduleCache = globalSingleton(
+  Symbol.for("sibujs.microfrontend.moduleCache.v1"),
+  () => new Map<string, Promise<unknown>>(),
+);
 
 // --------------------------------------------------------------------------
 // createMicroApp
diff --git a/src/platform/routeActions.ts b/src/platform/routeActions.ts
index f94fbbf..f1e016c 100644
--- a/src/platform/routeActions.ts
+++ b/src/platform/routeActions.ts
@@ -20,7 +20,13 @@ export function createAction<T>(actionFn: ActionFn<T>): ActionResult<T> {
   const [error, setError] = signal<Error | undefined>(undefined);
   const [loading, setLoading] = signal<boolean>(false);
 
+  // Sequence concurrent submits so a slower earlier call can't clobber the
+  // reactive state of a faster later one. Each caller still gets its own
+  // result/throw — only the shared signals are gated to the latest run.
+  let activeRun = 0;
+
   const submit = async (input: FormData | Record<string, unknown>): Promise<T> => {
+    const runId = ++activeRun;
     batch(() => {
       setLoading(true);
       setError(undefined);
@@ -28,17 +34,21 @@ export function createAction<T>(actionFn: ActionFn<T>): ActionResult<T> {
 
     try {
       const result = await actionFn(input);
-      batch(() => {
-        setData(result);
-        setLoading(false);
-      });
+      if (runId === activeRun) {
+        batch(() => {
+          setData(result);
+          setLoading(false);
+        });
+      }
       return result;
     } catch (err) {
       const actionError = err instanceof Error ? err : new Error(String(err));
-      batch(() => {
-        setError(actionError);
-        setLoading(false);
-      });
+      if (runId === activeRun) {
+        batch(() => {
+          setError(actionError);
+          setLoading(false);
+        });
+      }
       throw actionError;
     }
   };
diff --git a/src/platform/scrollRestoration.ts b/src/platform/scrollRestoration.ts
index 2f902fd..480d54d 100644
--- a/src/platform/scrollRestoration.ts
+++ b/src/platform/scrollRestoration.ts
@@ -19,16 +19,15 @@ export function scrollRestoration(options?: ScrollRestorationOptions): {
   let currentKey: string | null = null;
 
   const save = (key: string): void => {
-    positions.set(key, {
-      x: window.scrollX,
-      y: window.scrollY,
-    });
+    if (typeof window !== "undefined") {
+      positions.set(key, { x: window.scrollX, y: window.scrollY });
+    }
     currentKey = key;
   };
 
   const restore = (key: string): void => {
     const pos = positions.get(key);
-    if (pos) {
+    if (pos && typeof window !== "undefined") {
       window.scrollTo(pos.x, pos.y);
     }
     currentKey = key;
@@ -38,8 +37,8 @@ export function scrollRestoration(options?: ScrollRestorationOptions): {
     return positions.get(key);
   };
 
-  // In auto mode, save/restore on popstate events
-  if (mode === "auto") {
+  // In auto mode, save/restore on popstate events (client-only).
+  if (mode === "auto" && typeof window !== "undefined") {
     popstateHandler = () => {
       if (currentKey) {
         save(currentKey);
diff --git a/src/platform/wasm.ts b/src/platform/wasm.ts
index da4688f..ab9a201 100644
--- a/src/platform/wasm.ts
+++ b/src/platform/wasm.ts
@@ -5,6 +5,7 @@
  */
 
 import { signal } from "../core/signals/signal";
+import { globalSingleton } from "../utils/globalSingleton";
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -28,8 +29,16 @@ export interface WasmConfig {
 
 // ─── Module Cache ───────────────────────────────────────────────────────────
 
-const moduleCache = new Map<string, WebAssembly.Module>();
-const instanceCache = new Map<string, WebAssembly.Instance>();
+// Shared across duplicate module copies so a double-loaded bundle doesn't
+// re-fetch/recompile the same WASM, and a keyed instance stays a true singleton.
+const moduleCache = globalSingleton(
+  Symbol.for("sibujs.wasm.moduleCache.v1"),
+  () => new Map<string, WebAssembly.Module>(),
+);
+const instanceCache = globalSingleton(
+  Symbol.for("sibujs.wasm.instanceCache.v1"),
+  () => new Map<string, WebAssembly.Instance>(),
+);
 
 // ─── wasm Hook ───────────────────────────────────────────────────────────
 
@@ -94,7 +103,14 @@ export function wasm<T extends Record<string, unknown> = Record<string, unknown>
 /**
  * Load and instantiate a WebAssembly module.
  * Supports loading from URL, ArrayBuffer, or Uint8Array.
- * Caches compiled modules for reuse.
+ *
+ * Caching: keyed by `cacheKey` (or, for a URL source, the URL itself). A keyed
+ * load is memoized as a **singleton instance** — every caller with the same key
+ * receives the *same* `WebAssembly.Instance`, which shares one linear memory and
+ * mutable globals. This is intentional (load-once / reuse), but it means callers
+ * that need isolated state must use distinct cache keys, or pass a non-URL source
+ * with no `cacheKey` (which instantiates fresh every call). Compiled modules are
+ * immutable and always safe to share.
  */
 export interface LoadWasmOptions {
   imports?: WebAssembly.Imports;
diff --git a/src/plugins/i18n.ts b/src/plugins/i18n.ts
index 9fdba57..fad8791 100644
--- a/src/plugins/i18n.ts
+++ b/src/plugins/i18n.ts
@@ -1,12 +1,22 @@
 import { span } from "../core/rendering/html";
 import { signal } from "../core/signals/signal";
+import { globalSingleton } from "../utils/globalSingleton";
 
 type Translations = Record<string, string>;
 type LocaleMap = Record<string, Translations>;
 type Params = Record<string, string | number>;
 
-const [currentLocale, setLocaleInternal] = signal("en");
-const locales: LocaleMap = {};
+// The active locale and the translation map are shared via globalSingleton so a
+// bundler that duplicates the `plugins` chunk doesn't split i18n into two
+// worlds (where `setLocale()` in one copy never reaches `t()`/`Trans()` in
+// another). NOTE: this state is still process-global — per-request SSR locale
+// isolation is a separate follow-up (see TODO.md §C).
+const _i18n = globalSingleton(Symbol.for("sibujs.i18n.v1"), () => ({
+  locale: signal("en"),
+  locales: {} as LocaleMap,
+}));
+const [currentLocale, setLocaleInternal] = _i18n.locale;
+const locales = _i18n.locales;
 
 export function setLocale(locale: string) {
   setLocaleInternal(locale);
diff --git a/src/plugins/modular.ts b/src/plugins/modular.ts
index e2d9dc1..1f347ef 100644
--- a/src/plugins/modular.ts
+++ b/src/plugins/modular.ts
@@ -153,9 +153,10 @@ export function lazyModule<T>(loader: () => Promise<T>): { get: () => Promise<T>
       return loadedFlag;
     },
     async get(): Promise<T> {
-      if (loadedFlag && cached !== undefined) {
-        return cached;
-      }
+      // Gate on the flag alone — a loader that legitimately resolves to
+      // `undefined` (or a falsy module) must still be cached, not re-invoked
+      // (which would re-run side-effectful imports) on every get().
+      if (loadedFlag) return cached as T;
       cached = await loader();
       loadedFlag = true;
       return cached;
diff --git a/src/plugins/plugin.ts b/src/plugins/plugin.ts
index 4314a61..e2c1686 100644
--- a/src/plugins/plugin.ts
+++ b/src/plugins/plugin.ts
@@ -2,6 +2,8 @@
 // PLUGIN ARCHITECTURE
 // ============================================================================
 
+import { globalSingleton } from "../utils/globalSingleton";
+
 export interface PluginContext {
   /** Register a global hook */
   onInit: (callback: () => void) => void;
@@ -123,8 +125,12 @@ export function createPluginRegistry(): PluginRegistry {
 }
 
 // Default singleton registry (kept for back-compat with existing public API).
-let defaultRegistry: PluginRegistry = createPluginRegistry();
-let defaultRegistryTouched = false;
+// Shared across duplicate module copies so plugins installed through one copy
+// are visible to `inject()` called through another.
+const _defaults = globalSingleton(Symbol.for("sibujs.plugins.defaultRegistry.v1"), () => ({
+  registry: createPluginRegistry(),
+  touched: false,
+}));
 
 /**
  * Creates a plugin definition.
@@ -137,44 +143,44 @@ export function createPlugin(name: string, install: (ctx: PluginContext, options
  * Installs a plugin into the default (singleton) registry.
  */
 export function plugin(plugin: SibuPlugin, options?: unknown): void {
-  defaultRegistryTouched = true;
-  defaultRegistry.plugin(plugin, options);
+  _defaults.touched = true;
+  _defaults.registry.plugin(plugin, options);
 }
 
 /**
  * Retrieve a value provided by a plugin (from the default registry).
  */
 export function inject<T = unknown>(key: string, defaultValue?: T): T {
-  return defaultRegistry.inject<T>(key, defaultValue);
+  return _defaults.registry.inject<T>(key, defaultValue);
 }
 
 /**
  * Trigger mount hooks for an element (default registry).
  */
 export function triggerPluginMount(element: HTMLElement): void {
-  defaultRegistry.triggerMount(element);
+  _defaults.registry.triggerMount(element);
 }
 
 /**
  * Trigger unmount hooks for an element (default registry).
  */
 export function triggerPluginUnmount(element: HTMLElement): void {
-  defaultRegistry.triggerUnmount(element);
+  _defaults.registry.triggerUnmount(element);
 }
 
 /**
  * Trigger error hooks (default registry).
  */
 export function triggerPluginError(error: Error): void {
-  defaultRegistry.triggerError(error);
+  _defaults.registry.triggerError(error);
 }
 
 /**
  * Reset the default plugin registry (useful for testing).
  */
 export function resetPlugins(): void {
-  defaultRegistry.reset();
-  defaultRegistryTouched = false;
+  _defaults.registry.reset();
+  _defaults.touched = false;
 }
 
 /**
@@ -183,12 +189,12 @@ export function resetPlugins(): void {
  * accidental interleaving of singleton + registry use).
  */
 export function setDefaultPluginRegistry(registry: PluginRegistry): void {
-  if (defaultRegistryTouched && defaultRegistry.installedPlugins.size > 0) {
+  if (_defaults.touched && _defaults.registry.installedPlugins.size > 0) {
     console.warn(
       "[Plugin] Replacing default plugin registry while plugins are already installed on the singleton. " +
         "This may indicate mixed singleton/registry usage.",
     );
   }
-  defaultRegistry = registry;
-  defaultRegistryTouched = true;
+  _defaults.registry = registry;
+  _defaults.touched = true;
 }
diff --git a/src/plugins/router.ts b/src/plugins/router.ts
index 48a8966..f7db707 100644
--- a/src/plugins/router.ts
+++ b/src/plugins/router.ts
@@ -243,11 +243,44 @@ class RouteMatcher {
   private parentChain = new Map<string, RouteDef[]>();
   private namedRoutes = new Map<string, RouteDef>();
   private compiledPatterns = new LRUCache<string, { regex: RegExp; keys: string[] }>(50);
+  // Pattern routes (those with params/wildcards) ordered most-specific-first,
+  // rebuilt lazily after any mutation. Static full paths are served by the
+  // exact-match map and excluded here.
+  private patternOrder: [string, RouteDef][] | null = null;
 
   constructor(routes: RouteDef[]) {
     this.buildIndex(routes);
   }
 
+  // Specificity per segment: static (2) > param `:x` (1) > wildcard `*` (0).
+  private static specificity(path: string): number[] {
+    return path
+      .split("/")
+      .filter(Boolean)
+      .map((seg) => (seg.startsWith(":") ? 1 : seg.includes("*") ? 0 : 2));
+  }
+
+  private getPatternOrder(): [string, RouteDef][] {
+    if (this.patternOrder) return this.patternOrder;
+    const patterns = [...this.routeTrie].filter(([p]) => p.includes(":") || p.includes("*"));
+    // Stable sort: equal-specificity routes keep their registration order, so a
+    // broad route can't shadow a more specific one while existing ties are
+    // unaffected.
+    patterns.sort(([a], [b]) => {
+      const ka = RouteMatcher.specificity(a);
+      const kb = RouteMatcher.specificity(b);
+      const len = Math.max(ka.length, kb.length);
+      for (let i = 0; i < len; i++) {
+        const va = ka[i] ?? -1;
+        const vb = kb[i] ?? -1;
+        if (va !== vb) return vb - va;
+      }
+      return 0;
+    });
+    this.patternOrder = patterns;
+    return patterns;
+  }
+
   private buildIndex(routes: RouteDef[], parentPath = "", ancestors: RouteDef[] = []): void {
     for (const route of routes) {
       const fullPath = parentPath + route.path;
@@ -285,8 +318,9 @@ class RouteMatcher {
       return { route: exactMatch, params: {}, matched: this.parentChain.get(path) || [exactMatch] };
     }
 
-    // Try pattern matching
-    for (const [routePath, route] of this.routeTrie) {
+    // Try pattern matching, most-specific-first so a broad param/wildcard
+    // route can't shadow a more specific route that also matches.
+    for (const [routePath, route] of this.getPatternOrder()) {
       const match = this.matchPattern(path, routePath);
       if (match) {
         return { route, params: match.params, matched: this.parentChain.get(routePath) || [route] };
@@ -380,10 +414,12 @@ class RouteMatcher {
     this.parentChain.clear();
     this.namedRoutes.clear();
     this.compiledPatterns.clear();
+    this.patternOrder = null;
     this.buildIndex(routes);
   }
 
   addRoute(route: RouteDef, parentPath = ""): void {
+    this.patternOrder = null;
     const fullPath = parentPath + route.path;
     const parentAncestors = this.parentChain.get(parentPath) || [];
     const chain = [...parentAncestors, route];
@@ -399,6 +435,7 @@ class RouteMatcher {
 
   removeRoute(path: string): void {
     this.compiledPatterns.clear();
+    this.patternOrder = null;
     const root = this.routeTrie.get(path);
     if (!root) return;
 
@@ -681,6 +718,11 @@ class ComponentLoader {
   }
 
   private isAsyncComponent(comp: Component | AsyncComponent | LazyComponent): boolean {
+    // Prefer the reliable signals: the LAZY_MARKER stamped by `lazy()` and a
+    // genuine async function. The `toString()` source sniff is a best-effort
+    // fallback for an un-wrapped `() => import("./Page")` shorthand — dynamic
+    // `import(` is preserved verbatim by bundlers (it drives code-splitting), so
+    // it survives minification, but wrapping in `lazy()` is the robust form.
     return (
       (comp as any)[LAZY_MARKER] === true ||
       comp.constructor.name === "AsyncFunction" ||
@@ -771,15 +813,18 @@ export class SibuRouter {
   }
 
   private initialize(): void {
-    // Set up event listeners
-    if (this.options.mode === "history") {
-      const popstateHandler = () => this.handleLocationChange(true);
-      window.addEventListener("popstate", popstateHandler);
-      this.cleanup.push(() => window.removeEventListener("popstate", popstateHandler));
-    } else {
-      const hashHandler = () => this.handleLocationChange(true);
-      window.addEventListener("hashchange", hashHandler);
-      this.cleanup.push(() => window.removeEventListener("hashchange", hashHandler));
+    // Set up event listeners. Guarded so constructing a router under SSR (e.g.
+    // createMemoryRouter, advertised for testing/SSR) doesn't throw on `window`.
+    if (typeof window !== "undefined") {
+      if (this.options.mode === "history") {
+        const popstateHandler = () => this.handleLocationChange(true);
+        window.addEventListener("popstate", popstateHandler);
+        this.cleanup.push(() => window.removeEventListener("popstate", popstateHandler));
+      } else {
+        const hashHandler = () => this.handleLocationChange(true);
+        window.addEventListener("hashchange", hashHandler);
+        this.cleanup.push(() => window.removeEventListener("hashchange", hashHandler));
+      }
     }
 
     // Set initial route
@@ -1566,10 +1611,18 @@ export function Route(): Node {
     });
   }
 
-  routeCleanups.push(() => {
+  let routeTorn = false;
+  const routeCleanup = () => {
+    if (routeTorn) return;
+    routeTorn = true;
     routeTeardown();
     cleanupNodes();
-  });
+  };
+  // Tie cleanup to the anchor so removing this outlet's subtree (e.g. a parent
+  // layout change) releases its tracking + nodes immediately — not only on
+  // destroyRouter(). Idempotent, so the destroyRouter() drain stays safe.
+  registerDisposer(anchor, routeCleanup);
+  routeCleanups.push(routeCleanup);
 
   return anchor;
 }
@@ -1741,7 +1794,10 @@ export function KeepAliveRoute(options?: { max?: number; include?: string[] }):
     });
   }
 
-  routeCleanups.push(() => {
+  let kaTorn = false;
+  const kaCleanup = () => {
+    if (kaTorn) return;
+    kaTorn = true;
     kaTeardown();
     for (const node of cache.values()) {
       dispose(node);
@@ -1751,7 +1807,11 @@ export function KeepAliveRoute(options?: { max?: number; include?: string[] }):
     lruOrder.length = 0;
     if (currentNode?.parentNode) currentNode.parentNode.removeChild(currentNode);
     currentNode = null;
-  });
+  };
+  // The cached detached subtrees are the heaviest leak here — release them when
+  // the outlet's anchor subtree is disposed, not only on destroyRouter().
+  registerDisposer(anchor, kaCleanup);
+  routeCleanups.push(kaCleanup);
 
   return anchor;
 }
@@ -1760,19 +1820,26 @@ export function KeepAliveRoute(options?: { max?: number; include?: string[] }):
 // ROUTER LINK COMPONENT
 // ============================================================================
 
-export function RouterLink(props: {
-  to: NavigationTarget;
-  replace?: boolean;
-  activeClass?: string;
-  exactActiveClass?: string;
-  nodes?: string | Node | (string | Node)[];
-  target?: string;
-  rel?: string;
-  [key: string]: unknown;
-}): HTMLElement {
+export function RouterLink(
+  props: {
+    to: NavigationTarget;
+    replace?: boolean;
+    activeClass?: string;
+    exactActiveClass?: string;
+    /** @deprecated Pass children positionally: `RouterLink(props, children)`. */
+    nodes?: string | Node | (string | Node)[];
+    target?: string;
+    rel?: string;
+    [key: string]: unknown;
+  },
+  children?: string | Node | (string | Node)[],
+): HTMLElement {
   if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
 
   const { to, replace = false, activeClass, exactActiveClass, nodes, target, rel, class: classAttr, ...attrs } = props;
+  // Children pass positionally (the framework-wide convention); `nodes` is kept
+  // only as a deprecated fallback for existing callers.
+  const content = children !== undefined ? children : nodes;
   const baseClass = typeof classAttr === "string" ? classAttr : "";
 
   const routeGetter = _routerRef.current.routeGetter;
@@ -1847,12 +1914,12 @@ export function RouterLink(props: {
   });
 
   // Set content
-  if (typeof nodes === "string") {
-    link.textContent = nodes;
-  } else if (nodes instanceof Node) {
-    link.appendChild(nodes);
-  } else if (Array.isArray(nodes)) {
-    nodes.forEach((child) => {
+  if (typeof content === "string") {
+    link.textContent = content;
+  } else if (content instanceof Node) {
+    link.appendChild(content);
+  } else if (Array.isArray(content)) {
+    content.forEach((child) => {
       if (typeof child === "string") {
         link.appendChild(document.createTextNode(child));
       } else if (child instanceof Node) {
@@ -2156,14 +2223,19 @@ export function Outlet(): Node {
       if (anchor.parentNode) update();
     });
   }
-  routeCleanups.push(() => {
+  let outletTorn = false;
+  const outletCleanup = () => {
+    if (outletTorn) return;
+    outletTorn = true;
     outletTeardown();
     if (currentNode) {
       dispose(currentNode);
       if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
       currentNode = null;
     }
-  });
+  };
+  registerDisposer(anchor, outletCleanup);
+  routeCleanups.push(outletCleanup);
   return anchor;
 }
 
diff --git a/src/plugins/routerSSR.ts b/src/plugins/routerSSR.ts
index 3398797..7e7b75c 100644
--- a/src/plugins/routerSSR.ts
+++ b/src/plugins/routerSSR.ts
@@ -501,18 +501,17 @@ export function hydrateRouter(routes: SSRRouteDef[], options?: { container?: HTM
     return;
   }
 
-  // 2. Create the router with routes but wrap so we can control initialization.
-  //    We use createRouter which sets the global router, then immediately set
-  //    the route state to what the server resolved, preventing a redundant
-  //    initial navigation and re-render.
+  // 2. Create the client router. Its constructor resolves the initial route
+  //    from `window.location`, which on hydration matches the URL the server
+  //    rendered (and therefore `serverState.path`). We intentionally do NOT
+  //    issue an explicit navigate() to `serverState.path` here: a real
+  //    navigation would re-render and discard the server-rendered DOM, which is
+  //    exactly what hydration must avoid. If the address bar and
+  //    `serverState.path` ever diverge (e.g. a server-side normalization), the
+  //    location-driven resolution reconciles to the live URL.
   createRouter(routes as RouteDef[]);
 
-  // 3. Set the current route to the server's resolved state by navigating
-  //    to the server-known path with replace semantics. This synchronizes
-  //    the router's internal state with the server's resolved route without
-  //    causing a DOM update (since the content is already rendered).
-
-  // 4. Hydrate the existing DOM.
+  // 3. Hydrate the existing DOM.
   const container = options?.container || document.getElementById("app");
   if (container && serverState.path) {
     // Find the component that the server rendered for this route
diff --git a/src/testing/a11y.ts b/src/testing/a11y.ts
index 68a8870..f0ae771 100644
--- a/src/testing/a11y.ts
+++ b/src/testing/a11y.ts
@@ -679,7 +679,7 @@ export function checkAriaAttributes(root: Element): A11yViolation[] {
         if (attr.name === "aria-checked" || attr.name === "aria-pressed") {
           validValues.push("mixed");
         }
-        if (!validValues.includes(attr.value) && attr.value !== "undefined") {
+        if (!validValues.includes(attr.value)) {
           violations.push({
             rule: "aria-valid-attr-value",
             level: "error",
diff --git a/src/testing/e2e.ts b/src/testing/e2e.ts
index a867fbe..80a9bd2 100644
--- a/src/testing/e2e.ts
+++ b/src/testing/e2e.ts
@@ -44,7 +44,17 @@ export function createHttpMock(routes: MockRoute[] = [], options: { afterEach?:
   const mockFetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
     const method = init?.method || "GET";
-    const body = init?.body ? JSON.parse(String(init.body)) : undefined;
+    let body: unknown;
+    if (init?.body != null) {
+      const raw = String(init.body);
+      try {
+        body = JSON.parse(raw);
+      } catch {
+        // Non-JSON body (plain text, form-encoded, stringified FormData) — keep
+        // the raw value instead of throwing and breaking the mock.
+        body = raw;
+      }
+    }
 
     requestLog.push({ url, method, body, timestamp: Date.now() });
 
diff --git a/src/testing/index.ts b/src/testing/index.ts
index 7b2911c..b62dc03 100644
--- a/src/testing/index.ts
+++ b/src/testing/index.ts
@@ -3,6 +3,7 @@
 // ============================================================================
 
 import { dispose } from "../core/rendering/dispose";
+import { globalSingleton } from "../utils/globalSingleton";
 
 /**
  * Escape a value for safe embedding in a CSS attribute selector.
@@ -16,8 +17,10 @@ function escapeSelector(value: string): string {
 }
 
 // Tracks containers produced by `render()` so tests can bulk-clean via
-// `unmountAll()` when individual `unmount()` calls were missed.
-const _renderedContainers = new Set<HTMLElement>();
+// `unmountAll()` when individual `unmount()` calls were missed. Shared via
+// globalSingleton so a duplicated copy of this module doesn't register into one
+// Set while `unmountAll()` clears another, leaking mounted containers/effects.
+const _renderedContainers = globalSingleton(Symbol.for("sibujs.testing.containers.v1"), () => new Set<HTMLElement>());
 
 /**
  * Unmount every container still alive from prior `render()` calls.
diff --git a/src/ui/TransitionGroup.ts b/src/ui/TransitionGroup.ts
index 04e3c48..21c6f45 100644
--- a/src/ui/TransitionGroup.ts
+++ b/src/ui/TransitionGroup.ts
@@ -30,6 +30,10 @@ export function TransitionGroup(options: TransitionGroupOptions): {
     if (options.leave) {
       await options.leave(el);
     }
+    // Drop the cached rect too — otherwise an element removed via remove()
+    // (rather than track(), which clears the whole map) lingers in `positions`
+    // for the group's lifetime.
+    positions.delete(el);
     setElements((prev) => prev.filter((e) => e !== el));
   }
 
diff --git a/src/ui/a11y.ts b/src/ui/a11y.ts
index ebe4fb0..2247e20 100644
--- a/src/ui/a11y.ts
+++ b/src/ui/a11y.ts
@@ -1,6 +1,7 @@
 import { registerDisposer } from "../core/rendering/dispose";
 import { signal } from "../core/signals/signal";
 import { track } from "../reactivity/track";
+import { globalSingleton } from "../utils/globalSingleton";
 
 // ============================================================================
 // ACCESSIBILITY
@@ -258,14 +259,15 @@ export function hotkey(
  * queue so that each message has a chance to be read before the next one
  * overwrites the live region.
  */
-const announceQueues: Record<"polite" | "assertive", string[]> = {
-  polite: [],
-  assertive: [],
-};
-const announceDraining: Record<"polite" | "assertive", boolean> = {
-  polite: false,
-  assertive: false,
-};
+// Shared via globalSingleton: the queues and the draining flags both target the
+// single `#sibu-announce-*` live region in the DOM, so a duplicated copy of this
+// module must not run its own parallel drain loop against the same region.
+const _announce = globalSingleton(Symbol.for("sibujs.a11y.announce.v1"), () => ({
+  queues: { polite: [] as string[], assertive: [] as string[] },
+  draining: { polite: false, assertive: false },
+}));
+const announceQueues: Record<"polite" | "assertive", string[]> = _announce.queues;
+const announceDraining: Record<"polite" | "assertive", boolean> = _announce.draining;
 const ANNOUNCE_INTERVAL_MS = 150;
 
 function ensureLiveRegion(priority: "polite" | "assertive"): HTMLElement {
diff --git a/src/ui/animationPresets.ts b/src/ui/animationPresets.ts
index aa66b1b..e30af81 100644
--- a/src/ui/animationPresets.ts
+++ b/src/ui/animationPresets.ts
@@ -4,6 +4,8 @@
  * All presets respect reduced motion preferences.
  */
 
+import { prefersReducedMotion } from "./reducedMotion";
+
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 export interface AnimationPreset {
@@ -20,9 +22,6 @@ export interface PresetOptions {
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
-const prefersReducedMotion = () =>
-  typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
-
 function createPreset(
   keyframes: Keyframe[],
   defaults: KeyframeAnimationOptions,
diff --git a/src/ui/dialog.ts b/src/ui/dialog.ts
index bea0b7e..df29da4 100644
--- a/src/ui/dialog.ts
+++ b/src/ui/dialog.ts
@@ -1,4 +1,5 @@
 import { signal } from "../core/signals/signal";
+import { globalSingleton } from "../utils/globalSingleton";
 
 /**
  * dialog provides reactive dialog state management with escape-to-close support.
@@ -16,8 +17,14 @@ type DialogEntry = {
   close: () => void;
 };
 
-const dialogStack: DialogEntry[] = [];
-let globalListenerAttached = false;
+// Shared via globalSingleton so a duplicated copy of this module doesn't keep
+// its own stack + listener — otherwise each copy attaches its own keydown
+// handler and "Escape closes the top dialog" breaks across copies.
+const _dlg = globalSingleton(Symbol.for("sibujs.dialog.v1"), () => ({
+  stack: [] as DialogEntry[],
+  listenerAttached: false,
+}));
+const dialogStack = _dlg.stack;
 
 /**
  * Test-only helper to reset the module-level stack between specs. Client-only:
@@ -28,9 +35,9 @@ let globalListenerAttached = false;
  */
 export function __resetDialogStack(): void {
   while (dialogStack.length > 0) dialogStack.pop();
-  if (typeof window !== "undefined" && globalListenerAttached) {
+  if (typeof window !== "undefined" && _dlg.listenerAttached) {
     window.removeEventListener("keydown", handleGlobalKeydown);
-    globalListenerAttached = false;
+    _dlg.listenerAttached = false;
   }
 }
 
@@ -41,17 +48,17 @@ function handleGlobalKeydown(event: KeyboardEvent): void {
 }
 
 function ensureGlobalListener(): void {
-  if (typeof window === "undefined" || globalListenerAttached) return;
+  if (typeof window === "undefined" || _dlg.listenerAttached) return;
   window.addEventListener("keydown", handleGlobalKeydown);
-  globalListenerAttached = true;
+  _dlg.listenerAttached = true;
 }
 
 function removeGlobalListenerIfIdle(): void {
   if (typeof window === "undefined") return;
-  if (!globalListenerAttached) return;
+  if (!_dlg.listenerAttached) return;
   if (dialogStack.length > 0) return;
   window.removeEventListener("keydown", handleGlobalKeydown);
-  globalListenerAttached = false;
+  _dlg.listenerAttached = false;
 }
 
 export function dialog(): {
diff --git a/src/ui/form.ts b/src/ui/form.ts
index 414d6df..c2472dd 100644
--- a/src/ui/form.ts
+++ b/src/ui/form.ts
@@ -1,4 +1,6 @@
+import { registerDisposer } from "../core/rendering/dispose";
 import { derived } from "../core/signals/derived";
+import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 
 // ============================================================================
@@ -165,15 +167,42 @@ export function bindField<T>(field: FormField<T>, extras?: Record<string, unknow
 
   // Merge extras.on with field handlers — field handlers always win so extras
   // can't accidentally clobber the value/change/blur wiring.
-  const { on: extraOn, value: _ignoreValue, ...restExtras } = (extras ?? {}) as Record<string, unknown>;
+  const {
+    on: extraOn,
+    value: _ignoreValue,
+    onElement: extraOnElement,
+    ...restExtras
+  } = (extras ?? {}) as Record<string, unknown>;
   const mergedOn =
     extraOn && typeof extraOn === "object"
       ? { ...(extraOn as Record<string, (e: Event) => void>), ...fieldOn }
       : fieldOn;
 
+  // Write-back: a `<select multiple>` can't be driven by the plain `value` prop
+  // (assigning an array to `el.value` clears the selection), so reflect the
+  // field's array value onto each option's `selected` flag via a reactive
+  // effect bound to the element. Every other control type is handled correctly
+  // by the `value` prop alone, so this only engages for multi-selects.
+  const onElement = (el: HTMLElement): void => {
+    if (el instanceof HTMLSelectElement && el.multiple) {
+      const stop = effect(() => {
+        const v = field.value() as unknown;
+        const selected = Array.isArray(v) ? v.map(String) : [];
+        for (const opt of Array.from(el.options)) {
+          opt.selected = selected.includes(opt.value);
+        }
+      });
+      registerDisposer(el, stop);
+    }
+    if (typeof extraOnElement === "function") {
+      (extraOnElement as (el: HTMLElement) => void)(el);
+    }
+  };
+
   return {
     value: field.value as () => unknown,
     on: mergedOn as BoundFieldProps["on"],
+    onElement,
     ...restExtras,
   };
 }
@@ -244,9 +273,27 @@ export function form<T extends Record<string, unknown>>(config: FormConfig<T>):
     return true;
   });
 
+  // Dirty-check that doesn't false-positive on array/object initials (e.g. a
+  // multi-select `initial: []`): a fresh array is never `Object.is`-equal to the
+  // original, so fall back to a shallow structural comparison.
+  const valueEquals = (a: unknown, b: unknown): boolean => {
+    if (Object.is(a, b)) return true;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      return a.length === b.length && a.every((v, i) => Object.is(v, b[i]));
+    }
+    if (a && b && typeof a === "object" && typeof b === "object") {
+      const ak = Object.keys(a);
+      const bk = Object.keys(b as object);
+      return (
+        ak.length === bk.length &&
+        ak.every((k) => Object.is((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k]))
+      );
+    }
+    return false;
+  };
   const isDirty = derived(() => {
     for (const [name, cfg] of fieldEntries) {
-      if (!Object.is(fieldMap[name].value(), cfg.initial)) return true;
+      if (!valueEquals(fieldMap[name].value(), cfg.initial)) return true;
     }
     return false;
   });
diff --git a/src/ui/hover.ts b/src/ui/hover.ts
index 80e0854..f7ad08d 100644
--- a/src/ui/hover.ts
+++ b/src/ui/hover.ts
@@ -1,3 +1,4 @@
+import { registerDisposer } from "../core/rendering/dispose";
 import { signal } from "../core/signals/signal";
 
 /**
@@ -36,5 +37,9 @@ export function hover(target: HTMLElement): {
     target.removeEventListener("pointerleave", onLeave);
   }
 
+  // Also release when the element is disposed, so the listeners don't leak if
+  // the caller forgets to call dispose() (mirrors a11y.focus()/createListbox).
+  registerDisposer(target, dispose);
+
   return { hovered, dispose };
 }
diff --git a/src/ui/infiniteScroll.ts b/src/ui/infiniteScroll.ts
index 090a67b..3d5fabe 100644
--- a/src/ui/infiniteScroll.ts
+++ b/src/ui/infiniteScroll.ts
@@ -43,6 +43,14 @@ export function infiniteScroll(options: {
       await onLoadMore();
     } finally {
       setLoading(false);
+      // If the sentinel is still intersecting after the append (e.g. the newly
+      // loaded content didn't push it out of view, or the page isn't full yet),
+      // the observer won't fire again on its own — re-observe to force a fresh
+      // intersection check so loading doesn't stall.
+      if (!disposed && observer && _current && hasMore()) {
+        observer.unobserve(_current);
+        observer.observe(_current);
+      }
     }
   }
 
diff --git a/src/ui/inputMask.ts b/src/ui/inputMask.ts
index bad8ef5..e996670 100644
--- a/src/ui/inputMask.ts
+++ b/src/ui/inputMask.ts
@@ -93,8 +93,6 @@ export function inputMask(options: MaskOptions): {
     return /[^a-zA-Z0-9]/g;
   }
   const stripRegex = buildStripRegex();
-  const rawCharTest = options.pattern.includes("*") ? () => true : (c: string) => /[a-zA-Z0-9]/.test(c);
-
   function bind(input: HTMLInputElement): () => void {
     const onInput = () => {
       const cursorBefore = input.selectionStart ?? input.value.length;
@@ -105,20 +103,24 @@ export function inputMask(options: MaskOptions): {
       setRawValue(extractRaw(masked));
       input.value = masked;
 
-      let rawBefore = 0;
-      for (let i = 0; i < cursorBefore && i < oldValue.length; i++) {
-        if (rawCharTest(oldValue[i])) rawBefore++;
-      }
+      // Count raw (non-literal) chars before the caret using the SAME strip
+      // rule that derives `raw`. This is correct for digit/letter masks, "*"
+      // (keep-all) masks, and patterns with leading literals alike — the old
+      // per-char test counted literals for "*" masks and mis-handled a leading
+      // literal.
+      const rawBefore = oldValue.slice(0, cursorBefore).replace(stripRegex, "").length;
+
+      // Walk the freshly-masked value to the position just after the
+      // rawBefore-th editable slot, stepping over auto-inserted literals.
+      // Stopping once `counted === rawBefore` keeps the caret correct even when
+      // rawBefore is 0 (caret stays before the first slot/leading literal).
       let newCursor = 0;
       let counted = 0;
-      for (; newCursor < masked.length; newCursor++) {
+      while (newCursor < masked.length && counted < rawBefore) {
         if (newCursor < options.pattern.length && isSlot(options.pattern[newCursor])) {
           counted++;
-          if (counted >= rawBefore) {
-            newCursor++;
-            break;
-          }
         }
+        newCursor++;
       }
       // setSelectionRange throws (InvalidStateError) on input types that don't
       // support selection (number, email, date, …). Masks are normally on text
diff --git a/src/ui/pagination.ts b/src/ui/pagination.ts
index 57ebad2..512bd2c 100644
--- a/src/ui/pagination.ts
+++ b/src/ui/pagination.ts
@@ -23,25 +23,30 @@ export function pagination(options: { totalItems: () => number; pageSize?: numbe
     return Math.max(1, Math.ceil(total / pageSizeValue));
   });
 
+  // The exposed page is clamped to the valid range, so when totalItems shrinks
+  // below the current page, page()/startIndex()/endIndex() stay in bounds
+  // instead of pointing past the data.
+  const currentPage = derived(() => Math.min(Math.max(1, page()), totalPages()));
+
   const startIndex = derived(() => {
-    return (page() - 1) * pageSizeValue;
+    return (currentPage() - 1) * pageSizeValue;
   });
 
   const endIndex = derived(() => {
-    const end = page() * pageSizeValue;
+    const end = currentPage() * pageSizeValue;
     const total = options.totalItems();
     return Math.min(end, total);
   });
 
   function next(): void {
-    if (page() < totalPages()) {
-      setPage((p) => p + 1);
+    if (currentPage() < totalPages()) {
+      setPage(currentPage() + 1);
     }
   }
 
   function prev(): void {
-    if (page() > 1) {
-      setPage((p) => p - 1);
+    if (currentPage() > 1) {
+      setPage(currentPage() - 1);
     }
   }
 
@@ -50,5 +55,5 @@ export function pagination(options: { totalItems: () => number; pageSize?: numbe
     setPage(clamped);
   }
 
-  return { page, pageSize, totalPages, next, prev, goTo, startIndex, endIndex };
+  return { page: currentPage, pageSize, totalPages, next, prev, goTo, startIndex, endIndex };
 }
diff --git a/src/ui/reducedMotion.ts b/src/ui/reducedMotion.ts
index e7fafa0..d65a22b 100644
--- a/src/ui/reducedMotion.ts
+++ b/src/ui/reducedMotion.ts
@@ -1,5 +1,15 @@
 import { signal } from "../core/signals/signal";
 
+/**
+ * One-shot check of the `prefers-reduced-motion: reduce` media query. Returns
+ * false under SSR / where `matchMedia` is unavailable. Use this for imperative
+ * "should I animate right now?" decisions; use {@link reducedMotion} when you
+ * need a value that reacts to the user changing the setting.
+ */
+export function prefersReducedMotion(): boolean {
+  return typeof window !== "undefined" && !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+}
+
 /**
  * reducedMotion returns a reactive boolean tracking whether the user
  * prefers reduced motion via the `prefers-reduced-motion` media query.
diff --git a/src/ui/scopedStyle.ts b/src/ui/scopedStyle.ts
index 96809d0..dc4ab3b 100644
--- a/src/ui/scopedStyle.ts
+++ b/src/ui/scopedStyle.ts
@@ -2,7 +2,11 @@
 // SCOPED STYLE ISOLATION
 // ============================================================================
 
-let scopeCounter = 0;
+import { globalSingleton } from "../utils/globalSingleton";
+
+// Shared via globalSingleton so a duplicated copy of this module doesn't restart
+// at 0 and emit colliding `sibu-s*` scope ids (cross-bundle style collisions).
+const _scope = globalSingleton(Symbol.for("sibujs.scopedStyle.v1"), () => ({ n: 0 }));
 
 /**
  * Decode CSS escape sequences so the sanitizer can catch obfuscated
@@ -75,7 +79,7 @@ function sanitizeCSS(css: string): string {
  * background images, use inline styles via the `style` prop instead.
  */
 export function scopedStyle(css: string): { scope: string; attr: string } {
-  const id = `sibu-s${scopeCounter++}`;
+  const id = `sibu-s${_scope.n++}`;
   const attr = `data-${id}`;
 
   // Sanitize CSS to prevent data exfiltration attacks
diff --git a/src/ui/scrollLock.ts b/src/ui/scrollLock.ts
index 1602a9b..ed6da80 100644
--- a/src/ui/scrollLock.ts
+++ b/src/ui/scrollLock.ts
@@ -18,6 +18,8 @@
  * lock.unlock();
  * ```
  */
+import { globalSingleton } from "../utils/globalSingleton";
+
 export interface ScrollLockHandle {
   /** Activate a lock. Idempotent per-handle if called twice. */
   lock: () => void;
@@ -34,9 +36,14 @@ export interface ScrollLockHandle {
 // the lock is active — if application code assigns `body.style.overflow`
 // during a lock, that value will be clobbered on unlock. Keep modal state
 // in scrollLock handles, not direct style writes.
-let lockCount = 0;
-let savedOverflow: string | null = null;
-let savedPaddingRight: string | null = null;
+// Shared via globalSingleton so a duplicated copy of this module doesn't keep
+// its own counter/snapshot — otherwise one copy's N→0 unlock would restore
+// `overflow` while another copy still holds an open lock.
+const _lock = globalSingleton(Symbol.for("sibujs.scrollLock.v1"), () => ({
+  count: 0,
+  savedOverflow: null as string | null,
+  savedPaddingRight: null as string | null,
+}));
 
 export function scrollLock(): ScrollLockHandle {
   let owned = false;
@@ -44,15 +51,15 @@ export function scrollLock(): ScrollLockHandle {
   function lock() {
     if (owned) return;
     owned = true;
-    lockCount++;
+    _lock.count++;
     // Only the 0 → 1 transition snapshots and mutates the body; nested locks
     // increment the counter and otherwise no-op.
-    if (lockCount !== 1 || typeof document === "undefined") return;
+    if (_lock.count !== 1 || typeof document === "undefined") return;
 
     const body = document.body;
     const scrollBarWidth = window.innerWidth - document.documentElement.clientWidth;
-    savedOverflow = body.style.overflow;
-    savedPaddingRight = body.style.paddingRight;
+    _lock.savedOverflow = body.style.overflow;
+    _lock.savedPaddingRight = body.style.paddingRight;
     body.style.overflow = "hidden";
     if (scrollBarWidth > 0) {
       body.style.paddingRight = `${scrollBarWidth}px`;
@@ -62,15 +69,15 @@ export function scrollLock(): ScrollLockHandle {
   function unlock() {
     if (!owned) return;
     owned = false;
-    lockCount = Math.max(0, lockCount - 1);
+    _lock.count = Math.max(0, _lock.count - 1);
     // Only the N → 0 transition restores the snapshot.
-    if (lockCount !== 0 || typeof document === "undefined") return;
+    if (_lock.count !== 0 || typeof document === "undefined") return;
 
     const body = document.body;
-    body.style.overflow = savedOverflow ?? "";
-    body.style.paddingRight = savedPaddingRight ?? "";
-    savedOverflow = null;
-    savedPaddingRight = null;
+    body.style.overflow = _lock.savedOverflow ?? "";
+    body.style.paddingRight = _lock.savedPaddingRight ?? "";
+    _lock.savedOverflow = null;
+    _lock.savedPaddingRight = null;
   }
 
   return { lock, unlock };
diff --git a/src/ui/socket.ts b/src/ui/socket.ts
index d95b835..aeb76db 100644
--- a/src/ui/socket.ts
+++ b/src/ui/socket.ts
@@ -66,6 +66,12 @@ export function socket(
 
   function connect(): void {
     if (disposed) return;
+    // WebSocket is absent under SSR and some edge runtimes — degrade to a
+    // closed socket instead of throwing at construction.
+    if (typeof WebSocket === "undefined") {
+      setStatus("closed");
+      return;
+    }
 
     const safeUrl = validateWsUrl(getUrl());
     if (safeUrl === null) {
diff --git a/src/ui/springSignal.ts b/src/ui/springSignal.ts
index 867fefe..17ccc7c 100644
--- a/src/ui/springSignal.ts
+++ b/src/ui/springSignal.ts
@@ -1,4 +1,5 @@
 import { signal } from "../core/signals/signal";
+import { prefersReducedMotion } from "./reducedMotion";
 
 /**
  * Options for springSignal.
@@ -12,9 +13,6 @@ export interface SpringOptions {
   precision?: number;
 }
 
-const prefersReducedMotion = (): boolean =>
-  typeof window !== "undefined" && !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
-
 /**
  * Creates a reactive spring-animated value. The getter returns the
  * current animated number (updated every frame via rAF). The setter
diff --git a/src/ui/stream.ts b/src/ui/stream.ts
index 42744a7..2c04365 100644
--- a/src/ui/stream.ts
+++ b/src/ui/stream.ts
@@ -52,6 +52,12 @@ export function stream(
 
   function connect(): void {
     if (disposed) return;
+    // EventSource is absent under SSR and some edge runtimes — degrade to a
+    // closed stream instead of throwing at construction.
+    if (typeof EventSource === "undefined") {
+      setStatus("closed");
+      return;
+    }
 
     const safeUrl = validateSseUrl(url);
     if (safeUrl === null) {
diff --git a/src/ui/transition.ts b/src/ui/transition.ts
index 19f0110..f5dc049 100644
--- a/src/ui/transition.ts
+++ b/src/ui/transition.ts
@@ -3,6 +3,8 @@
  * Provides declarative transition and spring animations for elements.
  */
 
+import { registerDisposer } from "../core/rendering/dispose";
+
 export interface TransitionOptions {
   /** CSS property to animate (e.g., "opacity", "transform") */
   property?: string;
@@ -137,6 +139,10 @@ export function transition(
     });
   }
 
+  // If the element is disposed mid-transition, clear the pending timer (and
+  // settle any awaited promise) so the timer doesn't retain the element.
+  registerDisposer(element, cancelPending);
+
   return { enter, leave };
 }
 
diff --git a/src/utils/globalSingleton.ts b/src/utils/globalSingleton.ts
new file mode 100644
index 0000000..4f5f940
--- /dev/null
+++ b/src/utils/globalSingleton.ts
@@ -0,0 +1,24 @@
+/**
+ * First-copy-wins singleton holder.
+ *
+ * Returns the value stored on `globalThis` under `key`, creating it (once) from
+ * `create` if absent. This makes a piece of coordination state survive a
+ * bundler loading this module more than once on a page (Vite `optimizeDeps` /
+ * esbuild dependency pre-bundling can materialize the same chunk twice). Every
+ * duplicate copy resolves the SAME object, so they coordinate instead of
+ * silently splitting into independent worlds.
+ *
+ * The helper itself is pure (only reads/writes `globalThis[key]`), so it is
+ * safe under duplication too — whichever copy runs first wins the `??=`.
+ *
+ * Keys MUST be created with `Symbol.for(...)` so duplicate module copies share
+ * the same symbol. Use a versioned suffix (`"sibujs.<name>.v1"`) and only bump
+ * the version on an incompatible change to the held value's shape.
+ *
+ * @example
+ * const cache = globalSingleton(Symbol.for("sibujs.query.v1"), () => new Map());
+ */
+export function globalSingleton<T>(key: symbol, create: () => T): T {
+  const g = globalThis as typeof globalThis & Record<symbol, unknown>;
+  return (g[key] ??= create()) as T;
+}
diff --git a/src/widgets/Combobox.ts b/src/widgets/Combobox.ts
index 1b2b212..b95f6fd 100644
--- a/src/widgets/Combobox.ts
+++ b/src/widgets/Combobox.ts
@@ -1,10 +1,10 @@
+import { createId } from "../core/rendering/createId";
 import { derived } from "../core/signals/derived";
 import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 import { watch } from "../core/signals/watch";
 import { batch } from "../reactivity/batch";
 
-let comboboxIdCounter = 0;
 const boundComboboxes = new WeakMap<HTMLElement, () => void>();
 
 export interface ComboboxOptions<T> {
@@ -111,7 +111,15 @@ export function combobox<T>(options: ComboboxOptions<T>): {
     const existing = boundComboboxes.get(els.input);
     if (existing) return existing;
 
-    const listboxId = `sibu-combobox-listbox-${++comboboxIdCounter}`;
+    // Capture the attributes bind() mutates so teardown can restore them.
+    const prevListboxId = els.listbox.id;
+    const prevListboxRole = els.listbox.getAttribute("role");
+    const prevListboxHidden = els.listbox.hidden;
+    const prevInputRole = els.input.getAttribute("role");
+    const prevInputAutocomplete = els.input.getAttribute("aria-autocomplete");
+    const prevInputControls = els.input.getAttribute("aria-controls");
+
+    const listboxId = createId("sibu-combobox-listbox");
     els.listbox.id = listboxId;
     els.listbox.setAttribute("role", "listbox");
     els.input.setAttribute("role", "combobox");
@@ -180,10 +188,19 @@ export function combobox<T>(options: ComboboxOptions<T>): {
       }, 100);
     };
 
+    // Keep focus on the input when a pointer goes down inside the listbox, so
+    // selecting an option doesn't blur the input and race the blur-close timer.
+    // preventDefault on mousedown stops the focus shift without blocking the
+    // option's subsequent click handler.
+    const onListboxPointerDown = (e: Event) => {
+      e.preventDefault();
+    };
+
     els.input.addEventListener("input", onInput);
     els.input.addEventListener("keydown", onKey);
     els.input.addEventListener("focus", onFocus);
     els.input.addEventListener("blur", onBlur);
+    els.listbox.addEventListener("mousedown", onListboxPointerDown);
 
     const teardown = () => {
       boundComboboxes.delete(els.input);
@@ -192,10 +209,25 @@ export function combobox<T>(options: ComboboxOptions<T>): {
       els.input.removeEventListener("keydown", onKey);
       els.input.removeEventListener("focus", onFocus);
       els.input.removeEventListener("blur", onBlur);
+      els.listbox.removeEventListener("mousedown", onListboxPointerDown);
       if (blurTimer !== null) {
         clearTimeout(blurTimer);
         blurTimer = null;
       }
+      // Restore the attributes bind() mutated (mirrors Accordion/Tabs/Popover).
+      if (prevListboxId === "") els.listbox.removeAttribute("id");
+      else els.listbox.id = prevListboxId;
+      if (prevListboxRole === null) els.listbox.removeAttribute("role");
+      else els.listbox.setAttribute("role", prevListboxRole);
+      els.listbox.hidden = prevListboxHidden;
+      if (prevInputRole === null) els.input.removeAttribute("role");
+      else els.input.setAttribute("role", prevInputRole);
+      if (prevInputAutocomplete === null) els.input.removeAttribute("aria-autocomplete");
+      else els.input.setAttribute("aria-autocomplete", prevInputAutocomplete);
+      if (prevInputControls === null) els.input.removeAttribute("aria-controls");
+      else els.input.setAttribute("aria-controls", prevInputControls);
+      els.input.removeAttribute("aria-expanded");
+      els.input.removeAttribute("aria-activedescendant");
     };
     boundComboboxes.set(els.input, teardown);
     return teardown;
diff --git a/src/widgets/FileUpload.ts b/src/widgets/FileUpload.ts
index bdb7861..5588e3a 100644
--- a/src/widgets/FileUpload.ts
+++ b/src/widgets/FileUpload.ts
@@ -1,8 +1,8 @@
+import { createId } from "../core/rendering/createId";
 import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 import { batch } from "../reactivity/batch";
 
-let fileUploadIdCounter = 0;
 const boundFileUploads = new WeakMap<HTMLElement, () => void>();
 
 export interface FileUploadOptions {
@@ -122,7 +122,7 @@ export function fileUpload(options?: FileUploadOptions): {
     const existing = boundFileUploads.get(els.input);
     if (existing) return existing;
 
-    const id = `sibu-fileupload-${++fileUploadIdCounter}`;
+    const id = createId("sibu-fileupload");
     const restore: Array<() => void> = [];
     if (accept) els.input.accept = accept;
     els.input.multiple = multiple;
diff --git a/src/widgets/Popover.ts b/src/widgets/Popover.ts
index 9fce02f..c0a3346 100644
--- a/src/widgets/Popover.ts
+++ b/src/widgets/Popover.ts
@@ -1,7 +1,7 @@
+import { createId } from "../core/rendering/createId";
 import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 
-let popoverIdCounter = 0;
 const boundPopovers = new WeakMap<HTMLElement, () => void>();
 
 /**
@@ -35,7 +35,7 @@ export function popover(): {
     const existing = boundPopovers.get(els.trigger);
     if (existing) return existing;
 
-    const id = `sibu-popover-${++popoverIdCounter}`;
+    const id = createId("sibu-popover");
     // Capture prior attribute state so teardown can restore (or remove)
     // every attribute we touch — bind() should be reversible.
     const prevPopoverRole = els.popover.getAttribute("role");
diff --git a/src/widgets/Select.ts b/src/widgets/Select.ts
index cc94bdc..3eed482 100644
--- a/src/widgets/Select.ts
+++ b/src/widgets/Select.ts
@@ -1,9 +1,9 @@
+import { createId } from "../core/rendering/createId";
 import { derived } from "../core/signals/derived";
 import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 import { batch } from "../reactivity/batch";
 
-let selectIdCounter = 0;
 const boundSelects = new WeakMap<HTMLElement, () => void>();
 
 export interface SelectOptions<T> {
@@ -136,7 +136,13 @@ export function select<T>(options: SelectOptions<T>): {
     const existing = boundSelects.get(els.listbox);
     if (existing) return existing;
 
-    const listboxId = `sibu-select-${++selectIdCounter}`;
+    // Capture the attributes bind() mutates so teardown can restore them.
+    const prevId = els.listbox.id;
+    const prevRole = els.listbox.getAttribute("role");
+    const prevMultiselectable = els.listbox.getAttribute("aria-multiselectable");
+    const prevTabIndex = els.listbox.getAttribute("tabindex");
+
+    const listboxId = createId("sibu-select");
     els.listbox.id = listboxId;
     els.listbox.setAttribute("role", "listbox");
     els.listbox.setAttribute("aria-multiselectable", multiple ? "true" : "false");
@@ -201,6 +207,16 @@ export function select<T>(options: SelectOptions<T>): {
       fxTeardown();
       els.listbox.removeEventListener("keydown", onKey);
       if (typeTimer !== null) clearTimeout(typeTimer);
+      // Restore the attributes bind() mutated (mirrors Accordion/Tabs/Popover).
+      if (prevId === "") els.listbox.removeAttribute("id");
+      else els.listbox.id = prevId;
+      if (prevRole === null) els.listbox.removeAttribute("role");
+      else els.listbox.setAttribute("role", prevRole);
+      if (prevMultiselectable === null) els.listbox.removeAttribute("aria-multiselectable");
+      else els.listbox.setAttribute("aria-multiselectable", prevMultiselectable);
+      if (prevTabIndex === null) els.listbox.removeAttribute("tabindex");
+      else els.listbox.setAttribute("tabindex", prevTabIndex);
+      els.listbox.removeAttribute("aria-activedescendant");
     };
     boundSelects.set(els.listbox, teardown);
     return teardown;
diff --git a/src/widgets/Tooltip.ts b/src/widgets/Tooltip.ts
index 8d9da56..11c463f 100644
--- a/src/widgets/Tooltip.ts
+++ b/src/widgets/Tooltip.ts
@@ -1,8 +1,7 @@
+import { createId } from "../core/rendering/createId";
 import { effect } from "../core/signals/effect";
 import { signal } from "../core/signals/signal";
 
-let tooltipIdCounter = 0;
-
 // Track which trigger elements already have a bind() active so a second
 // call short-circuits rather than corrupting aria-describedby restore.
 const boundTriggers = new WeakMap<HTMLElement, () => void>();
@@ -71,7 +70,7 @@ export function tooltip(options?: { delay?: number; hideDelay?: number }): {
     // aria-describedby restore on double-bind.
     const existing = boundTriggers.get(els.trigger);
     if (existing) return existing;
-    const id = `sibu-tooltip-${++tooltipIdCounter}`;
+    const id = createId("sibu-tooltip");
     els.tooltip.setAttribute("role", "tooltip");
     els.tooltip.id = id;
     const prevDescribedBy = els.trigger.getAttribute("aria-describedby");
diff --git a/src/widgets/contentEditable.ts b/src/widgets/contentEditable.ts
index ce96ad1..159b204 100644
--- a/src/widgets/contentEditable.ts
+++ b/src/widgets/contentEditable.ts
@@ -29,8 +29,13 @@ export interface SetContentOptions {
  * Uses the modern Selection/Range API instead of the deprecated
  * document.execCommand. Formatting is applied by wrapping the current
  * selection in the appropriate inline element.
+ *
+ * @param element Optional editor element to scope formatting to. When provided,
+ *   `bold()`/`italic()`/`underline()` ignore any selection that lives outside it
+ *   — otherwise a selection elsewhere on the page could be mutated, since the
+ *   Selection API is global.
  */
-export function contentEditable(): {
+export function contentEditable(element?: HTMLElement): {
   content: () => string;
   /**
    * Update the reactive content value.
@@ -82,6 +87,11 @@ export function contentEditable(): {
 
     const range = selection.getRangeAt(0);
 
+    // Scope formatting to the bound editor: ignore a selection that lives
+    // outside it (e.g. text selected elsewhere on the page) so the formatting
+    // commands can't mutate unrelated DOM.
+    if (element && !element.contains(range.commonAncestorContainer)) return;
+
     // Check if we're already inside the same tag — if so, unwrap
     const ancestor = range.commonAncestorContainer;
     const existingWrap = findAncestorByTag(
diff --git a/src/widgets/datePicker.ts b/src/widgets/datePicker.ts
index 2ef7064..b2822de 100644
--- a/src/widgets/datePicker.ts
+++ b/src/widgets/datePicker.ts
@@ -175,13 +175,25 @@ export function datePicker(options?: DatePickerOptions): {
     const existing = boundDatePickers.get(els.grid);
     if (existing) return existing;
 
+    // Capture the attributes bind() mutates so teardown can restore them.
+    const prevGridRole = els.grid.getAttribute("role");
+    const prevGridTabIndex = els.grid.getAttribute("tabindex");
+    const prevGridLabel = els.grid.getAttribute("aria-label");
+
     els.grid.setAttribute("role", "grid");
     if (els.grid.tabIndex < 0) els.grid.tabIndex = 0;
 
+    // Set when a keyboard navigation moves the view date, so the effect can move
+    // real focus to the newly-current cell (not just the roving tabindex).
+    let pendingFocus = false;
+
     const fxTeardown = effect(() => {
       const sel = selectedDate();
       const view = viewDate();
       const days = daysInMonth();
+      // Give the grid an accessible name reflecting the month on display.
+      els.grid.setAttribute("aria-label", view.toLocaleDateString(undefined, { month: "long", year: "numeric" }));
+      let viewCell: HTMLElement | null = null;
       for (const d of days) {
         const cell = els.cell(d.date);
         if (!cell) continue;
@@ -190,7 +202,15 @@ export function datePicker(options?: DatePickerOptions): {
         if (d.isDisabled) cell.setAttribute("aria-disabled", "true");
         else cell.removeAttribute("aria-disabled");
         // Roving tabindex on focused-day (view date) cell.
-        cell.tabIndex = isSameCalendarDay(view, d.date) ? 0 : -1;
+        const isView = isSameCalendarDay(view, d.date);
+        cell.tabIndex = isView ? 0 : -1;
+        if (isView) viewCell = cell;
+      }
+      // After a keyboard move, follow the roving tabindex with real focus so
+      // screen-reader / keyboard users land on the day they navigated to.
+      if (pendingFocus && viewCell && typeof viewCell.focus === "function") {
+        pendingFocus = false;
+        viewCell.focus();
       }
     });
 
@@ -203,6 +223,18 @@ export function datePicker(options?: DatePickerOptions): {
     }
 
     const onKey = (e: KeyboardEvent) => {
+      if (
+        e.key === "ArrowLeft" ||
+        e.key === "ArrowRight" ||
+        e.key === "ArrowUp" ||
+        e.key === "ArrowDown" ||
+        e.key === "Home" ||
+        e.key === "End" ||
+        e.key === "PageUp" ||
+        e.key === "PageDown"
+      ) {
+        pendingFocus = true;
+      }
       switch (e.key) {
         case "ArrowLeft":
           e.preventDefault();
@@ -252,6 +284,14 @@ export function datePicker(options?: DatePickerOptions): {
       boundDatePickers.delete(els.grid);
       fxTeardown();
       els.grid.removeEventListener("keydown", onKey);
+      // Restore the grid attributes bind() mutated so the element can be
+      // re-bound or reused cleanly (mirrors Accordion/Tabs/Popover).
+      if (prevGridRole === null) els.grid.removeAttribute("role");
+      else els.grid.setAttribute("role", prevGridRole);
+      if (prevGridTabIndex === null) els.grid.removeAttribute("tabindex");
+      else els.grid.setAttribute("tabindex", prevGridTabIndex);
+      if (prevGridLabel === null) els.grid.removeAttribute("aria-label");
+      else els.grid.setAttribute("aria-label", prevGridLabel);
     };
     boundDatePickers.set(els.grid, teardown);
     return teardown;
diff --git a/tests/audit-coverage.test.ts b/tests/audit-coverage.test.ts
new file mode 100644
index 0000000..caa97ee
--- /dev/null
+++ b/tests/audit-coverage.test.ts
@@ -0,0 +1,132 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { Loading } from "../src/components/Loading";
+import { dispose } from "../src/core/rendering/dispose";
+import { persisted } from "../src/patterns/persist";
+import { Head } from "../src/platform/head";
+import { hover } from "../src/ui/hover";
+import { stream } from "../src/ui/stream";
+import { combobox } from "../src/widgets/Combobox";
+import { datePicker } from "../src/widgets/datePicker";
+import { select as selectWidget } from "../src/widgets/Select";
+
+// Regression coverage for the audit's accessibility (E), SSR-guard (C), and
+// leak/disposer (B) themes — the mechanical fixes that lacked dedicated tests.
+
+// ── E3 — Loading is announced to assistive tech ─────────────────────────────
+describe("Loading — screen-reader semantics (E3)", () => {
+  it("exposes role=status / aria-live and a default label, deferring to text when present", () => {
+    const bare = Loading();
+    expect(bare.getAttribute("role")).toBe("status");
+    expect(bare.getAttribute("aria-live")).toBe("polite");
+    expect(bare.getAttribute("aria-label")).toBe("Loading"); // no visible text → labeled
+
+    const labelled = Loading({ text: "Saving…" });
+    expect(labelled.getAttribute("role")).toBe("status");
+    expect(labelled.getAttribute("aria-label")).toBeNull(); // visible text is the name
+  });
+});
+
+// ── E5 — widget bind() is reversible ────────────────────────────────────────
+describe("Select.bind() — reversible ARIA wiring (E5)", () => {
+  it("restores the listbox's attributes on teardown", () => {
+    const listbox = document.createElement("ul");
+    const sel = selectWidget<string>({ items: ["a", "b"] });
+
+    const teardown = sel.bind({ listbox, option: () => null });
+    expect(listbox.getAttribute("role")).toBe("listbox");
+    expect(listbox.id).not.toBe("");
+    expect(listbox.getAttribute("aria-multiselectable")).toBe("false");
+
+    teardown();
+    expect(listbox.getAttribute("role")).toBeNull();
+    expect(listbox.id).toBe("");
+    expect(listbox.getAttribute("aria-multiselectable")).toBeNull();
+    expect(listbox.getAttribute("tabindex")).toBeNull();
+  });
+});
+
+// ── E6 — combobox option click doesn't race the blur-close ──────────────────
+describe("combobox.bind() — pointer-down inside the listbox keeps input focus (E6)", () => {
+  it("prevents default on listbox mousedown so the option click lands", () => {
+    const input = document.createElement("input");
+    const listbox = document.createElement("ul");
+    const cb = combobox<string>({ items: ["apple", "banana"] });
+
+    const teardown = cb.bind({ input, listbox, option: () => null });
+    const ev = new MouseEvent("mousedown", { cancelable: true, bubbles: true });
+    listbox.dispatchEvent(ev);
+    expect(ev.defaultPrevented).toBe(true);
+    teardown();
+  });
+});
+
+// ── E1 — datePicker grid has an accessible name (and E5 restore) ────────────
+describe("datePicker.bind() — grid role + accessible name (E1)", () => {
+  it("labels the grid with the displayed month and restores attributes on teardown", () => {
+    const grid = document.createElement("div");
+    const dp = datePicker({ initialDate: new Date(2026, 5, 15) });
+
+    const teardown = dp.bind({ grid, cell: () => null });
+    expect(grid.getAttribute("role")).toBe("grid");
+    expect(grid.getAttribute("aria-label")).toMatch(/2026/); // month/year name
+
+    teardown();
+    expect(grid.getAttribute("role")).toBeNull();
+    expect(grid.getAttribute("aria-label")).toBeNull();
+  });
+});
+
+// ── C4 — stream degrades instead of throwing where EventSource is absent ────
+describe("stream — SSR / unsupported-runtime guard (C4)", () => {
+  it("stays 'closed' instead of throwing when EventSource is unavailable", () => {
+    // jsdom provides no EventSource — connect() must not throw at construction.
+    expect(typeof EventSource).toBe("undefined");
+    const s = stream("https://example.com/sse");
+    expect(s.status()).toBe("closed");
+    s.dispose();
+  });
+});
+
+// ── C1 — persist degrades to a plain signal when storage is unavailable ─────
+describe("persisted — degrades gracefully when storage throws/absent (C1)", () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it("still works as a signal when localStorage is unavailable", () => {
+    vi.stubGlobal("localStorage", undefined);
+    const [value, setValue] = persisted("audit-c1", "initial");
+    expect(value()).toBe("initial");
+    setValue("next"); // must not throw despite no storage
+    expect(value()).toBe("next");
+  });
+});
+
+// ── B2 — Head() ties its injected <head> elements to disposal ───────────────
+describe("Head() — injected elements are released on dispose (B2)", () => {
+  it("removes its managed meta element when the anchor is disposed", () => {
+    const sel = 'meta[name="sibu-audit-b2"]';
+    expect(document.head.querySelector(sel)).toBeNull();
+
+    const anchor = Head({ title: "Audit B2", meta: [{ name: "sibu-audit-b2", content: "x" }] });
+    expect(document.head.querySelector(sel)?.getAttribute("content")).toBe("x");
+
+    dispose(anchor);
+    // Without the disposer this element would leak in <head> forever.
+    expect(document.head.querySelector(sel)).toBeNull();
+  });
+});
+
+// ── B7 — hover() releases its listeners on element disposal ─────────────────
+describe("hover() — listeners released with the element (B7)", () => {
+  it("stops responding to pointer events once the element is disposed", () => {
+    const el = document.createElement("div");
+    const h = hover(el);
+
+    el.dispatchEvent(new Event("pointerenter"));
+    expect(h.hovered()).toBe(true);
+
+    dispose(el); // registerDisposer(el, dispose) removes the listeners
+    el.dispatchEvent(new Event("pointerleave"));
+    // The leave listener is gone, so the state is no longer mutated.
+    expect(h.hovered()).toBe(true);
+  });
+});
diff --git a/tests/audit-followups.test.ts b/tests/audit-followups.test.ts
new file mode 100644
index 0000000..91e8e5f
--- /dev/null
+++ b/tests/audit-followups.test.ts
@@ -0,0 +1,200 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { option, select } from "../src/core/rendering/html";
+import { signal } from "../src/core/signals/signal";
+import { initDevTools } from "../src/devtools/devtools";
+import { captureSignalGraph } from "../src/devtools/signalGraph";
+import { type NormalizedSchema, normalize } from "../src/performance/normalize";
+import { createAction } from "../src/platform/routeActions";
+import { lazyModule } from "../src/plugins/modular";
+import { createRouter, destroyRouter, navigate, route } from "../src/plugins/router";
+import { bindField, form } from "../src/ui/form";
+import { inputMask } from "../src/ui/inputMask";
+import { pagination } from "../src/ui/pagination";
+
+// Regression tests for the non-core audit follow-ups (TODO.md theme D).
+
+describe("pagination — reactive clamp when totalItems shrinks (D9)", () => {
+  it("clamps the current page and indices when the dataset shrinks", () => {
+    const [total, setTotal] = signal(100);
+    const p = pagination({ totalItems: () => total(), pageSize: 10 });
+
+    p.goTo(8);
+    expect(p.page()).toBe(8);
+    expect(p.startIndex()).toBe(70);
+
+    // Dataset shrinks to 2 pages while we're on page 8.
+    setTotal(20);
+    expect(p.totalPages()).toBe(2);
+    expect(p.page()).toBe(2); // clamped, not stuck at 8
+    expect(p.startIndex()).toBe(10); // points at valid data, not past the end
+  });
+});
+
+describe("form — isDirty does not false-positive on array/object initials (D3)", () => {
+  it("treats an unchanged multi-select array as not dirty", () => {
+    const f = form({ tags: { initial: ["a", "b"] as string[] } });
+    expect(f.isDirty()).toBe(false); // fresh array !== initial under Object.is
+
+    f.fields.tags.set(["a", "c"]);
+    expect(f.isDirty()).toBe(true);
+
+    f.fields.tags.set(["a", "b"]); // structurally equal to the initial again
+    expect(f.isDirty()).toBe(false);
+  });
+});
+
+describe("inputMask — caret restoration for '*' masks with literals (D8)", () => {
+  it("keeps the caret before the edited slot instead of jumping past the literal", () => {
+    const mask = inputMask({ pattern: "**-**" });
+    const input = document.createElement("input");
+    document.body.appendChild(input);
+    const dispose = mask.bind(input);
+
+    input.value = "ab-cd";
+    input.setSelectionRange(4, 4); // caret before "d" — 3 raw chars ("abc") precede it
+    input.dispatchEvent(new Event("input"));
+
+    expect(input.value).toBe("ab-cd");
+    // The old algorithm counted the literal "-" as a raw char (rawCharTest was
+    // `() => true` for "*" masks) and pushed the caret to 5 (end); it must stay at 4.
+    expect(input.selectionStart).toBe(4);
+
+    dispose();
+    document.body.removeChild(input);
+  });
+});
+
+describe("bindField — <select multiple> reactive write-back (D1)", () => {
+  it("reflects the field's array onto option.selected, initially and on change", () => {
+    const f = form({ tags: { initial: ["a", "c"] as string[] } });
+    const el = select(bindField(f.fields.tags, { multiple: true }), [
+      option({ value: "a" }, "A"),
+      option({ value: "b" }, "B"),
+      option({ value: "c" }, "C"),
+    ]) as HTMLSelectElement;
+
+    expect(el.multiple).toBe(true);
+    // Initial render reflects the array initial onto the options.
+    expect(Array.from(el.selectedOptions, (o) => o.value).sort()).toEqual(["a", "c"]);
+
+    // Reactive write-back: updating the field re-selects the matching options.
+    f.fields.tags.set(["b"]);
+    expect(Array.from(el.selectedOptions, (o) => o.value)).toEqual(["b"]);
+
+    f.fields.tags.set([]);
+    expect(el.selectedOptions.length).toBe(0);
+  });
+});
+
+describe("lazyModule — caches a loader that resolves to undefined/falsy (D11)", () => {
+  it("invokes the loader only once even when it resolves to undefined", async () => {
+    let calls = 0;
+    const m = lazyModule(async () => {
+      calls++;
+      return undefined;
+    });
+    await m.get();
+    await m.get();
+    await m.get();
+    expect(calls).toBe(1);
+    expect(m.loaded).toBe(true);
+  });
+});
+
+describe("normalize — child relations default to id, not the parent idKey (D12)", () => {
+  it("normalizes a child with the default id key when the parent has a custom one", () => {
+    const schema: NormalizedSchema = {
+      name: "post",
+      idKey: "postId",
+      relations: { author: "user" },
+    };
+    const data = { postId: "p1", title: "Hello", author: { id: "u1", name: "Alice" } };
+
+    const { entities } = normalize(data, schema);
+
+    expect((entities.user as Record<string, unknown>).u1).toMatchObject({ id: "u1", name: "Alice" });
+    // Before the fix the child reused the parent idKey ("postId") → String(undefined).
+    expect((entities.user as Record<string, unknown>).undefined).toBeUndefined();
+  });
+});
+
+describe("createAction — a slow older submit cannot clobber a newer one (D7)", () => {
+  it("keeps the latest run's result even when an earlier run resolves later", async () => {
+    let resolveFirst!: (v: string) => void;
+    let resolveSecond!: (v: string) => void;
+
+    const action = createAction<string>((input) => {
+      const id = (input as { id: number }).id;
+      return new Promise<string>((resolve) => {
+        if (id === 1) resolveFirst = resolve;
+        else resolveSecond = resolve;
+      });
+    });
+
+    const p1 = action.submit({ id: 1 });
+    const p2 = action.submit({ id: 2 });
+
+    // The newer (second) submit resolves first.
+    resolveSecond("second");
+    await p2;
+    expect(action.data()).toBe("second");
+    expect(action.loading()).toBe(false);
+
+    // The older (first) submit resolves late — it must NOT overwrite state.
+    resolveFirst("first");
+    await p1;
+    expect(action.data()).toBe("second");
+  });
+});
+
+describe("router — a broad param route does not shadow a more specific one (D16)", () => {
+  afterEach(() => {
+    try {
+      destroyRouter();
+    } catch {}
+    window.history.replaceState({}, "", "/");
+  });
+
+  it("matches the more specific route even when the broad one is registered first", async () => {
+    createRouter([
+      // Broad two-param route registered FIRST — registration order used to win.
+      { path: "/:section/:item", component: () => document.createElement("div") },
+      // More specific (one static segment) route registered second.
+      { path: "/users/:id", component: () => document.createElement("div") },
+    ]);
+
+    await navigate("/users/42");
+
+    // Specificity wins: params come from "/users/:id", not "/:section/:item".
+    expect(route().params).toEqual({ id: "42" });
+  });
+});
+
+describe("captureSignalGraph — the real devtools hook exposes the node inventory (D4)", () => {
+  afterEach(() => {
+    delete (globalThis as unknown as Record<string, unknown>).__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  });
+
+  it("reports id/name/kind/value for tracked nodes (was always-empty before wiring)", () => {
+    initDevTools();
+    const hook = (
+      globalThis as unknown as {
+        __SIBU_DEVTOOLS_GLOBAL_HOOK__: { nodes: Map<number, unknown> };
+      }
+    ).__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+
+    hook.nodes.set(1, { id: 1, type: "signal", name: "count", ref: { value: 42, __sc: 1 }, createdAt: 0 });
+    hook.nodes.set(2, { id: 2, type: "computed", name: "doubled", ref: { _v: 84, __sc: 0 }, createdAt: 0 });
+    hook.nodes.set(3, { id: 3, type: "effect", name: "logger", ref: {}, createdAt: 0 });
+
+    const snap = captureSignalGraph();
+    const byId = Object.fromEntries(snap.nodes.map((n) => [n.id, n]));
+
+    expect(byId["1"]).toMatchObject({ name: "count", kind: "signal", value: "42" });
+    expect(byId["2"]).toMatchObject({ name: "doubled", kind: "derived", value: "84" }); // computed -> "derived"
+    expect(byId["3"]).toMatchObject({ name: "logger", kind: "effect", value: "undefined" });
+
+    // Edge identities aren't tracked by the lightweight registry → 0 edges.
+    expect(snap.edgeCount).toBe(0);
+  });
+});