sibujs 4.13.1 → 4.14.1

package/dist/chunk-L2IPKGUJ.js

@@ -0,0 +1,2596 @@
+import {
+  acquireTitle
+} from "./chunk-52XFPGSN.js";
+import {
+  STATIC_VALUE_RESOLVER,
+  planHeadElementEntry,
+  planMetaEntry,
+  recordServerHead,
+  serializeHeadEntry
+} from "./chunk-TOV4PN3P.js";
+import {
+  appendChildren,
+  resolveClassValue
+} from "./chunk-ZKI4SDZ2.js";
+import {
+  setSafeAttribute
+} from "./chunk-3T7TWMSD.js";
+import {
+  effect
+} from "./chunk-FFXZ6ELZ.js";
+import {
+  sanitizeUrl,
+  stripControlChars
+} from "./chunk-B3HOT4TK.js";
+import {
+  getRequestStore,
+  trackPending
+} from "./chunk-UYTYNCMZ.js";
+import {
+  signal
+} from "./chunk-FCWOMATN.js";
+import {
+  bindOwnerScope,
+  getOwnerScope,
+  runWithOwnerScope,
+  track,
+  untracked
+} from "./chunk-LAHX7XFG.js";
+import {
+  dispose,
+  registerDisposer
+} from "./chunk-S37PZD6I.js";
+import {
+  captureScope,
+  devWarn,
+  inScope,
+  isDev,
+  isHydrating,
+  keyedScope
+} from "./chunk-NT3ZYB5S.js";
+
+// 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", "twitter:image"]);
+var TWITTER_FIELDS = [
+  ["card", "twitter:card"],
+  ["site", "twitter:site"],
+  ["creator", "twitter:creator"],
+  ["title", "twitter:title"],
+  ["description", "twitter:description"],
+  ["image", "twitter:image"]
+];
+var JSON_LD_ATTR = "data-sibu-ld";
+function serializeJsonLd(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function jsonLdScript(data) {
+  return `<script type="application/ld+json">${serializeJsonLd(data)}</script>`;
+}
+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();
+  let twitter;
+  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.robots !== void 0) merged.robots = layer.robots;
+    if (layer.alternates !== void 0) merged.alternates = layer.alternates;
+    if (layer.jsonLd !== void 0) merged.jsonLd = layer.jsonLd;
+    if (layer.og) {
+      for (const [field] of OG_FIELDS) if (layer.og[field] !== void 0) og[field] = layer.og[field];
+    }
+    if (layer.twitter) {
+      twitter ?? (twitter = {});
+      for (const [field] of TWITTER_FIELDS)
+        if (layer.twitter[field] !== void 0) twitter[field] = layer.twitter[field];
+    }
+    for (const entry of layer.meta ?? []) {
+      const id = metaIdentity(entry);
+      if (id) meta.set(id, entry);
+    }
+  }
+  merged.og = og;
+  merged.twitter = twitter;
+  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 existing = tags.findIndex((t) => t.key === key);
+    if (existing !== -1) tags.splice(existing, 1);
+    const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
+    if (plan.kind === "drop") return;
+    const planned = Object.fromEntries(plan.attributes);
+    if (tag === "link" && !planned.href) return;
+    tags.push({ key, tag, attrs: planned });
+  };
+  if (description !== null) push2("meta:name:description", "meta", { name: "description", content: description });
+  const robots = resolveValue(merged.robots, route2);
+  if (robots !== null) push2("meta:name:robots", "meta", { name: "robots", content: robots });
+  if (canonical !== null) push2("link:rel:canonical", "link", { rel: "canonical", href: canonical });
+  const alternates = typeof merged.alternates === "function" ? merged.alternates(route2) : merged.alternates;
+  for (const alt of alternates ?? []) {
+    const href = resolveValue(alt.href, route2);
+    if (href === null || !alt.hreflang) continue;
+    push2(`link:hreflang:${alt.hreflang.toLowerCase()}`, "link", { rel: "alternate", hreflang: alt.hreflang, href });
+  }
+  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 });
+  }
+  if (merged.twitter) {
+    const tw = merged.twitter;
+    const ogValue = (field) => {
+      const fromOg = og[field] === void 0 ? void 0 : resolveValue(og[field], route2);
+      if (fromOg !== void 0) return fromOg;
+      return field === "title" ? ownTitle : field === "description" ? description : null;
+    };
+    for (const [field, name] of TWITTER_FIELDS) {
+      let value = tw[field] === void 0 ? void 0 : resolveValue(tw[field], route2);
+      if (value === void 0 && (field === "title" || field === "description" || field === "image")) {
+        value = ogValue(field);
+      }
+      if (value == null) continue;
+      if (OG_URL_PROPERTIES.has(name)) {
+        value = sanitizeUrl(value);
+        if (value === "") continue;
+      }
+      push2(`meta:name:${name}`, "meta", { name, 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);
+  }
+  const ld = typeof merged.jsonLd === "function" ? merged.jsonLd(route2) : merged.jsonLd;
+  const ldList = ld == null ? [] : Array.isArray(ld) ? ld : [ld];
+  ldList.forEach((data, i) => {
+    let text;
+    try {
+      text = serializeJsonLd(data);
+    } catch {
+      return;
+    }
+    tags.push({
+      key: `script:${JSON_LD_ATTR}:${i}`,
+      tag: "script",
+      attrs: { type: "application/ld+json", [JSON_LD_ATTR]: String(i) },
+      text
+    });
+  });
+  return { title, tags };
+}
+function tagToHTML(t) {
+  if (t.tag === "script") {
+    return `<script type="application/ld+json" ${JSON_LD_ATTR}="${t.attrs[JSON_LD_ATTR]}" ${ROUTE_HEAD_ATTR}="">${t.text ?? ""}</script>`;
+  }
+  const html = serializeHeadEntry(t.tag, t.attrs);
+  return html ? html.replace(/ \/>$/, ` ${ROUTE_HEAD_ATTR}="" />`) : "";
+}
+function serverHeadLayer(route2, defaults) {
+  const head = resolveRouteHead(route2, defaults);
+  return {
+    title: head.title ?? void 0,
+    tags: head.tags.map((t) => ({ key: t.key, html: tagToHTML(t) })).filter((t) => t.html !== "")
+  };
+}
+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 t of head.tags) {
+    const html = tagToHTML(t);
+    if (html) parts.push(html);
+  }
+  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) && (tag.text === void 0 || existing.textContent === tag.text))
+      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);
+    if (tag.tag === "script" && tag.attrs.type === "application/ld+json") next.textContent = tag.text ?? "";
+    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((t) => el.matches(selectorFor(t.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/utils/prerenderHook.ts
+var HOST_KEY = /* @__PURE__ */ Symbol.for("sibujs.prerender.v1");
+function host() {
+  return globalThis[HOST_KEY];
+}
+function isPrerendering() {
+  return host() !== void 0;
+}
+function prerenderRoute() {
+  return host()?.route ?? null;
+}
+function prerenderWait(promise, label = "prerenderWait") {
+  host()?.wait(promise);
+  return trackPending(promise, label);
+}
+
+// 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 trimTrailingSlashes(path) {
+  let end = path.length;
+  while (end > 0 && path.charCodeAt(end - 1) === 47) end--;
+  return end === path.length ? path : path.slice(0, end);
+}
+function stripBase(url, base) {
+  const prefix = base ? trimTrailingSlashes(base) : "";
+  if (!prefix) return url;
+  const cut = url.search(/[?#]/);
+  const path = cut === -1 ? url : url.slice(0, cut);
+  const rest = cut === -1 ? "" : url.slice(cut);
+  if (path !== prefix && !path.startsWith(`${prefix}/`)) return url;
+  return (path.slice(prefix.length) || "/") + rest;
+}
+function normalizePathname(path) {
+  if (!path) return "/";
+  const trimmed = path.length > 1 ? trimTrailingSlashes(path) : 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 build = () => scope ? runWithOwnerScope(scope, component) : component();
+    const result = scope?.adopt ? inScope(scope.adopt, build) : build();
+    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;
+    // A memory router in a server request: the route its head layer describes,
+    // and the layer's withdraw function (see `updateHead`).
+    this.serverHeadRoute = null;
+    this.withdrawServerHead = null;
+    // The location of a "memory" router (it has no browser location).
+    this.memoryLocation = "/";
+    /**
+     * What the initial navigation did, for a server render's HTTP status: the
+     * result, and the status of the first redirect hop it took (a `redirect`
+     * record's `status`, 302 by default; 302 for a guard redirect).
+     * @internal
+     */
+    this.initialOutcome = {
+      result: null,
+      redirectStatus: null,
+      redirectBy: 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;
+    if (this.options.mode === "memory") this.memoryLocation = stripBase(this.options.url || "/", this.options.base);
+    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" && this.options.mode !== "memory") {
+      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).then((result) => {
+          this.initialOutcome.result = result ?? null;
+        });
+      }
+      this.isReadySetter(true);
+      prerenderWait(initial.then(this.resolveReady, this.resolveReady), "router:navigation");
+    });
+  }
+  /** 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 once the initial navigation committed or failed (before component loads). @internal */
+  whenNavigated() {
+    return this.readyPromise;
+  }
+  /** 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 (mode === "memory") return this.memoryLocation;
+    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 split = splitRouteUrl(fullPath);
+    const { query: queryString, hash } = split;
+    const path = this.options.trailingSlash === "ignore" && split.path.length > 1 ? trimTrailingSlashes(split.path) || "/" : split.path;
+    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");
+        }
+        options.redirectStatus ?? (options.redirectStatus = 302);
+        options.redirectBy ?? (options.redirectBy = "guard");
+        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");
+                }
+                options.redirectStatus ?? (options.redirectStatus = 302);
+                options.redirectBy ?? (options.redirectBy = "guard");
+                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");
+        }
+        options.redirectStatus ?? (options.redirectStatus = typeof route2.status === "number" ? route2.status : 302);
+        options.redirectBy ?? (options.redirectBy = "route");
+        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");
+        }
+        options.redirectStatus ?? (options.redirectStatus = 302);
+        options.redirectBy ?? (options.redirectBy = "guard");
+        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 (this.options.mode === "memory") {
+      const search = serializeQuery(to.queryAll);
+      this.memoryLocation = to.path + (search ? `?${search}` : "") + (to.hash ? `#${to.hash}` : "");
+    } else if (!options.skipHistory) {
+      this.updateHistory(to, options);
+    }
+    if (options.initialResolution) {
+      this.initialOutcome.redirectStatus = options.redirectStatus ?? null;
+      this.initialOutcome.redirectBy = options.redirectBy ?? null;
+    }
+    if (!options.initialResolution) this.navEpoch++;
+    this.currentRouteSetter(to);
+    this.updateHead(to);
+    this.guards.runAfterEach(to, from);
+    this.handleScrollBehavior(to, from);
+  }
+  updateHead(to) {
+    if (this.destroyed) return;
+    if (this.options.mode === "memory" && getRequestStore()) {
+      this.serverHeadRoute = to;
+      if (this.withdrawServerHead === null && routeHasHead(to.matched, this.options.head)) {
+        this.withdrawServerHead = recordServerHead(() => {
+          const route2 = this.serverHeadRoute;
+          if (route2 === null || !routeHasHead(route2.matched, this.options.head)) return null;
+          return serverHeadLayer(route2, this.options.head);
+        });
+      }
+      return;
+    }
+    if (typeof document === "undefined") 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), `router:load ${route2.path}`);
+  }
+  /**
+   * 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), `router:render ${route2.path}`);
+  }
+  /** 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.withdrawServerHead?.();
+    this.withdrawServerHead = null;
+    this.serverHeadRoute = 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 _globalRouterRef = globalThis[ROUTER_KEY] ?? (globalThis[ROUTER_KEY] = { current: null });
+var REQUEST_ROUTER = "router";
+var _routerRef = {
+  get current() {
+    const own = getRequestStore()?.slots?.get(REQUEST_ROUTER);
+    return own ?? _globalRouterRef.current;
+  },
+  set current(router2) {
+    const slots = getRequestStore()?.slots;
+    if (slots?.get(REQUEST_ROUTER)) slots.set(REQUEST_ROUTER, router2);
+    else _globalRouterRef.current = router2;
+  }
+};
+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 = {}) {
+  let routes;
+  if (Array.isArray(routesOrOptions)) {
+    routes = normalizeRoutes(routesOrOptions);
+  } else {
+    options = routesOrOptions;
+    routes = [];
+  }
+  const store = getRequestStore();
+  if (options.mode === "memory" && store) {
+    const slots = store.slots ?? (store.slots = /* @__PURE__ */ new Map());
+    slots.get(REQUEST_ROUTER)?.destroy();
+    const router2 = new SibuRouter(routes, options);
+    slots.set(REQUEST_ROUTER, router2);
+    return router2;
+  }
+  if (_routerRef.current) {
+    _routerRef.current.destroy();
+  }
+  _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) {
+    /** Creation scope the instance is built in (adopting hydration); see `adoptScope`. */
+    this.adopt = null;
+    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, adopt = null) {
+  const scope = new RouteScope(route2);
+  scope.adopt = adopt;
+  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");
+  const adoptScope = captureScope();
+  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 && !isHydrating()) {
+      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,
+            keyedScope(adoptScope, routeDef.path)
+          );
+          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");
+  const adoptScope = captureScope();
+  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,
+        keyedScope(adoptScope, childRoute.path)
+      );
+      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(plugin) {
+  routerPlugins.push(plugin);
+  if (_routerRef.current?.isReady && plugin.onReady) {
+    plugin.onReady();
+  }
+  let removeGuard = null;
+  if (_routerRef.current && plugin.onNavigate) {
+    removeGuard = _routerRef.current.afterEach((to, from) => {
+      plugin.onNavigate?.(to, from);
+    });
+  }
+  return () => {
+    const idx = routerPlugins.indexOf(plugin);
+    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)
+  };
+}
+
+export {
+  serializeJsonLd,
+  jsonLdScript,
+  resolveRouteHead,
+  routeHeadToHTML,
+  isPrerendering,
+  prerenderRoute,
+  prerenderWait,
+  SibuRouter,
+  createRouter,
+  setRoutes,
+  route,
+  router,
+  routerReady,
+  navigate,
+  push,
+  replace,
+  go,
+  back,
+  forward,
+  beforeEach,
+  beforeResolve,
+  afterEach,
+  Route,
+  KeepAliveRoute,
+  RouterLink,
+  Suspense,
+  lazy,
+  preloadRoute,
+  __getNavigationEpoch,
+  hasRoute,
+  getRouteInfo,
+  buildURL,
+  destroyRouter,
+  __removeRouterPagehideHandler,
+  Outlet,
+  addRoute,
+  removeRoute,
+  routerState,
+  routerPlugin,
+  setRouteTransition,
+  getRouteTransition,
+  createMemoryRouter
+};