sibujs 3.4.0 → 4.0.0

package/dist/plugins.js

@@ -18,7 +18,7 @@ import {
   preloadCritical,
   prerenderRoutes,
   satisfies
-} from "./chunk-F7HW2NI5.js";
+} from "./chunk-AW6HPJ3L.js";
 import {
   isUnsafeKey
 } from "./chunk-H3SRKIYX.js";
@@ -35,78 +35,126 @@ import {
 } from "./chunk-WWV3SJ3L.js";
 import {
   span
-} from "./chunk-3Z2NGWQI.js";
+} from "./chunk-ES2GERY2.js";
 import {
   escapeScriptJson,
-  isDangerousMetaRefresh,
-  renderToString
-} from "./chunk-EX77FXTT.js";
-import "./chunk-JNGGM2XE.js";
-import "./chunk-K35BAR4P.js";
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
+  renderToString,
+  serializeHeadEntry
+} from "./chunk-HYCCIYNS.js";
+import "./chunk-DQVUBVNX.js";
+import "./chunk-4MFZMLUU.js";
 import {
   isUrlAttribute,
-  sanitizeCSSValue,
+  sanitizeStyleAttribute,
   sanitizeUrl,
   stripControlChars
-} from "./chunk-L3GAGWCC.js";
+} from "./chunk-5INI7D2L.js";
+import {
+  globalSingleton
+} from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-BUKYCWHX.js";
-import "./chunk-S3NFJO6L.js";
+} from "./chunk-PBQEW5VW.js";
+import {
+  getRequestStore
+} from "./chunk-TIRZCERI.js";
 import {
   dispose,
   registerDisposer
-} from "./chunk-5VGSK6D2.js";
+} from "./chunk-DHDZ7IVN.js";
 import {
   signal
-} from "./chunk-KZBEVFXZ.js";
+} from "./chunk-W55YHPEP.js";
 import {
   track
-} from "./chunk-OOUQUCNN.js";
-import "./chunk-COY6PUD2.js";
+} from "./chunk-ACBT6UZS.js";
+import {
+  devWarn,
+  isDev
+} from "./chunk-VPP2FONR.js";
 
 // 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, (_, p) => String(params[p] ?? "")) : 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
-function isSafeNavigationTarget(path) {
-  if (path === "") return true;
+function classifyNavigationTarget(path) {
+  if (path === "") return "internal";
   const normalized = stripControlChars(path).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(path) {
+  return classifyNavigationTarget(path) === "internal";
+}
+function normalizePathname(path) {
+  if (!path) return "/";
+  const trimmed = path.length > 1 ? path.replace(/\/+$/, "") : path;
+  return trimmed || "/";
 }
+function normalizeQuery(query) {
+  const params = new URLSearchParams(query);
+  return [...params.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 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();
@@ -167,9 +215,9 @@ var NavigationController = class {
       }
     }
   }
-  abort() {
+  abort(reason) {
     if (this.currentController) {
-      this.currentController.abort();
+      this.currentController.abort(reason);
       this.currentController = null;
     }
   }
@@ -355,6 +403,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);
@@ -363,6 +412,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);
@@ -459,13 +509,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) {
@@ -476,91 +529,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;
@@ -569,6 +764,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: "",
@@ -606,7 +812,9 @@ var _SibuRouter = class _SibuRouter {
       }
     }
     queueMicrotask(() => {
-      this.handleLocationChange(true);
+      if (!this.navigator.isNavigating) {
+        this.handleLocationChange(true, true);
+      }
       this.isReadySetter(true);
     });
   }
@@ -620,14 +828,15 @@ var _SibuRouter = class _SibuRouter {
       matched: []
     };
   }
-  handleLocationChange(skipHistory = true) {
+  handleLocationChange(skipHistory = true, initialResolution = false) {
     const path = this.getCurrentPath();
-    this.navigate(path, { replace: true, skipHistory }).catch((err) => {
+    this.navigate(path, { replace: true, skipHistory, initialResolution }).catch((err) => {
       console.error("[Router] Error during location change navigation:", err);
     });
   }
   getCurrentPath() {
     const { mode, base } = this.options;
+    if (typeof window === "undefined") return "/";
     if (mode === "hash") {
       return window.location.hash.slice(1) || "/";
     }
@@ -659,15 +868,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);
       });
@@ -675,30 +884,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((p) => `"${p}"`).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) {
@@ -709,47 +931,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);
+          throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
         }
-        if (typeof redirectPath === "string" && !isSafeNavigationTarget(redirectPath)) {
-          throw new NavigationFailureError("aborted", from, to);
-        }
-        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);
@@ -777,29 +1012,76 @@ var _SibuRouter = class _SibuRouter {
     return path;
   }
   isSameRoute(from, to) {
+    if (from.matched.length === 0 && to.matched.length > 0) return false;
     return from.path === to.path && JSON.stringify(from.params) === JSON.stringify(to.params) && JSON.stringify(from.query) === JSON.stringify(to.query) && from.hash === to.hash;
   }
   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 g = globalThis;
+    if (typeof g.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;
+    g.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) {
@@ -834,12 +1116,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();
@@ -882,10 +1170,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) {
@@ -895,12 +1184,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) {
@@ -1004,6 +1297,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;
@@ -1081,7 +1381,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 {
@@ -1110,17 +1410,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);
@@ -1128,6 +1433,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)));
     }
@@ -1144,12 +1450,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);
@@ -1167,16 +1474,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) {
@@ -1193,63 +1498,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 () => {
@@ -1262,10 +1566,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);
@@ -1274,7 +1578,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);
@@ -1287,8 +1594,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 link = document.createElement("a");
   link.href = href;
   if (target) {
@@ -1304,8 +1615,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);
@@ -1327,7 +1639,7 @@ function RouterLink(props, children) {
         const safe = sanitizeUrl(str);
         if (safe) link.setAttribute(key, safe);
       } else if (lkey === "style") {
-        link.setAttribute(key, sanitizeCSSValue(str));
+        link.setAttribute(key, sanitizeStyleAttribute(str));
       } else {
         link.setAttribute(key, str);
       }
@@ -1347,10 +1659,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 (link.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);
     });
@@ -1366,68 +1681,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;
 }
@@ -1442,12 +1769,15 @@ async function preloadRoute(to) {
   const match = _routerRef.current["matcher"].match(path.split("?")[0].split("#")[0]);
   if (match && "component" in match.route) {
     try {
-      await _routerRef.current.loadComponent(match.route, path);
+      await _routerRef.current.preloadPlan(match.route, path);
     } 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;
@@ -1489,6 +1819,7 @@ function Outlet() {
   let currentNode = null;
   let currentChild = null;
   let navSeq = 0;
+  let outletTorn = false;
   const clearCurrent = () => {
     if (currentNode) {
       dispose(currentNode);
@@ -1497,8 +1828,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) {
@@ -1513,17 +1850,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);
     }
   };
@@ -1533,16 +1874,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);
@@ -1803,16 +2145,10 @@ function renderRouteToString(url, routes, _options) {
 function renderRouteToDocument(url, routes, options) {
   const { html, state } = 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    ");
@@ -1851,20 +2187,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();
+  import("./ssr-JFP5535P.js").then(async ({ hydrate }) => {
+    const { replaceChildrenSafely } = await import("./dispose-4FZ6OFXR.js");
+    if (__getNavigationEpoch() !== bootstrapEpoch) return;
     if (resolved.component) {
-      import("./ssr-2PPULEK2.js").then(({ hydrate }) => {
-        if (resolved.component) {
-          hydrate(resolved.component, container);
-        }
-      }).catch((err) => {
-        if (typeof console !== "undefined") {
-          console.error("[SibuJS routerSSR] failed to load hydrate:", err);
-        }
-      });
+      hydrate(resolved.component, container);
+      return;
     }
-  }
+    replaceChildrenSafely(container);
+  }).catch((err) => {
+    if (typeof console !== "undefined") {
+      console.error("[SibuJS routerSSR] failed to load hydrate:", err);
+    }
+  });
 }
 function createSSRRouter(routes) {
   return {
@@ -1879,54 +2218,6 @@ function createSSRRouter(routes) {
     }
   };
 }
-var SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-function isSafeAttrName(name) {
-  return SAFE_ATTR_NAME.test(name);
-}
-function isEventHandlerAttr(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
-var URL_ATTRS = /* @__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 (!isSafeAttrName(rawKey)) continue;
-    if (isEventHandlerAttr(rawKey)) continue;
-    const lowerKey = rawKey.toLowerCase();
-    let value = String(attrs[rawKey]);
-    if (URL_ATTRS.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;");
 }
@@ -1942,6 +2233,7 @@ export {
   Suspense,
   Trans,
   VERSION,
+  __getNavigationEpoch,
   __removeRouterPagehideHandler,
   addRoute,
   afterEach,