sibujs 4.13.0 → 4.14.0

package/dist/plugins.js

@@ -1,6 +1,44 @@
 import {
-  prerenderWait
-} from "./chunk-B36ADEIR.js";
+  KeepAliveRoute,
+  Outlet,
+  Route,
+  RouterLink,
+  SibuRouter,
+  Suspense,
+  __getNavigationEpoch,
+  __removeRouterPagehideHandler,
+  addRoute,
+  afterEach,
+  back,
+  beforeEach,
+  beforeResolve,
+  buildURL,
+  createMemoryRouter,
+  createRouter,
+  destroyRouter,
+  forward,
+  getRouteInfo,
+  getRouteTransition,
+  go,
+  hasRoute,
+  jsonLdScript,
+  lazy,
+  navigate,
+  preloadRoute,
+  push,
+  removeRoute,
+  replace,
+  resolveRouteHead,
+  route,
+  routeHeadToHTML,
+  router,
+  routerPlugin,
+  routerReady,
+  routerState,
+  serializeJsonLd,
+  setRouteTransition,
+  setRoutes
+} from "./chunk-VM2U5LEL.js";
 import {
   MigrationStorageError,
   VERSION,
@@ -22,10 +60,8 @@ import {
   preloadCritical,
   prerenderRoutes,
   satisfies
-} from "./chunk-IV74C2YX.js";
-import {
-  acquireTitle
-} from "./chunk-52XFPGSN.js";
+} from "./chunk-4TQDTWWN.js";
+import "./chunk-52XFPGSN.js";
 import {
   PluginInstallCancelledError,
   createPlugin,
@@ -38,61 +74,43 @@ import {
   triggerPluginError,
   triggerPluginMount,
   triggerPluginUnmount
-} from "./chunk-J6FW5TV6.js";
+} from "./chunk-3HEX6QJQ.js";
 import {
   span
-} from "./chunk-L3QHS4O4.js";
+} from "./chunk-7ILEHTVX.js";
 import {
-  STATIC_VALUE_RESOLVER,
   escapeScriptJson,
-  planHeadElementEntry,
-  planMetaEntry,
   renderToString,
   serializeHeadEntry
-} from "./chunk-2F4PSJ5Z.js";
-import "./chunk-AM6DZLBM.js";
+} from "./chunk-BOYKGGVD.js";
+import "./chunk-CNPT6NKV.js";
+import "./chunk-LJMX4SQ7.js";
+import "./chunk-3HZOSMPX.js";
 import {
   isUnsafeKey,
   readOwnGlobal
 } from "./chunk-62BDYGAG.js";
-import {
-  appendChildren,
-  resolveClassValue
-} from "./chunk-346BYZL2.js";
-import {
-  setSafeAttribute
-} from "./chunk-HDKDBC6V.js";
-import "./chunk-F2UWOZ6J.js";
+import "./chunk-CJ7KS3DF.js";
+import "./chunk-HQIAL7F2.js";
+import "./chunk-RVWJGWCL.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
+import "./chunk-AE32RGWX.js";
 import {
-  effect
-} from "./chunk-BRRRVLHQ.js";
-import {
-  sanitizeUrl,
-  stripControlChars
-} from "./chunk-EXXSN3BW.js";
+  sanitizeUrl
+} from "./chunk-B3HOT4TK.js";
 import {
   getRequestStore
-} from "./chunk-7XHATCIH.js";
+} from "./chunk-UYTYNCMZ.js";
 import "./chunk-5HZXGZ6T.js";
 import {
   signal
-} from "./chunk-GNSRXK34.js";
-import {
-  bindOwnerScope,
-  getOwnerScope,
-  runWithOwnerScope,
-  track,
-  untracked
-} from "./chunk-HVVRXRGO.js";
-import {
-  devWarn,
-  dispose,
-  isDev,
-  registerDisposer
-} from "./chunk-NYNYSPK7.js";
+} from "./chunk-4FJSAUKB.js";
+import "./chunk-MIRKTVH4.js";
+import "./chunk-S37PZD6I.js";
+import "./chunk-NT3ZYB5S.js";
+import "./chunk-R5U7XKVJ.js";
 
 // src/plugins/i18n.ts
 var _i18n = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.i18n.v1"), () => ({
@@ -167,2291 +185,6 @@ function getAvailableLocales() {
   return Object.keys(locales);
 }
 
-// src/plugins/routeHead.ts
-var OG_FIELDS = [
-  ["title", "og:title"],
-  ["description", "og:description"],
-  ["image", "og:image"],
-  ["url", "og:url"],
-  ["type", "og:type"],
-  ["siteName", "og:site_name"]
-];
-var OG_URL_PROPERTIES = /* @__PURE__ */ new Set(["og:image", "og:url"]);
-var ROUTE_HEAD_ATTR = "data-sibu-head";
-var BASE_TITLE_ATTR = "data-sibu-base-title";
-function routeHasHead(matched, defaults) {
-  if (defaults) return true;
-  for (const record of matched) if (record.head) return true;
-  return false;
-}
-function resolveValue(value, route2) {
-  if (value == null) return null;
-  const v = typeof value === "function" ? value(route2) : value;
-  return v == null ? null : String(v);
-}
-function mergeHeads(route2, defaults) {
-  const layers = [];
-  if (defaults) layers.push(defaults);
-  for (const record of route2.matched) {
-    const head = record.head;
-    if (head) layers.push(head);
-  }
-  const merged = {};
-  const og = {};
-  const meta = /* @__PURE__ */ new Map();
-  for (const layer of layers) {
-    if (layer.title !== void 0) merged.title = layer.title;
-    if (layer.description !== void 0) merged.description = layer.description;
-    if (layer.canonical !== void 0) merged.canonical = layer.canonical;
-    if (layer.og) {
-      for (const [field] of OG_FIELDS) if (layer.og[field] !== void 0) og[field] = layer.og[field];
-    }
-    for (const entry of layer.meta ?? []) {
-      const id = metaIdentity(entry);
-      if (id) meta.set(id, entry);
-    }
-  }
-  merged.og = og;
-  merged.meta = Array.from(meta.values());
-  return merged;
-}
-function metaIdentity(entry) {
-  const name = typeof entry.name === "string" ? entry.name : null;
-  if (name) return `name:${name.toLowerCase()}`;
-  const property = typeof entry.property === "string" ? entry.property : null;
-  if (property) return `property:${property.toLowerCase()}`;
-  return null;
-}
-function applyTemplate(title, template) {
-  if (!template) return title;
-  return typeof template === "function" ? template(title) : template.replace("%s", title);
-}
-function resolveRouteHead(route2, defaults) {
-  const merged = mergeHeads(route2, defaults);
-  const ownTitle = resolveValue(merged.title, route2);
-  const routeSetTitle = route2.matched.some((r) => r.head?.title != null);
-  const title = ownTitle === null ? null : routeSetTitle ? applyTemplate(ownTitle, defaults?.titleTemplate) : ownTitle;
-  const description = resolveValue(merged.description, route2);
-  const canonical = resolveValue(merged.canonical, route2);
-  const tags = [];
-  const push2 = (key, tag, attrs) => {
-    const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
-    if (plan.kind === "drop") return;
-    tags.push({ key, tag, attrs: Object.fromEntries(plan.attributes) });
-  };
-  if (description !== null) push2("meta:name:description", "meta", { name: "description", content: description });
-  if (canonical !== null) push2("link:rel:canonical", "link", { rel: "canonical", href: canonical });
-  const og = merged.og ?? {};
-  for (const [field, property] of OG_FIELDS) {
-    let value = og[field] === void 0 ? void 0 : resolveValue(og[field], route2);
-    if (value === void 0) {
-      if (field === "title") value = ownTitle;
-      else if (field === "description") value = description;
-      else if (field === "url") value = canonical;
-      else value = null;
-    }
-    if (value === null) continue;
-    if (OG_URL_PROPERTIES.has(property)) {
-      value = sanitizeUrl(value);
-      if (value === "") continue;
-    }
-    push2(`meta:property:${property}`, "meta", { property, content: value });
-  }
-  for (const entry of merged.meta ?? []) {
-    const id = metaIdentity(entry);
-    if (!id) continue;
-    const attrs = {};
-    for (const [name, v] of Object.entries(entry)) {
-      const resolved = resolveValue(v, route2);
-      if (resolved !== null) attrs[name] = resolved;
-    }
-    push2(`meta:${id}`, "meta", attrs);
-  }
-  return { title, tags };
-}
-function escapeText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function routeHeadToHTML(head) {
-  const parts = [];
-  if (head.title !== null) parts.push(`<title>${escapeText(head.title)}</title>`);
-  for (const t2 of head.tags) {
-    const html = serializeHeadEntry(t2.tag, t2.attrs);
-    if (html) parts.push(html.replace(/ \/>$/, ` ${ROUTE_HEAD_ATTR}="" />`));
-  }
-  return parts.join("\n");
-}
-function selectorFor(key) {
-  const [tag, attr, ...rest] = key.split(":");
-  const value = rest.join(":").replace(/["\\]/g, "\\$&");
-  return `${tag}[${attr}="${value}" i]`;
-}
-function createRouteHeadController(defaults) {
-  const [current, setCurrent] = signal(null);
-  const owned = /* @__PURE__ */ new Map();
-  const initial = new Set(Array.from(document.head.children));
-  const titleEl = document.head.querySelector("title");
-  const baseTitle = titleEl?.getAttribute(BASE_TITLE_ATTR) ?? document.title;
-  let titleLease = null;
-  let firstApply = true;
-  const publish = (tag) => {
-    const existing = owned.get(tag.key);
-    if (existing && sameAttrs(existing, tag.attrs)) return;
-    if (!existing) {
-      for (const el of Array.from(document.head.querySelectorAll(selectorFor(tag.key)))) {
-        if (initial.has(el)) {
-          el.remove();
-          initial.delete(el);
-        }
-      }
-    }
-    const next = document.createElement(tag.tag);
-    for (const [name, value] of Object.entries(tag.attrs)) next.setAttribute(name, value);
-    next.setAttribute(ROUTE_HEAD_ATTR, "");
-    if (existing?.parentNode) existing.replaceWith(next);
-    else document.head.appendChild(next);
-    owned.set(tag.key, next);
-  };
-  const apply = (head) => {
-    if (firstApply) {
-      firstApply = false;
-      for (const el of Array.from(document.head.querySelectorAll(`[${ROUTE_HEAD_ATTR}]`))) {
-        if (initial.has(el) && !head.tags.some((t2) => el.matches(selectorFor(t2.key)))) {
-          el.remove();
-          initial.delete(el);
-        }
-      }
-    }
-    const keep = /* @__PURE__ */ new Set();
-    for (const tag of head.tags) {
-      keep.add(tag.key);
-      publish(tag);
-    }
-    for (const [key, el] of owned) {
-      if (keep.has(key)) continue;
-      el.remove();
-      owned.delete(key);
-    }
-    const title = head.title ?? baseTitle;
-    if (titleLease) titleLease.set(title);
-    else titleLease = acquireTitle(title);
-  };
-  const stop = effect(() => {
-    const route2 = current();
-    if (route2 === null) return;
-    const head = resolveRouteHead(route2, defaults);
-    untracked(() => apply(head));
-  });
-  return {
-    update(route2) {
-      setCurrent(route2);
-    },
-    dispose() {
-      stop();
-      for (const el of owned.values()) el.remove();
-      owned.clear();
-      titleLease?.release();
-      titleLease = null;
-    }
-  };
-}
-function sameAttrs(el, attrs) {
-  const names = Object.keys(attrs);
-  if (el.attributes.length !== names.length + 1) return false;
-  for (const name of names) if (el.getAttribute(name) !== attrs[name]) return false;
-  return true;
-}
-
-// src/plugins/router.ts
-function splitRouteUrl(url) {
-  const hashIndex = url.indexOf("#");
-  const beforeHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
-  const hash = hashIndex === -1 ? "" : url.slice(hashIndex + 1);
-  const queryIndex = beforeHash.indexOf("?");
-  const path = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
-  const query = queryIndex === -1 ? "" : beforeHash.slice(queryIndex + 1);
-  return { path, query, hash };
-}
-function classifyNavigationTarget(path) {
-  if (path === "") return "internal";
-  const normalized = stripControlChars(path).replace(/\\/g, "/");
-  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 parseQuery(query) {
-  return Object.fromEntries(new URLSearchParams(query));
-}
-function parseQueryAll(query) {
-  const all = /* @__PURE__ */ new Map();
-  for (const [key, value] of new URLSearchParams(query)) {
-    const values = all.get(key);
-    if (values) values.push(value);
-    else all.set(key, [value]);
-  }
-  return Object.fromEntries(all);
-}
-function serializeQuery(query) {
-  const search = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (Array.isArray(value)) for (const v of value) search.append(key, String(v));
-    else search.append(key, String(value));
-  }
-  return search.toString();
-}
-function paramsIdentity(params) {
-  return JSON.stringify(Object.entries(params).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
-}
-function queryIdentity(query) {
-  return paramsIdentity(typeof query === "string" ? parseQueryAll(query) : query);
-}
-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();
-    this.maxSize = Math.max(1, maxSize);
-  }
-  get(key) {
-    const value = this.cache.get(key);
-    if (value !== void 0) {
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== void 0) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  has(key) {
-    return this.cache.has(key);
-  }
-  delete(key) {
-    return this.cache.delete(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
-  }
-};
-var NavigationController = class {
-  constructor() {
-    this.currentController = null;
-  }
-  async navigate(navigationFn) {
-    if (this.currentController) {
-      this.currentController.abort();
-    }
-    this.currentController = new AbortController();
-    const signal2 = this.currentController.signal;
-    try {
-      await navigationFn(signal2);
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        return;
-      }
-      throw error;
-    } finally {
-      if (this.currentController?.signal === signal2) {
-        this.currentController = null;
-      }
-    }
-  }
-  abort(reason) {
-    if (this.currentController) {
-      this.currentController.abort(reason);
-      this.currentController = null;
-    }
-  }
-  get isNavigating() {
-    return this.currentController !== null;
-  }
-};
-var RouteMatcher = class _RouteMatcher {
-  constructor(routes) {
-    this.routeTrie = /* @__PURE__ */ new Map();
-    this.parentChain = /* @__PURE__ */ new Map();
-    this.namedRoutes = /* @__PURE__ */ new Map();
-    this.compiledPatterns = new LRUCache(50);
-    // Pattern routes (those with params/wildcards) ordered most-specific-first,
-    // rebuilt lazily after any mutation. Static full paths are served by the
-    // exact-match map and excluded here.
-    this.patternOrder = null;
-    this.buildIndex(routes);
-  }
-  // Specificity per segment: static (2) > param `:x` (1) > wildcard `*` (0).
-  static specificity(path) {
-    return path.split("/").filter(Boolean).map((seg) => seg.startsWith(":") ? 1 : seg.includes("*") ? 0 : 2);
-  }
-  getPatternOrder() {
-    if (this.patternOrder) return this.patternOrder;
-    const patterns = [...this.routeTrie].filter(([p]) => p.includes(":") || p.includes("*"));
-    patterns.sort(([a], [b]) => {
-      const ka = _RouteMatcher.specificity(a);
-      const kb = _RouteMatcher.specificity(b);
-      const len = Math.max(ka.length, kb.length);
-      for (let i = 0; i < len; i++) {
-        const va = ka[i] ?? -1;
-        const vb = kb[i] ?? -1;
-        if (va !== vb) return vb - va;
-      }
-      return 0;
-    });
-    this.patternOrder = patterns;
-    return patterns;
-  }
-  buildIndex(routes, parentPath = "", ancestors = []) {
-    for (const route2 of routes) {
-      const fullPath = parentPath + route2.path;
-      const chain = [...ancestors, route2];
-      this.routeTrie.set(fullPath, route2);
-      this.parentChain.set(fullPath, chain);
-      if (route2.name) {
-        this.namedRoutes.set(route2.name, route2);
-      }
-      if (route2.alias) {
-        const aliases = Array.isArray(route2.alias) ? route2.alias : [route2.alias];
-        for (const alias of aliases) {
-          this.routeTrie.set(parentPath + alias, route2);
-          this.parentChain.set(parentPath + alias, chain);
-        }
-      }
-      if (route2.children?.length) {
-        this.buildIndex(route2.children, fullPath, chain);
-      }
-    }
-  }
-  match(path) {
-    const exactMatch = this.routeTrie.get(path);
-    if (exactMatch) {
-      return { route: exactMatch, params: {}, matched: this.parentChain.get(path) || [exactMatch] };
-    }
-    for (const [routePath, route2] of this.getPatternOrder()) {
-      const match = this.matchPattern(path, routePath);
-      if (match) {
-        return { route: route2, params: match.params, matched: this.parentChain.get(routePath) || [route2] };
-      }
-    }
-    return null;
-  }
-  findByName(name) {
-    return this.namedRoutes.get(name) || null;
-  }
-  matchPattern(path, routePath) {
-    if (routePath === "*") {
-      return { params: { pathMatch: path } };
-    }
-    if (routePath.endsWith("/*")) {
-      const basePath = routePath.slice(0, -2);
-      if (path === basePath || path.startsWith(`${basePath}/`)) {
-        return { params: { pathMatch: path.slice(basePath.length) } };
-      }
-      return null;
-    }
-    let compiled = this.compiledPatterns.get(routePath);
-    if (!compiled) {
-      compiled = this.compileRoute(routePath);
-      this.compiledPatterns.set(routePath, compiled);
-    }
-    const match = path.match(compiled.regex);
-    if (match) {
-      const params = {};
-      compiled.keys.forEach((key, i) => {
-        const raw = match[i + 1];
-        if (raw !== void 0) {
-          try {
-            params[key] = decodeURIComponent(raw);
-          } catch {
-            params[key] = raw;
-          }
-        }
-      });
-      return { params };
-    }
-    return null;
-  }
-  compileRoute(routePath) {
-    const keys = [];
-    const escapeRegex = (s) => s.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
-    const parts = routePath.split(/(\/:[^/]+\??)/);
-    let pattern = "";
-    for (const part of parts) {
-      if (part.startsWith("/:")) {
-        if (part.endsWith("?")) {
-          keys.push(part.slice(2, -1));
-          pattern += "(?:/([^/]+))?";
-        } else {
-          keys.push(part.slice(2));
-          pattern += "/([^/]+)";
-        }
-      } else {
-        pattern += escapeRegex(part);
-      }
-    }
-    return {
-      regex: new RegExp(`^${pattern}$`),
-      keys
-    };
-  }
-  rebuild(routes) {
-    this.routeTrie.clear();
-    this.parentChain.clear();
-    this.namedRoutes.clear();
-    this.compiledPatterns.clear();
-    this.patternOrder = null;
-    this.buildIndex(routes);
-  }
-  addRoute(route2, parentPath = "") {
-    this.patternOrder = null;
-    const fullPath = parentPath + route2.path;
-    const parentAncestors = this.parentChain.get(parentPath) || [];
-    const chain = [...parentAncestors, route2];
-    this.routeTrie.set(fullPath, route2);
-    this.parentChain.set(fullPath, chain);
-    if (route2.name) {
-      this.namedRoutes.set(route2.name, route2);
-    }
-    if (route2.children?.length) {
-      this.buildIndex(route2.children, fullPath, chain);
-    }
-  }
-  removeRoute(path) {
-    this.compiledPatterns.clear();
-    this.patternOrder = null;
-    const root = this.routeTrie.get(path);
-    if (!root) return;
-    const removed = /* @__PURE__ */ new Set();
-    const collect = (r) => {
-      removed.add(r);
-      if (r.children) for (const child of r.children) collect(child);
-    };
-    collect(root);
-    for (const [key, route2] of [...this.routeTrie]) {
-      if (removed.has(route2)) this.routeTrie.delete(key);
-    }
-    for (const [key, chain] of [...this.parentChain]) {
-      if (chain.length > 0 && removed.has(chain[chain.length - 1])) this.parentChain.delete(key);
-    }
-    for (const [name, route2] of [...this.namedRoutes]) {
-      if (removed.has(route2)) this.namedRoutes.delete(name);
-    }
-  }
-};
-var GuardManager = class {
-  constructor(timeout = 5e3) {
-    this.beforeEachGuards = [];
-    this.beforeResolveGuards = [];
-    this.afterEachHooks = [];
-    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);
-      if (result !== true) return result;
-    }
-    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);
-      if (result !== true) return result;
-    }
-    return true;
-  }
-  runAfterEach(to, from) {
-    for (const hook of this.afterEachHooks) {
-      try {
-        hook(to, from);
-      } catch (error) {
-        console.error("[Router] AfterEach hook error:", error);
-      }
-    }
-  }
-  runGuard(guard, to, from, signal2) {
-    return new Promise((resolve, reject) => {
-      if (signal2.aborted) {
-        reject(new Error("Navigation aborted"));
-        return;
-      }
-      let resolved = false;
-      const next = (result) => {
-        if (resolved || signal2.aborted) return;
-        resolved = true;
-        clearTimeout(timeoutId);
-        signal2.removeEventListener("abort", abortHandler);
-        if (result instanceof Error) {
-          reject(result);
-        } else if (result === false) {
-          resolve(false);
-        } else if (typeof result === "string") {
-          resolve(result);
-        } else {
-          resolve(true);
-        }
-      };
-      const abortHandler = () => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timeoutId);
-          reject(new Error("Navigation aborted"));
-        }
-      };
-      const timeoutId = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          signal2.removeEventListener("abort", abortHandler);
-          reject(new Error("Guard timeout"));
-        }
-      }, this.timeout);
-      signal2.addEventListener("abort", abortHandler);
-      try {
-        guard(to, from, next);
-      } catch (error) {
-        clearTimeout(timeoutId);
-        signal2.removeEventListener("abort", abortHandler);
-        if (!resolved) {
-          resolved = true;
-          reject(error instanceof Error ? error : new Error(String(error)));
-        }
-      }
-    });
-  }
-  addBeforeEach(guard) {
-    this.beforeEachGuards.push(guard);
-    return () => {
-      const index = this.beforeEachGuards.indexOf(guard);
-      if (index > -1) this.beforeEachGuards.splice(index, 1);
-    };
-  }
-  addBeforeResolve(guard) {
-    this.beforeResolveGuards.push(guard);
-    return () => {
-      const index = this.beforeResolveGuards.indexOf(guard);
-      if (index > -1) this.beforeResolveGuards.splice(index, 1);
-    };
-  }
-  addAfterEach(hook) {
-    this.afterEachHooks.push(hook);
-    return () => {
-      const index = this.afterEachHooks.indexOf(hook);
-      if (index > -1) this.afterEachHooks.splice(index, 1);
-    };
-  }
-  clear() {
-    this.beforeEachGuards = [];
-    this.beforeResolveGuards = [];
-    this.afterEachHooks = [];
-  }
-};
-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.planCache = new LRUCache(cacheSize);
-    this.retryDelay = retryDelay;
-  }
-  keyFor(route2) {
-    let key = this.routeKeys.get(route2);
-    if (key === void 0) {
-      key = `route#${this.keyCounter++}`;
-      this.routeKeys.set(route2, key);
-    }
-    return key;
-  }
-  /**
-   * 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.planCache.get(cacheKey);
-    if (cached) return cached;
-    const existingPromise = this.loadingPromises.get(cacheKey);
-    if (existingPromise) return existingPromise;
-    this.assertNotHot(cacheKey);
-    const loadingPromise = this.doLoadPlan(comp, routePath);
-    this.loadingPromises.set(cacheKey, loadingPromise);
-    try {
-      const plan = await loadingPromise;
-      this.planCache.set(cacheKey, plan);
-      this.errorCache.delete(cacheKey);
-      return plan;
-    } catch (error) {
-      this.noteError(cacheKey);
-      throw error;
-    } finally {
-      this.loadingPromises.delete(cacheKey);
-    }
-  }
-  /** 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, scope) {
-    if (plan.kind === "factory") {
-      return this.instantiateFactory(plan.component, route2, routePath, scope);
-    }
-    const factory = await this.resolveModuleFactory(plan, route2, routePath);
-    return this.instantiateFactory(factory, route2, routePath, scope);
-  }
-  /**
-   * 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 {
-      resolved = await pending;
-    } catch (error) {
-      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;
-  }
-  /**
-   * 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, scope, depth = 0) {
-    const result = scope ? runWithOwnerScope(scope, component) : 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, scope, depth + 1);
-    }
-    throw new Error(`Component for route "${routePath}" must return Element, got ${typeof value}`);
-  }
-  /**
-   * 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";
-  }
-  /**
-   * 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;
-    }
-    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.planCache.clear();
-    this.errorCache.clear();
-    this.loadingPromises.clear();
-    this.moduleLoads.clear();
-  }
-};
-_ComponentLoader.MAX_ERROR_ENTRIES = 256;
-var ComponentLoader = _ComponentLoader;
-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;
-    // Created the first time a committed route needs a managed <head>.
-    this.headController = null;
-    // `readyPromise` plus the matched components loaded; created on the first
-    // `routerReady()` call only, so an app that never asks pays nothing and its
-    // outlets load exactly as before.
-    this.loadedPromise = null;
-    this.readyPromise = new Promise((resolve) => {
-      this.resolveReady = resolve;
-    });
-    this.options = {
-      mode: "history",
-      base: "",
-      linkActiveClass: "router-link-active",
-      linkExactActiveClass: "router-link-exact-active",
-      fallback: true,
-      guardTimeout: 5e3,
-      cacheSize: 50,
-      errorRetryDelay: 1e3,
-      preloadStrategy: "none",
-      ...options
-    };
-    const [currentRouteState, setCurrentRouteState] = signal(this.createInitialRoute());
-    const [isReadyState, setIsReadyState] = signal(false);
-    this.currentRouteGetter = currentRouteState;
-    this.currentRouteSetter = setCurrentRouteState;
-    this.isReadyGetter = isReadyState;
-    this.isReadySetter = setIsReadyState;
-    this.matcher = new RouteMatcher(routes);
-    this.guards = new GuardManager(this.options.guardTimeout);
-    this.loader = new ComponentLoader(this.options.cacheSize, this.options.errorRetryDelay);
-    this.navigator = new NavigationController();
-    this.initialize();
-  }
-  initialize() {
-    if (typeof window !== "undefined") {
-      if (this.options.mode === "history") {
-        const popstateHandler = () => this.handleLocationChange(true);
-        window.addEventListener("popstate", popstateHandler);
-        this.cleanup.push(() => window.removeEventListener("popstate", popstateHandler));
-      } else {
-        const hashHandler = () => this.handleLocationChange(true);
-        window.addEventListener("hashchange", hashHandler);
-        this.cleanup.push(() => window.removeEventListener("hashchange", hashHandler));
-      }
-    }
-    queueMicrotask(() => {
-      let initial = Promise.resolve();
-      if (!this.navigator.isNavigating) {
-        initial = this.handleLocationChange(true, true);
-      }
-      this.isReadySetter(true);
-      prerenderWait(initial.then(this.resolveReady, this.resolveReady));
-    });
-  }
-  /** Load the component of every record the current route matched, without instantiating any. */
-  async preloadMatched() {
-    const current = untracked(() => this.currentRouteGetter());
-    for (const record of current.matched) {
-      if ("redirect" in record) continue;
-      try {
-        await this.loader.preloadPlan(record, current.path);
-      } catch {
-        this.loader.clearErrors();
-      }
-    }
-  }
-  /** Settles after the initial navigation and its component loads; see `routerReady()`. */
-  whenReady() {
-    this.loadedPromise ?? (this.loadedPromise = this.readyPromise.then(() => this.destroyed ? void 0 : this.preloadMatched()));
-    return this.loadedPromise;
-  }
-  createInitialRoute() {
-    return {
-      path: "/",
-      params: {},
-      query: {},
-      queryAll: {},
-      hash: "",
-      meta: {},
-      matched: []
-    };
-  }
-  handleLocationChange(skipHistory = true, initialResolution = false) {
-    const path = this.getCurrentPath();
-    return 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) || "/";
-    }
-    let path = window.location.pathname;
-    if (base && (path === base || path.startsWith(`${base}/`))) {
-      path = path.slice(base.length);
-    }
-    return (path || "/") + window.location.search + window.location.hash;
-  }
-  createRouteContext(fullPath) {
-    const { path, query: queryString, hash } = splitRouteUrl(fullPath);
-    const query = parseQuery(queryString);
-    const queryAll = parseQueryAll(queryString);
-    const match = this.matcher.match(path || "/");
-    const params = match?.params || {};
-    const meta = match?.route.meta || {};
-    const matched = match?.matched || [];
-    return {
-      path: path || "/",
-      params,
-      query,
-      queryAll,
-      hash,
-      meta,
-      matched
-    };
-  }
-  // Public API
-  async navigate(to, options = {}) {
-    try {
-      await this.navigator.navigate(async (signal2) => {
-        const targetPath = this.resolvePath(to);
-        if (!isRouterNavigable(targetPath)) {
-          const from2 = this.currentRouteGetter();
-          const toContext2 = this.createRouteContext(targetPath);
-          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, void 0, "duplicate");
-        }
-        await this.performNavigation(toContext, from, options, signal2);
-      });
-      return { success: true, route: this.currentRouteGetter() };
-    } catch (error) {
-      if (error instanceof NavigationFailureError) {
-        const failure2 = error.toFailure();
-        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, reason, failure };
-    }
-  }
-  async performNavigation(to, from, options, signal2, depth = 0, redirectChain = []) {
-    const chain = depth === 0 ? [to.path] : redirectChain;
-    if (depth >= _SibuRouter.MAX_REDIRECT_DEPTH) {
-      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 (!isRouterNavigable(beforeEachResult)) {
-          throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
-        }
-        return this.performNavigation(this.createRouteContext(beforeEachResult), from, options, signal2, depth + 1, [
-          ...chain,
-          beforeEachResult
-        ]);
-      }
-      throw new NavigationFailureError("aborted", from, to, void 0, "guard");
-    }
-    const match = this.matcher.match(to.path);
-    if (match) {
-      const { route: route2 } = match;
-      for (const matchedRoute of match.matched) {
-        if ("beforeEnter" in matchedRoute && matchedRoute.beforeEnter) {
-          const guards = Array.isArray(matchedRoute.beforeEnter) ? matchedRoute.beforeEnter : [matchedRoute.beforeEnter];
-          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 (!isRouterNavigable(result)) {
-                  throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
-                }
-                return this.performNavigation(this.createRouteContext(result), from, options, signal2, depth + 1, [
-                  ...chain,
-                  result
-                ]);
-              }
-              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" && !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, void 0, "unsafe-target");
-        }
-        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 (!isRouterNavigable(beforeResolveResult)) {
-          throw new NavigationFailureError("aborted", from, to, void 0, "unsafe-target");
-        }
-        return this.performNavigation(this.createRouteContext(beforeResolveResult), from, options, signal2, depth + 1, [
-          ...chain,
-          beforeResolveResult
-        ]);
-      }
-      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.updateHead(to);
-    this.guards.runAfterEach(to, from);
-    this.handleScrollBehavior(to, from);
-  }
-  updateHead(to) {
-    if (typeof document === "undefined" || this.destroyed) return;
-    if (this.headController === null) {
-      if (!routeHasHead(to.matched, this.options.head)) return;
-      this.headController = createRouteHeadController(this.options.head);
-    }
-    this.headController.update(to);
-  }
-  resolvePath(to) {
-    if (typeof to === "string") return to;
-    let path = to.path || "";
-    if (to.name && !path) {
-      const namedRoute = this.matcher.findByName(to.name);
-      if (namedRoute) {
-        path = namedRoute.path;
-      }
-    }
-    if (to.params) {
-      for (const [key, value] of Object.entries(to.params)) {
-        path = path.replace(new RegExp(`:${key}(?=[/?#]|$)`, "g"), encodeURIComponent(value));
-      }
-    }
-    const search = to.query ? serializeQuery(to.query) : "";
-    if (search) {
-      path += `?${search}`;
-    }
-    if (to.hash) {
-      path += `#${to.hash}`;
-    }
-    return path;
-  }
-  isSameRoute(from, to) {
-    if (from.matched.length === 0 && to.matched.length > 0) return false;
-    return from.path === to.path && paramsIdentity(from.params) === paramsIdentity(to.params) && queryIdentity(from.queryAll) === queryIdentity(to.queryAll) && from.hash === to.hash;
-  }
-  updateHistory(to, options) {
-    const search = serializeQuery(to.queryAll);
-    const routeUrl = to.path + (search ? `?${search}` : "") + (to.hash ? `#${to.hash}` : "");
-    const loc = globalThis.location;
-    const fullPath = this.options.mode === "hash" ? `${loc ? loc.pathname + loc.search : ""}#${routeUrl}` : this.options.base + routeUrl;
-    const h = globalThis.history;
-    if (!h) return;
-    if (options.replace) {
-      h.replaceState(options.state || {}, "", fullPath);
-    } else {
-      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) {
-    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
-  /**
-   * 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 prerenderWait(this.loader.loadPlan(route2, routePath));
-  }
-  /**
-   * Create exactly one real instance from an already-resolved plan. With a
-   * `scope`, the factory runs in it (see `RouteScope`).
-   */
-  async instantiateComponent(plan, route2, routePath, scope) {
-    return prerenderWait(this.loader.instantiate(plan, route2, routePath, scope));
-  }
-  /** 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) {
-    return this.guards.addBeforeEach(guard);
-  }
-  beforeResolve(guard) {
-    return this.guards.addBeforeResolve(guard);
-  }
-  afterEach(hook) {
-    return this.guards.addAfterEach(hook);
-  }
-  // Utility methods
-  push(to) {
-    return this.navigate(to);
-  }
-  replace(to) {
-    return this.navigate(to, { replace: true });
-  }
-  go(delta) {
-    history.go(delta);
-  }
-  back() {
-    history.back();
-  }
-  forward() {
-    history.forward();
-  }
-  // State getters
-  get currentRoute() {
-    return this.currentRouteGetter();
-  }
-  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.destroyed = true;
-    this.navEpoch++;
-    this.navigator.abort(ABORT_ROUTER_DESTROYED);
-    for (const fn of this.cleanup) fn();
-    this.cleanup = [];
-    this.guards.clear();
-    this.loader.clearCache();
-    this.isReadySetter(false);
-    this.headController?.dispose();
-    this.headController = null;
-    this.resolveReady();
-  }
-  // Cache management
-  clearCache() {
-    this.loader.clearCache();
-  }
-  clearErrorCache() {
-    this.loader.clearErrors();
-  }
-  // Route management
-  updateRoutes(routes) {
-    this.matcher.rebuild(routes);
-    this.clearCache();
-  }
-  /**
-   * Add a route dynamically at runtime.
-   */
-  addRoute(route2, parentPath) {
-    this.matcher.addRoute(route2, parentPath);
-    this.clearCache();
-  }
-  /**
-   * Remove a route by path.
-   */
-  removeRoute(path) {
-    this.matcher.removeRoute(path);
-    this.clearCache();
-  }
-  /**
-   * Get the reactive route getter for tracking.
-   */
-  get routeGetter() {
-    return this.currentRouteGetter;
-  }
-};
-_SibuRouter.MAX_REDIRECT_DEPTH = 10;
-var SibuRouter = _SibuRouter;
-var NavigationFailureError = class extends Error {
-  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) {
-      this.cause = 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 });
-var [routerRevision, setRouterRevision] = signal(0);
-var awaitingParent = /* @__PURE__ */ new Map();
-var parentObserver = null;
-function stopParentObserverIfIdle() {
-  if (parentObserver && awaitingParent.size === 0) {
-    parentObserver.disconnect();
-    parentObserver = null;
-  }
-}
-function whenAnchorAttached(anchor, run) {
-  let cancelled = false;
-  queueMicrotask(() => {
-    if (cancelled) return;
-    if (anchor.parentNode) {
-      cancelled = true;
-      run();
-      return;
-    }
-    if (typeof MutationObserver === "undefined" || typeof document === "undefined") return;
-    awaitingParent.set(anchor, () => {
-      cancelled = true;
-      run();
-    });
-    if (!parentObserver) {
-      parentObserver = new MutationObserver(() => {
-        for (const [node, cb] of awaitingParent) {
-          if (!node.parentNode) continue;
-          awaitingParent.delete(node);
-          cb();
-        }
-        stopParentObserverIfIdle();
-      });
-      parentObserver.observe(document, { childList: true, subtree: true });
-    }
-  });
-  return () => {
-    if (cancelled) return;
-    cancelled = true;
-    awaitingParent.delete(anchor);
-    stopParentObserverIfIdle();
-  };
-}
-function attachRetry(anchor, rerun) {
-  const run = bindOwnerScope(rerun);
-  let cancelWait = null;
-  return {
-    request: () => {
-      if (cancelWait) return;
-      cancelWait = whenAnchorAttached(anchor, () => {
-        cancelWait = null;
-        run();
-      });
-    },
-    cancel: () => {
-      cancelWait?.();
-      cancelWait = null;
-    }
-  };
-}
-function normalizeRoutes(routes) {
-  return routes.map((route2) => {
-    const normalizedChildren = route2.children && route2.children.length > 0 ? normalizeRoutes(route2.children) : route2.children;
-    if ("lazy" in route2 && typeof route2.lazy === "function") {
-      const { lazy: importFn, ...rest } = route2;
-      const asyncRoute = {
-        ...rest,
-        component: lazy(importFn),
-        children: normalizedChildren
-      };
-      return asyncRoute;
-    }
-    if (normalizedChildren !== route2.children) {
-      return { ...route2, children: normalizedChildren };
-    }
-    return route2;
-  });
-}
-function createRouter(routesOrOptions, options = {}) {
-  if (_routerRef.current) {
-    _routerRef.current.destroy();
-  }
-  let routes;
-  if (Array.isArray(routesOrOptions)) {
-    routes = normalizeRoutes(routesOrOptions);
-  } else {
-    options = routesOrOptions;
-    routes = [];
-  }
-  _routerRef.current = new SibuRouter(routes, options);
-  ensureRouterPagehide();
-  setRouterRevision((n) => n + 1);
-  return _routerRef.current;
-}
-function setRoutes(routes) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  _routerRef.current.updateRoutes(normalizeRoutes(routes));
-}
-var RouteScope = class {
-  constructor(route2) {
-    this.released = false;
-    const [get, set] = signal(route2);
-    this.get = get;
-    this.set = set;
-  }
-  /** The instance's route, or `null` once released. Reactive. */
-  read() {
-    return this.get();
-  }
-  /** Hand a kept instance the route of the navigation that kept it. */
-  update(route2) {
-    if (!this.released) this.set(route2);
-  }
-  /**
-   * Called when the instance is disposed. The switch to "no scope" is
-   * published a microtask later, once the whole dispose has finished: a
-   * teardown the instance registered after this one (an `onMount` effect, say)
-   * may still be alive at this point, and must not re-run against the
-   * router-global route on its way out.
-   */
-  release() {
-    if (this.released) return;
-    this.released = true;
-    queueMicrotask(() => this.set(null));
-  }
-};
-function activeRouteScope() {
-  const scope = getOwnerScope();
-  return scope instanceof RouteScope ? scope : null;
-}
-function scopedRoute(router2) {
-  const scope = activeRouteScope();
-  if (scope) {
-    const committed = scope.read();
-    if (committed !== null) return committed;
-  }
-  return router2.currentRoute;
-}
-var instanceScopes = /* @__PURE__ */ new WeakMap();
-async function instantiateScoped(router2, plan, routeDef, routePath, route2) {
-  const scope = new RouteScope(route2);
-  const node = await router2.instantiateComponent(plan, routeDef, routePath, scope);
-  if (node) {
-    instanceScopes.set(node, scope);
-    registerDisposer(node, () => scope.release());
-  }
-  return node;
-}
-function updateInstanceRoute(node, route2) {
-  if (node) instanceScopes.get(node)?.update(route2);
-}
-function disposeOwned(node) {
-  const scope = instanceScopes.get(node);
-  if (scope) runWithOwnerScope(scope, () => dispose(node));
-  else dispose(node);
-}
-function route() {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return scopedRoute(_routerRef.current);
-}
-function router() {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return {
-    currentRoute: scopedRoute(_routerRef.current),
-    isReady: _routerRef.current.isReady,
-    isNavigating: _routerRef.current.isNavigating,
-    push: (to) => _routerRef.current?.push(to),
-    replace: (to) => _routerRef.current?.replace(to),
-    go: (delta) => _routerRef.current?.go(delta),
-    back: () => _routerRef.current?.back(),
-    forward: () => _routerRef.current?.forward(),
-    beforeEach: (guard) => _routerRef.current?.beforeEach(guard),
-    beforeResolve: (guard) => _routerRef.current?.beforeResolve(guard),
-    afterEach: (hook) => _routerRef.current?.afterEach(hook)
-  };
-}
-function routerReady() {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.whenReady();
-}
-function navigate(to, options) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.navigate(to, options);
-}
-function push(to) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.push(to);
-}
-function replace(to) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.replace(to);
-}
-function go(delta) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  _routerRef.current.go(delta);
-}
-function back() {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  _routerRef.current.back();
-}
-function forward() {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  _routerRef.current.forward();
-}
-function beforeEach(guard) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.beforeEach(guard);
-}
-function beforeResolve(guard) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.beforeResolve(guard);
-}
-function afterEach(hook) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current.afterEach(hook);
-}
-var routeCleanups = [];
-var ownParamNamesCache = /* @__PURE__ */ new WeakMap();
-function ownParamNames(record) {
-  const cached = ownParamNamesCache.get(record);
-  if (cached) return cached;
-  const aliases = record.alias == null ? [] : Array.isArray(record.alias) ? record.alias : [record.alias];
-  const names = /* @__PURE__ */ new Set();
-  for (const pattern of [record.path, ...aliases]) {
-    for (const m of pattern.matchAll(/\/:([^/]+)/g)) {
-      names.add(m[1].endsWith("?") ? m[1].slice(0, -1) : m[1]);
-    }
-  }
-  const result = [...names];
-  ownParamNamesCache.set(record, result);
-  return result;
-}
-function instanceKey(owner, records, route2) {
-  const custom = owner.key;
-  if (custom) return untracked(() => String(custom(route2)));
-  const parts = [];
-  for (const record of records) {
-    for (const name of ownParamNames(record)) parts.push(name, route2.params[name] ?? null);
-  }
-  return JSON.stringify(parts);
-}
-function Route() {
-  const anchor = document.createComment("route-outlet");
-  let currentNode = null;
-  let loadingNode = null;
-  let errorNode = null;
-  let navSeq = 0;
-  let currentTopRoute = null;
-  let currentKey = null;
-  let routeTorn = false;
-  const commitTarget = (seq) => routeTorn || seq !== navSeq ? null : anchor.parentNode;
-  const retryIfDetached = (seq) => {
-    if (!routeTorn && seq === navSeq && !anchor.parentNode) attachWait.request();
-  };
-  const release = (node) => {
-    if (!node) return;
-    disposeOwned(node);
-    node.parentNode?.removeChild(node);
-  };
-  const cleanupNodes = () => {
-    [currentNode, loadingNode, errorNode].forEach((node) => {
-      if (!node) return;
-      disposeOwned(node);
-      if (node.parentNode) {
-        node.parentNode.removeChild(node);
-      }
-    });
-    currentNode = null;
-    loadingNode = null;
-    errorNode = null;
-  };
-  const showLoading = () => {
-    if (!loadingNode && anchor.parentNode) {
-      loadingNode = document.createElement("div");
-      loadingNode.className = "route-loading";
-      loadingNode.setAttribute("role", "status");
-      loadingNode.setAttribute("aria-label", "Loading route");
-      const spinner = document.createElement("div");
-      spinner.className = "route-loading-spinner";
-      spinner.setAttribute("aria-hidden", "true");
-      const text = document.createElement("span");
-      text.textContent = "Loading...";
-      text.className = "route-loading-text";
-      loadingNode.appendChild(spinner);
-      loadingNode.appendChild(text);
-      anchor.parentNode.insertBefore(loadingNode, anchor.nextSibling);
-    }
-  };
-  const hideLoading = () => {
-    if (loadingNode?.parentNode) {
-      loadingNode.parentNode.removeChild(loadingNode);
-      loadingNode = null;
-    }
-  };
-  const showError = (error, routeDef) => {
-    if (!anchor.parentNode) return;
-    cleanupNodes();
-    errorNode = document.createElement("div");
-    errorNode.className = "route-error";
-    errorNode.setAttribute("role", "alert");
-    errorNode.setAttribute("aria-live", "assertive");
-    if (routeDef && "component" in routeDef) {
-      const src = routeDef.component.toString();
-      const importMatch = src.match(/import\(["']([^"']+)["']\)/);
-      if (importMatch) {
-        errorNode.setAttribute("data-component-source", importMatch[1]);
-      }
-      if (routeDef.component.name) {
-        errorNode.setAttribute("data-component-name", routeDef.component.name);
-      }
-    }
-    errorNode.__routeError = error;
-    const title = document.createElement("h3");
-    title.textContent = "Route Error";
-    title.className = "route-error-title";
-    const message = document.createElement("p");
-    message.textContent = error.message || "Failed to load route component";
-    message.className = "route-error-message";
-    const retryButton = document.createElement("button");
-    retryButton.textContent = "Retry";
-    retryButton.className = "route-error-retry";
-    retryButton.type = "button";
-    const onRetryClick = () => {
-      if (_routerRef.current) {
-        _routerRef.current.clearErrorCache();
-        update();
-      }
-    };
-    retryButton.addEventListener("click", onRetryClick);
-    registerDisposer(retryButton, () => retryButton.removeEventListener("click", onRetryClick));
-    errorNode.appendChild(title);
-    errorNode.appendChild(message);
-    errorNode.appendChild(retryButton);
-    anchor.parentNode.insertBefore(errorNode, anchor.nextSibling);
-  };
-  const update = async () => {
-    routerRevision();
-    if (routeTorn || !_routerRef.current) return;
-    const seq = ++navSeq;
-    const route2 = scopedRoute(_routerRef.current);
-    try {
-      const match = _routerRef.current["matcher"].match(route2.path);
-      if (!match) {
-        currentTopRoute = null;
-        currentKey = null;
-        cleanupNodes();
-        return;
-      }
-      const routeDef = match.matched[0] || match.route;
-      const key = instanceKey(routeDef, [routeDef], route2);
-      if (routeDef === currentTopRoute && key === currentKey && currentNode) {
-        updateInstanceRoute(currentNode, route2);
-        return;
-      }
-      if ("redirect" in routeDef) {
-        const redirectPath = typeof routeDef.redirect === "function" ? routeDef.redirect(route2) : routeDef.redirect;
-        queueMicrotask(() => {
-          _routerRef.current?.navigate(redirectPath).catch((err) => {
-            if (typeof console !== "undefined") console.error("[router] redirect failed:", err);
-          });
-        });
-        return;
-      }
-      if ("component" in routeDef) {
-        try {
-          const isAsync = routeDef.component.constructor.name === "AsyncFunction" || routeDef.component.toString().includes("import(");
-          if (isAsync) {
-            showLoading();
-          }
-          const plan = await _routerRef.current.loadPlan(routeDef, route2.path);
-          if (!commitTarget(seq)) {
-            retryIfDetached(seq);
-            return;
-          }
-          const node = await instantiateScoped(_routerRef.current, plan, routeDef, route2.path, route2);
-          const parent = commitTarget(seq);
-          if (!parent) {
-            release(node);
-            retryIfDetached(seq);
-            return;
-          }
-          if (node) {
-            currentTopRoute = routeDef;
-            currentKey = key;
-            cleanupNodes();
-            parent.insertBefore(node, anchor.nextSibling);
-            currentNode = node;
-          }
-        } catch (error) {
-          if (routeTorn || seq !== navSeq) return;
-          hideLoading();
-          console.error("[Route] Component error:", error);
-          fail(seq, error, routeDef);
-        }
-      }
-    } catch (error) {
-      if (seq !== navSeq) return;
-      if (routeTorn) return;
-      console.error("[Route] Update failed:", error);
-      fail(seq, error);
-    }
-  };
-  let unshownFailure = null;
-  const fail = (seq, error, routeDef) => {
-    const err = error instanceof Error ? error : new Error(String(error));
-    if (anchor.parentNode) {
-      showError(err, routeDef);
-      return;
-    }
-    unshownFailure = { seq, error: err, routeDef };
-    attachWait.request();
-  };
-  const onAttached = () => {
-    const failure = unshownFailure;
-    unshownFailure = null;
-    if (failure && failure.seq === navSeq) showError(failure.error, failure.routeDef);
-    else update();
-  };
-  let routeInitialized = false;
-  const originalUpdate = update;
-  const wrappedUpdate = async () => {
-    await originalUpdate();
-    routeInitialized = true;
-  };
-  const attachWait = attachRetry(anchor, onAttached);
-  const routeTeardown = track(wrappedUpdate);
-  if (!routeInitialized) {
-    queueMicrotask(
-      bindOwnerScope(() => {
-        if (!routeInitialized && anchor.parentNode) wrappedUpdate();
-      })
-    );
-  }
-  const routeCleanup = () => {
-    if (routeTorn) return;
-    routeTorn = true;
-    navSeq++;
-    routeTeardown();
-    attachWait.cancel();
-    unshownFailure = null;
-    cleanupNodes();
-    currentTopRoute = null;
-    currentKey = null;
-  };
-  registerDisposer(anchor, routeCleanup);
-  routeCleanups.push(routeCleanup);
-  return anchor;
-}
-function KeepAliveRoute(options) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  const anchor = document.createComment("keep-alive-route");
-  const cache = /* @__PURE__ */ new Map();
-  const lruOrder = [];
-  const routerOpts = _routerRef.current["options"];
-  const keepAliveOpt = routerOpts.keepAlive;
-  const maxCache = options?.max ?? (typeof keepAliveOpt === "number" ? keepAliveOpt : 20);
-  const includeNames = options?.include ?? (Array.isArray(keepAliveOpt) ? keepAliveOpt : void 0);
-  let currentNode = null;
-  let currentKey = "";
-  let currentCached = false;
-  let updateSeq = 0;
-  let kaTorn = false;
-  const update = async () => {
-    routerRevision();
-    if (kaTorn || !_routerRef.current) return;
-    const seq = ++updateSeq;
-    const router2 = _routerRef.current;
-    const route2 = scopedRoute(router2);
-    const match = router2["matcher"].match(route2.path);
-    if (!match) return;
-    const { route: routeDef } = match;
-    if ("redirect" in routeDef) {
-      const redirectPath = typeof routeDef.redirect === "function" ? routeDef.redirect(route2) : routeDef.redirect;
-      queueMicrotask(() => {
-        _routerRef.current?.navigate(redirectPath).catch((err) => {
-          if (typeof console !== "undefined") console.error("[router] redirect failed:", err);
-        });
-      });
-      return;
-    }
-    if (!("component" in routeDef)) return;
-    const cacheKey = JSON.stringify([route2.path, queryIdentity(route2.queryAll), route2.hash]);
-    const shouldCache = !includeNames || routeDef.name != null && includeNames.includes(routeDef.name);
-    if (cacheKey === currentKey && currentNode) {
-      updateInstanceRoute(currentNode, route2);
-      return;
-    }
-    if (!anchor.parentNode) {
-      attachWait.request();
-      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 instantiateScoped(router2, plan, routeDef, route2.path, route2);
-      } catch (error) {
-        if (kaTorn || seq !== updateSeq) return;
-        console.error("[KeepAliveRoute] Component error:", error);
-        return;
-      }
-      if (!node) return;
-      if (kaTorn || seq !== updateSeq) {
-        disposeOwned(node);
-        return;
-      }
-    }
-    const parent = anchor.parentNode;
-    if (!parent) {
-      if (!fromCache) disposeOwned(node);
-      attachWait.request();
-      return;
-    }
-    if (currentNode && currentNode !== node) {
-      if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
-      if (!currentCached) disposeOwned(currentNode);
-    }
-    if (fromCache) {
-      updateInstanceRoute(node, route2);
-      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;
-        }
-        const evictNode = cache.get(evictKey);
-        if (evictNode) {
-          disposeOwned(evictNode);
-          if (evictNode.parentNode) evictNode.parentNode.removeChild(evictNode);
-          cache.delete(evictKey);
-        }
-      }
-    }
-    currentNode = node;
-    currentCached = fromCache || shouldCache;
-    currentKey = cacheKey;
-    parent.insertBefore(node, anchor.nextSibling);
-  };
-  let initialized = false;
-  const wrappedUpdate = async () => {
-    await update();
-    initialized = true;
-  };
-  const attachWait = attachRetry(anchor, update);
-  const kaTeardown = track(wrappedUpdate);
-  if (!initialized) {
-    queueMicrotask(
-      bindOwnerScope(() => {
-        if (!initialized && anchor.parentNode) wrappedUpdate();
-      })
-    );
-  }
-  const kaCleanup = () => {
-    if (kaTorn) return;
-    kaTorn = true;
-    updateSeq++;
-    kaTeardown();
-    attachWait.cancel();
-    for (const node of cache.values()) {
-      disposeOwned(node);
-      if (node.parentNode) node.parentNode.removeChild(node);
-    }
-    cache.clear();
-    lruOrder.length = 0;
-    if (currentNode?.parentNode) currentNode.parentNode.removeChild(currentNode);
-    if (currentNode && !currentCached) disposeOwned(currentNode);
-    currentNode = null;
-    currentKey = "";
-    currentCached = false;
-  };
-  registerDisposer(anchor, kaCleanup);
-  routeCleanups.push(kaCleanup);
-  return anchor;
-}
-function RouterLink(props, children) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  const { to, replace: replace2 = false, activeClass, exactActiveClass, nodes, target, rel, class: classAttr, ...attrs } = props;
-  const content = children !== void 0 ? children : nodes;
-  const routeGetter = _routerRef.current.routeGetter;
-  const rawHref = _routerRef.current["resolvePath"](to);
-  const kind = classifyNavigationTarget(rawHref);
-  const href = kind === "unsafe" ? "#" : rawHref;
-  const { path: hrefPathRaw, query: hrefQueryRaw, hash: hrefHash } = splitRouteUrl(href);
-  const targetPath = normalizePathname(hrefPathRaw);
-  const targetQuery = queryIdentity(hrefQueryRaw);
-  const link = document.createElement("a");
-  link.href = kind === "internal" && _routerRef.current["options"].mode === "hash" ? `#${href}` : href;
-  if (target) {
-    link.target = target;
-    if (target === "_blank") {
-      link.rel = rel ? `${rel} noopener noreferrer` : "noopener noreferrer";
-    } else if (rel) {
-      link.rel = rel;
-    }
-  } else if (rel) {
-    link.rel = rel;
-  }
-  const options = _routerRef.current["options"];
-  const effectCleanup = effect(() => {
-    const route2 = routeGetter();
-    const currentPath = normalizePathname(route2.path);
-    const isActive = kind === "internal" && isPathnameAncestor(targetPath, currentPath);
-    const isExactActive = kind === "internal" && currentPath === targetPath && queryIdentity(route2.queryAll) === targetQuery && route2.hash === hrefHash;
-    const classes = [];
-    if (isActive) {
-      if (activeClass) classes.push(activeClass);
-      else if (options.linkActiveClass) classes.push(options.linkActiveClass);
-    }
-    if (isExactActive) {
-      if (exactActiveClass) classes.push(exactActiveClass);
-      else if (options.linkExactActiveClass) classes.push(options.linkExactActiveClass);
-    }
-    link.className = [resolveClassValue(classAttr), ...classes].filter(Boolean).join(" ");
-  });
-  registerDisposer(link, effectCleanup);
-  Object.entries(attrs).forEach(([key, value]) => {
-    const lkey = key.toLowerCase();
-    if (lkey === "href" || lkey[0] === "o" && lkey[1] === "n") return;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      setSafeAttribute(link, key, String(value), { syncValueProperty: false, label: "RouterLink" });
-    }
-  });
-  if (content !== void 0) appendChildren(link, content);
-  const onLinkClick = (e) => {
-    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);
-    });
-  };
-  link.addEventListener("click", onLinkClick);
-  registerDisposer(link, () => {
-    link.removeEventListener("click", onLinkClick);
-  });
-  return link;
-}
-function Suspense(props) {
-  const anchor = document.createComment("suspense-boundary");
-  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 = () => {
-    release(currentNode);
-    release(fallbackNode);
-    currentNode = null;
-    fallbackNode = null;
-  };
-  const showFallback = (myGeneration) => {
-    if (fallbackNode || !props.fallback || tornDown) return;
-    if (!anchor.parentNode) return;
-    let fallback;
-    try {
-      fallback = typeof props.fallback === "function" ? props.fallback() : props.fallback;
-    } catch (error) {
-      console.error("[Suspense] Fallback error:", error);
-      return;
-    }
-    if (!fallback || fallback.nodeType !== 1) return;
-    const parent = commitTarget(myGeneration);
-    if (!parent) {
-      release(fallback);
-      return;
-    }
-    fallbackNode = fallback;
-    parent.insertBefore(fallbackNode, anchor.nextSibling);
-  };
-  const render = async () => {
-    if (tornDown || isLoading) return;
-    isLoading = true;
-    const myGeneration = ++generation;
-    try {
-      const result = props.nodes();
-      let element;
-      const isNode = typeof result?.nodeType === "number";
-      if (!isNode && result != null && typeof result.then === "function") {
-        showFallback(myGeneration);
-        element = await result;
-      } else {
-        element = result;
-      }
-      const parent = commitTarget(myGeneration);
-      if (!parent) {
-        release(element);
-        cleanupNodes();
-        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(bindOwnerScope(render));
-  return anchor;
-}
-var LAZY_MARKER = /* @__PURE__ */ Symbol.for("sibujs:lazy");
-function lazy(importFn) {
-  importFn[LAZY_MARKER] = true;
-  return importFn;
-}
-async function preloadRoute(to) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  const path = _routerRef.current["resolvePath"](to);
-  const match = _routerRef.current["matcher"].match(path.split("?")[0].split("#")[0]);
-  if (match && "component" in match.route) {
-    try {
-      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;
-}
-function getRouteInfo(name) {
-  if (!_routerRef.current) return null;
-  return _routerRef.current["matcher"].findByName(name);
-}
-function buildURL(to) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  return _routerRef.current["resolvePath"](to);
-}
-function destroyRouter() {
-  for (const fn of routeCleanups) fn();
-  routeCleanups.length = 0;
-  if (_routerRef.current) {
-    _routerRef.current.destroy();
-    _routerRef.current = null;
-  }
-}
-var _routerPagehideHandler = null;
-function ensureRouterPagehide() {
-  if (_routerPagehideHandler || typeof window === "undefined") return;
-  _routerPagehideHandler = (event) => {
-    if (event.persisted === false) {
-      destroyRouter();
-    }
-  };
-  window.addEventListener("pagehide", _routerPagehideHandler);
-}
-function __removeRouterPagehideHandler() {
-  if (_routerPagehideHandler && typeof window !== "undefined") {
-    window.removeEventListener("pagehide", _routerPagehideHandler);
-    _routerPagehideHandler = null;
-  }
-}
-function Outlet() {
-  const anchor = document.createComment("route-outlet-nested");
-  let currentNode = null;
-  let currentChild = null;
-  let currentKey = null;
-  let navSeq = 0;
-  let outletTorn = false;
-  const clearCurrent = () => {
-    if (currentNode) {
-      disposeOwned(currentNode);
-      if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
-      currentNode = null;
-    }
-    currentChild = null;
-    currentKey = null;
-  };
-  const commitTarget = (seq) => outletTorn || seq !== navSeq ? null : anchor.parentNode;
-  const retryIfDetached = (seq) => {
-    if (!outletTorn && seq === navSeq && !anchor.parentNode) attachWait.request();
-  };
-  const release = (node) => {
-    if (!node) return;
-    disposeOwned(node);
-    node.parentNode?.removeChild(node);
-  };
-  const update = async () => {
-    routerRevision();
-    if (outletTorn || !_routerRef.current) return;
-    const seq = ++navSeq;
-    const route2 = scopedRoute(_routerRef.current);
-    if (route2.matched.length < 2) {
-      clearCurrent();
-      return;
-    }
-    const childRoute = route2.matched[route2.matched.length - 1];
-    if (!childRoute || !("component" in childRoute)) {
-      clearCurrent();
-      return;
-    }
-    const key = instanceKey(childRoute, route2.matched.slice(1), route2);
-    if (childRoute === currentChild && key === currentKey && currentNode) {
-      updateInstanceRoute(currentNode, route2);
-      return;
-    }
-    try {
-      const cacheKey = `${route2.path}\0${childRoute.path}`;
-      const plan = await _routerRef.current.loadPlan(childRoute, cacheKey);
-      if (!commitTarget(seq)) {
-        retryIfDetached(seq);
-        return;
-      }
-      const node = await instantiateScoped(_routerRef.current, plan, childRoute, cacheKey, route2);
-      const parent = commitTarget(seq);
-      if (!parent) {
-        release(node);
-        retryIfDetached(seq);
-        return;
-      }
-      if (!node) return;
-      clearCurrent();
-      parent.insertBefore(node, anchor.nextSibling);
-      currentNode = node;
-      currentChild = childRoute;
-      currentKey = key;
-    } catch (error) {
-      if (outletTorn || seq !== navSeq) return;
-      console.error("[Outlet] Failed to render child route:", error);
-    }
-  };
-  const attachWait = attachRetry(anchor, update);
-  const outletTeardown = track(update);
-  if (!anchor.parentNode) {
-    queueMicrotask(
-      bindOwnerScope(() => {
-        if (anchor.parentNode) update();
-      })
-    );
-  }
-  const outletCleanup = () => {
-    if (outletTorn) return;
-    outletTorn = true;
-    navSeq++;
-    outletTeardown();
-    attachWait.cancel();
-    if (currentNode) {
-      disposeOwned(currentNode);
-      if (currentNode.parentNode) currentNode.parentNode.removeChild(currentNode);
-      currentNode = null;
-    }
-    currentChild = null;
-    currentKey = null;
-  };
-  registerDisposer(anchor, outletCleanup);
-  routeCleanups.push(outletCleanup);
-  return anchor;
-}
-function addRoute(route2, parentPath) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  _routerRef.current.addRoute(route2, parentPath);
-}
-function removeRoute(path) {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  _routerRef.current.removeRoute(path);
-}
-function routerState() {
-  if (!_routerRef.current) throw new Error("Router not initialized. Call createRouter() first.");
-  const router2 = _routerRef.current;
-  return {
-    currentPath: () => scopedRoute(router2).path,
-    params: () => scopedRoute(router2).params,
-    query: () => scopedRoute(router2).query,
-    queryAll: () => scopedRoute(router2).queryAll,
-    hash: () => scopedRoute(router2).hash,
-    meta: () => scopedRoute(router2).meta,
-    isNavigating: () => router2.isNavigating,
-    isReady: () => router2.isReady
-  };
-}
-var routerPlugins = [];
-function routerPlugin(plugin2) {
-  routerPlugins.push(plugin2);
-  if (_routerRef.current?.isReady && plugin2.onReady) {
-    plugin2.onReady();
-  }
-  let removeGuard = null;
-  if (_routerRef.current && plugin2.onNavigate) {
-    removeGuard = _routerRef.current.afterEach((to, from) => {
-      plugin2.onNavigate?.(to, from);
-    });
-  }
-  return () => {
-    const idx = routerPlugins.indexOf(plugin2);
-    if (idx !== -1) routerPlugins.splice(idx, 1);
-    removeGuard?.();
-  };
-}
-var _routeTransitionOptions = null;
-function setRouteTransition(options) {
-  _routeTransitionOptions = options;
-}
-function getRouteTransition() {
-  return _routeTransitionOptions;
-}
-function createMemoryRouter(routes, _initialPath = "/") {
-  const router2 = createRouter(routes, { mode: "hash" });
-  return {
-    router: router2,
-    currentPath: () => router2.currentRoute.path,
-    push: (path) => router2.push(path)
-  };
-}
-
 // src/plugins/routerSSR.ts
 function safeDecode(raw) {
   try {
@@ -2697,8 +430,8 @@ function hydrateRouter(routes, options) {
   const liveUrl = `${window.location.pathname}${window.location.search}${window.location.hash}`;
   const resolved = resolveServerRoute(liveUrl, routes);
   const bootstrapEpoch = __getNavigationEpoch();
-  import("./ssr-VBM6J5SJ.js").then(async ({ hydrate }) => {
-    const { replaceChildrenSafely } = await import("./dispose-GEIG2KOF.js");
+  import("./ssr-NECEU4X4.js").then(async ({ hydrate }) => {
+    const { replaceChildrenSafely } = await import("./dispose-EIHHHDC7.js");
     if (__getNavigationEpoch() !== bootstrapEpoch) return;
     if (resolved.component) {
       hydrate(resolved.component, container);
@@ -2779,6 +512,7 @@ export {
   hydrateRouter,
   inject,
   isPluginInstallCancelledError,
+  jsonLdScript,
   lazy,
   lazyModule,
   navigate,
@@ -2804,6 +538,7 @@ export {
   routerReady,
   routerState,
   satisfies,
+  serializeJsonLd,
   serializeRouteState,
   setDefaultPluginRegistry,
   setLocale,