sibujs 3.4.1 → 4.0.0

package/dist/plugins.cjs

@@ -48,19 +48,117 @@ var init_dev = __esm({
   }
 });
 
+// src/core/errors.ts
+function state() {
+  const g2 = globalThis;
+  const existing = g2[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g2[ERROR_STATE_KEY] = created;
+  return created;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+}
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+function claimedByBoundary(error, context) {
+  const raw = context.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self2 = node;
+  return typeof self2.dispatchEvent === "function" ? self2 : null;
+}
+function defaultReport(error, context) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
+}
+function reportError(error, context) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context)) return;
+    const s2 = state();
+    const handler = s2.handler;
+    if (handler && s2.handlerDepth === 0) {
+      s2.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s2.handlerDepth--;
+      }
+    }
+    defaultReport(err, context);
+  });
+}
+var ERROR_STATE_KEY, REACTIVE_REGISTRY_KEY, PROPAGATE_EVENT;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+    REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+    PROPAGATE_EVENT = "sibu:error-propagate";
+  }
+});
+
 // src/utils/sanitize.ts
 function stripControlChars(value) {
   return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
 }
+function canonicalAttrName(name) {
+  return name.replace(/[A-Z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32));
+}
 function isEventHandlerAttr(name) {
   if (name.length < 3) return false;
   const lower = name.toLowerCase();
   return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
 }
 function sanitizeUrl(url) {
-  const trimmed = stripControlChars(url).trim();
-  if (!trimmed) return "";
-  const lower = trimmed.toLowerCase();
+  const probe = stripControlChars(url).trim();
+  if (!probe) return "";
+  const output2 = url.replace(OUTER_TRIM, "");
+  const lower = probe.toLowerCase();
   let schemeEnd = -1;
   for (let i2 = 0; i2 < lower.length; i2++) {
     const ch = lower.charCodeAt(i2);
@@ -70,11 +168,11 @@ function sanitizeUrl(url) {
     }
     if (ch === 47 || ch === 63 || ch === 35) break;
   }
-  if (schemeEnd === -1) return trimmed;
+  if (schemeEnd === -1) return output2;
   const scheme = lower.slice(0, schemeEnd + 1);
-  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return trimmed;
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output2;
   if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
-  return trimmed;
+  return output2;
 }
 function sanitizeSrcset(value) {
   const parts = value.split(",");
@@ -84,43 +182,114 @@ function sanitizeSrcset(value) {
     if (!part) continue;
     const m = part.match(/^(\S+)(\s+.+)?$/);
     if (!m) continue;
+    if (m[2] !== void 0 && !SRCSET_DESCRIPTOR.test(m[2])) continue;
     const safe = sanitizeUrl(m[1]);
     if (!safe) continue;
     out.push(m[2] ? `${safe}${m[2]}` : safe);
   }
   return out.join(", ");
 }
+function isCssWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function isHexDigit(ch) {
+  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+}
+function decodeCssEscapes(value) {
+  let out = "";
+  for (let i2 = 0; i2 < value.length; i2++) {
+    const ch = value[i2];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    if (i2 + 1 >= value.length) break;
+    const next = value[i2 + 1];
+    if (next === "\n" || next === "\f") {
+      i2 += 1;
+      continue;
+    }
+    if (next === "\r") {
+      i2 += value[i2 + 2] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (isHexDigit(next)) {
+      let hex = "";
+      let j = i2 + 1;
+      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
+        hex += value[j];
+        j++;
+      }
+      if (j < value.length && isCssWhitespace(value[j])) {
+        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
+      }
+      const code2 = Number.parseInt(hex, 16);
+      const invalid = code2 === 0 || code2 > 1114111 || code2 >= 55296 && code2 <= 57343;
+      out += invalid ? "\uFFFD" : String.fromCodePoint(code2);
+      i2 = j - 1;
+      continue;
+    }
+    out += next;
+    i2 += 1;
+  }
+  return out;
+}
 function sanitizeCSSValue(value) {
   if (!CSS_DANGER_GATE.test(value)) return value;
-  const decoded = value.replace(/\\([0-9a-fA-F]{1,6})\s?/g, (_m, hex) => {
-    const code2 = Number.parseInt(hex, 16);
-    if (!Number.isFinite(code2) || code2 < 0 || code2 > 1114111) return "";
-    try {
-      return String.fromCodePoint(code2);
-    } catch {
-      return "";
-    }
-  });
-  const lower = decoded.toLowerCase().replace(/\s+/g, "");
+  const normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
+  const lower = normalized.toLowerCase().replace(/\s+/g, "");
   if (lower.includes("url(") || lower.includes("expression(") || lower.includes("javascript:") || lower.includes("vbscript:") || lower.includes("-moz-binding") || lower.includes("behavior:") || lower.includes("@import") || lower.includes("image-set(") || lower.includes("filter:progid")) {
     return "";
   }
   return value;
 }
+function sanitizeStyleAttribute(cssText) {
+  const input2 = String(cssText);
+  if (input2.trim() === "") return "";
+  if (typeof document === "undefined") {
+    return sanitizeCSSValue(input2) === "" ? "" : input2;
+  }
+  const probe = document.createElement("div");
+  try {
+    probe.style.cssText = input2;
+  } catch {
+    return "";
+  }
+  const declarations = [];
+  for (let i2 = 0; i2 < probe.style.length; i2++) {
+    const property = probe.style[i2];
+    const value = probe.style.getPropertyValue(property);
+    if (sanitizeCSSValue(value) === "") continue;
+    if (sanitizeCSSValue(`${property}:${value}`) === "") continue;
+    const priority = probe.style.getPropertyPriority(property);
+    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
+  }
+  return declarations.join("; ");
+}
+function isHtmlContentAttribute(name) {
+  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
+}
 function isUrlAttribute(attr) {
   return URL_ATTRIBUTES.has(attr.toLowerCase());
 }
+function isPolicyAttribute(name) {
+  const lower = name.toLowerCase();
+  return lower === "style" || URL_ATTRIBUTES.has(lower);
+}
 function sanitizeAttributeString(attr, value) {
   const lower = attr.toLowerCase();
   if (lower === "srcset") return sanitizeSrcset(value);
   if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
+  if (lower === "style") return sanitizeStyleAttribute(value);
   return value;
 }
-var SAFE_URL_PROTOCOLS, CSS_DANGER_GATE, URL_ATTRIBUTES;
+var SAFE_URL_PROTOCOLS, OUTER_TRIM, SRCSET_DESCRIPTOR, CSS_DANGER_GATE, URL_ATTRIBUTES, HTML_CONTENT_ATTRIBUTES;
 var init_sanitize = __esm({
   "src/utils/sanitize.ts"() {
     "use strict";
     SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
+    OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
+    SRCSET_DESCRIPTOR = /^\s+\d+(\.\d+)?[wx]$/;
     CSS_DANGER_GATE = /[(:@\\]/;
     URL_ATTRIBUTES = /* @__PURE__ */ new Set([
       "href",
@@ -134,8 +303,125 @@ var init_sanitize = __esm({
       "background",
       "srcset",
       "ping",
-      "data"
+      "data",
+      // `<html manifest>` is a URL sink too. It was carried only by the SSR
+      // serializers' private copy of this set; folding that copy into this one would
+      // otherwise have silently dropped its coverage.
+      "manifest"
     ]);
+    HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
+  }
+});
+
+// src/core/rendering/dispose.ts
+var dispose_exports = {};
+__export(dispose_exports, {
+  MAX_DRAIN_TEARDOWNS: () => MAX_DRAIN_TEARDOWNS,
+  checkLeaks: () => checkLeaks,
+  dispose: () => dispose,
+  registerDisposer: () => registerDisposer,
+  replaceChildrenSafely: () => replaceChildrenSafely,
+  reportDrainRunaway: () => reportDrainRunaway,
+  unregisterDisposer: () => unregisterDisposer
+});
+function reportDrainRunaway(label2, executed, remaining) {
+  if (typeof console === "undefined") return;
+  console.error(
+    `[SibuJS ${label2}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
+    { executed, remaining }
+  );
+}
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  if (_isDev4) activeBindingCount++;
+}
+function unregisterDisposer(node, teardown) {
+  const disposers = elementDisposers.get(node);
+  if (!disposers) return;
+  const index = disposers.indexOf(teardown);
+  if (index === -1) return;
+  disposers.splice(index, 1);
+  if (_isDev4) activeBindingCount--;
+  if (disposers.length === 0) elementDisposers.delete(node);
+}
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i2 = 0; i2 < children.length; i2++) {
+      stack.push(children[i2]);
+    }
+  }
+  for (let i2 = order.length - 1; i2 >= 0; i2--) {
+    const current = order[i2];
+    if (elementDisposers.has(current)) {
+      let executed = 0;
+      let runaway = false;
+      while (!runaway) {
+        const pending = elementDisposers.get(current);
+        if (!pending || pending.length === 0) break;
+        const snapshot = pending.slice();
+        elementDisposers.delete(current);
+        if (_isDev4) activeBindingCount -= snapshot.length;
+        for (let i3 = 0; i3 < snapshot.length; i3++) {
+          if (executed >= MAX_DRAIN_TEARDOWNS) {
+            const rest = snapshot.slice(i3);
+            const added = elementDisposers.get(current);
+            elementDisposers.set(current, added ? rest.concat(added) : rest);
+            if (_isDev4) activeBindingCount += rest.length;
+            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+            runaway = true;
+            break;
+          }
+          executed++;
+          try {
+            snapshot[i3]();
+          } catch (err) {
+            reportError(err, { phase: "cleanup", name: "disposer" });
+          }
+        }
+      }
+    }
+  }
+}
+function replaceChildrenSafely(parent, ...next) {
+  for (let i2 = 0; i2 < next.length; i2++) {
+    const node = next[i2];
+    node.parentNode?.removeChild(node);
+  }
+  const current = Array.from(parent.childNodes);
+  for (let i2 = 0; i2 < current.length; i2++) {
+    dispose(current[i2]);
+  }
+  parent.replaceChildren(...next);
+}
+function checkLeaks(warnThreshold = 0) {
+  if (!_isDev4) return 0;
+  if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
+    devWarn(
+      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
+    );
+  }
+  return activeBindingCount;
+}
+var elementDisposers, MAX_DRAIN_TEARDOWNS, _isDev4, activeBindingCount;
+var init_dispose = __esm({
+  "src/core/rendering/dispose.ts"() {
+    "use strict";
+    init_dev();
+    init_errors();
+    elementDisposers = /* @__PURE__ */ new WeakMap();
+    MAX_DRAIN_TEARDOWNS = 1e4;
+    _isDev4 = isDev();
+    activeBindingCount = 0;
   }
 });
 
@@ -148,16 +434,19 @@ function detectSSRShared() {
       const getBuiltin = process.getBuiltinModule;
       if (typeof getBuiltin === "function") {
         mod = getBuiltin("node:async_hooks");
-      } else {
-        const req = Function("return typeof require==='function'?require:null")();
-        if (req) mod = req("node:async_hooks");
+      } else if (typeof require === "function") {
+        mod = require("async_hooks");
       }
       if (mod) detected = new mod.AsyncLocalStorage();
     }
   } catch {
     detected = null;
   }
-  return { als: detected, fallbackStore: { ssr: false, suspenseIdCounter: 0 } };
+  return {
+    als: detected,
+    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
+    fallbackDepth: 0
+  };
 }
 function getSSRStore() {
   if (als) {
@@ -166,6 +455,10 @@ function getSSRStore() {
   }
   return fallbackStore;
 }
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
 function isSSR() {
   return getSSRStore().ssr;
 }
@@ -177,6 +470,179 @@ var init_ssr_context = __esm({
     _shared = globalThis[SSR_KEY] ?? (globalThis[SSR_KEY] = detectSSRShared());
     als = _shared.als;
     fallbackStore = _shared.fallbackStore;
+    _shared.fallbackDepth ?? (_shared.fallbackDepth = 0);
+  }
+});
+
+// src/utils/metaRefresh.ts
+function isAsciiWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function trimAsciiWhitespace(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && isAsciiWhitespace(value[start])) start++;
+  while (end > start && isAsciiWhitespace(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+function parseMetaRefreshContent(content) {
+  const raw = trimAsciiWhitespace(stripControlChars(content));
+  if (raw === "") return forbidden("empty content");
+  let i2 = 0;
+  while (i2 < raw.length && raw[i2] >= "0" && raw[i2] <= "9") i2++;
+  if (i2 === 0) return forbidden("missing or non-numeric delay");
+  const delay = Number.parseInt(raw.slice(0, i2), 10);
+  if (!Number.isFinite(delay)) return forbidden("unparseable delay");
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (i2 === raw.length) return { kind: "delay-only", delay };
+  if (raw[i2] !== ";" && raw[i2] !== ",") return forbidden("unexpected text after delay");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  const keyStart = i2;
+  while (i2 < raw.length && !isAsciiWhitespace(raw[i2]) && raw[i2] !== "=") i2++;
+  const key = raw.slice(keyStart, i2).toLowerCase();
+  if (key !== "url") return forbidden(`unsupported refresh key ${JSON.stringify(key)}`);
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (raw[i2] !== "=") return forbidden("missing '=' after url");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  let destination;
+  const quote = raw[i2];
+  if (quote === '"' || quote === "'") {
+    const close = raw.indexOf(quote, i2 + 1);
+    if (close === -1) return forbidden("unterminated quoted destination");
+    destination = raw.slice(i2 + 1, close);
+    const rest = trimAsciiWhitespace(raw.slice(close + 1));
+    if (rest !== "") return forbidden("trailing text after quoted destination");
+  } else {
+    destination = trimAsciiWhitespace(raw.slice(i2));
+    if (/[;,]/.test(destination)) return forbidden("multiple refresh assignments");
+  }
+  if (destination === "") return forbidden("empty destination");
+  const sanitizedDestination = sanitizeUrl(destination);
+  if (sanitizedDestination === "") return forbidden("destination uses a disallowed protocol");
+  return { kind: "allowed", delay, destination, sanitizedDestination };
+}
+function resolveMetaRefreshPolicy(attributes) {
+  let httpEquiv;
+  let content;
+  let duplicateName;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, value] of attributes) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) duplicateName = canonical;
+    seen.add(canonical);
+    if (canonical === "http-equiv") httpEquiv = value;
+    else if (canonical === "content") content = value;
+  }
+  if (duplicateName !== void 0) {
+    return forbidden(`duplicate case-insensitive attribute ${JSON.stringify(duplicateName)}`);
+  }
+  if (typeof httpEquiv !== "string") return { kind: "not-refresh" };
+  if (trimAsciiWhitespace(stripControlChars(httpEquiv)).toLowerCase() !== "refresh") {
+    return { kind: "not-refresh" };
+  }
+  if (typeof content !== "string") return { kind: "not-refresh" };
+  return parseMetaRefreshContent(content);
+}
+function normalizeMetaAttributes(props) {
+  const out = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(props)) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) return null;
+    seen.add(canonical);
+    out.set(key, props[key]);
+  }
+  return out;
+}
+function isForbiddenMetaEntry(props) {
+  const normalized = normalizeMetaAttributes(props);
+  if (normalized === null) return true;
+  return resolveMetaRefreshPolicy(normalized).kind === "forbidden";
+}
+var forbidden;
+var init_metaRefresh = __esm({
+  "src/utils/metaRefresh.ts"() {
+    "use strict";
+    init_sanitize();
+    forbidden = (reason) => ({ kind: "forbidden", reason });
+  }
+});
+
+// src/utils/headEntry.ts
+function isEmittableHeadAttrName(name) {
+  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
+  const canonical = canonicalAttrName(name);
+  if (isEventHandlerAttr(canonical)) return false;
+  if (isHtmlContentAttribute(canonical)) return false;
+  return true;
+}
+function sanitizeHeadAttrValue(canonical, value) {
+  if (!isPolicyAttribute(canonical)) return value;
+  const safe = sanitizeAttributeString(canonical, value);
+  return safe === "" ? null : safe;
+}
+function findDuplicateAttributeName(names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const canonical = canonicalAttrName(name);
+    if (seen.has(canonical)) return canonical;
+    seen.add(canonical);
+  }
+  return null;
+}
+function planEntry(props, resolver, applyRefreshPolicy) {
+  const rawNames = Object.keys(props);
+  const duplicate = findDuplicateAttributeName(rawNames);
+  if (duplicate !== null) {
+    return { kind: "drop", reason: `duplicate case-insensitive attribute ${JSON.stringify(duplicate)}` };
+  }
+  const attributes = /* @__PURE__ */ new Map();
+  let reactive = false;
+  for (const name of rawNames) {
+    if (!Object.hasOwn(props, name)) continue;
+    if (!isEmittableHeadAttrName(name)) continue;
+    const authored = props[name];
+    if (resolver.isReactiveValue?.(authored)) reactive = true;
+    const canonical = canonicalAttrName(name);
+    const sanitized = sanitizeHeadAttrValue(canonical, resolver.resolveValue(name, authored));
+    if (sanitized === null) continue;
+    attributes.set(canonical, sanitized);
+  }
+  if (attributes.size === 0) return { kind: "drop", reason: "no effective attributes remain" };
+  const refresh = applyRefreshPolicy ? resolveMetaRefreshPolicy(attributes) : { kind: "not-refresh" };
+  if (refresh.kind === "forbidden") return { kind: "drop", reason: refresh.reason };
+  if (reactive && (refresh.kind === "allowed" || refresh.kind === "delay-only")) {
+    return { kind: "drop", reason: "a reactive meta entry may not publish a native refresh directive" };
+  }
+  return { kind: "publish", attributes, refresh };
+}
+function planMetaEntry(props, resolver) {
+  return planEntry(props, resolver, true);
+}
+function planHeadElementEntry(props, resolver) {
+  return planEntry(props, resolver, false);
+}
+function escapeHeadAttrValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeHeadEntry(tag, attrs) {
+  const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
+  if (plan.kind === "drop") return "";
+  const pairs = Array.from(plan.attributes, ([name, value]) => `${name}="${escapeHeadAttrValue(value)}"`).join(" ");
+  return `<${tag} ${pairs} />`;
+}
+var SAFE_HEAD_ATTR_NAME, STATIC_VALUE_RESOLVER;
+var init_headEntry = __esm({
+  "src/utils/headEntry.ts"() {
+    "use strict";
+    init_metaRefresh();
+    init_sanitize();
+    SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
+    STATIC_VALUE_RESOLVER = {
+      resolveValue: (_name, value) => String(value)
+    };
   }
 });
 
@@ -202,14 +668,20 @@ __export(ssr_exports, {
   suspenseSwapScript: () => suspenseSwapScript,
   trustHTML: () => trustHTML
 });
-function sanitizeUrlAttr(name, value) {
-  return name === "srcset" ? sanitizeSrcset(value) : sanitizeUrl(value);
+function isPolicyAttr(lowerName) {
+  return isPolicyAttribute(lowerName);
+}
+function isForbiddenSsrAttr(lowerName) {
+  return isHtmlContentAttribute(lowerName);
+}
+function sanitizeSsrAttributeValue(lowerName, value) {
+  return sanitizeAttributeString(lowerName, value);
 }
 function isSafeAttrName(name) {
   return SAFE_ATTR_NAME.test(name);
 }
 function ssrErrorComment(err) {
-  if (_isDev9) {
+  if (_isDev8) {
     const msg = escapeHtml(err instanceof Error ? err.message : String(err));
     return `<!--SSR error: ${safeCommentText(msg)}-->`;
   }
@@ -239,20 +711,21 @@ function renderToString(element) {
   }
   const tag = element.tagName.toLowerCase();
   if (tag === "script" || tag === "style") {
-    return _isDev9 ? `<!--ssr:${tag}-stripped-->` : "";
+    return _isDev8 ? `<!--ssr:${tag}-stripped-->` : "";
   }
   if (!/^[a-z][a-z0-9-]*$/i.test(tag)) {
-    return _isDev9 ? "<!--ssr:invalid-tag-->" : "";
+    return _isDev8 ? "<!--ssr:invalid-tag-->" : "";
   }
   let html2 = `<${tag}`;
   for (const attr of Array.from(element.attributes)) {
     const rawName = attr.name;
     if (!isSafeAttrName(rawName)) continue;
     if (isEventHandlerAttr(rawName)) continue;
+    if (isForbiddenSsrAttr(rawName)) continue;
     const lowerName = rawName.toLowerCase();
     let value = attr.value;
-    if (URL_ATTRS.has(lowerName)) {
-      value = sanitizeUrlAttr(lowerName, value);
+    if (isPolicyAttr(lowerName)) {
+      value = sanitizeSsrAttributeValue(lowerName, value);
       if (!value) continue;
     }
     html2 += ` ${rawName}="${escapeAttr(value)}"`;
@@ -283,7 +756,7 @@ function hydrate(component, container, options = {}) {
       const first = mismatches[0];
       if (options.onMismatch) {
         options.onMismatch(first);
-      } else if (_isDev9) {
+      } else if (_isDev8) {
         console.warn(
           `[SibuJS hydration] ${first.message}
   at ${first.path}
@@ -293,9 +766,20 @@ function hydrate(component, container, options = {}) {
       }
     }
   }
-  container.replaceChildren(clientTree);
+  replaceChildrenSafely(container, clientTree);
   container.setAttribute("data-sibu-hydrated", "true");
 }
+function directTextOf(node) {
+  let out = "";
+  for (const child of Array.from(node.childNodes)) {
+    if (child.nodeType === 3) out += child.nodeValue ?? "";
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function disposeAndReplace(outgoing, next) {
+  dispose(outgoing);
+  outgoing.replaceWith(next);
+}
 function collectMismatches(serverNode, clientNode, path2, out, max = 5) {
   if (out.length >= max) return;
   const nodePath = path2 || clientNode?.tagName?.toLowerCase() || "(root)";
@@ -371,6 +855,18 @@ function collectMismatches(serverNode, clientNode, path2, out, max = 5) {
       });
     }
   }
+  const serverText = directTextOf(serverNode);
+  const clientText = directTextOf(clientNode);
+  if (serverText !== clientText) {
+    out.push({
+      kind: "text",
+      path: nodePath,
+      serverValue: serverText,
+      clientValue: clientText,
+      message: "Text content differs between server and client."
+    });
+    if (out.length >= max) return;
+  }
   const serverChildren = Array.from(serverNode.children);
   const clientChildren = Array.from(clientNode.children);
   const max2 = Math.max(serverChildren.length, clientChildren.length);
@@ -390,10 +886,11 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
     if (!Object.hasOwn(attrs, rawKey)) continue;
     if (!isSafeAttrName(rawKey)) continue;
     if (!allowEventHandlers && isEventHandlerAttr(rawKey)) continue;
+    if (isForbiddenSsrAttr(rawKey)) continue;
     const lowerKey = rawKey.toLowerCase();
     let value = String(attrs[rawKey]);
-    if (URL_ATTRS.has(lowerKey)) {
-      value = sanitizeUrlAttr(lowerKey, value);
+    if (isPolicyAttr(lowerKey)) {
+      value = sanitizeSsrAttributeValue(lowerKey, value);
       if (!value) continue;
     }
     out.push(`${rawKey}="${escapeAttr(value)}"`);
@@ -401,18 +898,7 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
   return out.join(" ");
 }
 function isDangerousMetaRefresh(metaProps) {
-  let httpEquiv;
-  let content;
-  for (const k in metaProps) {
-    const lk = k.toLowerCase();
-    if (lk === "http-equiv") httpEquiv = metaProps[k];
-    else if (lk === "content") content = metaProps[k];
-  }
-  if (typeof httpEquiv !== "string") return false;
-  if (httpEquiv.toLowerCase() !== "refresh") return false;
-  if (typeof content !== "string") return false;
-  const normalized = stripControlChars(content).toLowerCase();
-  return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
+  return isForbiddenMetaEntry(metaProps);
 }
 function renderToDocument(component, options = {}) {
   let content;
@@ -421,15 +907,8 @@ function renderToDocument(component, options = {}) {
   } catch (err) {
     content = ssrErrorComment(err);
   }
-  const metaTags = (options.meta || []).map((attrs) => {
-    if (isDangerousMetaRefresh(attrs)) return "";
-    const pairs = buildAttrString(attrs);
-    return pairs ? `<meta ${pairs} />` : "";
-  }).filter(Boolean).join("\n    ");
-  const linkTags = (options.links || []).map((attrs) => {
-    const pairs = buildAttrString(attrs);
-    return pairs ? `<link ${pairs} />` : "";
-  }).filter(Boolean).join("\n    ");
+  const metaTags = (options.meta || []).map((attrs) => serializeHeadEntry("meta", attrs)).filter(Boolean).join("\n    ");
+  const linkTags = (options.links || []).map((attrs) => serializeHeadEntry("link", attrs)).filter(Boolean).join("\n    ");
   const scriptTags = (options.scripts || []).map((src) => {
     const safe = sanitizeUrl(String(src));
     if (!safe) return "";
@@ -478,11 +957,11 @@ async function* renderToStream(element) {
   }
   const tag = element.tagName.toLowerCase();
   if (tag === "script" || tag === "style") {
-    if (_isDev9) yield `<!--ssr:${tag}-stripped-->`;
+    if (_isDev8) yield `<!--ssr:${tag}-stripped-->`;
     return;
   }
   if (!/^[a-z][a-z0-9-]*$/i.test(tag)) {
-    if (_isDev9) yield "<!--ssr:invalid-tag-->";
+    if (_isDev8) yield "<!--ssr:invalid-tag-->";
     return;
   }
   let openTag = `<${tag}`;
@@ -490,14 +969,18 @@ async function* renderToStream(element) {
     const rawName = attr.name;
     if (!isSafeAttrName(rawName)) continue;
     if (isEventHandlerAttr(rawName)) continue;
+    if (isForbiddenSsrAttr(rawName)) continue;
     const lowerName = rawName.toLowerCase();
     let value = attr.value;
-    if (URL_ATTRS.has(lowerName)) {
-      value = sanitizeUrlAttr(lowerName, value);
+    if (isPolicyAttr(lowerName)) {
+      value = sanitizeSsrAttributeValue(lowerName, value);
       if (!value) continue;
     }
     openTag += ` ${rawName}="${escapeAttr(value)}"`;
   }
+  if (element.dataset && !element.dataset.sibuHydrate) {
+    openTag += ` data-sibu-ssr="true"`;
+  }
   if (VOID_ELEMENTS.has(tag)) {
     yield `${openTag} />`;
     return;
@@ -543,9 +1026,13 @@ function island(id, component) {
   el.setAttribute("data-sibu-island", id);
   return el;
 }
+function isAlreadyHydrated(element) {
+  return element.hasAttribute("data-sibu-hydrated");
+}
 function hydrateIslands(container, islands) {
   const markers = container.querySelectorAll("[data-sibu-island]");
   for (const marker2 of Array.from(markers)) {
+    if (isAlreadyHydrated(marker2)) continue;
     const id = marker2.getAttribute("data-sibu-island") ?? "";
     if (!Object.hasOwn(islands, id)) continue;
     const factory = islands[id];
@@ -553,7 +1040,7 @@ function hydrateIslands(container, islands) {
     const clientTree = factory();
     clientTree.setAttribute("data-sibu-island", id);
     clientTree.setAttribute("data-sibu-hydrated", "true");
-    marker2.replaceWith(clientTree);
+    disposeAndReplace(marker2, clientTree);
   }
   container.setAttribute("data-sibu-hydrated", "partial");
 }
@@ -561,6 +1048,7 @@ function hydrateProgressively(container, islands, options) {
   const markers = container.querySelectorAll("[data-sibu-island]");
   const cleanups = [];
   for (const marker2 of Array.from(markers)) {
+    if (isAlreadyHydrated(marker2)) continue;
     const id = marker2.getAttribute("data-sibu-island") ?? "";
     if (!Object.hasOwn(islands, id)) continue;
     const factory = islands[id];
@@ -570,10 +1058,11 @@ function hydrateProgressively(container, islands, options) {
         for (const entry of entries) {
           if (entry.isIntersecting) {
             observer.disconnect();
+            if (isAlreadyHydrated(marker2) || marker2.parentNode === null) break;
             const clientTree = factory();
             clientTree.setAttribute("data-sibu-island", id);
             clientTree.setAttribute("data-sibu-hydrated", "true");
-            marker2.replaceWith(clientTree);
+            disposeAndReplace(marker2, clientTree);
             break;
           }
         }
@@ -614,7 +1103,7 @@ function ssrSuspense(props) {
     },
     (err) => {
       if (timer) clearTimeout(timer);
-      if (_isDev9) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
+      if (_isDev8) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
       return { id, html: fallbackHtml };
     }
   );
@@ -628,7 +1117,7 @@ function suspenseSwapScript(id, nonce) {
     );
   }
   const nonceAttr = nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
-  return `<script${nonceAttr}>(function(){var t=document.getElementById("sibu-resolved-${id}");var f=document.querySelector('[data-sibu-suspense-id="${id}"]');if(t&&f){while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
+  return `<script${nonceAttr}>(function(){var t=document.getElementById("sibu-resolved-${id}");var f=document.querySelector('[data-sibu-suspense-id="${id}"]');if(t&&f){while(f.firstChild)f.removeChild(f.firstChild);while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
 }
 async function* renderToSuspenseStream(element, pendingBoundaries = [], options) {
   yield* renderToStream(element);
@@ -644,8 +1133,8 @@ async function* renderToSuspenseStream(element, pendingBoundaries = [], options)
 function escapeScriptJson(json) {
   return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
-function serializeState(state, nonce, options) {
-  const rawJson = JSON.stringify(state);
+function serializeState(state2, nonce, options) {
+  const rawJson = JSON.stringify(state2);
   const maxBytes = options?.maxBytes ?? DEFAULT_MAX_SSR_BYTES;
   const byteLen = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(rawJson).byteLength : Buffer.byteLength(rawJson, "utf8");
   if (byteLen > maxBytes) {
@@ -657,7 +1146,7 @@ function serializeState(state, nonce, options) {
 }
 function deserializeState(validate) {
   if (typeof window === "undefined") return void 0;
-  if (_isDev9 && !validate) {
+  if (_isDev8 && !validate) {
     console.warn(
       "[SibuJS SSR] deserializeState() called without a validate guard \u2014 tampered SSR payloads will not be detected."
     );
@@ -674,29 +1163,18 @@ function escapeHtml(str) {
 function escapeAttr(str) {
   return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-var _isDev9, SAFE_ATTR_NAME, URL_ATTRS, VOID_ELEMENTS, SAFE_ID, SAFE_SUSPENSE_ID, SSR_DATA_ATTR, DEFAULT_MAX_SSR_BYTES;
+var _isDev8, SAFE_ATTR_NAME, VOID_ELEMENTS, SAFE_ID, SAFE_SUSPENSE_ID, SSR_DATA_ATTR, DEFAULT_MAX_SSR_BYTES;
 var init_ssr = __esm({
   "src/platform/ssr.ts"() {
     "use strict";
     init_dev();
+    init_dispose();
     init_ssr_context();
+    init_headEntry();
+    init_metaRefresh();
     init_sanitize();
-    _isDev9 = isDev();
+    _isDev8 = isDev();
     SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-    URL_ATTRS = /* @__PURE__ */ new Set([
-      "href",
-      "src",
-      "action",
-      "formaction",
-      "cite",
-      "poster",
-      "background",
-      "srcset",
-      "ping",
-      "manifest",
-      "data",
-      "xlink:href"
-    ]);
     VOID_ELEMENTS = /* @__PURE__ */ new Set([
       "area",
       "base",
@@ -731,6 +1209,7 @@ __export(plugins_exports, {
   Suspense: () => Suspense,
   Trans: () => Trans,
   VERSION: () => VERSION,
+  __getNavigationEpoch: () => __getNavigationEpoch,
   __removeRouterPagehideHandler: () => __removeRouterPagehideHandler,
   addRoute: () => addRoute,
   afterEach: () => afterEach,
@@ -805,15 +1284,92 @@ module.exports = __toCommonJS(plugins_exports);
 init_dev();
 
 // src/reactivity/bindAttribute.ts
+init_errors();
+init_sanitize();
+
+// src/utils/setSafeAttribute.ts
 init_dev();
 init_sanitize();
+var _isDev2 = isDev();
+var HTML_NS = "http://www.w3.org/1999/xhtml";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
+function isHtmlElement(el) {
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS;
+}
+function setProp(el, key, val) {
+  el[key] = val;
+}
+function namespaceFor(el, name) {
+  if (el.namespaceURI !== SVG_NS) return null;
+  const lower = name.toLowerCase();
+  if (lower.startsWith("xlink:")) return XLINK_NS;
+  if (lower.startsWith("xml:")) return XML_NS;
+  return null;
+}
+function setSafeAttribute(el, name, value, options = {}) {
+  const ns = namespaceFor(el, name);
+  const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
+  if (isEventHandlerAttr(name)) {
+    if (_isDev2) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set event-handler attribute "${name}". Its value would be evaluated as JavaScript. Use on:{ ${name.slice(2)}: fn } instead.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  if (value == null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
+  if (isHtmlContentAttribute(name)) {
+    if (_isDev2) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set "${name}". The browser parses this attribute as a nested HTML document, so a generic string value cannot be made safe \u2014 attribute escaping is undone before the parse. Build the frame's content another way.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  const html2 = isHtmlElement(el);
+  const idlName = html2 ? name.toLowerCase() : name;
+  if (typeof value === "boolean") {
+    if (html2 && BOOLEAN_IDL_ATTRS.has(idlName) && idlName in el) {
+      setProp(el, idlName, value);
+    } else if (value) {
+      if (ns) el.setAttributeNS(ns, name, "");
+      else el.setAttribute(name, "");
+    } else if (ns) {
+      el.removeAttributeNS(ns, localName);
+    } else {
+      el.removeAttribute(name);
+    }
+    return true;
+  }
+  const str = String(value);
+  if (options.syncValueProperty !== false && html2 && (idlName === "value" || idlName === "checked") && idlName in el) {
+    setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
+    return true;
+  }
+  const safe = sanitizeAttributeString(name, str);
+  const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
+  if (current === safe) return true;
+  if (ns) el.setAttributeNS(ns, name, safe);
+  else el.setAttribute(name, safe);
+  return true;
+}
 
 // src/reactivity/track.ts
 init_dev();
 
 // src/reactivity/track-core.ts
-init_dev();
-var _isDev2 = isDev();
+init_errors();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -821,6 +1377,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -905,9 +1462,28 @@ function safeInvoke(sub2) {
   try {
     sub2();
   } catch (err) {
-    if (_isDev2) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s2 = sub2;
+    reportError(err, { phase: s2._errorPhase ?? "effect", name: s2.__name, node: s2._errorNode });
   }
 }
+function depsChanged(sub2) {
+  let node = sub2.depsHead ?? null;
+  if (node === null) return true;
+  while (node !== null) {
+    const sig = node.sig;
+    if (sig === null) return true;
+    if (sig._d === true && sig._validate !== void 0) {
+      try {
+        sig._validate();
+      } catch {
+        return true;
+      }
+    }
+    if (node.depVersion !== sig.__v) return true;
+    node = node.subNext;
+  }
+  return false;
+}
 var suspendDepth = 0;
 var trackingSuspended = false;
 function suspendTracking() {
@@ -988,7 +1564,7 @@ function track(effectFn, subscriber) {
   const sub2 = subscriber;
   return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s2 = subscriber;
     if (s2._disposed || s2._reentrant) return;
@@ -1004,13 +1580,17 @@ function reactiveBinding(commit) {
   subscriber.depsTail = null;
   subscriber._epoch = 0;
   subscriber._structDirty = false;
+  subscriber._hasComputedDep = false;
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
   subscriber._disposed = false;
+  subscriber._errorPhase = "binding";
+  subscriber._errorNode = ownerNode;
   run();
   return subscriber._dispose ?? (subscriber._dispose = () => {
     subscriber._disposed = true;
+    subscriber._errorNode = void 0;
     cleanup(subscriber);
   });
 }
@@ -1022,9 +1602,12 @@ function recordDependency(signal2) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub2) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub2._hasComputedDep = true;
   const node = allocNode(signal2, sub2, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub2, node);
@@ -1043,9 +1626,10 @@ function cleanup(subscriber) {
     node = next;
   }
 }
-var maxSubscriberRepeats = 50;
+var maxSubscriberRepeats = 1e3;
 var maxDrainIterations = 1e6;
 var drainEpoch = 0;
+var quarantined = /* @__PURE__ */ new Set();
 function setMaxSubscriberRepeats(n) {
   const prev = maxSubscriberRepeats;
   if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
@@ -1067,19 +1651,21 @@ function tickRepeat(sub2) {
   return s2._runs > maxSubscriberRepeats;
 }
 function cycleError(sub2) {
-  if (typeof console !== "undefined") {
-    const name = sub2.__name ?? "<unnamed>";
-    console.error(
-      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
-    );
-  }
+  const name = sub2.__name ?? "<unnamed>";
+  reportError(
+    new Error(
+      `subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. This subscriber is quarantined for the rest of this update; other pending work still runs.`
+    ),
+    { phase: "scheduler", name }
+  );
 }
 function absoluteDrainError() {
-  if (typeof console !== "undefined") {
-    console.error(
-      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
-    );
-  }
+  reportError(
+    new Error(
+      `Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    ),
+    { phase: "scheduler" }
+  );
 }
 function drainQueue() {
   let i2 = 0;
@@ -1089,11 +1675,14 @@ function drainQueue() {
       break;
     }
     const sub2 = pendingQueue[i2++];
+    pendingSet.delete(sub2);
+    if (quarantined.size > 0 && quarantined.has(sub2)) continue;
+    if (sub2._hasComputedDep === true && !depsChanged(sub2)) continue;
     if (tickRepeat(sub2)) {
       cycleError(sub2);
-      break;
+      quarantined.add(sub2);
+      continue;
     }
-    pendingSet.delete(sub2);
     safeInvoke(sub2);
   }
 }
@@ -1108,6 +1697,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -1201,6 +1791,7 @@ function notifySubscribers(signal2) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -1228,7 +1819,7 @@ function forEachSubscriber(signal2, visit) {
 
 // src/reactivity/track.ts
 var _isDev3 = isDev();
-var _runtimeVersion = true ? "3.4.1" : "dev";
+var _runtimeVersion = true ? "4.0.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -1285,16 +1876,9 @@ var getSubscriberDeps2 = API.getSubscriberDeps;
 var forEachSubscriber2 = API.forEachSubscriber;
 
 // src/reactivity/bindAttribute.ts
-var _isDev4 = isDev();
-function setProp(el, key, val) {
-  el[key] = val;
-}
 function bindAttribute(el, attr, getter) {
   if (isEventHandlerAttr(attr)) {
-    if (_isDev4)
-      devWarn(
-        `bindAttribute: refusing to bind event-handler attribute "${attr}". Use on:{ ${attr.slice(2)}: fn } instead.`
-      );
+    setSafeAttribute(el, attr, "", { label: `bindAttribute("${attr}")` });
     return () => {
     };
   }
@@ -1303,97 +1887,19 @@ function bindAttribute(el, attr, getter) {
     try {
       value = getter();
     } catch (err) {
-      if (_isDev4)
-        devWarn(`bindAttribute: getter for "${attr}" threw: ${err instanceof Error ? err.message : String(err)}`);
-      return;
-    }
-    if (typeof value === "boolean") {
-      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
-        setProp(el, attr, value);
-      } else if (value) {
-        el.setAttribute(attr, "");
-      } else {
-        el.removeAttribute(attr);
-      }
+      reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
       return;
     }
-    const str = String(value);
-    if ((attr === "value" || attr === "checked") && attr in el) {
-      setProp(el, attr, attr === "checked" ? Boolean(value) : str);
-    } else {
-      el.setAttribute(attr, sanitizeAttributeString(attr, str));
-    }
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
   }
-  return reactiveBinding2(commit);
+  return reactiveBinding2(commit, el);
 }
 
 // src/reactivity/bindChildNode.ts
 init_dev();
-
-// src/core/rendering/dispose.ts
-init_dev();
-var elementDisposers = /* @__PURE__ */ new WeakMap();
+init_errors();
+init_dispose();
 var _isDev5 = isDev();
-var activeBindingCount = 0;
-function registerDisposer(node, teardown) {
-  let disposers = elementDisposers.get(node);
-  if (!disposers) {
-    disposers = [];
-    elementDisposers.set(node, disposers);
-  }
-  disposers.push(teardown);
-  if (_isDev5) activeBindingCount++;
-}
-function dispose(node) {
-  const stack = [node];
-  const order = [];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    order.push(current);
-    const children = Array.from(current.childNodes);
-    for (let i2 = 0; i2 < children.length; i2++) {
-      stack.push(children[i2]);
-    }
-  }
-  for (let i2 = order.length - 1; i2 >= 0; i2--) {
-    const current = order[i2];
-    const disposers = elementDisposers.get(current);
-    if (disposers) {
-      const snapshot = disposers.slice();
-      elementDisposers.delete(current);
-      if (_isDev5) activeBindingCount -= snapshot.length;
-      for (const d of snapshot) {
-        try {
-          d();
-        } catch (err) {
-          if (_isDev5 && typeof console !== "undefined") {
-            console.warn("[SibuJS] Disposer threw during cleanup:", err);
-          }
-        }
-      }
-      let extraPasses = 0;
-      while (extraPasses++ < 8) {
-        const added = elementDisposers.get(current);
-        if (!added || added.length === 0) break;
-        const moreSnapshot = added.slice();
-        elementDisposers.delete(current);
-        if (_isDev5) activeBindingCount -= moreSnapshot.length;
-        for (const d of moreSnapshot) {
-          try {
-            d();
-          } catch (err) {
-            if (_isDev5 && typeof console !== "undefined") {
-              console.warn("[SibuJS] Disposer threw during cleanup:", err);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// src/reactivity/bindChildNode.ts
-var _isDev6 = isDev();
 function bindChildNode(placeholder, getter) {
   let lastNodes = [];
   function commit() {
@@ -1401,7 +1907,7 @@ function bindChildNode(placeholder, getter) {
     try {
       result = getter();
     } catch (err) {
-      if (_isDev6) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: "bindChildNode", node: placeholder });
       return;
     }
     if (result == null || typeof result === "boolean") {
@@ -1427,7 +1933,7 @@ function bindChildNode(placeholder, getter) {
         if (item == null || typeof item === "boolean") continue;
         const node = item instanceof Node ? item : document.createTextNode(String(item));
         if (seen.has(node)) {
-          if (_isDev6)
+          if (_isDev5)
             devWarn("bindChildNode: duplicate node reference in array \u2014 only the first occurrence is rendered.");
           continue;
         }
@@ -1462,13 +1968,14 @@ function bindChildNode(placeholder, getter) {
     }
     lastNodes = newNodes;
   }
-  return reactiveBinding2(commit);
+  return reactiveBinding2(commit, placeholder);
 }
 
 // src/core/rendering/tagFactory.ts
 init_sanitize();
-var SVG_NS = "http://www.w3.org/2000/svg";
-var _isDev7 = isDev();
+init_dispose();
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+var _isDev6 = isDev();
 var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
 function isBlockedTag(tag) {
   return BLOCKED_TAGS.has(tag.toLowerCase());
@@ -1486,9 +1993,6 @@ var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "self",
   "frames"
 ]);
-function setProp2(el, key, val) {
-  el[key] = val;
-}
 function looksLikeClassList(s2) {
   const t2 = s2.trim();
   if (!t2) return false;
@@ -1512,13 +2016,13 @@ function toKebab(prop) {
 function applyStyle(el, style2) {
   if (typeof style2 === "function") {
     const teardown = track2(() => {
-      el.setAttribute("style", style2());
+      el.setAttribute("style", sanitizeStyleAttribute(String(style2())));
     });
     registerDisposer(el, teardown);
     return;
   }
   if (typeof style2 === "string") {
-    el.setAttribute("style", style2);
+    el.setAttribute("style", sanitizeStyleAttribute(style2));
     return;
   }
   const htmlEl = el;
@@ -1639,7 +2143,7 @@ var tagFactory = (tag, ns) => {
         appendChildren(el, second);
         return el;
       }
-      if (_isDev7 && looksLikeClassList(first)) {
+      if (_isDev6 && looksLikeClassList(first)) {
         devWarn(
           `tagFactory: lone string "${first}" looks like a class list but is being rendered as TEXT. For a class, use ${tag}({ class: "${first}" }) \u2014 or ${tag}("${first}", children) to set the class AND add children.`
         );
@@ -1660,7 +2164,7 @@ var tagFactory = (tag, ns) => {
     if (pClass != null) applyClass(el, pClass);
     const pId = props.id;
     if (pId != null) {
-      if (_isDev7 && typeof pId === "string" && CLOBBER_RISKY_IDS.has(pId.toLowerCase())) {
+      if (_isDev6 && typeof pId === "string" && CLOBBER_RISKY_IDS.has(pId.toLowerCase())) {
         devWarn(
           `tagFactory: element id="${pId}" matches a common global and may cause DOM clobbering. Avoid setting ids from untrusted input.`
         );
@@ -1675,7 +2179,7 @@ var tagFactory = (tag, ns) => {
         const handler = pOn[ev];
         if (typeof handler === "function") {
           el.addEventListener(ev, handler);
-        } else if (_isDev7) {
+        } else if (_isDev6) {
           devWarn(
             `tagFactory: on.${ev} handler is not a function (got ${typeof handler}). Event listener was not attached.`
           );
@@ -1703,16 +2207,8 @@ var tagFactory = (tag, ns) => {
           if (isEventHandlerAttr(key)) continue;
           if (typeof value === "function") {
             registerDisposer(el, bindAttribute(el, key, value));
-          } else if (typeof value === "boolean") {
-            if (key in el && (key === "checked" || key === "disabled" || key === "selected")) {
-              setProp2(el, key, value);
-            } else if (value) {
-              el.setAttribute(key, "");
-            } else {
-              el.removeAttribute(key);
-            }
           } else {
-            el.setAttribute(key, sanitizeAttributeString(key, String(value)));
+            setSafeAttribute(el, key, value, { syncValueProperty: false, label: "tagFactory" });
           }
         }
       }
@@ -1797,7 +2293,7 @@ var param = tagFactory("param");
 var picture = tagFactory("picture");
 var portal = tagFactory("portal");
 var source = tagFactory("source");
-var svg = tagFactory("svg", SVG_NS);
+var svg = tagFactory("svg", SVG_NS2);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -1838,26 +2334,26 @@ var base = tagFactory("base");
 var link = tagFactory("link");
 var meta = tagFactory("meta");
 var style = tagFactory("style");
-var circle = tagFactory("circle", SVG_NS);
-var ellipse = tagFactory("ellipse", SVG_NS);
-var g = tagFactory("g", SVG_NS);
-var line = tagFactory("line", SVG_NS);
-var path = tagFactory("path", SVG_NS);
-var polygon = tagFactory("polygon", SVG_NS);
-var polyline = tagFactory("polyline", SVG_NS);
-var rect = tagFactory("rect", SVG_NS);
-var text = tagFactory("text", SVG_NS);
-var tspan = tagFactory("tspan", SVG_NS);
-var defs = tagFactory("defs", SVG_NS);
-var clipPath = tagFactory("clipPath", SVG_NS);
-var mask = tagFactory("mask", SVG_NS);
-var pattern = tagFactory("pattern", SVG_NS);
-var linearGradient = tagFactory("linearGradient", SVG_NS);
-var radialGradient = tagFactory("radialGradient", SVG_NS);
-var stop = tagFactory("stop", SVG_NS);
-var use = tagFactory("use", SVG_NS);
-var symbol = tagFactory("symbol", SVG_NS);
-var marker = tagFactory("marker", SVG_NS);
+var circle = tagFactory("circle", SVG_NS2);
+var ellipse = tagFactory("ellipse", SVG_NS2);
+var g = tagFactory("g", SVG_NS2);
+var line = tagFactory("line", SVG_NS2);
+var path = tagFactory("path", SVG_NS2);
+var polygon = tagFactory("polygon", SVG_NS2);
+var polyline = tagFactory("polyline", SVG_NS2);
+var rect = tagFactory("rect", SVG_NS2);
+var text = tagFactory("text", SVG_NS2);
+var tspan = tagFactory("tspan", SVG_NS2);
+var defs = tagFactory("defs", SVG_NS2);
+var clipPath = tagFactory("clipPath", SVG_NS2);
+var mask = tagFactory("mask", SVG_NS2);
+var pattern = tagFactory("pattern", SVG_NS2);
+var linearGradient = tagFactory("linearGradient", SVG_NS2);
+var radialGradient = tagFactory("radialGradient", SVG_NS2);
+var stop = tagFactory("stop", SVG_NS2);
+var use = tagFactory("use", SVG_NS2);
+var symbol = tagFactory("symbol", SVG_NS2);
+var marker = tagFactory("marker", SVG_NS2);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -1915,74 +2411,79 @@ var isBatching = API2.isBatching;
 // src/core/signals/signal.ts
 init_dev();
 var _g = globalThis;
-var _isDev8 = isDev();
+var _isDev7 = isDev();
 function signal(initial, options) {
-  const state = {
+  const state2 = {
     value: initial,
     __v: 0,
     __sc: 0,
     subsHead: null,
     subsTail: null,
     __activeNode: null,
-    __name: void 0
+    __name: void 0,
+    _d: false,
+    _validate: void 0
   };
-  const debugName = _isDev8 ? options?.name : void 0;
+  const debugName = _isDev7 ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state.__name = debugName;
+  if (debugName) state2.__name = debugName;
   function get() {
-    recordDependency2(state);
-    return state.value;
+    recordDependency2(state2);
+    return state2.value;
   }
-  get.__signal = state;
+  get.__signal = state2;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state.value = newValue;
-      state.__v++;
-      if (_isDev8) {
+      state2.value = newValue;
+      state2.__v++;
+      if (_isDev7) {
         const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+        if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
-  } else if (_isDev8) {
+  } else if (_isDev7) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
+      state2.value = newValue;
+      state2.__v++;
       const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   } else {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      state2.value = newValue;
+      state2.__v++;
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   }
-  if (_isDev8) {
+  if (_isDev7) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+    if (hook) hook.emit("signal:create", { signal: state2, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
 
+// src/plugins/i18n.ts
+init_ssr_context();
+
 // src/utils/globalSingleton.ts
 function globalSingleton(key, create) {
   const g2 = globalThis;
@@ -1992,37 +2493,65 @@ function globalSingleton(key, create) {
 // src/plugins/i18n.ts
 var _i18n = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.i18n.v1"), () => ({
   locale: signal("en"),
-  locales: {}
+  locales: /* @__PURE__ */ Object.create(null)
 }));
-var [currentLocale, setLocaleInternal] = _i18n.locale;
+var [clientLocale, setClientLocale] = _i18n.locale;
 var locales = _i18n.locales;
+function dictionaryFor(locale) {
+  return Object.hasOwn(locales, locale) ? locales[locale] : void 0;
+}
+function lookup(key) {
+  const dictionary = dictionaryFor(getLocale());
+  if (dictionary === void 0 || !Object.hasOwn(dictionary, key)) return void 0;
+  const message = dictionary[key];
+  return typeof message === "string" ? message : void 0;
+}
 function setLocale(locale) {
-  setLocaleInternal(locale);
+  const request = getRequestStore();
+  if (request) {
+    request.locale = locale;
+    return;
+  }
+  setClientLocale(locale);
 }
 function getLocale() {
-  return currentLocale();
+  const request = getRequestStore();
+  if (request) {
+    return request.locale ?? clientLocale();
+  }
+  return clientLocale();
 }
 function registerTranslations(locale, messages) {
-  locales[locale] = { ...locales[locale], ...messages };
+  const prepared = { ...messages };
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), dictionaryFor(locale), prepared);
+  Object.defineProperty(locales, locale, {
+    value: merged,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
 }
 function t(key, params) {
-  const locale = currentLocale();
-  const message = locales[locale]?.[key] || key;
+  const message = lookup(key) ?? key;
   return params ? message.replace(/\{(\w+)\}/g, (_, p2) => String(params[p2] ?? "")) : message;
 }
 function Trans(key, params) {
   return span(() => t(key, params));
 }
 function hasTranslation(key) {
-  const locale = currentLocale();
-  return key in (locales[locale] || {});
+  return lookup(key) !== void 0;
 }
 function getAvailableLocales() {
   return Object.keys(locales);
 }
 
+// src/plugins/router.ts
+init_dev();
+init_dispose();
+
 // src/core/signals/effect.ts
 init_dev();
+init_errors();
 init_ssr_context();
 var _g2 = globalThis;
 var MAX_RERUNS = 100;
@@ -2034,7 +2563,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i2]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -2047,11 +2576,12 @@ function drainReruns(ctx) {
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
-    if (_g2.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-      console.error(
-        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-      );
-    }
+    reportError(
+      new Error(
+        `effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      ),
+      { phase: "effect" }
+    );
   }
 }
 function disposeEffect(ctx) {
@@ -2128,6 +2658,8 @@ function effect(effectFn, options) {
   sub2.depsTail = null;
   sub2._epoch = 0;
   sub2._structDirty = false;
+  sub2._hasComputedDep = false;
+  sub2._errorPhase = "effect";
   sub2._runEpoch = 0;
   sub2._runs = 0;
   ctx.subscriber = sub2;
@@ -2146,12 +2678,32 @@ function effect(effectFn, options) {
 
 // src/plugins/router.ts
 init_sanitize();
-function isSafeNavigationTarget(path2) {
-  if (path2 === "") return true;
+function classifyNavigationTarget(path2) {
+  if (path2 === "") return "internal";
   const normalized = stripControlChars(path2).replace(/\\/g, "/");
-  if (normalized.startsWith("//")) return false;
-  return sanitizeUrl(normalized) !== "";
+  if (normalized === "") return "internal";
+  if (normalized.startsWith("//")) return "unsafe";
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(normalized)) return "internal";
+  return sanitizeUrl(normalized) === "" ? "unsafe" : "external";
+}
+function isRouterNavigable(path2) {
+  return classifyNavigationTarget(path2) === "internal";
 }
+function normalizePathname(path2) {
+  if (!path2) return "/";
+  const trimmed = path2.length > 1 ? path2.replace(/\/+$/, "") : path2;
+  return trimmed || "/";
+}
+function normalizeQuery(query) {
+  const params = new URLSearchParams(query);
+  return [...params.entries()].sort(([a2], [b2]) => a2 < b2 ? -1 : a2 > b2 ? 1 : 0).map(([k, v]) => `${k}=${v}`).join("&");
+}
+function isPathnameAncestor(target, current) {
+  if (target === current) return true;
+  if (target === "/") return false;
+  return current.startsWith(`${target}/`);
+}
+var ABORT_ROUTER_DESTROYED = "sibu:router-destroyed";
 var LRUCache = class {
   constructor(maxSize = 100) {
     this.cache = /* @__PURE__ */ new Map();
@@ -2212,9 +2764,9 @@ var NavigationController = class {
       }
     }
   }
-  abort() {
+  abort(reason) {
     if (this.currentController) {
-      this.currentController.abort();
+      this.currentController.abort(reason);
       this.currentController = null;
     }
   }
@@ -2400,6 +2952,7 @@ var GuardManager = class {
     this.timeout = timeout;
   }
   async runBeforeEach(to, from, signal2) {
+    if (signal2.aborted) throw new Error("Navigation aborted");
     for (const guard of this.beforeEachGuards) {
       if (signal2.aborted) throw new Error("Navigation aborted");
       const result = await this.runGuard(guard, to, from, signal2);
@@ -2408,6 +2961,7 @@ var GuardManager = class {
     return true;
   }
   async runBeforeResolve(to, from, signal2) {
+    if (signal2.aborted) throw new Error("Navigation aborted");
     for (const guard of this.beforeResolveGuards) {
       if (signal2.aborted) throw new Error("Navigation aborted");
       const result = await this.runGuard(guard, to, from, signal2);
@@ -2504,13 +3058,16 @@ var _ComponentLoader = class _ComponentLoader {
   constructor(cacheSize = 50, retryDelay = 1e3) {
     this.errorCache = /* @__PURE__ */ new Map();
     this.loadingPromises = /* @__PURE__ */ new Map();
+    // In-flight *module* resolutions for deferred plans, so concurrent first
+    // mounts of a lazy route do not each run the loader arrow.
+    this.moduleLoads = /* @__PURE__ */ new Map();
     // Stable per-route-definition id. Caching by the RESOLVED path (e.g.
     // /users/123) gave the cache one entry per visited URL, so parameterized
     // routes thrashed/evicted and the component was reloaded every navigation.
     // Keying by route-definition identity makes the cache effective again.
     this.routeKeys = /* @__PURE__ */ new WeakMap();
     this.keyCounter = 0;
-    this.componentCache = new LRUCache(cacheSize);
+    this.planCache = new LRUCache(cacheSize);
     this.retryDelay = retryDelay;
   }
   keyFor(route2) {
@@ -2521,91 +3078,233 @@ var _ComponentLoader = class _ComponentLoader {
     }
     return key;
   }
-  async loadComponent(route2, routePath) {
+  /**
+   * Resolve the route's **plan** — how to produce an instance — without ever
+   * instantiating a component to inspect it.
+   *
+   * Loading a route component and instantiating one are separate operations.
+   * The loader never invokes a user component factory merely to validate its
+   * return type; validation happens on the instance that will actually be
+   * mounted. (LOAD-001)
+   */
+  async loadPlan(route2, routePath) {
     if (!("component" in route2)) {
       throw new Error(`Route ${routePath} does not have a component`);
     }
     const comp = route2.component;
     const cacheKey = this.keyFor(route2);
-    const cached = this.componentCache.get(cacheKey);
+    const cached = this.planCache.get(cacheKey);
     if (cached) return cached;
     const existingPromise = this.loadingPromises.get(cacheKey);
     if (existingPromise) return existingPromise;
-    const errorInfo = this.errorCache.get(cacheKey);
-    if (errorInfo && Date.now() - errorInfo.timestamp < this.retryDelay) {
-      throw new Error(`Component loading failed recently, retry in ${this.retryDelay}ms`);
-    }
-    const loadingPromise = this.doLoadComponent(comp, routePath);
+    this.assertNotHot(cacheKey);
+    const loadingPromise = this.doLoadPlan(comp, routePath);
     this.loadingPromises.set(cacheKey, loadingPromise);
     try {
-      const component = await loadingPromise;
-      this.componentCache.set(cacheKey, component);
+      const plan = await loadingPromise;
+      this.planCache.set(cacheKey, plan);
       this.errorCache.delete(cacheKey);
-      return component;
+      return plan;
     } catch (error) {
-      const currentError = this.errorCache.get(cacheKey) || { timestamp: 0, count: 0 };
-      if (!this.errorCache.has(cacheKey) && this.errorCache.size >= _ComponentLoader.MAX_ERROR_ENTRIES) {
-        const oldest = this.errorCache.keys().next().value;
-        if (oldest !== void 0) this.errorCache.delete(oldest);
-      }
-      this.errorCache.set(cacheKey, {
-        timestamp: Date.now(),
-        count: currentError.count + 1
-      });
+      this.noteError(cacheKey);
       throw error;
     } finally {
       this.loadingPromises.delete(cacheKey);
     }
   }
-  async doLoadComponent(comp, routePath) {
-    if (!this.isAsyncComponent(comp)) {
-      const result = comp();
-      if (!this.isElement(result)) {
-        throw new Error(`Component for route "${routePath}" must return Element, got ${typeof result}`);
-      }
-      return comp;
+  /** Reject early while a recent load failure for this route is still hot. */
+  assertNotHot(cacheKey) {
+    const errorInfo = this.errorCache.get(cacheKey);
+    if (errorInfo && Date.now() - errorInfo.timestamp < this.retryDelay) {
+      throw new Error(`Component loading failed recently, retry in ${this.retryDelay}ms`);
+    }
+  }
+  /**
+   * Record a load failure. Keyed by route-definition id, so the map is bounded
+   * by the number of route definitions; still capped defensively, evicting the
+   * oldest.
+   */
+  noteError(cacheKey) {
+    const currentError = this.errorCache.get(cacheKey) || { timestamp: 0, count: 0 };
+    if (!this.errorCache.has(cacheKey) && this.errorCache.size >= _ComponentLoader.MAX_ERROR_ENTRIES) {
+      const oldest = this.errorCache.keys().next().value;
+      if (oldest !== void 0) this.errorCache.delete(oldest);
+    }
+    this.errorCache.set(cacheKey, { timestamp: Date.now(), count: currentError.count + 1 });
+  }
+  /**
+   * Classify without instantiating.
+   *
+   * The `lazy()` brand decides, and nothing else: a branded loader is
+   * `deferred`, everything else is a `factory`. No inspection of the function's
+   * type or source is involved, so an unbranded factory can never become
+   * preload-executable. (LOAD-004)
+   *
+   * An unbranded factory that happens to resolve to a module — an un-marked
+   * `async () => ({ default: Page })` — still works: that is unwrapped during
+   * real instantiation, where the produced value is used rather than discarded.
+   */
+  async doLoadPlan(comp, routePath) {
+    if (typeof comp !== "function") {
+      throw new Error(`Component for route "${routePath}" must be a function, got ${typeof comp}`);
+    }
+    if (!this.isDeferredModule(comp)) {
+      return { kind: "factory", component: comp };
+    }
+    return { kind: "deferred", load: comp };
+  }
+  /**
+   * Create **one** real route component instance, validating what will actually
+   * be mounted.
+   *
+   * `route` is used only to upgrade a `deferred` plan once a lazy module has
+   * resolved, so the import happens once and later mounts call the module's
+   * factory directly.
+   */
+  async instantiate(plan, route2, routePath) {
+    if (plan.kind === "factory") {
+      return this.instantiateFactory(plan.component, route2, routePath);
     }
+    const factory = await this.resolveModuleFactory(plan, route2, routePath);
+    return this.instantiateFactory(factory, route2, routePath);
+  }
+  /**
+   * Resolve a deferred plan's module and cache the factory it exports —
+   * **without invoking that factory**.
+   *
+   * Shared by instantiation and preloading, so a preload racing a navigation to
+   * the same route imports the module once. A deferred plan is only ever a
+   * module loader (see `isDeferredModule`), so a resolution that is not
+   * module-shaped is a configuration error and is reported as one.
+   */
+  async resolveModuleFactory(plan, route2, routePath) {
+    const cacheKey = this.keyFor(route2);
+    const cached = this.planCache.get(cacheKey);
+    if (cached && cached.kind === "factory") return cached.component;
+    this.assertNotHot(cacheKey);
+    let pending = this.moduleLoads.get(cacheKey);
+    const owner = pending === void 0;
+    if (pending === void 0) {
+      pending = plan.load();
+      this.moduleLoads.set(cacheKey, pending);
+    }
+    let resolved;
     try {
-      const result = await comp();
-      const component = this.extractComponent(result, routePath);
-      const testElement = component();
-      if (!this.isElement(testElement)) {
-        throw new Error(`Component for route "${routePath}" must return Element, got ${typeof testElement}`);
-      }
-      return component;
+      resolved = await pending;
     } catch (error) {
-      const wrapped = new Error(
-        `Failed to load component for route "${routePath}": ${error instanceof Error ? error.message : String(error)}`
-      );
-      wrapped.cause = error;
-      throw wrapped;
+      this.noteError(cacheKey);
+      throw error;
+    } finally {
+      if (owner) this.moduleLoads.delete(cacheKey);
     }
+    const factory = this.extractFactory(resolved, routePath);
+    this.planCache.set(cacheKey, { kind: "factory", component: factory });
+    return factory;
   }
-  isAsyncComponent(comp) {
-    return comp[LAZY_MARKER] === true || comp.constructor.name === "AsyncFunction" || typeof comp === "function" && comp.toString().includes("import(");
+  /**
+   * Invoke a factory exactly once and validate the instance it produced.
+   *
+   * A factory may turn out to resolve to a *module* rather than an Element —
+   * an un-marked `async () => ({ default: Page })` is indistinguishable from a
+   * component factory until it runs. That is settled here, on the real
+   * invocation, and the plan is upgraded so later mounts skip the extra hop.
+   * `depth` bounds that unwrapping; a module whose default is itself a module
+   * is a configuration error, not something to chase.
+   */
+  async instantiateFactory(component, route2, routePath, depth = 0) {
+    const result = component();
+    const value = this.isThenable(result) ? await result : result;
+    if (this.isElement(value)) return value;
+    if (depth === 0 && this.isFactoryLike(value)) {
+      const factory = this.extractFactory(value, routePath);
+      this.planCache.set(this.keyFor(route2), { kind: "factory", component: factory });
+      return this.instantiateFactory(factory, route2, routePath, depth + 1);
+    }
+    throw new Error(`Component for route "${routePath}" must return Element, got ${typeof value}`);
   }
-  isElement(value) {
-    return value instanceof Element;
+  /**
+   * Something `extractFactory` can turn into a component factory: a bare
+   * callable, or a module namespace carrying a callable `default`. Both are
+   * long-supported shapes for an async loader's resolution.
+   */
+  isFactoryLike(value) {
+    if (typeof value === "function") return true;
+    return typeof value === "object" && value !== null && typeof value.default === "function";
   }
-  extractComponent(result, routePath) {
-    if ("default" in result && typeof result.default === "function") {
+  /**
+   * Pull a factory out of a resolved lazy module **without calling it**. Only
+   * what can be checked without running user code is checked here: that a
+   * default export exists and is callable.
+   */
+  extractFactory(result, routePath) {
+    if (typeof result === "function") return result;
+    if (typeof result === "object" && result !== null && typeof result.default === "function") {
       return result.default;
     }
-    if (typeof result === "function") {
-      return result;
-    }
-    if (this.isElement(result)) {
-      return () => result;
-    }
     throw new Error(`Invalid component module for route "${routePath}"`);
   }
+  /**
+   * Prepare explicitly deferred route code without creating a component
+   * instance or any DOM.
+   *
+   * Only routes explicitly branded as deferred — a loader wrapped in `lazy()` —
+   * are resolved during preload. Direct component factories, whether
+   * synchronous, `async`, or Promise-returning, are `factory` plans and
+   * therefore require no preload work at all.
+   *
+   * ```text
+   * factory plan   → preload no-op
+   * deferred plan  → resolve module → cache factory → no component invocation
+   * ```
+   *
+   * Deferred module resolution caches the component factory the module exports
+   * **without invoking it**. (LOAD-004)
+   */
+  async preloadPlan(route2, routePath) {
+    const plan = await this.loadPlan(route2, routePath);
+    if (plan.kind === "factory") return;
+    await this.resolveModuleFactory(plan, route2, routePath);
+  }
+  isThenable(value) {
+    return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+  }
+  /**
+   * Is this route component an **explicitly declared module loader**?
+   *
+   * Preload is the only place SibuJS executes a route function before the
+   * router needs an instance, so permission to do that must be explicit. The
+   * brand stamped by `lazy()` is the sole authority.
+   *
+   * Everything the loader once inferred is deliberately *not* a signal:
+   *
+   * - `constructor.name === "AsyncFunction"` — cannot distinguish
+   *   `async () => import("./Page")` from `async () => div()`. Treating the
+   *   latter as a module loader is what made preload invoke user
+   *   components. (LOAD-003)
+   * - `toString().includes("import(")` — source text is a representation, not
+   *   semantics. An ordinary component with `"import('./x')"` in a string, a
+   *   template literal, or a comment was executed during preload; and the same
+   *   text can vanish under a bundler that rewrites dynamic imports into its
+   *   own chunk-loader calls. Both directions are wrong, and no better regex
+   *   fixes that — the defect is source inspection itself. (LOAD-004)
+   *
+   * A brand is metadata: it survives TypeScript, every bundler, and
+   * minification, because it is part of runtime behaviour rather than syntax.
+   */
+  isDeferredModule(comp) {
+    return comp[LAZY_MARKER] === true;
+  }
+  isElement(value) {
+    return value instanceof Element;
+  }
   clearErrors() {
     this.errorCache.clear();
   }
   clearCache() {
-    this.componentCache.clear();
+    this.planCache.clear();
     this.errorCache.clear();
     this.loadingPromises.clear();
+    this.moduleLoads.clear();
   }
 };
 _ComponentLoader.MAX_ERROR_ENTRIES = 256;
@@ -2614,6 +3313,17 @@ var _SibuRouter = class _SibuRouter {
   constructor(routes, options = {}) {
     // Event listeners cleanup
     this.cleanup = [];
+    // Set by destroy(). Lets a navigation still in flight report
+    // "router-destroyed" rather than the generic "superseded".
+    this.destroyed = false;
+    // Monotonic navigation generation. Bumped by every committed navigation that
+    // can acquire DOM ownership, and by destroy(). Async work that wants to
+    // commit into the DOM captures this first and re-checks before committing:
+    // unlike a URL comparison it distinguishes "/b" generation 10 from "/b"
+    // generation 12, so an A→B→A round trip can never restore commit permission
+    // to superseded work. The router's own initial location resolution is
+    // excluded — it establishes the bootstrap route rather than superseding it.
+    this.navEpoch = 0;
     this.options = {
       mode: "history",
       base: "",
@@ -2652,7 +3362,7 @@ var _SibuRouter = class _SibuRouter {
     }
     queueMicrotask(() => {
       if (!this.navigator.isNavigating) {
-        this.handleLocationChange(true);
+        this.handleLocationChange(true, true);
       }
       this.isReadySetter(true);
     });
@@ -2667,14 +3377,15 @@ var _SibuRouter = class _SibuRouter {
       matched: []
     };
   }
-  handleLocationChange(skipHistory = true) {
+  handleLocationChange(skipHistory = true, initialResolution = false) {
     const path2 = this.getCurrentPath();
-    this.navigate(path2, { replace: true, skipHistory }).catch((err) => {
+    this.navigate(path2, { replace: true, skipHistory, initialResolution }).catch((err) => {
       console.error("[Router] Error during location change navigation:", err);
     });
   }
   getCurrentPath() {
     const { mode, base: base2 } = this.options;
+    if (typeof window === "undefined") return "/";
     if (mode === "hash") {
       return window.location.hash.slice(1) || "/";
     }
@@ -2706,15 +3417,15 @@ var _SibuRouter = class _SibuRouter {
     try {
       await this.navigator.navigate(async (signal2) => {
         const targetPath = this.resolvePath(to);
-        if (!isSafeNavigationTarget(targetPath)) {
+        if (!isRouterNavigable(targetPath)) {
           const from2 = this.currentRouteGetter();
           const toContext2 = this.createRouteContext(targetPath);
-          throw new NavigationFailureError("aborted", from2, toContext2);
+          throw new NavigationFailureError("aborted", from2, toContext2, void 0, "unsafe-target");
         }
         const from = this.currentRouteGetter();
         const toContext = this.createRouteContext(targetPath);
         if (this.isSameRoute(from, toContext)) {
-          throw new NavigationFailureError("duplicated", from, toContext);
+          throw new NavigationFailureError("duplicated", from, toContext, void 0, "duplicate");
         }
         await this.performNavigation(toContext, from, options, signal2);
       });
@@ -2722,30 +3433,43 @@ var _SibuRouter = class _SibuRouter {
     } catch (error) {
       if (error instanceof NavigationFailureError) {
         const failure2 = error.toFailure();
-        return { success: false, type: failure2.type, failure: failure2 };
+        return { success: false, type: failure2.type, reason: failure2.reason, failure: failure2 };
       }
+      const isAbort = error instanceof Error && error.message === "Navigation aborted";
+      const reason = isAbort ? this.destroyed ? "router-destroyed" : "superseded" : "error";
       const failure = {
         type: "aborted",
+        reason,
         from: this.currentRouteGetter(),
         to: this.createRouteContext(this.resolvePath(to)),
         error: error instanceof Error ? error : new Error(String(error))
       };
-      return { success: false, type: failure.type, failure };
+      return { success: false, type: failure.type, reason, failure };
     }
   }
-  async performNavigation(to, from, options, signal2, depth = 0) {
+  async performNavigation(to, from, options, signal2, depth = 0, redirectChain = []) {
+    const chain = depth === 0 ? [to.path] : redirectChain;
     if (depth >= _SibuRouter.MAX_REDIRECT_DEPTH) {
-      throw new NavigationFailureError("aborted", from, to);
+      if (isDev()) {
+        devWarn(
+          `Router: redirect loop detected \u2014 navigation aborted after ${_SibuRouter.MAX_REDIRECT_DEPTH} hops.
+  ${chain.map((p2) => `"${p2}"`).join(" -> ")}`
+        );
+      }
+      throw new NavigationFailureError("aborted", from, to, void 0, "redirect-loop");
     }
     const beforeEachResult = await this.guards.runBeforeEach(to, from, signal2);
     if (beforeEachResult !== true) {
       if (typeof beforeEachResult === "string") {
-        if (!isSafeNavigationTarget(beforeEachResult)) {
-          throw new NavigationFailureError("aborted", from, to);
+        if (!isRouterNavigable(beforeEachResult)) {
+          throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
         }
-        return this.performNavigation(this.createRouteContext(beforeEachResult), from, options, signal2, depth + 1);
+        return this.performNavigation(this.createRouteContext(beforeEachResult), from, options, signal2, depth + 1, [
+          ...chain,
+          beforeEachResult
+        ]);
       }
-      throw new NavigationFailureError("aborted", from, to);
+      throw new NavigationFailureError("aborted", from, to, void 0, "guard");
     }
     const match = this.matcher.match(to.path);
     if (match) {
@@ -2756,47 +3480,60 @@ var _SibuRouter = class _SibuRouter {
           for (const guard of guards) {
             if (signal2.aborted) throw new Error("Navigation aborted");
             const result = await guard(to, from);
+            if (signal2.aborted) {
+              throw new NavigationFailureError("aborted", from, to, void 0, abortReasonOf(signal2));
+            }
             if (result !== true) {
               if (typeof result === "string") {
-                if (!isSafeNavigationTarget(result)) {
-                  throw new NavigationFailureError("aborted", from, to);
+                if (!isRouterNavigable(result)) {
+                  throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
                 }
-                return this.performNavigation(this.createRouteContext(result), from, options, signal2, depth + 1);
+                return this.performNavigation(this.createRouteContext(result), from, options, signal2, depth + 1, [
+                  ...chain,
+                  result
+                ]);
               }
-              throw new NavigationFailureError("aborted", from, to);
+              throw new NavigationFailureError("aborted", from, to, void 0, "guard");
             }
           }
         }
       }
       if ("redirect" in route2) {
         const redirectPath = typeof route2.redirect === "function" ? route2.redirect(to) : route2.redirect;
-        if (typeof redirectPath === "string" && /^(https?:)?\/\//i.test(redirectPath)) {
-          if (typeof console !== "undefined") {
+        if (typeof redirectPath === "string" && !isRouterNavigable(redirectPath)) {
+          if (classifyNavigationTarget(redirectPath) === "external" && typeof console !== "undefined") {
             console.error(
               `[SibuJS Router] Refusing absolute/protocol-relative redirect "${redirectPath}" \u2014 open-redirect risk.`
             );
           }
-          throw new NavigationFailureError("aborted", from, to);
-        }
-        if (typeof redirectPath === "string" && !isSafeNavigationTarget(redirectPath)) {
-          throw new NavigationFailureError("aborted", from, to);
+          throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
         }
-        return this.performNavigation(this.createRouteContext(redirectPath), from, options, signal2, depth + 1);
+        return this.performNavigation(this.createRouteContext(redirectPath), from, options, signal2, depth + 1, [
+          ...chain,
+          redirectPath
+        ]);
       }
     }
     const beforeResolveResult = await this.guards.runBeforeResolve(to, from, signal2);
     if (beforeResolveResult !== true) {
       if (typeof beforeResolveResult === "string") {
-        if (!isSafeNavigationTarget(beforeResolveResult)) {
-          throw new NavigationFailureError("aborted", from, to);
+        if (!isRouterNavigable(beforeResolveResult)) {
+          throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
         }
-        return this.performNavigation(this.createRouteContext(beforeResolveResult), from, options, signal2, depth + 1);
+        return this.performNavigation(this.createRouteContext(beforeResolveResult), from, options, signal2, depth + 1, [
+          ...chain,
+          beforeResolveResult
+        ]);
       }
-      throw new NavigationFailureError("aborted", from, to);
+      throw new NavigationFailureError("aborted", from, to, void 0, "guard");
+    }
+    if (signal2.aborted) {
+      throw new NavigationFailureError("aborted", from, to, void 0, abortReasonOf(signal2));
     }
     if (!options.skipHistory) {
       this.updateHistory(to, options);
     }
+    if (!options.initialResolution) this.navEpoch++;
     this.currentRouteSetter(to);
     this.guards.runAfterEach(to, from);
     this.handleScrollBehavior(to, from);
@@ -2829,25 +3566,71 @@ var _SibuRouter = class _SibuRouter {
   }
   updateHistory(to, options) {
     const fullPath = this.options.base + to.path + (Object.keys(to.query).length ? `?${new URLSearchParams(to.query).toString()}` : "") + (to.hash ? `#${to.hash}` : "");
+    const h = globalThis.history;
+    if (!h) return;
     if (options.replace) {
-      history.replaceState(options.state || {}, "", fullPath);
+      h.replaceState(options.state || {}, "", fullPath);
     } else {
-      history.pushState(options.state || {}, "", fullPath);
+      h.pushState(options.state || {}, "", fullPath);
     }
   }
+  /**
+   * Apply the configured `scrollBehavior`, if the runtime can actually scroll.
+   *
+   * This runs *after* the route has been committed, so an exception here does
+   * not merely skip scrolling — it propagates out of `navigateInternal` and the
+   * navigation is reported as `success: false` while the route state says it
+   * succeeded. In a DOM-less runtime the bare `requestAnimationFrame` did
+   * exactly that: a legal `scrollBehavior` option made every navigation report
+   * failure under SSR and in memory-router-style tests. (MEM-001)
+   *
+   * Policy A, consistent with the history write in `updateHistory()` (NODE-001):
+   * the route still commits, and only the browser-only side effect is skipped.
+   *
+   * Both primitives are probed, not just `window` — `requestAnimationFrame` and
+   * `scrollTo` can be missing independently (jsdom without a rAF polyfill, a
+   * partial DOM shim). `requestAnimationFrame` is invoked as a method on the
+   * global object rather than through a detached reference, since browsers
+   * reject a bare call with "Illegal invocation".
+   */
   handleScrollBehavior(to, from) {
-    if (this.options.scrollBehavior) {
-      const scrollTo = this.options.scrollBehavior(to, from, null);
-      if (scrollTo) {
-        requestAnimationFrame(() => {
-          window.scrollTo(scrollTo.x, scrollTo.y);
-        });
-      }
+    const scrollBehavior = this.options.scrollBehavior;
+    if (!scrollBehavior) return;
+    const g2 = globalThis;
+    if (typeof g2.requestAnimationFrame !== "function") return;
+    if (typeof window === "undefined" || typeof window.scrollTo !== "function") return;
+    let position;
+    try {
+      position = scrollBehavior(to, from, null);
+    } catch (error) {
+      if (typeof console !== "undefined") console.error("[router] scrollBehavior failed:", error);
+      return;
     }
+    if (!position) return;
+    const { x, y } = position;
+    g2.requestAnimationFrame(() => {
+      try {
+        window.scrollTo(x, y);
+      } catch (error) {
+        if (typeof console !== "undefined") console.error("[router] scroll failed:", error);
+      }
+    });
   }
   // Component loading
-  async loadComponent(route2, routePath) {
-    return this.loader.loadComponent(route2, routePath);
+  /**
+   * Resolve how this route's component will be produced, without instantiating
+   * anything. Pair with {@link instantiateComponent} at the commit boundary.
+   */
+  async loadPlan(route2, routePath) {
+    return this.loader.loadPlan(route2, routePath);
+  }
+  /** Create exactly one real instance from an already-resolved plan. */
+  async instantiateComponent(plan, route2, routePath) {
+    return this.loader.instantiate(plan, route2, routePath);
+  }
+  /** Resolve a route's module/factory without creating any component instance. */
+  async preloadPlan(route2, routePath) {
+    return this.loader.preloadPlan(route2, routePath);
   }
   // Guards API
   beforeEach(guard) {
@@ -2882,12 +3665,18 @@ var _SibuRouter = class _SibuRouter {
   get isReady() {
     return this.isReadyGetter();
   }
+  /** @internal Navigation generation — see `navEpoch`. Not a public API. */
+  get navigationEpoch() {
+    return this.navEpoch;
+  }
   get isNavigating() {
     return this.navigator.isNavigating;
   }
   // Cleanup
   destroy() {
-    this.navigator.abort();
+    this.destroyed = true;
+    this.navEpoch++;
+    this.navigator.abort(ABORT_ROUTER_DESTROYED);
     for (const fn of this.cleanup) fn();
     this.cleanup = [];
     this.guards.clear();
@@ -2930,10 +3719,11 @@ var _SibuRouter = class _SibuRouter {
 _SibuRouter.MAX_REDIRECT_DEPTH = 10;
 var SibuRouter = _SibuRouter;
 var NavigationFailureError = class extends Error {
-  constructor(type, from, to, error) {
-    super(`Navigation ${type}: from ${from.path} to ${to.path}`);
+  constructor(type, from, to, error, reason) {
+    super(`Navigation ${type}${reason ? ` (${reason})` : ""}: from ${from.path} to ${to.path}`);
     this.name = "NavigationFailureError";
     this.type = type;
+    this.reason = reason;
     this.from = from;
     this.to = to;
     if (error) {
@@ -2943,12 +3733,16 @@ var NavigationFailureError = class extends Error {
   toFailure() {
     return {
       type: this.type,
+      reason: this.reason,
       from: this.from,
       to: this.to,
       error: this.cause instanceof Error ? this.cause : void 0
     };
   }
 };
+function abortReasonOf(signal2) {
+  return signal2.reason === ABORT_ROUTER_DESTROYED ? "router-destroyed" : "superseded";
+}
 var ROUTER_KEY = /* @__PURE__ */ Symbol.for("sibujs.router.v1");
 var _routerRef = globalThis[ROUTER_KEY] ?? (globalThis[ROUTER_KEY] = { current: null });
 function normalizeRoutes(routes) {
@@ -3052,6 +3846,13 @@ function Route() {
   let errorNode = null;
   let navSeq = 0;
   let currentTopRoute = null;
+  let routeTorn = false;
+  const commitTarget = (seq) => routeTorn || seq !== navSeq ? null : anchor.parentNode;
+  const release = (node) => {
+    if (!node) return;
+    dispose(node);
+    node.parentNode?.removeChild(node);
+  };
   const cleanupNodes = () => {
     [currentNode, loadingNode, errorNode].forEach((node) => {
       if (!node) return;
@@ -3129,7 +3930,7 @@ function Route() {
     anchor.parentNode.insertBefore(errorNode, anchor.nextSibling);
   };
   const update = async () => {
-    if (!_routerRef.current) return;
+    if (routeTorn || !_routerRef.current) return;
     const seq = ++navSeq;
     const route2 = _routerRef.current.currentRoute;
     try {
@@ -3158,17 +3959,22 @@ function Route() {
           if (isAsync) {
             showLoading();
           }
-          const component = await _routerRef.current.loadComponent(routeDef, route2.path);
-          if (seq !== navSeq) return;
-          const node = component();
-          if (node && anchor.parentNode) {
+          const plan = await _routerRef.current.loadPlan(routeDef, route2.path);
+          if (!commitTarget(seq)) return;
+          const node = await _routerRef.current.instantiateComponent(plan, routeDef, route2.path);
+          const parent = commitTarget(seq);
+          if (!parent) {
+            release(node);
+            return;
+          }
+          if (node) {
             currentTopRoute = routeDef;
             cleanupNodes();
-            anchor.parentNode.insertBefore(node, anchor.nextSibling);
+            parent.insertBefore(node, anchor.nextSibling);
             currentNode = node;
           }
         } catch (error) {
-          if (seq !== navSeq) return;
+          if (routeTorn || seq !== navSeq) return;
           hideLoading();
           console.error("[Route] Component error:", error);
           showError(error instanceof Error ? error : new Error(String(error)), routeDef);
@@ -3176,6 +3982,7 @@ function Route() {
       }
     } catch (error) {
       if (seq !== navSeq) return;
+      if (routeTorn) return;
       console.error("[Route] Update failed:", error);
       showError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -3192,12 +3999,13 @@ function Route() {
       if (!routeInitialized && anchor.parentNode) wrappedUpdate();
     });
   }
-  let routeTorn = false;
   const routeCleanup = () => {
     if (routeTorn) return;
     routeTorn = true;
+    navSeq++;
     routeTeardown();
     cleanupNodes();
+    currentTopRoute = null;
   };
   registerDisposer(anchor, routeCleanup);
   routeCleanups.push(routeCleanup);
@@ -3215,16 +4023,14 @@ function KeepAliveRoute(options) {
   let currentNode = null;
   let currentKey = "";
   let currentCached = false;
-  let isUpdating = false;
-  let pendingUpdate = false;
+  let updateSeq = 0;
+  let kaTorn = false;
   const update = async () => {
-    if (!_routerRef.current) return;
-    if (isUpdating) {
-      pendingUpdate = true;
-      return;
-    }
-    const route2 = _routerRef.current.currentRoute;
-    const match = _routerRef.current["matcher"].match(route2.path);
+    if (kaTorn || !_routerRef.current) return;
+    const seq = ++updateSeq;
+    const router2 = _routerRef.current;
+    const route2 = router2.currentRoute;
+    const match = router2["matcher"].match(route2.path);
     if (!match) return;
     const { route: routeDef } = match;
     if ("redirect" in routeDef) {
@@ -3241,63 +4047,62 @@ function KeepAliveRoute(options) {
     const cacheKey = `${route2.path}${queryStr}${route2.hash ? `#${route2.hash}` : ""}`;
     const shouldCache = !includeNames || routeDef.name != null && includeNames.includes(routeDef.name);
     if (cacheKey === currentKey && currentNode) return;
-    isUpdating = true;
+    if (!anchor.parentNode) return;
+    let node = null;
+    let fromCache = false;
+    if (shouldCache && cache.has(cacheKey)) {
+      node = cache.get(cacheKey);
+      fromCache = true;
+    } else {
+      try {
+        const plan = await router2.loadPlan(routeDef, route2.path);
+        if (kaTorn || seq !== updateSeq) return;
+        node = await router2.instantiateComponent(plan, routeDef, route2.path);
+      } catch (error) {
+        if (kaTorn || seq !== updateSeq) return;
+        console.error("[KeepAliveRoute] Component error:", error);
+        return;
+      }
+      if (!node) return;
+      if (kaTorn || seq !== updateSeq) {
+        dispose(node);
+        return;
+      }
+    }
     const parent = anchor.parentNode;
     if (!parent) {
-      isUpdating = false;
+      if (!fromCache) dispose(node);
       return;
     }
-    try {
-      if (currentNode?.parentNode) {
-        parent.removeChild(currentNode);
-        if (!currentCached) {
-          dispose(currentNode);
-        }
-      }
-      if (shouldCache && cache.has(cacheKey)) {
-        currentNode = cache.get(cacheKey);
-        currentCached = true;
-        const idx = lruOrder.indexOf(cacheKey);
-        if (idx !== -1) {
-          lruOrder.splice(idx, 1);
-        }
-        lruOrder.push(cacheKey);
-      } else {
-        const component = await _routerRef.current.loadComponent(routeDef, route2.path);
-        const node = component();
-        if (!node || route2.path !== _routerRef.current.currentRoute.path) {
-          isUpdating = false;
-          return;
+    if (currentNode && currentNode !== node) {
+      if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
+      if (!currentCached) dispose(currentNode);
+    }
+    if (fromCache) {
+      const idx = lruOrder.indexOf(cacheKey);
+      if (idx !== -1) lruOrder.splice(idx, 1);
+      lruOrder.push(cacheKey);
+    } else if (shouldCache) {
+      cache.set(cacheKey, node);
+      lruOrder.push(cacheKey);
+      while (lruOrder.length > maxCache) {
+        const evictKey = lruOrder.shift();
+        if (evictKey === cacheKey) {
+          lruOrder.push(evictKey);
+          break;
         }
-        currentNode = node;
-        currentCached = shouldCache;
-        if (shouldCache) {
-          cache.set(cacheKey, node);
-          lruOrder.push(cacheKey);
-          while (lruOrder.length > maxCache) {
-            const evictKey = lruOrder.shift();
-            const evictNode = cache.get(evictKey);
-            if (evictNode) {
-              dispose(evictNode);
-              if (evictNode.parentNode) evictNode.parentNode.removeChild(evictNode);
-              cache.delete(evictKey);
-            }
-          }
+        const evictNode = cache.get(evictKey);
+        if (evictNode) {
+          dispose(evictNode);
+          if (evictNode.parentNode) evictNode.parentNode.removeChild(evictNode);
+          cache.delete(evictKey);
         }
       }
-      currentKey = cacheKey;
-      if (currentNode) {
-        parent.insertBefore(currentNode, anchor.nextSibling);
-      }
-    } catch (error) {
-      console.error("[KeepAliveRoute] Component error:", error);
-    } finally {
-      isUpdating = false;
-      if (pendingUpdate) {
-        pendingUpdate = false;
-        update();
-      }
     }
+    currentNode = node;
+    currentCached = fromCache || shouldCache;
+    currentKey = cacheKey;
+    parent.insertBefore(node, anchor.nextSibling);
   };
   let initialized = false;
   const wrappedUpdate = async () => {
@@ -3310,10 +4115,10 @@ function KeepAliveRoute(options) {
       if (!initialized && anchor.parentNode) wrappedUpdate();
     });
   }
-  let kaTorn = false;
   const kaCleanup = () => {
     if (kaTorn) return;
     kaTorn = true;
+    updateSeq++;
     kaTeardown();
     for (const node of cache.values()) {
       dispose(node);
@@ -3322,7 +4127,10 @@ function KeepAliveRoute(options) {
     cache.clear();
     lruOrder.length = 0;
     if (currentNode?.parentNode) currentNode.parentNode.removeChild(currentNode);
+    if (currentNode && !currentCached) dispose(currentNode);
     currentNode = null;
+    currentKey = "";
+    currentCached = false;
   };
   registerDisposer(anchor, kaCleanup);
   routeCleanups.push(kaCleanup);
@@ -3335,8 +4143,12 @@ function RouterLink(props, children) {
   const baseClass = typeof classAttr === "string" ? classAttr : "";
   const routeGetter = _routerRef.current.routeGetter;
   const rawHref = _routerRef.current["resolvePath"](to);
-  const href = isSafeNavigationTarget(rawHref) ? rawHref : "#";
-  const hrefPath = href.split("?")[0].split("#")[0];
+  const kind = classifyNavigationTarget(rawHref);
+  const href = kind === "unsafe" ? "#" : rawHref;
+  const [hrefBeforeHash, hrefHash = ""] = href.split("#");
+  const [hrefPathRaw, hrefQueryRaw = ""] = hrefBeforeHash.split("?");
+  const targetPath = normalizePathname(hrefPathRaw);
+  const targetQuery = normalizeQuery(hrefQueryRaw);
   const link2 = document.createElement("a");
   link2.href = href;
   if (target) {
@@ -3352,8 +4164,9 @@ function RouterLink(props, children) {
   const options = _routerRef.current["options"];
   const effectCleanup = effect(() => {
     const route2 = routeGetter();
-    const isActive = route2.path.startsWith(hrefPath);
-    const isExactActive = route2.path === hrefPath;
+    const currentPath = normalizePathname(route2.path);
+    const isActive = kind === "internal" && isPathnameAncestor(targetPath, currentPath);
+    const isExactActive = kind === "internal" && currentPath === targetPath && normalizeQuery(route2.query) === targetQuery && route2.hash === hrefHash;
     const classes = [];
     if (isActive) {
       if (activeClass) classes.push(activeClass);
@@ -3375,7 +4188,7 @@ function RouterLink(props, children) {
         const safe = sanitizeUrl(str);
         if (safe) link2.setAttribute(key, safe);
       } else if (lkey === "style") {
-        link2.setAttribute(key, sanitizeCSSValue(str));
+        link2.setAttribute(key, sanitizeStyleAttribute(str));
       } else {
         link2.setAttribute(key, str);
       }
@@ -3395,10 +4208,13 @@ function RouterLink(props, children) {
     });
   }
   const onLinkClick = (e) => {
-    if (target || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) {
+    if (e.defaultPrevented || target || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) {
       return;
     }
+    if (link2.hasAttribute("download")) return;
+    if (kind === "external") return;
     e.preventDefault();
+    if (kind === "unsafe") return;
     _routerRef.current?.navigate(to, { replace: replace2 }).catch((err) => {
       if (typeof console !== "undefined") console.error("[router] link navigate failed:", err);
     });
@@ -3414,68 +4230,80 @@ function Suspense(props) {
   let currentNode = null;
   let fallbackNode = null;
   let isLoading = false;
+  let generation = 0;
+  let tornDown = false;
+  const release = (node) => {
+    if (!node) return;
+    dispose(node);
+    node.parentNode?.removeChild(node);
+  };
+  const commitTarget = (myGeneration) => tornDown || myGeneration !== generation ? null : anchor.parentNode;
   const cleanupNodes = () => {
-    [currentNode, fallbackNode].forEach((node) => {
-      if (node?.parentNode) {
-        node.parentNode.removeChild(node);
-      }
-    });
+    release(currentNode);
+    release(fallbackNode);
     currentNode = null;
     fallbackNode = null;
   };
-  const showFallback = () => {
-    if (fallbackNode || !props.fallback || !anchor.parentNode) return;
+  const showFallback = (myGeneration) => {
+    if (fallbackNode || !props.fallback || tornDown) return;
+    if (!anchor.parentNode) return;
+    let fallback;
     try {
-      const fallback = typeof props.fallback === "function" ? props.fallback() : props.fallback;
-      if (fallback instanceof HTMLElement) {
-        fallbackNode = fallback;
-        anchor.parentNode.insertBefore(fallbackNode, anchor.nextSibling);
-      }
+      fallback = typeof props.fallback === "function" ? props.fallback() : props.fallback;
     } catch (error) {
       console.error("[Suspense] Fallback error:", error);
+      return;
     }
-  };
-  const hideFallback = () => {
-    if (fallbackNode?.parentNode) {
-      fallbackNode.parentNode.removeChild(fallbackNode);
-      fallbackNode = null;
+    if (!(fallback instanceof HTMLElement)) return;
+    const parent = commitTarget(myGeneration);
+    if (!parent) {
+      release(fallback);
+      return;
     }
+    fallbackNode = fallback;
+    parent.insertBefore(fallbackNode, anchor.nextSibling);
   };
   const render = async () => {
-    if (isLoading) return;
+    if (tornDown || isLoading) return;
     isLoading = true;
+    const myGeneration = ++generation;
     try {
       const result = props.nodes();
+      let element;
       if (result instanceof Promise) {
-        showFallback();
-        const element = await result;
-        if (anchor.parentNode) {
-          cleanupNodes();
-          anchor.parentNode.insertBefore(element, anchor.nextSibling);
-          currentNode = element;
-        }
+        showFallback(myGeneration);
+        element = await result;
       } else {
-        if (anchor.parentNode) {
-          cleanupNodes();
-          anchor.parentNode.insertBefore(result, anchor.nextSibling);
-          currentNode = result;
-        }
+        element = result;
       }
-    } catch (error) {
-      hideFallback();
-      console.error("[Suspense] Nodes error:", error);
-      if (anchor.parentNode) {
-        const errorElement = document.createElement("div");
-        errorElement.className = "suspense-error";
-        errorElement.textContent = error instanceof Error ? error.message : "Failed to load";
+      const parent = commitTarget(myGeneration);
+      if (!parent) {
+        release(element);
         cleanupNodes();
-        anchor.parentNode.insertBefore(errorElement, anchor.nextSibling);
-        currentNode = errorElement;
+        return;
       }
+      cleanupNodes();
+      parent.insertBefore(element, anchor.nextSibling);
+      currentNode = element;
+    } catch (error) {
+      console.error("[Suspense] Nodes error:", error);
+      const parent = commitTarget(myGeneration);
+      cleanupNodes();
+      if (!parent) return;
+      const errorElement = document.createElement("div");
+      errorElement.className = "suspense-error";
+      errorElement.textContent = error instanceof Error ? error.message : "Failed to load";
+      parent.insertBefore(errorElement, anchor.nextSibling);
+      currentNode = errorElement;
     } finally {
       isLoading = false;
     }
   };
+  registerDisposer(anchor, () => {
+    tornDown = true;
+    generation++;
+    cleanupNodes();
+  });
   queueMicrotask(render);
   return anchor;
 }
@@ -3490,12 +4318,15 @@ async function preloadRoute(to) {
   const match = _routerRef.current["matcher"].match(path2.split("?")[0].split("#")[0]);
   if (match && "component" in match.route) {
     try {
-      await _routerRef.current.loadComponent(match.route, path2);
+      await _routerRef.current.preloadPlan(match.route, path2);
     } catch (error) {
       console.warn("[Router] Preload failed:", error);
     }
   }
 }
+function __getNavigationEpoch() {
+  return _routerRef.current?.navigationEpoch ?? -1;
+}
 function hasRoute(name) {
   if (!_routerRef.current) return false;
   return _routerRef.current["matcher"].findByName(name) !== null;
@@ -3537,6 +4368,7 @@ function Outlet() {
   let currentNode = null;
   let currentChild = null;
   let navSeq = 0;
+  let outletTorn = false;
   const clearCurrent = () => {
     if (currentNode) {
       dispose(currentNode);
@@ -3545,8 +4377,14 @@ function Outlet() {
     }
     currentChild = null;
   };
+  const commitTarget = (seq) => outletTorn || seq !== navSeq ? null : anchor.parentNode;
+  const release = (node) => {
+    if (!node) return;
+    dispose(node);
+    node.parentNode?.removeChild(node);
+  };
   const update = async () => {
-    if (!_routerRef.current) return;
+    if (outletTorn || !_routerRef.current) return;
     const seq = ++navSeq;
     const route2 = _routerRef.current.currentRoute;
     if (route2.matched.length < 2) {
@@ -3561,17 +4399,21 @@ function Outlet() {
     if (childRoute === currentChild && currentNode) return;
     try {
       const cacheKey = `${route2.path}\0${childRoute.path}`;
-      const component = await _routerRef.current.loadComponent(childRoute, cacheKey);
-      if (seq !== navSeq) return;
-      const node = component();
-      if (node && anchor.parentNode) {
-        clearCurrent();
-        anchor.parentNode.insertBefore(node, anchor.nextSibling);
-        currentNode = node;
-        currentChild = childRoute;
+      const plan = await _routerRef.current.loadPlan(childRoute, cacheKey);
+      if (!commitTarget(seq)) return;
+      const node = await _routerRef.current.instantiateComponent(plan, childRoute, cacheKey);
+      const parent = commitTarget(seq);
+      if (!parent) {
+        release(node);
+        return;
       }
+      if (!node) return;
+      clearCurrent();
+      parent.insertBefore(node, anchor.nextSibling);
+      currentNode = node;
+      currentChild = childRoute;
     } catch (error) {
-      if (seq !== navSeq) return;
+      if (outletTorn || seq !== navSeq) return;
       console.error("[Outlet] Failed to render child route:", error);
     }
   };
@@ -3581,16 +4423,17 @@ function Outlet() {
       if (anchor.parentNode) update();
     });
   }
-  let outletTorn = false;
   const outletCleanup = () => {
     if (outletTorn) return;
     outletTorn = true;
+    navSeq++;
     outletTeardown();
     if (currentNode) {
       dispose(currentNode);
       if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
       currentNode = null;
     }
+    currentChild = null;
   };
   registerDisposer(anchor, outletCleanup);
   routeCleanups.push(outletCleanup);
@@ -3661,6 +4504,8 @@ function isUnsafeKey(key) {
 }
 
 // src/plugins/routerSSR.ts
+init_headEntry();
+init_sanitize();
 function safeDecode(raw) {
   try {
     return decodeURIComponent(raw);
@@ -3858,22 +4703,16 @@ function renderRouteToString(url, routes, _options) {
   };
 }
 function renderRouteToDocument(url, routes, options) {
-  const { html: html2, state } = renderRouteToString(url, routes, options);
+  const { html: html2, state: state2 } = renderRouteToString(url, routes, options);
   const opts = options || {};
-  const metaTags = (opts.meta || []).filter((attrs) => !isDangerousMetaRefresh(attrs)).map((attrs) => {
-    const pairs = buildSafeAttrString(attrs);
-    return pairs ? `<meta ${pairs} />` : "";
-  }).filter(Boolean).join("\n    ");
-  const linkTags = (opts.links || []).map((attrs) => {
-    const pairs = buildSafeAttrString(attrs);
-    return pairs ? `<link ${pairs} />` : "";
-  }).filter(Boolean).join("\n    ");
+  const metaTags = (opts.meta || []).map((attrs) => serializeHeadEntry("meta", attrs)).filter(Boolean).join("\n    ");
+  const linkTags = (opts.links || []).map((attrs) => serializeHeadEntry("link", attrs)).filter(Boolean).join("\n    ");
   const scriptTags = (opts.scripts || []).map((src) => {
-    const safe = sanitizeUrlLocal(String(src));
+    const safe = sanitizeUrl(String(src));
     if (!safe) return "";
     return `<script src="${escapeAttrLocal(safe)}"></script>`;
   }).filter(Boolean).join("\n    ");
-  const stateScript = serializeRouteState(state, opts.nonce);
+  const stateScript = serializeRouteState(state2, opts.nonce);
   return `<!DOCTYPE html>
 <html>
   <head>
@@ -3891,8 +4730,8 @@ function renderRouteToDocument(url, routes, options) {
   </body>
 </html>`;
 }
-function serializeRouteState(state, nonce) {
-  const json = escapeScriptJson(JSON.stringify(state));
+function serializeRouteState(state2, nonce) {
+  const json = escapeScriptJson(JSON.stringify(state2));
   const nonceAttr = nonce ? ` nonce="${escapeAttrLocal(nonce)}"` : "";
   return `<script${nonceAttr}>window.${SSR_ROUTE_STATE_KEY}=${json}</script>`;
 }
@@ -3908,20 +4747,23 @@ function hydrateRouter(routes, options) {
   }
   createRouter(routes);
   const container = options?.container || document.getElementById("app");
-  if (container && serverState.path) {
-    const resolved = resolveServerRoute(serverState.path, routes);
+  if (!container) return;
+  const liveUrl = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+  const resolved = resolveServerRoute(liveUrl, routes);
+  const bootstrapEpoch = __getNavigationEpoch();
+  Promise.resolve().then(() => (init_ssr(), ssr_exports)).then(async ({ hydrate: hydrate2 }) => {
+    const { replaceChildrenSafely: replaceChildrenSafely2 } = await Promise.resolve().then(() => (init_dispose(), dispose_exports));
+    if (__getNavigationEpoch() !== bootstrapEpoch) return;
     if (resolved.component) {
-      Promise.resolve().then(() => (init_ssr(), ssr_exports)).then(({ hydrate: hydrate2 }) => {
-        if (resolved.component) {
-          hydrate2(resolved.component, container);
-        }
-      }).catch((err) => {
-        if (typeof console !== "undefined") {
-          console.error("[SibuJS routerSSR] failed to load hydrate:", err);
-        }
-      });
+      hydrate2(resolved.component, container);
+      return;
     }
-  }
+    replaceChildrenSafely2(container);
+  }).catch((err) => {
+    if (typeof console !== "undefined") {
+      console.error("[SibuJS routerSSR] failed to load hydrate:", err);
+    }
+  });
 }
 function createSSRRouter(routes) {
   return {
@@ -3936,54 +4778,6 @@ function createSSRRouter(routes) {
     }
   };
 }
-var SAFE_ATTR_NAME2 = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-function isSafeAttrName2(name) {
-  return SAFE_ATTR_NAME2.test(name);
-}
-function isEventHandlerAttr2(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
-var URL_ATTRS2 = /* @__PURE__ */ new Set([
-  "href",
-  "src",
-  "action",
-  "formaction",
-  "cite",
-  "poster",
-  "background",
-  "srcset",
-  "ping",
-  "manifest",
-  "data",
-  "xlink:href"
-]);
-function sanitizeUrlLocal(url) {
-  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
-  if (!trimmed) return "";
-  const lower = trimmed.toLowerCase();
-  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
-    return "";
-  }
-  return trimmed;
-}
-function buildSafeAttrString(attrs) {
-  const out = [];
-  for (const rawKey of Object.keys(attrs)) {
-    if (!Object.hasOwn(attrs, rawKey)) continue;
-    if (!isSafeAttrName2(rawKey)) continue;
-    if (isEventHandlerAttr2(rawKey)) continue;
-    const lowerKey = rawKey.toLowerCase();
-    let value = String(attrs[rawKey]);
-    if (URL_ATTRS2.has(lowerKey)) {
-      value = sanitizeUrlLocal(value);
-      if (!value) continue;
-    }
-    out.push(`${rawKey}="${escapeAttrLocal(value)}"`);
-  }
-  return out.join(" ");
-}
 function escapeHtmlLocal(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -4816,6 +5610,7 @@ function createBootSequence() {
   Suspense,
   Trans,
   VERSION,
+  __getNavigationEpoch,
   __removeRouterPagehideHandler,
   addRoute,
   afterEach,