sibujs 4.12.0 → 4.13.1

package/dist/plugins.cjs

@@ -980,6 +980,80 @@ var init_globalSingleton = __esm({
   }
 });
 
+// src/utils/headEntry.ts
+function isEmittableHeadAttrName(name) {
+  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
+  const canonical = canonicalAttrName(name);
+  if (isEventHandlerAttr(canonical)) return false;
+  if (isHtmlContentAttribute(canonical)) return false;
+  return true;
+}
+function sanitizeHeadAttrValue(canonical, value) {
+  return resolveAttributeValue(canonical, value);
+}
+function findDuplicateAttributeName(names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const canonical = canonicalAttrName(name);
+    if (seen.has(canonical)) return canonical;
+    seen.add(canonical);
+  }
+  return null;
+}
+function planEntry(props, resolver, applyRefreshPolicy) {
+  const rawNames = Object.keys(props);
+  const duplicate = findDuplicateAttributeName(rawNames);
+  if (duplicate !== null) {
+    return { kind: "drop", reason: `duplicate case-insensitive attribute ${JSON.stringify(duplicate)}` };
+  }
+  const attributes = /* @__PURE__ */ new Map();
+  let reactive = false;
+  for (const name of rawNames) {
+    if (!Object.hasOwn(props, name)) continue;
+    if (!isEmittableHeadAttrName(name)) continue;
+    const authored = props[name];
+    if (resolver.isReactiveValue?.(authored)) reactive = true;
+    const canonical = canonicalAttrName(name);
+    const sanitized = sanitizeHeadAttrValue(canonical, resolver.resolveValue(name, authored));
+    if (sanitized === null) continue;
+    attributes.set(canonical, sanitized);
+  }
+  if (attributes.size === 0) return { kind: "drop", reason: "no effective attributes remain" };
+  const refresh = applyRefreshPolicy ? resolveMetaRefreshPolicy(attributes) : { kind: "not-refresh" };
+  if (refresh.kind === "forbidden") return { kind: "drop", reason: refresh.reason };
+  if (reactive && (refresh.kind === "allowed" || refresh.kind === "delay-only")) {
+    return { kind: "drop", reason: "a reactive meta entry may not publish a native refresh directive" };
+  }
+  return { kind: "publish", attributes, refresh };
+}
+function planMetaEntry(props, resolver) {
+  return planEntry(props, resolver, true);
+}
+function planHeadElementEntry(props, resolver) {
+  return planEntry(props, resolver, false);
+}
+function escapeHeadAttrValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeHeadEntry(tag, attrs) {
+  const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
+  if (plan.kind === "drop") return "";
+  const pairs = Array.from(plan.attributes, ([name, value]) => `${name}="${escapeHeadAttrValue(value)}"`).join(" ");
+  return `<${tag} ${pairs} />`;
+}
+var SAFE_HEAD_ATTR_NAME, STATIC_VALUE_RESOLVER;
+var init_headEntry = __esm({
+  "src/utils/headEntry.ts"() {
+    "use strict";
+    init_metaRefresh();
+    init_sanitize();
+    SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
+    STATIC_VALUE_RESOLVER = {
+      resolveValue: (_name, value) => String(value)
+    };
+  }
+});
+
 // src/utils/embedPolicy.ts
 function currentEmbedAllowlist() {
   const scoped = getRequestStore()?.caches?.get(REQUEST_CACHE)?.get("allowed");
@@ -1122,80 +1196,6 @@ var init_guards = __esm({
   }
 });
 
-// src/utils/headEntry.ts
-function isEmittableHeadAttrName(name) {
-  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
-  const canonical = canonicalAttrName(name);
-  if (isEventHandlerAttr(canonical)) return false;
-  if (isHtmlContentAttribute(canonical)) return false;
-  return true;
-}
-function sanitizeHeadAttrValue(canonical, value) {
-  return resolveAttributeValue(canonical, value);
-}
-function findDuplicateAttributeName(names) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const name of names) {
-    const canonical = canonicalAttrName(name);
-    if (seen.has(canonical)) return canonical;
-    seen.add(canonical);
-  }
-  return null;
-}
-function planEntry(props, resolver, applyRefreshPolicy) {
-  const rawNames = Object.keys(props);
-  const duplicate = findDuplicateAttributeName(rawNames);
-  if (duplicate !== null) {
-    return { kind: "drop", reason: `duplicate case-insensitive attribute ${JSON.stringify(duplicate)}` };
-  }
-  const attributes = /* @__PURE__ */ new Map();
-  let reactive = false;
-  for (const name of rawNames) {
-    if (!Object.hasOwn(props, name)) continue;
-    if (!isEmittableHeadAttrName(name)) continue;
-    const authored = props[name];
-    if (resolver.isReactiveValue?.(authored)) reactive = true;
-    const canonical = canonicalAttrName(name);
-    const sanitized = sanitizeHeadAttrValue(canonical, resolver.resolveValue(name, authored));
-    if (sanitized === null) continue;
-    attributes.set(canonical, sanitized);
-  }
-  if (attributes.size === 0) return { kind: "drop", reason: "no effective attributes remain" };
-  const refresh = applyRefreshPolicy ? resolveMetaRefreshPolicy(attributes) : { kind: "not-refresh" };
-  if (refresh.kind === "forbidden") return { kind: "drop", reason: refresh.reason };
-  if (reactive && (refresh.kind === "allowed" || refresh.kind === "delay-only")) {
-    return { kind: "drop", reason: "a reactive meta entry may not publish a native refresh directive" };
-  }
-  return { kind: "publish", attributes, refresh };
-}
-function planMetaEntry(props, resolver) {
-  return planEntry(props, resolver, true);
-}
-function planHeadElementEntry(props, resolver) {
-  return planEntry(props, resolver, false);
-}
-function escapeHeadAttrValue(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function serializeHeadEntry(tag, attrs) {
-  const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
-  if (plan.kind === "drop") return "";
-  const pairs = Array.from(plan.attributes, ([name, value]) => `${name}="${escapeHeadAttrValue(value)}"`).join(" ");
-  return `<${tag} ${pairs} />`;
-}
-var SAFE_HEAD_ATTR_NAME, STATIC_VALUE_RESOLVER;
-var init_headEntry = __esm({
-  "src/utils/headEntry.ts"() {
-    "use strict";
-    init_metaRefresh();
-    init_sanitize();
-    SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-    STATIC_VALUE_RESOLVER = {
-      resolveValue: (_name, value) => String(value)
-    };
-  }
-});
-
 // src/platform/ssr.ts
 var ssr_exports = {};
 __export(ssr_exports, {
@@ -1943,10 +1943,13 @@ __export(plugins_exports, {
   renderRouteToString: () => renderRouteToString,
   replace: () => replace,
   resetPlugins: () => resetPlugins,
+  resolveRouteHead: () => resolveRouteHead,
   resolveServerRoute: () => resolveServerRoute,
   route: () => route,
+  routeHeadToHTML: () => routeHeadToHTML,
   router: () => router,
   routerPlugin: () => routerPlugin,
+  routerReady: () => routerReady,
   routerState: () => routerState,
   satisfies: () => satisfies,
   serializeRouteState: () => serializeRouteState,
@@ -1962,100 +1965,219 @@ __export(plugins_exports, {
 });
 module.exports = __toCommonJS(plugins_exports);
 
-// src/core/rendering/tagFactory.ts
-init_dev();
-
-// src/reactivity/bindAttribute.ts
-init_errors();
-init_sanitize();
-
-// src/utils/setSafeAttribute.ts
-init_dev();
-init_elementPolicy();
-init_sanitize();
-var HTML_NS2 = "http://www.w3.org/1999/xhtml";
-var SVG_NS2 = "http://www.w3.org/2000/svg";
-var XLINK_NS = "http://www.w3.org/1999/xlink";
-var XML_NS = "http://www.w3.org/XML/1998/namespace";
-var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
-function isHtmlElement(el) {
-  return el.namespaceURI === null || el.namespaceURI === HTML_NS2;
-}
-function warnContextualRefusal(label2, name, refusal) {
-  devWarnLazy(() => {
-    const reasons = [
-      "",
-      'the element would become a <meta http-equiv="refresh"> directive the shared refresh policy forbids (a destination outside the URL allowlist, or a directive too malformed to read unambiguously)',
-      "a <meta> whose http-equiv or content is reactive may never carry a refresh directive: a browser schedules the navigation as soon as the directive is valid, and nothing can withdraw it when the state changes back",
-      "a runtime value may not choose the program a <script> runs; name the script in static template source, or load it through Head({ script }) as an explicit trust decision",
-      "an SVG animation may not target a URL, event-handler or nested-document attribute; its to / values would be written into that attribute without passing the URL policy",
-      'a runtime-chosen href may not become an applied <link rel="stylesheet">: a well-formed URL is not a trusted stylesheet. Name the stylesheet in static template source, or load a runtime-chosen one through Head({ link }) as an explicit trust decision'
-    ];
-    return `${label2}: refusing "${name}" in this element's context \u2014 ${reasons[refusal]}. The write was not performed.`;
-  });
-}
-function setProp(el, key, val) {
-  el[key] = val;
-}
-function namespaceFor(el, name) {
-  if (el.namespaceURI !== SVG_NS2) return null;
-  const lower = name.toLowerCase();
-  if (lower.startsWith("xlink:")) return XLINK_NS;
-  if (lower.startsWith("xml:")) return XML_NS;
-  return null;
-}
-function setSafeAttribute(el, name, value, options = {}) {
-  const written = commitSafeAttribute(el, name, value, options);
-  if (el.localName === "link") settleAttributeProvenance(el, name, options.reactive ? "reactive" : "runtime");
-  return written;
-}
-function commitSafeAttribute(el, name, value, options) {
-  const ns = namespaceFor(el, name);
-  const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
-  if (isEventHandlerAttr(name)) {
-    if (DEV) {
-      devWarn(
-        `${options.label ?? "setSafeAttribute"}: refusing to set event-handler attribute "${name}". Its value would be evaluated as JavaScript. Use on:{ ${name.slice(2)}: fn } instead.`
-      );
-    }
-    if (ns) el.removeAttributeNS(ns, localName);
-    else el.removeAttribute(name);
-    return false;
-  }
-  const pending = value == null || value === false ? null : value === true ? "" : String(value);
-  const refusal = contextualAttributeRefusal(el, name, pending, options.reactive ? "reactive" : "runtime");
-  if (refusal !== ContextualRefusal.None) {
-    warnContextualRefusal(options.label ?? "setSafeAttribute", name, refusal);
-    if (ns) el.removeAttributeNS(ns, localName);
-    else el.removeAttribute(name);
-    return false;
-  }
-  if (value == null) {
-    if (ns) el.removeAttributeNS(ns, localName);
-    else el.removeAttribute(name);
-    return true;
-  }
-  if (isHtmlContentAttribute(name)) {
-    if (DEV) {
-      devWarn(
-        `${options.label ?? "setSafeAttribute"}: refusing to set "${name}". The browser parses this attribute as a nested HTML document, so a generic string value cannot be made safe \u2014 attribute escaping is undone before the parse. Build the frame's content another way.`
-      );
-    }
-    if (ns) el.removeAttributeNS(ns, localName);
-    else el.removeAttribute(name);
-    return false;
-  }
-  const html2 = isHtmlElement(el);
-  const idlName = html2 ? name.toLowerCase() : name;
-  if (typeof value === "boolean") {
-    if (name.length > 5 && name.slice(0, 5).toLowerCase() === "aria-") {
-      const token = value ? "true" : "false";
-      if ((ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name)) !== token) {
-        if (ns) el.setAttributeNS(ns, name, token);
-        else el.setAttribute(name, token);
+// src/plugins/ecosystem.ts
+function createTestHarness() {
+  let container;
+  return {
+    /** Set up a clean DOM container before each test */
+    setup() {
+      container = document.createElement("div");
+      container.setAttribute("data-sibu-test", "true");
+      document.body.appendChild(container);
+      return container;
+    },
+    /** Tear down the DOM container after each test */
+    teardown() {
+      if (container?.parentNode) {
+        container.parentNode.removeChild(container);
       }
-      return true;
-    }
+    },
+    /** Render a component into the test container */
+    render(component) {
+      const el = typeof component === "function" ? component() : component;
+      container.appendChild(el);
+      return el;
+    },
+    /** Get the test container */
+    getContainer() {
+      return container;
+    },
+    /** Wait for reactive updates to settle */
+    async flush() {
+      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => requestAnimationFrame(() => r()));
+    },
+    /** Query within the container */
+    query(selector) {
+      return container.querySelector(selector);
+    },
+    /** Query all matching elements within the container */
+    queryAll(selector) {
+      return Array.from(container.querySelectorAll(selector));
+    },
+    /** Simulate a click event */
+    click(el) {
+      el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    },
+    /** Simulate input value change */
+    input(el, value) {
+      el.value = value;
+      el.dispatchEvent(new Event("input", { bubbles: true }));
+    }
+  };
+}
+var bundlerMetadata = {
+  name: "sibu",
+  sideEffects: false,
+  modules: {
+    core: ["html", "mount", "each", "slots", "fragment", "catch", "portal", "directives"],
+    hooks: ["signal", "effect", "derived", "watch", "store", "ref", "array", "deepSignal"],
+    plugins: ["router", "i18n"],
+    components: ["ErrorBoundary", "Loading"],
+    ssr: ["ssr"],
+    advanced: ["globalStore", "machine", "optimistic", "timeTravel", "scheduler", "plugin"]
+  },
+  /** Generate import map for module resolution */
+  generateImportMap(base2 = "/node_modules/sibu/") {
+    const map2 = {};
+    for (const [category, modules] of Object.entries(this.modules)) {
+      for (const mod of modules) {
+        const dir = category === "hooks" ? "core" : category;
+        map2[`sibu/${mod}`] = `${base2}src/${dir}/${mod}.js`;
+      }
+    }
+    return map2;
+  }
+};
+function healthCheck() {
+  const checks = [];
+  const hasDOM = typeof document !== "undefined";
+  checks.push({
+    name: "DOM Environment",
+    passed: hasDOM,
+    message: hasDOM ? "DOM is available" : "No DOM environment (SSR mode)"
+  });
+  const hasRAF = typeof requestAnimationFrame !== "undefined";
+  checks.push({
+    name: "requestAnimationFrame",
+    passed: hasRAF,
+    message: hasRAF ? "Available" : "Not available (polyfill may be needed)"
+  });
+  const hasMO = typeof MutationObserver !== "undefined";
+  checks.push({
+    name: "MutationObserver",
+    passed: hasMO,
+    message: hasMO ? "Available" : "Not available (lifecycle hooks may not work)"
+  });
+  const allPassed = checks.every((c) => c.passed);
+  return {
+    status: allPassed ? "ok" : "warning",
+    checks
+  };
+}
+var env = {
+  /** True when running in a browser with a DOM */
+  isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
+  /** True when running in Node.js */
+  isNode: typeof process !== "undefined" && !!process.versions?.node,
+  /** True when running inside a Web Worker */
+  isWorker: typeof self !== "undefined" && typeof self.importScripts === "function",
+  /** True when running inside Deno */
+  isDeno: typeof globalThis.Deno !== "undefined",
+  /** True when running inside Bun */
+  isBun: typeof globalThis.Bun !== "undefined",
+  /** True when no window object is available (server-side rendering) */
+  isSSR: typeof window === "undefined",
+  /** True when NODE_ENV is not "production" */
+  isDev: typeof process !== "undefined" && process.env?.NODE_ENV !== "production",
+  /** True when NODE_ENV is "test" or VITEST is set */
+  isTest: typeof process !== "undefined" && (process.env?.NODE_ENV === "test" || process.env?.VITEST === "true")
+};
+
+// src/core/rendering/tagFactory.ts
+init_dev();
+
+// src/reactivity/bindAttribute.ts
+init_errors();
+init_sanitize();
+
+// src/utils/setSafeAttribute.ts
+init_dev();
+init_elementPolicy();
+init_sanitize();
+var HTML_NS2 = "http://www.w3.org/1999/xhtml";
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
+function isHtmlElement(el) {
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS2;
+}
+function warnContextualRefusal(label2, name, refusal) {
+  devWarnLazy(() => {
+    const reasons = [
+      "",
+      'the element would become a <meta http-equiv="refresh"> directive the shared refresh policy forbids (a destination outside the URL allowlist, or a directive too malformed to read unambiguously)',
+      "a <meta> whose http-equiv or content is reactive may never carry a refresh directive: a browser schedules the navigation as soon as the directive is valid, and nothing can withdraw it when the state changes back",
+      "a runtime value may not choose the program a <script> runs; name the script in static template source, or load it through Head({ script }) as an explicit trust decision",
+      "an SVG animation may not target a URL, event-handler or nested-document attribute; its to / values would be written into that attribute without passing the URL policy",
+      'a runtime-chosen href may not become an applied <link rel="stylesheet">: a well-formed URL is not a trusted stylesheet. Name the stylesheet in static template source, or load a runtime-chosen one through Head({ link }) as an explicit trust decision'
+    ];
+    return `${label2}: refusing "${name}" in this element's context \u2014 ${reasons[refusal]}. The write was not performed.`;
+  });
+}
+function setProp(el, key, val) {
+  el[key] = val;
+}
+function namespaceFor(el, name) {
+  if (el.namespaceURI !== SVG_NS2) return null;
+  const lower = name.toLowerCase();
+  if (lower.startsWith("xlink:")) return XLINK_NS;
+  if (lower.startsWith("xml:")) return XML_NS;
+  return null;
+}
+function setSafeAttribute(el, name, value, options = {}) {
+  const written = commitSafeAttribute(el, name, value, options);
+  if (el.localName === "link") settleAttributeProvenance(el, name, options.reactive ? "reactive" : "runtime");
+  return written;
+}
+function commitSafeAttribute(el, name, value, options) {
+  const ns = namespaceFor(el, name);
+  const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
+  if (isEventHandlerAttr(name)) {
+    if (DEV) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set event-handler attribute "${name}". Its value would be evaluated as JavaScript. Use on:{ ${name.slice(2)}: fn } instead.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  const pending = value == null || value === false ? null : value === true ? "" : String(value);
+  const refusal = contextualAttributeRefusal(el, name, pending, options.reactive ? "reactive" : "runtime");
+  if (refusal !== ContextualRefusal.None) {
+    warnContextualRefusal(options.label ?? "setSafeAttribute", name, refusal);
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  if (value == null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
+  if (isHtmlContentAttribute(name)) {
+    if (DEV) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set "${name}". The browser parses this attribute as a nested HTML document, so a generic string value cannot be made safe \u2014 attribute escaping is undone before the parse. Build the frame's content another way.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  const html2 = isHtmlElement(el);
+  const idlName = html2 ? name.toLowerCase() : name;
+  if (typeof value === "boolean") {
+    if (name.length > 5 && name.slice(0, 5).toLowerCase() === "aria-") {
+      const token = value ? "true" : "false";
+      if ((ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name)) !== token) {
+        if (ns) el.setAttributeNS(ns, name, token);
+        else el.setAttribute(name, token);
+      }
+      return true;
+    }
     if (html2 && BOOLEAN_IDL_ATTRS.has(idlName) && idlName in el) {
       setProp(el, idlName, value);
     } else if (value) {
@@ -2253,6 +2375,7 @@ function bindOwnerScope(fn) {
   if (scope === null) return fn;
   return (...args) => runWithOwnerScope(scope, () => fn(...args));
 }
+var currentStructOwner = null;
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
@@ -2272,6 +2395,9 @@ function retrack(effectFn, subscriber) {
   if (prevScope !== null && !sub2._epoch && sub2._scope === void 0) sub2._scope = prevScope;
   const scope = sub2._scope === void 0 ? null : sub2._scope;
   if (scope !== prevScope) currentOwnerScope = scope;
+  const prevStructOwner = currentStructOwner;
+  if (prevStructOwner !== null && !sub2._epoch && !sub2._c && sub2._owner == null) sub2._owner = prevStructOwner;
+  if (sub2._tok != null) currentStructOwner = sub2._tok;
   const epoch = ++subscriberEpochCounter;
   sub2._epoch = epoch;
   sub2._structDirty = false;
@@ -2285,6 +2411,7 @@ function retrack(effectFn, subscriber) {
   } finally {
     currentSubscriber = prev;
     currentOwnerScope = prevScope;
+    currentStructOwner = prevStructOwner;
     if (savedDepth !== 0) {
       suspendDepth = savedDepth;
       suspendSavedSub = savedSuspendSub;
@@ -2341,7 +2468,25 @@ function track(effectFn, subscriber) {
   }
   return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit, ownerNode) {
+function reactiveBinding(commit, ownerNode, structural) {
+  return createBinding(commit, ownerNode, structural === true)._dispose;
+}
+function structuralBinding(commit, ownerNode) {
+  const sub2 = createBinding(commit, ownerNode, true);
+  return {
+    stop: sub2._dispose,
+    run: (fn) => {
+      const prev = currentStructOwner;
+      currentStructOwner = sub2._tok ?? null;
+      try {
+        return fn();
+      } finally {
+        currentStructOwner = prev;
+      }
+    }
+  };
+}
+function createBinding(commit, ownerNode, structural) {
   const run = () => {
     const s2 = subscriber;
     if (s2._disposed || s2._reentrant) return;
@@ -2364,19 +2509,25 @@ function reactiveBinding(commit, ownerNode) {
   subscriber._disposed = false;
   subscriber._errorPhase = "binding";
   subscriber._errorNode = ownerNode;
+  subscriber._tok = null;
+  subscriber._owner = null;
+  if (structural) subscriber._tok = { sub: subscriber };
   try {
     run();
   } catch (err) {
     subscriber._disposed = true;
     subscriber._errorNode = void 0;
+    if (subscriber._tok != null) subscriber._tok.sub = null;
     cleanup(subscriber);
     throw err;
   }
-  return subscriber._dispose ?? (subscriber._dispose = () => {
+  subscriber._dispose = () => {
     subscriber._disposed = true;
     subscriber._errorNode = void 0;
+    if (subscriber._tok != null) subscriber._tok.sub = null;
     cleanup(subscriber);
-  });
+  };
+  return subscriber;
 }
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
@@ -2400,6 +2551,7 @@ function recordDependency(signal2) {
 }
 function cleanup(subscriber) {
   const sub2 = subscriber;
+  if (sub2._owner != null) sub2._owner = null;
   let node = sub2.depsHead ?? null;
   sub2.depsHead = null;
   sub2.depsTail = null;
@@ -2459,20 +2611,41 @@ function drainQueue() {
       break;
     }
     const sub2 = pendingQueue[i2++];
-    pendingSet.delete(sub2);
-    if (quarantined.size > 0 && quarantined.has(sub2)) continue;
-    if (sub2._hasComputedDep === true && !depsChanged(sub2)) continue;
-    if (tickRepeat(sub2)) {
-      cycleError(sub2);
-      quarantined.add(sub2);
-      continue;
-    }
-    const pushed = beginDisposerCapture(sub2._cap ?? null);
-    try {
-      safeInvoke(sub2);
-    } finally {
-      if (pushed) endDisposerCapture();
-    }
+    if (!pendingSet.delete(sub2)) continue;
+    if (sub2._owner != null && pendingSet.size > 0) {
+      runPendingOwners(sub2);
+      if (pendingSet.has(sub2)) continue;
+    }
+    runQueued(sub2);
+  }
+}
+function runPendingOwners(sub2) {
+  for (; ; ) {
+    let outer = null;
+    for (let t2 = sub2._owner ?? null; t2 !== null; ) {
+      const o = t2.sub;
+      if (o === null) break;
+      if (pendingSet.has(o)) outer = o;
+      t2 = o._owner ?? null;
+    }
+    if (outer === null) return;
+    pendingSet.delete(outer);
+    runQueued(outer);
+  }
+}
+function runQueued(sub2) {
+  if (quarantined.size > 0 && quarantined.has(sub2)) return;
+  if (sub2._hasComputedDep === true && !depsChanged(sub2)) return;
+  if (tickRepeat(sub2)) {
+    cycleError(sub2);
+    quarantined.add(sub2);
+    return;
+  }
+  const pushed = beginDisposerCapture(sub2._cap ?? null);
+  try {
+    safeInvoke(sub2);
+  } finally {
+    if (pushed) endDisposerCapture();
   }
 }
 function drainNotificationQueue() {
@@ -2608,7 +2781,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.12.0" : "dev";
+var _runtimeVersion = true ? "4.13.1" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -2643,6 +2816,7 @@ function resolveReactiveApi() {
     getOwnerScope,
     runWithOwnerScope,
     bindOwnerScope,
+    structuralBinding,
     version: _runtimeVersion
   };
   g2[REGISTRY_KEY] = local;
@@ -2669,6 +2843,7 @@ var forEachSubscriber2 = API.forEachSubscriber;
 var getOwnerScope2 = API.getOwnerScope ?? getOwnerScope;
 var runWithOwnerScope2 = API.runWithOwnerScope ?? runWithOwnerScope;
 var bindOwnerScope2 = API.bindOwnerScope ?? bindOwnerScope;
+var structuralBinding2 = API.structuralBinding ?? ((commit, ownerNode) => ({ stop: API.reactiveBinding(commit, ownerNode), run: (fn) => fn() }));
 
 // src/reactivity/bindAttribute.ts
 function bindAttribute(el, attr, getter) {
@@ -2764,9 +2939,10 @@ function refocus(el, snapshot) {
     field.setSelectionRange(start, end, snapshot.direction ?? "none");
   }
 }
-function restoreFocusWithin(snapshot, nodes, where) {
+function restoreFocusWithin(snapshot, nodes, where, policy) {
   if (!snapshot) return;
   if (typeof document === "undefined") return;
+  if (policy === "discard") return;
   const active = document.activeElement;
   if (active === snapshot.el) return;
   if (active && active !== document.body && active !== document.documentElement) return;
@@ -2783,10 +2959,17 @@ function restoreFocusWithin(snapshot, nodes, where) {
     }
     ambiguous = count > 1;
   }
+  if (policy !== void 0 && typeof policy === "object") {
+    const target = typeof policy.restoreTo === "function" ? policy.restoreTo() : policy.restoreTo;
+    if (target?.isConnected) {
+      target.focus();
+      if (document.activeElement === target) return;
+    }
+  }
   devWarnLazy(() => {
     const id = snapshot.attr ? ` (${snapshot.attr}="${snapshot.value}")` : "";
     const why = ambiguous ? `several elements in the rebuilt subtree share ${snapshot.attr}="${snapshot.value}", so there is no way to tell which one the user was in \u2014 a shared name (a radio group) identifies a GROUP, not a control. Add a unique id or data-focus-key to each` : "no element in the rebuilt subtree carries the same identity. Give it a stable id, name, or data-focus-key that the rebuild reproduces";
-    return `${where}: a reactive rebuild discarded the focused element <${snapshot.tag.toLowerCase()}>${id} and could not re-establish it, so focus fell back to <body>. An in-progress edit ends here, and an in-progress IME composition is lost outright \u2014 a composition belongs to the DOM node, so it cannot survive the node being destroyed. ${why}, or stop the rebuild from happening: key the subtree with match(() => shapeKey(), { \u2026 }) so it is re-created only when the shape actually changes, and drive the rest with reactive attributes and text children, which mutate nodes in place instead of replacing them.`;
+    return `${where}: a reactive rebuild discarded the focused element <${snapshot.tag.toLowerCase()}>${id} and could not re-establish it, so focus fell back to <body>. An in-progress edit ends here, and an in-progress IME composition is lost outright \u2014 a composition belongs to the DOM node, so it cannot survive the node being destroyed. ${why}, or stop the rebuild from happening: key the subtree with match(() => shapeKey(), { \u2026 }) so it is re-created only when the shape actually changes, and drive the rest with reactive attributes and text children, which mutate nodes in place instead of replacing them. If dropping focus is INTENDED here (closing a panel, say), pass { focus: "discard" } to when()/match() to silence this, or { focus: { restoreTo: element } } to send focus somewhere other than <body>.`;
   });
 }
 
@@ -2861,7 +3044,7 @@ function bindChildNode(placeholder, getter) {
     lastNodes = newNodes;
     restoreFocusWithin(focused, newNodes, "bindChildNode");
   }
-  return reactiveBinding2(commit, placeholder);
+  return reactiveBinding2(commit, placeholder, true);
 }
 
 // src/core/rendering/tagFactory.ts
@@ -3518,37 +3701,451 @@ function getAvailableLocales() {
   return Object.keys(locales);
 }
 
-// src/plugins/router.ts
-init_dev();
-init_dispose();
-
-// src/core/signals/effect.ts
-init_dev();
-init_errors();
-init_ssr_context();
-var _g2 = globalThis;
-var MAX_RERUNS = 100;
-function flushUserCleanups(ctx) {
-  const list = ctx.userCleanups;
-  if (list.length === 0) return;
-  ctx.userCleanups = [];
-  const scope = ctx.subscriber._scope ?? null;
-  if (scope === getOwnerScope2()) runCleanups(list);
-  else runWithOwnerScope2(scope, () => runCleanups(list));
-}
-function runCleanups(list) {
-  for (let i2 = list.length - 1; i2 >= 0; i2--) {
-    try {
-      list[i2]();
-    } catch (err) {
-      reportError(err, { phase: "cleanup" });
+// src/plugins/modular.ts
+function createModuleRegistry() {
+  const modules = /* @__PURE__ */ new Map();
+  const resolving = [];
+  function resolveInternal(name) {
+    const entry = modules.get(name);
+    if (!entry) {
+      throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
     }
-  }
-}
-function drainReruns(ctx) {
-  let reruns = 1;
-  do {
-    ctx.rerunPending = false;
+    if (entry.state === "loaded") {
+      return entry.value;
+    }
+    if (entry.state === "resolving") {
+      const cycle = [...resolving.slice(resolving.indexOf(name)), name].join(" -> ");
+      throw new Error(`[ModuleRegistry] Circular dependency detected: ${cycle}`);
+    }
+    entry.state = "resolving";
+    resolving.push(name);
+    try {
+      for (const dep of entry.deps) {
+        resolveInternal(dep);
+      }
+      entry.value = entry.factory();
+      entry.state = "loaded";
+      return entry.value;
+    } catch (err) {
+      entry.state = "unloaded";
+      entry.value = void 0;
+      throw err;
+    } finally {
+      resolving.pop();
+    }
+  }
+  return {
+    /** Register a module with its factory function and optional dependencies */
+    register(name, factory, deps = []) {
+      modules.set(name, { factory, deps, state: "unloaded" });
+    },
+    /** Resolve a module, loading its dependencies first */
+    resolve(name) {
+      return resolveInternal(name);
+    },
+    /** Check if a module is registered */
+    has(name) {
+      return modules.has(name);
+    },
+    /** List all registered module names */
+    list() {
+      return Array.from(modules.keys());
+    },
+    /** Get the full dependency graph (transitive) for a module */
+    deps(name) {
+      const entry = modules.get(name);
+      if (!entry) {
+        throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
+      }
+      const visited = /* @__PURE__ */ new Set();
+      const result = [];
+      function walk(modName) {
+        const mod = modules.get(modName);
+        if (!mod) return;
+        for (const dep of mod.deps) {
+          if (!visited.has(dep)) {
+            visited.add(dep);
+            walk(dep);
+            result.push(dep);
+          }
+        }
+      }
+      walk(name);
+      return result;
+    },
+    /** Reset all loaded modules back to unloaded state (useful for testing) */
+    reset() {
+      for (const entry of modules.values()) {
+        entry.state = "unloaded";
+        entry.value = void 0;
+      }
+    }
+  };
+}
+function createBundle(modules) {
+  const cache = /* @__PURE__ */ new Map();
+  const bundle = {};
+  for (const key of Object.keys(modules)) {
+    Object.defineProperty(bundle, key, {
+      get() {
+        if (cache.has(key)) {
+          return cache.get(key);
+        }
+        const value = modules[key]();
+        cache.set(key, value);
+        return value;
+      },
+      enumerable: true,
+      configurable: false
+    });
+  }
+  return bundle;
+}
+function lazyModule(loader) {
+  let cached;
+  let loadedFlag = false;
+  let inFlight = null;
+  return {
+    get loaded() {
+      return loadedFlag;
+    },
+    get() {
+      if (loadedFlag) return Promise.resolve(cached);
+      if (inFlight) return inFlight;
+      let started;
+      try {
+        started = Promise.resolve(loader());
+      } catch (err) {
+        started = Promise.reject(err);
+      }
+      const attempt = started.then(
+        (value) => {
+          cached = value;
+          loadedFlag = true;
+          if (inFlight === attempt) inFlight = null;
+          return value;
+        },
+        (err) => {
+          if (inFlight === attempt) inFlight = null;
+          throw err;
+        }
+      );
+      inFlight = attempt;
+      return attempt;
+    }
+  };
+}
+var MODULE_ENTRY_POINTS = {
+  main: "./index.ts",
+  data: "./data.ts",
+  browser: "./browser.ts",
+  patterns: "./patterns.ts",
+  motion: "./motion.ts",
+  ui: "./ui.ts",
+  widgets: "./widgets.ts",
+  ssr: "./ssr.ts",
+  devtools: "./devtools.ts",
+  performance: "./performance.ts",
+  ecosystem: "./ecosystem.ts",
+  plugins: "./plugins.ts",
+  build: "./build.ts",
+  testing: "./testing.ts",
+  extras: "./extras.ts"
+};
+var CDN_ENTRY_POINTS = {
+  cdn: "./dist/cdn.global.js",
+  "cdn-dev": "./dist/cdn.dev.global.js",
+  "cdn-full": "./dist/cdn.full.global.js",
+  "cdn-full-dev": "./dist/cdn.full.dev.global.js"
+};
+var packageInfo = {
+  name: "sibujs",
+  version: true ? "4.13.1" : "dev",
+  entryPoints: MODULE_ENTRY_POINTS,
+  /**
+   * Generate the package.json `exports` map. Module entries resolve to the
+   * `.js` (ESM), `.cjs` and `.d.ts` files tsup emits into `dist/`; CDN entries
+   * resolve to their prebuilt global script.
+   */
+  generateExportsMap() {
+    const exportsMap = {};
+    for (const [name, sourcePath] of Object.entries(MODULE_ENTRY_POINTS)) {
+      const distPath = sourcePath.replace(/^\.\//, "./dist/").replace(/\.ts$/, "");
+      const subpath = name === "main" ? "." : `./${name}`;
+      exportsMap[subpath] = {
+        types: `${distPath}.d.ts`,
+        import: `${distPath}.js`,
+        require: `${distPath}.cjs`
+      };
+    }
+    for (const [name, file] of Object.entries(CDN_ENTRY_POINTS)) {
+      exportsMap[`./${name}`] = { default: file };
+    }
+    return exportsMap;
+  }
+};
+
+// src/plugins/plugin.ts
+init_dev();
+init_errors();
+
+// src/utils/adoptThenable.ts
+function adoptThenable(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (typeof then !== "function") return null;
+  return new Promise((resolve, reject) => {
+    queueMicrotask(() => {
+      try {
+        Reflect.apply(then, value, [resolve, reject]);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+// src/plugins/plugin.ts
+init_globalSingleton();
+var CANCELLED_BRAND = /* @__PURE__ */ Symbol.for("sibujs.plugins.installCancelled.v1");
+var _a;
+var PluginInstallCancelledError = class extends Error {
+  constructor(pluginName) {
+    super(`[Plugin] Installation of "${pluginName}" was cancelled before it was committed (registry reset).`);
+    /**
+     * Brand, not identity: the default registry is shared across duplicate copies
+     * of this module, so the error a caller receives may come from another copy's
+     * constructor. `instanceof` is taught to recognise the brand instead.
+     */
+    this[_a] = true;
+    this.name = "PluginInstallCancelledError";
+    this.pluginName = pluginName;
+  }
+  static [(_a = CANCELLED_BRAND, Symbol.hasInstance)](value) {
+    return isPluginInstallCancelledError(value);
+  }
+};
+function isPluginInstallCancelledError(value) {
+  return typeof value === "object" && value !== null && value[CANCELLED_BRAND] === true;
+}
+function createPluginRegistry() {
+  const installedPlugins = /* @__PURE__ */ new Set();
+  const hooks = { init: [], mount: [], unmount: [], error: [] };
+  const provided = /* @__PURE__ */ new Map();
+  const installStack = /* @__PURE__ */ new Set();
+  const pendingInstalls = /* @__PURE__ */ new Map();
+  let generation = 0;
+  const registry = {
+    installedPlugins,
+    hooks,
+    provided,
+    /**
+     * Install a plugin as a transaction.
+     *
+     * Hooks and providers registered through `ctx` are staged and committed
+     * only if `install()` returns; a throwing install leaves the registry
+     * exactly as it found it (and can simply be retried). The plugin is marked
+     * installed at commit, before its init hooks run.
+     *
+     * Each `plugin()` call is its own transaction: a dependency installed by a
+     * nested `plugin()` call commits on its own and stays installed even if the
+     * outer installation later fails.
+     */
+    plugin(p2, options) {
+      if (installedPlugins.has(p2.name)) {
+        console.warn(`[Plugin] "${p2.name}" is already installed.`);
+        return;
+      }
+      if (installStack.has(p2.name)) {
+        throw new Error(`[Plugin] "${p2.name}" is already being installed (recursive installation).`);
+      }
+      if (pendingInstalls.has(p2.name)) {
+        throw new Error(`[Plugin] "${p2.name}" is already being installed (asynchronous installation in flight).`);
+      }
+      const staged = { init: [], mount: [], unmount: [], error: [] };
+      const stagedProvided = /* @__PURE__ */ new Map();
+      let committed = false;
+      const myGeneration = generation;
+      const stale = () => {
+        if (myGeneration === generation) return false;
+        if (DEV) devWarn(`plugin: "${p2.name}" registered after the registry was reset; the registration was ignored.`);
+        return true;
+      };
+      const target = () => stale() ? null : committed ? hooks : staged;
+      const ctx = {
+        onInit: (cb) => void target()?.init.push(cb),
+        onMount: (cb) => void target()?.mount.push(cb),
+        onUnmount: (cb) => void target()?.unmount.push(cb),
+        onError: (cb) => void target()?.error.push(cb),
+        provide: (key, value) => {
+          if (stale()) return;
+          (committed ? provided : stagedProvided).set(key, value);
+        }
+      };
+      const commit = () => {
+        if (myGeneration !== generation) return false;
+        hooks.init.push(...staged.init);
+        hooks.mount.push(...staged.mount);
+        hooks.unmount.push(...staged.unmount);
+        hooks.error.push(...staged.error);
+        for (const [key, value] of stagedProvided) provided.set(key, value);
+        installedPlugins.add(p2.name);
+        committed = true;
+        if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+        for (const cb of staged.init.slice()) {
+          try {
+            cb();
+          } catch (e) {
+            console.error(`[Plugin] "${p2.name}" init error:`, e);
+          }
+        }
+        return true;
+      };
+      installStack.add(p2.name);
+      let pending;
+      try {
+        pending = adoptThenable(p2.install(ctx, options));
+      } finally {
+        installStack.delete(p2.name);
+      }
+      if (!pending) {
+        if (!commit()) throw new PluginInstallCancelledError(p2.name);
+        return;
+      }
+      if (myGeneration === generation) pendingInstalls.set(p2.name, myGeneration);
+      const settled = pending.then(
+        () => {
+          if (commit()) return;
+          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+          throw new PluginInstallCancelledError(p2.name);
+        },
+        (err) => {
+          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+          reportError(err, { phase: "async", name: `plugin(${p2.name})` });
+          throw err;
+        }
+      );
+      settled.catch(() => {
+      });
+      return settled;
+    },
+    inject(key, defaultValue) {
+      if (provided.has(key)) return provided.get(key);
+      if (defaultValue !== void 0) return defaultValue;
+      throw new Error(`[Plugin] No provider found for key "${key}"`);
+    },
+    triggerMount(element) {
+      const snapshot = hooks.mount.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(element);
+        } catch (e) {
+          console.error("[Plugin] Mount hook error:", e);
+        }
+      }
+    },
+    triggerUnmount(element) {
+      const snapshot = hooks.unmount.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(element);
+        } catch (e) {
+          console.error("[Plugin] Unmount hook error:", e);
+        }
+      }
+    },
+    triggerError(error) {
+      const snapshot = hooks.error.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(error);
+        } catch (e) {
+          console.error("[Plugin] Error hook error:", e);
+        }
+      }
+    },
+    reset() {
+      generation++;
+      pendingInstalls.clear();
+      installedPlugins.clear();
+      hooks.init.length = 0;
+      hooks.mount.length = 0;
+      hooks.unmount.length = 0;
+      hooks.error.length = 0;
+      provided.clear();
+    }
+  };
+  return registry;
+}
+var _defaults = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.plugins.defaultRegistry.v1"), () => ({
+  registry: createPluginRegistry(),
+  touched: false
+}));
+function createPlugin(name, install) {
+  return { name, install };
+}
+function plugin(plugin2, options) {
+  _defaults.touched = true;
+  return _defaults.registry.plugin(plugin2, options);
+}
+function inject(key, defaultValue) {
+  return _defaults.registry.inject(key, defaultValue);
+}
+function triggerPluginMount(element) {
+  _defaults.registry.triggerMount(element);
+}
+function triggerPluginUnmount(element) {
+  _defaults.registry.triggerUnmount(element);
+}
+function triggerPluginError(error) {
+  _defaults.registry.triggerError(error);
+}
+function resetPlugins() {
+  _defaults.registry.reset();
+  _defaults.touched = false;
+}
+function setDefaultPluginRegistry(registry) {
+  if (_defaults.touched && _defaults.registry.installedPlugins.size > 0) {
+    console.warn(
+      "[Plugin] Replacing default plugin registry while plugins are already installed on the singleton. This may indicate mixed singleton/registry usage."
+    );
+  }
+  _defaults.registry = registry;
+  _defaults.touched = true;
+}
+
+// src/core/signals/effect.ts
+init_dev();
+init_errors();
+init_ssr_context();
+var _g2 = globalThis;
+var MAX_RERUNS = 100;
+function flushUserCleanups(ctx) {
+  const list = ctx.userCleanups;
+  if (list.length === 0) return;
+  ctx.userCleanups = [];
+  const scope = ctx.subscriber._scope ?? null;
+  if (scope === getOwnerScope2()) runCleanups(list);
+  else runWithOwnerScope2(scope, () => runCleanups(list));
+}
+function runCleanups(list) {
+  for (let i2 = list.length - 1; i2 >= 0; i2--) {
+    try {
+      list[i2]();
+    } catch (err) {
+      reportError(err, { phase: "cleanup" });
+    }
+  }
+}
+function drainReruns(ctx) {
+  let reruns = 1;
+  do {
+    ctx.rerunPending = false;
     if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
     retrack2(ctx.bodyFn, ctx.subscriber);
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
@@ -3659,6 +4256,324 @@ function effect(effectFn, options) {
   return () => disposeEffect(ctx);
 }
 
+// src/utils/documentResources.ts
+init_globalSingleton();
+
+// src/utils/singletonResource.ts
+function singletonResource(io) {
+  let original = null;
+  let captured = false;
+  const stack = [];
+  function apply() {
+    if (stack.length > 0) {
+      io.write(stack[stack.length - 1].value);
+      return;
+    }
+    if (captured) {
+      io.write(original);
+      captured = false;
+      original = null;
+    }
+  }
+  return {
+    acquire(value) {
+      if (!captured) {
+        original = io.read();
+        captured = true;
+      }
+      const entry = { value, released: false };
+      stack.push(entry);
+      apply();
+      return {
+        set(next) {
+          if (entry.released) return;
+          entry.value = next;
+          apply();
+        },
+        release() {
+          if (entry.released) return;
+          entry.released = true;
+          const index = stack.indexOf(entry);
+          if (index !== -1) stack.splice(index, 1);
+          apply();
+        }
+      };
+    },
+    ownerCount() {
+      return stack.length;
+    }
+  };
+}
+
+// src/utils/documentResources.ts
+var INERT_LEASE = {
+  set() {
+  },
+  release() {
+  }
+};
+function inertLease() {
+  return INERT_LEASE;
+}
+var titleResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.documentTitle.v1"),
+  () => singletonResource({
+    read: () => document.title,
+    write: (value) => {
+      document.title = value;
+    }
+  })
+);
+var baseResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.documentBase.v1"),
+  () => singletonResource({
+    read: () => {
+      const el = document.head.querySelector("base");
+      if (!el) return null;
+      return {
+        href: el.getAttribute("href") ?? void 0,
+        target: el.getAttribute("target") ?? void 0
+      };
+    },
+    write: (spec) => {
+      const existing = document.head.querySelector("base");
+      if (spec === null) {
+        existing?.remove();
+        return;
+      }
+      const el = existing ?? document.head.appendChild(document.createElement("base"));
+      if (spec.href === void 0) el.removeAttribute("href");
+      else el.setAttribute("href", spec.href);
+      if (spec.target === void 0) el.removeAttribute("target");
+      else el.setAttribute("target", spec.target);
+    }
+  })
+);
+var scrollRestorationResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.historyScrollRestoration.v1"),
+  () => singletonResource({
+    read: () => history.scrollRestoration,
+    write: (mode) => {
+      history.scrollRestoration = mode;
+    }
+  })
+);
+function acquireTitle(value) {
+  if (typeof document === "undefined") return inertLease();
+  return titleResource.acquire(value);
+}
+
+// src/plugins/routeHead.ts
+init_headEntry();
+init_sanitize();
+var OG_FIELDS = [
+  ["title", "og:title"],
+  ["description", "og:description"],
+  ["image", "og:image"],
+  ["url", "og:url"],
+  ["type", "og:type"],
+  ["siteName", "og:site_name"]
+];
+var OG_URL_PROPERTIES = /* @__PURE__ */ new Set(["og:image", "og:url"]);
+var ROUTE_HEAD_ATTR = "data-sibu-head";
+var BASE_TITLE_ATTR = "data-sibu-base-title";
+function routeHasHead(matched, defaults) {
+  if (defaults) return true;
+  for (const record of matched) if (record.head) return true;
+  return false;
+}
+function resolveValue(value, route2) {
+  if (value == null) return null;
+  const v = typeof value === "function" ? value(route2) : value;
+  return v == null ? null : String(v);
+}
+function mergeHeads(route2, defaults) {
+  const layers = [];
+  if (defaults) layers.push(defaults);
+  for (const record of route2.matched) {
+    const head2 = record.head;
+    if (head2) layers.push(head2);
+  }
+  const merged = {};
+  const og = {};
+  const meta2 = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    if (layer.title !== void 0) merged.title = layer.title;
+    if (layer.description !== void 0) merged.description = layer.description;
+    if (layer.canonical !== void 0) merged.canonical = layer.canonical;
+    if (layer.og) {
+      for (const [field] of OG_FIELDS) if (layer.og[field] !== void 0) og[field] = layer.og[field];
+    }
+    for (const entry of layer.meta ?? []) {
+      const id = metaIdentity(entry);
+      if (id) meta2.set(id, entry);
+    }
+  }
+  merged.og = og;
+  merged.meta = Array.from(meta2.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(title2, template2) {
+  if (!template2) return title2;
+  return typeof template2 === "function" ? template2(title2) : template2.replace("%s", title2);
+}
+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 title2 = ownTitle === null ? null : routeSetTitle ? applyTemplate(ownTitle, defaults?.titleTemplate) : ownTitle;
+  const description = resolveValue(merged.description, route2);
+  const canonical = resolveValue(merged.canonical, route2);
+  const tags = [];
+  const push2 = (key, tag, attrs) => {
+    const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
+    if (plan.kind === "drop") return;
+    tags.push({ key, tag, attrs: Object.fromEntries(plan.attributes) });
+  };
+  if (description !== null) push2("meta:name:description", "meta", { name: "description", content: description });
+  if (canonical !== null) push2("link:rel:canonical", "link", { rel: "canonical", href: canonical });
+  const og = merged.og ?? {};
+  for (const [field, property] of OG_FIELDS) {
+    let value = og[field] === void 0 ? void 0 : resolveValue(og[field], route2);
+    if (value === void 0) {
+      if (field === "title") value = ownTitle;
+      else if (field === "description") value = description;
+      else if (field === "url") value = canonical;
+      else value = null;
+    }
+    if (value === null) continue;
+    if (OG_URL_PROPERTIES.has(property)) {
+      value = sanitizeUrl(value);
+      if (value === "") continue;
+    }
+    push2(`meta:property:${property}`, "meta", { property, content: value });
+  }
+  for (const entry of merged.meta ?? []) {
+    const id = metaIdentity(entry);
+    if (!id) continue;
+    const attrs = {};
+    for (const [name, v] of Object.entries(entry)) {
+      const resolved = resolveValue(v, route2);
+      if (resolved !== null) attrs[name] = resolved;
+    }
+    push2(`meta:${id}`, "meta", attrs);
+  }
+  return { title: title2, tags };
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function routeHeadToHTML(head2) {
+  const parts = [];
+  if (head2.title !== null) parts.push(`<title>${escapeText(head2.title)}</title>`);
+  for (const t2 of head2.tags) {
+    const html2 = serializeHeadEntry(t2.tag, t2.attrs);
+    if (html2) parts.push(html2.replace(/ \/>$/, ` ${ROUTE_HEAD_ATTR}="" />`));
+  }
+  return parts.join("\n");
+}
+function selectorFor(key) {
+  const [tag, attr, ...rest] = key.split(":");
+  const value = rest.join(":").replace(/["\\]/g, "\\$&");
+  return `${tag}[${attr}="${value}" i]`;
+}
+function createRouteHeadController(defaults) {
+  const [current, setCurrent] = signal(null);
+  const owned = /* @__PURE__ */ new Map();
+  const initial = new Set(Array.from(document.head.children));
+  const titleEl = document.head.querySelector("title");
+  const baseTitle = titleEl?.getAttribute(BASE_TITLE_ATTR) ?? document.title;
+  let titleLease = null;
+  let firstApply = true;
+  const publish = (tag) => {
+    const existing = owned.get(tag.key);
+    if (existing && sameAttrs(existing, tag.attrs)) return;
+    if (!existing) {
+      for (const el of Array.from(document.head.querySelectorAll(selectorFor(tag.key)))) {
+        if (initial.has(el)) {
+          el.remove();
+          initial.delete(el);
+        }
+      }
+    }
+    const next = document.createElement(tag.tag);
+    for (const [name, value] of Object.entries(tag.attrs)) next.setAttribute(name, value);
+    next.setAttribute(ROUTE_HEAD_ATTR, "");
+    if (existing?.parentNode) existing.replaceWith(next);
+    else document.head.appendChild(next);
+    owned.set(tag.key, next);
+  };
+  const apply = (head2) => {
+    if (firstApply) {
+      firstApply = false;
+      for (const el of Array.from(document.head.querySelectorAll(`[${ROUTE_HEAD_ATTR}]`))) {
+        if (initial.has(el) && !head2.tags.some((t2) => el.matches(selectorFor(t2.key)))) {
+          el.remove();
+          initial.delete(el);
+        }
+      }
+    }
+    const keep = /* @__PURE__ */ new Set();
+    for (const tag of head2.tags) {
+      keep.add(tag.key);
+      publish(tag);
+    }
+    for (const [key, el] of owned) {
+      if (keep.has(key)) continue;
+      el.remove();
+      owned.delete(key);
+    }
+    const title2 = head2.title ?? baseTitle;
+    if (titleLease) titleLease.set(title2);
+    else titleLease = acquireTitle(title2);
+  };
+  const stop2 = effect(() => {
+    const route2 = current();
+    if (route2 === null) return;
+    const head2 = resolveRouteHead(route2, defaults);
+    untracked2(() => apply(head2));
+  });
+  return {
+    update(route2) {
+      setCurrent(route2);
+    },
+    dispose() {
+      stop2();
+      for (const el of owned.values()) el.remove();
+      owned.clear();
+      titleLease?.release();
+      titleLease = null;
+    }
+  };
+}
+function sameAttrs(el, attrs) {
+  const names = Object.keys(attrs);
+  if (el.attributes.length !== names.length + 1) return false;
+  for (const name of names) if (el.getAttribute(name) !== attrs[name]) return false;
+  return true;
+}
+
+// src/plugins/router.ts
+init_dev();
+init_dispose();
+
+// src/utils/prerenderHook.ts
+var HOST_KEY = /* @__PURE__ */ Symbol.for("sibujs.prerender.v1");
+function host() {
+  return globalThis[HOST_KEY];
+}
+function prerenderWait(promise) {
+  host()?.wait(promise);
+  return promise;
+}
+
 // src/plugins/router.ts
 init_sanitize();
 function splitRouteUrl(url) {
@@ -4338,6 +5253,15 @@ var _SibuRouter = class _SibuRouter {
     // to superseded work. The router's own initial location resolution is
     // excluded — it establishes the bootstrap route rather than superseding it.
     this.navEpoch = 0;
+    // Created the first time a committed route needs a managed <head>.
+    this.headController = null;
+    // `readyPromise` plus the matched components loaded; created on the first
+    // `routerReady()` call only, so an app that never asks pays nothing and its
+    // outlets load exactly as before.
+    this.loadedPromise = null;
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
     this.options = {
       mode: "history",
       base: "",
@@ -4375,12 +5299,31 @@ var _SibuRouter = class _SibuRouter {
       }
     }
     queueMicrotask(() => {
+      let initial = Promise.resolve();
       if (!this.navigator.isNavigating) {
-        this.handleLocationChange(true, true);
+        initial = this.handleLocationChange(true, true);
       }
       this.isReadySetter(true);
+      prerenderWait(initial.then(this.resolveReady, this.resolveReady));
     });
   }
+  /** Load the component of every record the current route matched, without instantiating any. */
+  async preloadMatched() {
+    const current = untracked2(() => this.currentRouteGetter());
+    for (const record of current.matched) {
+      if ("redirect" in record) continue;
+      try {
+        await this.loader.preloadPlan(record, current.path);
+      } catch {
+        this.loader.clearErrors();
+      }
+    }
+  }
+  /** Settles after the initial navigation and its component loads; see `routerReady()`. */
+  whenReady() {
+    this.loadedPromise ?? (this.loadedPromise = this.readyPromise.then(() => this.destroyed ? void 0 : this.preloadMatched()));
+    return this.loadedPromise;
+  }
   createInitialRoute() {
     return {
       path: "/",
@@ -4394,7 +5337,7 @@ var _SibuRouter = class _SibuRouter {
   }
   handleLocationChange(skipHistory = true, initialResolution = false) {
     const path2 = this.getCurrentPath();
-    this.navigate(path2, { replace: true, skipHistory, initialResolution }).catch((err) => {
+    return this.navigate(path2, { replace: true, skipHistory, initialResolution }).catch((err) => {
       console.error("[Router] Error during location change navigation:", err);
     });
   }
@@ -4551,9 +5494,18 @@ var _SibuRouter = class _SibuRouter {
     }
     if (!options.initialResolution) this.navEpoch++;
     this.currentRouteSetter(to);
+    this.updateHead(to);
     this.guards.runAfterEach(to, from);
     this.handleScrollBehavior(to, from);
   }
+  updateHead(to) {
+    if (typeof document === "undefined" || this.destroyed) return;
+    if (this.headController === null) {
+      if (!routeHasHead(to.matched, this.options.head)) return;
+      this.headController = createRouteHeadController(this.options.head);
+    }
+    this.headController.update(to);
+  }
   resolvePath(to) {
     if (typeof to === "string") return to;
     let path2 = to.path || "";
@@ -4642,14 +5594,14 @@ var _SibuRouter = class _SibuRouter {
    * anything. Pair with {@link instantiateComponent} at the commit boundary.
    */
   async loadPlan(route2, routePath) {
-    return this.loader.loadPlan(route2, routePath);
+    return prerenderWait(this.loader.loadPlan(route2, routePath));
   }
   /**
    * Create exactly one real instance from an already-resolved plan. With a
    * `scope`, the factory runs in it (see `RouteScope`).
    */
   async instantiateComponent(plan, route2, routePath, scope) {
-    return this.loader.instantiate(plan, route2, routePath, scope);
+    return prerenderWait(this.loader.instantiate(plan, route2, routePath, scope));
   }
   /** Resolve a route's module/factory without creating any component instance. */
   async preloadPlan(route2, routePath) {
@@ -4705,6 +5657,9 @@ var _SibuRouter = class _SibuRouter {
     this.guards.clear();
     this.loader.clearCache();
     this.isReadySetter(false);
+    this.headController?.dispose();
+    this.headController = null;
+    this.resolveReady();
   }
   // Cache management
   clearCache() {
@@ -4943,6 +5898,10 @@ function router() {
     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);
@@ -5965,570 +6924,278 @@ function hydrateRouter(routes, options) {
     replaceChildrenSafely2(container);
   }).catch((err) => {
     if (typeof console !== "undefined") {
-      console.error("[SibuJS routerSSR] failed to load hydrate:", err);
-    }
-  });
-}
-function createSSRRouter(routes) {
-  return {
-    resolve(url) {
-      return resolveServerRoute(url, routes);
-    },
-    renderToString(url) {
-      return renderRouteToString(url, routes);
-    },
-    renderToDocument(url, options) {
-      return renderRouteToDocument(url, routes, options);
-    }
-  };
-}
-function escapeHtmlLocal(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeAttrLocal(str) {
-  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-// src/plugins/plugin.ts
-init_dev();
-init_errors();
-
-// src/utils/adoptThenable.ts
-function adoptThenable(value) {
-  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
-  let then;
-  try {
-    then = value.then;
-  } catch (error) {
-    return Promise.reject(error);
-  }
-  if (typeof then !== "function") return null;
-  return new Promise((resolve, reject) => {
-    queueMicrotask(() => {
-      try {
-        Reflect.apply(then, value, [resolve, reject]);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  });
-}
-
-// src/plugins/plugin.ts
-init_globalSingleton();
-var CANCELLED_BRAND = /* @__PURE__ */ Symbol.for("sibujs.plugins.installCancelled.v1");
-var _a;
-var PluginInstallCancelledError = class extends Error {
-  constructor(pluginName) {
-    super(`[Plugin] Installation of "${pluginName}" was cancelled before it was committed (registry reset).`);
-    /**
-     * Brand, not identity: the default registry is shared across duplicate copies
-     * of this module, so the error a caller receives may come from another copy's
-     * constructor. `instanceof` is taught to recognise the brand instead.
-     */
-    this[_a] = true;
-    this.name = "PluginInstallCancelledError";
-    this.pluginName = pluginName;
-  }
-  static [(_a = CANCELLED_BRAND, Symbol.hasInstance)](value) {
-    return isPluginInstallCancelledError(value);
-  }
-};
-function isPluginInstallCancelledError(value) {
-  return typeof value === "object" && value !== null && value[CANCELLED_BRAND] === true;
-}
-function createPluginRegistry() {
-  const installedPlugins = /* @__PURE__ */ new Set();
-  const hooks = { init: [], mount: [], unmount: [], error: [] };
-  const provided = /* @__PURE__ */ new Map();
-  const installStack = /* @__PURE__ */ new Set();
-  const pendingInstalls = /* @__PURE__ */ new Map();
-  let generation = 0;
-  const registry = {
-    installedPlugins,
-    hooks,
-    provided,
-    /**
-     * Install a plugin as a transaction.
-     *
-     * Hooks and providers registered through `ctx` are staged and committed
-     * only if `install()` returns; a throwing install leaves the registry
-     * exactly as it found it (and can simply be retried). The plugin is marked
-     * installed at commit, before its init hooks run.
-     *
-     * Each `plugin()` call is its own transaction: a dependency installed by a
-     * nested `plugin()` call commits on its own and stays installed even if the
-     * outer installation later fails.
-     */
-    plugin(p2, options) {
-      if (installedPlugins.has(p2.name)) {
-        console.warn(`[Plugin] "${p2.name}" is already installed.`);
-        return;
-      }
-      if (installStack.has(p2.name)) {
-        throw new Error(`[Plugin] "${p2.name}" is already being installed (recursive installation).`);
-      }
-      if (pendingInstalls.has(p2.name)) {
-        throw new Error(`[Plugin] "${p2.name}" is already being installed (asynchronous installation in flight).`);
-      }
-      const staged = { init: [], mount: [], unmount: [], error: [] };
-      const stagedProvided = /* @__PURE__ */ new Map();
-      let committed = false;
-      const myGeneration = generation;
-      const stale = () => {
-        if (myGeneration === generation) return false;
-        if (DEV) devWarn(`plugin: "${p2.name}" registered after the registry was reset; the registration was ignored.`);
-        return true;
-      };
-      const target = () => stale() ? null : committed ? hooks : staged;
-      const ctx = {
-        onInit: (cb) => void target()?.init.push(cb),
-        onMount: (cb) => void target()?.mount.push(cb),
-        onUnmount: (cb) => void target()?.unmount.push(cb),
-        onError: (cb) => void target()?.error.push(cb),
-        provide: (key, value) => {
-          if (stale()) return;
-          (committed ? provided : stagedProvided).set(key, value);
-        }
-      };
-      const commit = () => {
-        if (myGeneration !== generation) return false;
-        hooks.init.push(...staged.init);
-        hooks.mount.push(...staged.mount);
-        hooks.unmount.push(...staged.unmount);
-        hooks.error.push(...staged.error);
-        for (const [key, value] of stagedProvided) provided.set(key, value);
-        installedPlugins.add(p2.name);
-        committed = true;
-        if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
-        for (const cb of staged.init.slice()) {
-          try {
-            cb();
-          } catch (e) {
-            console.error(`[Plugin] "${p2.name}" init error:`, e);
-          }
-        }
-        return true;
-      };
-      installStack.add(p2.name);
-      let pending;
-      try {
-        pending = adoptThenable(p2.install(ctx, options));
-      } finally {
-        installStack.delete(p2.name);
-      }
-      if (!pending) {
-        if (!commit()) throw new PluginInstallCancelledError(p2.name);
-        return;
-      }
-      if (myGeneration === generation) pendingInstalls.set(p2.name, myGeneration);
-      const settled = pending.then(
-        () => {
-          if (commit()) return;
-          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
-          throw new PluginInstallCancelledError(p2.name);
-        },
-        (err) => {
-          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
-          reportError(err, { phase: "async", name: `plugin(${p2.name})` });
-          throw err;
-        }
-      );
-      settled.catch(() => {
-      });
-      return settled;
-    },
-    inject(key, defaultValue) {
-      if (provided.has(key)) return provided.get(key);
-      if (defaultValue !== void 0) return defaultValue;
-      throw new Error(`[Plugin] No provider found for key "${key}"`);
-    },
-    triggerMount(element) {
-      const snapshot = hooks.mount.slice();
-      for (const hook of snapshot) {
-        try {
-          hook(element);
-        } catch (e) {
-          console.error("[Plugin] Mount hook error:", e);
-        }
-      }
-    },
-    triggerUnmount(element) {
-      const snapshot = hooks.unmount.slice();
-      for (const hook of snapshot) {
-        try {
-          hook(element);
-        } catch (e) {
-          console.error("[Plugin] Unmount hook error:", e);
-        }
-      }
-    },
-    triggerError(error) {
-      const snapshot = hooks.error.slice();
-      for (const hook of snapshot) {
-        try {
-          hook(error);
-        } catch (e) {
-          console.error("[Plugin] Error hook error:", e);
-        }
-      }
-    },
-    reset() {
-      generation++;
-      pendingInstalls.clear();
-      installedPlugins.clear();
-      hooks.init.length = 0;
-      hooks.mount.length = 0;
-      hooks.unmount.length = 0;
-      hooks.error.length = 0;
-      provided.clear();
-    }
-  };
-  return registry;
-}
-var _defaults = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.plugins.defaultRegistry.v1"), () => ({
-  registry: createPluginRegistry(),
-  touched: false
-}));
-function createPlugin(name, install) {
-  return { name, install };
-}
-function plugin(plugin2, options) {
-  _defaults.touched = true;
-  return _defaults.registry.plugin(plugin2, options);
-}
-function inject(key, defaultValue) {
-  return _defaults.registry.inject(key, defaultValue);
-}
-function triggerPluginMount(element) {
-  _defaults.registry.triggerMount(element);
-}
-function triggerPluginUnmount(element) {
-  _defaults.registry.triggerUnmount(element);
+      console.error("[SibuJS routerSSR] failed to load hydrate:", err);
+    }
+  });
 }
-function triggerPluginError(error) {
-  _defaults.registry.triggerError(error);
+function createSSRRouter(routes) {
+  return {
+    resolve(url) {
+      return resolveServerRoute(url, routes);
+    },
+    renderToString(url) {
+      return renderRouteToString(url, routes);
+    },
+    renderToDocument(url, options) {
+      return renderRouteToDocument(url, routes, options);
+    }
+  };
 }
-function resetPlugins() {
-  _defaults.registry.reset();
-  _defaults.touched = false;
+function escapeHtmlLocal(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function setDefaultPluginRegistry(registry) {
-  if (_defaults.touched && _defaults.registry.installedPlugins.size > 0) {
-    console.warn(
-      "[Plugin] Replacing default plugin registry while plugins are already installed on the singleton. This may indicate mixed singleton/registry usage."
-    );
-  }
-  _defaults.registry = registry;
-  _defaults.touched = true;
+function escapeAttrLocal(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
-// src/plugins/modular.ts
-function createModuleRegistry() {
-  const modules = /* @__PURE__ */ new Map();
-  const resolving = [];
-  function resolveInternal(name) {
-    const entry = modules.get(name);
-    if (!entry) {
-      throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
-    }
-    if (entry.state === "loaded") {
-      return entry.value;
-    }
-    if (entry.state === "resolving") {
-      const cycle = [...resolving.slice(resolving.indexOf(name)), name].join(" -> ");
-      throw new Error(`[ModuleRegistry] Circular dependency detected: ${cycle}`);
+// src/plugins/startup.ts
+init_errors();
+init_ssr();
+init_sanitize();
+function preloadCritical(resources) {
+  if (typeof document === "undefined") return;
+  for (const resource of resources) {
+    const href = sanitizeUrl(resource.href);
+    if (!href) continue;
+    const safeHref = typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(href) : href.replace(/["\\]/g, "\\$&");
+    const existing = document.querySelector(`link[rel="preload"][href="${safeHref}"]`);
+    if (existing) continue;
+    const link2 = document.createElement("link");
+    link2.rel = "preload";
+    link2.href = href;
+    link2.setAttribute("as", resource.as);
+    if (resource.type) {
+      link2.type = resource.type;
     }
-    entry.state = "resolving";
-    resolving.push(name);
-    try {
-      for (const dep of entry.deps) {
-        resolveInternal(dep);
-      }
-      entry.value = entry.factory();
-      entry.state = "loaded";
-      return entry.value;
-    } catch (err) {
-      entry.state = "unloaded";
-      entry.value = void 0;
-      throw err;
-    } finally {
-      resolving.pop();
+    if (resource.crossOrigin) {
+      link2.crossOrigin = resource.crossOrigin;
     }
+    document.head.appendChild(link2);
   }
-  return {
-    /** Register a module with its factory function and optional dependencies */
-    register(name, factory, deps = []) {
-      modules.set(name, { factory, deps, state: "unloaded" });
-    },
-    /** Resolve a module, loading its dependencies first */
-    resolve(name) {
-      return resolveInternal(name);
-    },
-    /** Check if a module is registered */
-    has(name) {
-      return modules.has(name);
-    },
-    /** List all registered module names */
-    list() {
-      return Array.from(modules.keys());
-    },
-    /** Get the full dependency graph (transitive) for a module */
-    deps(name) {
-      const entry = modules.get(name);
-      if (!entry) {
-        throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
-      }
-      const visited = /* @__PURE__ */ new Set();
-      const result = [];
-      function walk(modName) {
-        const mod = modules.get(modName);
-        if (!mod) return;
-        for (const dep of mod.deps) {
-          if (!visited.has(dep)) {
-            visited.add(dep);
-            walk(dep);
-            result.push(dep);
-          }
-        }
-      }
-      walk(name);
-      return result;
-    },
-    /** Reset all loaded modules back to unloaded state (useful for testing) */
-    reset() {
-      for (const entry of modules.values()) {
-        entry.state = "unloaded";
-        entry.value = void 0;
-      }
-    }
-  };
 }
-function createBundle(modules) {
-  const cache = /* @__PURE__ */ new Map();
-  const bundle = {};
-  for (const key of Object.keys(modules)) {
-    Object.defineProperty(bundle, key, {
-      get() {
-        if (cache.has(key)) {
-          return cache.get(key);
-        }
-        const value = modules[key]();
-        cache.set(key, value);
-        return value;
-      },
-      enumerable: true,
-      configurable: false
-    });
+function assertCacheSize(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`[Startup] ${name} must be a non-negative integer, got ${value}`);
   }
-  return bundle;
 }
-function lazyModule(loader) {
-  let cached;
-  let loadedFlag = false;
-  let inFlight = null;
-  return {
-    get loaded() {
-      return loadedFlag;
-    },
-    get() {
-      if (loadedFlag) return Promise.resolve(cached);
-      if (inFlight) return inFlight;
-      let started;
-      try {
-        started = Promise.resolve(loader());
-      } catch (err) {
-        started = Promise.reject(err);
+function makeRoomFor(cache, key, maxSize, isValid) {
+  if (maxSize === 0) return false;
+  if (cache.has(key)) return true;
+  if (cache.size < maxSize) return true;
+  for (const [k, entry] of cache) {
+    if (!isValid(entry)) cache.delete(k);
+  }
+  while (cache.size >= maxSize) {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [k, entry] of cache) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldestKey = k;
       }
-      const attempt = started.then(
-        (value) => {
-          cached = value;
-          loadedFlag = true;
-          if (inFlight === attempt) inFlight = null;
-          return value;
-        },
-        (err) => {
-          if (inFlight === attempt) inFlight = null;
-          throw err;
-        }
-      );
-      inFlight = attempt;
-      return attempt;
     }
-  };
+    if (oldestKey === null) break;
+    cache.delete(oldestKey);
+  }
+  return true;
 }
-var MODULE_ENTRY_POINTS = {
-  main: "./index.ts",
-  data: "./data.ts",
-  browser: "./browser.ts",
-  patterns: "./patterns.ts",
-  motion: "./motion.ts",
-  ui: "./ui.ts",
-  widgets: "./widgets.ts",
-  ssr: "./ssr.ts",
-  devtools: "./devtools.ts",
-  performance: "./performance.ts",
-  ecosystem: "./ecosystem.ts",
-  plugins: "./plugins.ts",
-  build: "./build.ts",
-  testing: "./testing.ts",
-  extras: "./extras.ts"
-};
-var CDN_ENTRY_POINTS = {
-  cdn: "./dist/cdn.global.js",
-  "cdn-dev": "./dist/cdn.dev.global.js",
-  "cdn-full": "./dist/cdn.full.global.js",
-  "cdn-full-dev": "./dist/cdn.full.dev.global.js"
-};
-var packageInfo = {
-  name: "sibujs",
-  version: true ? "4.12.0" : "dev",
-  entryPoints: MODULE_ENTRY_POINTS,
-  /**
-   * Generate the package.json `exports` map. Module entries resolve to the
-   * `.js` (ESM), `.cjs` and `.d.ts` files tsup emits into `dist/`; CDN entries
-   * resolve to their prebuilt global script.
-   */
-  generateExportsMap() {
-    const exportsMap = {};
-    for (const [name, sourcePath] of Object.entries(MODULE_ENTRY_POINTS)) {
-      const distPath = sourcePath.replace(/^\.\//, "./dist/").replace(/\.ts$/, "");
-      const subpath = name === "main" ? "." : `./${name}`;
-      exportsMap[subpath] = {
-        types: `${distPath}.d.ts`,
-        import: `${distPath}.js`,
-        require: `${distPath}.cjs`
-      };
-    }
-    for (const [name, file] of Object.entries(CDN_ENTRY_POINTS)) {
-      exportsMap[`./${name}`] = { default: file };
-    }
-    return exportsMap;
+function prerenderRoutes(routes, options) {
+  const maxCacheSize = options?.maxCacheSize ?? 50;
+  const cacheTTL = options?.cacheTTL ?? 0;
+  assertCacheSize("maxCacheSize", maxCacheSize);
+  const cache = /* @__PURE__ */ new Map();
+  function isValid(entry) {
+    if (cacheTTL === 0) return true;
+    return Date.now() - entry.timestamp < cacheTTL;
+  }
+  for (const route2 of routes) {
+    if (!makeRoomFor(cache, route2.path, maxCacheSize, isValid)) break;
+    const html2 = renderToString(route2.component());
+    cache.set(route2.path, { html: html2, timestamp: Date.now() });
   }
-};
-
-// src/plugins/ecosystem.ts
-function createTestHarness() {
-  let container;
   return {
-    /** Set up a clean DOM container before each test */
-    setup() {
-      container = document.createElement("div");
-      container.setAttribute("data-sibu-test", "true");
-      document.body.appendChild(container);
-      return container;
+    /** Get cached HTML for a route, or undefined if not cached or expired */
+    get(path2) {
+      const entry = cache.get(path2);
+      if (!entry) return void 0;
+      if (!isValid(entry)) {
+        cache.delete(path2);
+        return void 0;
+      }
+      return entry.html;
     },
-    /** Tear down the DOM container after each test */
-    teardown() {
-      if (container?.parentNode) {
-        container.parentNode.removeChild(container);
+    /** Check if a route has been prerendered and is still valid */
+    has(path2) {
+      const entry = cache.get(path2);
+      if (!entry) return false;
+      if (!isValid(entry)) {
+        cache.delete(path2);
+        return false;
       }
+      return true;
     },
-    /** Render a component into the test container */
-    render(component) {
-      const el = typeof component === "function" ? component() : component;
-      container.appendChild(el);
-      return el;
+    /** Invalidate a cached route */
+    invalidate(path2) {
+      cache.delete(path2);
     },
-    /** Get the test container */
-    getContainer() {
-      return container;
+    /** Clear all cached routes */
+    clear() {
+      cache.clear();
     },
-    /** Wait for reactive updates to settle */
-    async flush() {
-      await new Promise((r) => setTimeout(r, 0));
-      await new Promise((r) => requestAnimationFrame(() => r()));
+    /** Get cache statistics */
+    stats() {
+      if (cacheTTL > 0) {
+        for (const [key, entry] of cache) {
+          if (!isValid(entry)) {
+            cache.delete(key);
+          }
+        }
+      }
+      return {
+        size: cache.size,
+        routes: Array.from(cache.keys())
+      };
+    }
+  };
+}
+function createSSRCache(config) {
+  const maxSize = config?.maxSize ?? 100;
+  const defaultTTL = config?.defaultTTL ?? 6e4;
+  assertCacheSize("maxSize", maxSize);
+  const cache = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  function isValid(entry) {
+    if (entry.ttl === 0) return true;
+    return Date.now() - entry.timestamp < entry.ttl;
+  }
+  return {
+    /** Get cached HTML for a key, or undefined if not cached or expired */
+    get(key) {
+      const entry = cache.get(key);
+      if (!entry) {
+        misses++;
+        return void 0;
+      }
+      if (!isValid(entry)) {
+        cache.delete(key);
+        misses++;
+        return void 0;
+      }
+      hits++;
+      return entry.html;
     },
-    /** Query within the container */
-    query(selector) {
-      return container.querySelector(selector);
+    /** Cache an HTML string with an optional TTL override */
+    set(key, html2, ttl) {
+      if (!makeRoomFor(cache, key, maxSize, isValid)) return;
+      cache.set(key, {
+        html: html2,
+        timestamp: Date.now(),
+        ttl: ttl ?? defaultTTL
+      });
     },
-    /** Query all matching elements within the container */
-    queryAll(selector) {
-      return Array.from(container.querySelectorAll(selector));
+    /** Check if a key exists in the cache and is still valid */
+    has(key) {
+      const entry = cache.get(key);
+      if (!entry) return false;
+      if (!isValid(entry)) {
+        cache.delete(key);
+        return false;
+      }
+      return true;
     },
-    /** Simulate a click event */
-    click(el) {
-      el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    /** Invalidate a cached entry */
+    invalidate(key) {
+      cache.delete(key);
     },
-    /** Simulate input value change */
-    input(el, value) {
-      el.value = value;
-      el.dispatchEvent(new Event("input", { bubbles: true }));
+    /** Clear all cached entries and reset statistics */
+    clear() {
+      cache.clear();
+      hits = 0;
+      misses = 0;
+    },
+    /** Get cache statistics including hit/miss counts */
+    stats() {
+      return { size: cache.size, hits, misses };
     }
   };
 }
-var bundlerMetadata = {
-  name: "sibu",
-  sideEffects: false,
-  modules: {
-    core: ["html", "mount", "each", "slots", "fragment", "catch", "portal", "directives"],
-    hooks: ["signal", "effect", "derived", "watch", "store", "ref", "array", "deepSignal"],
-    plugins: ["router", "i18n"],
-    components: ["ErrorBoundary", "Loading"],
-    ssr: ["ssr"],
-    advanced: ["globalStore", "machine", "optimistic", "timeTravel", "scheduler", "plugin"]
-  },
-  /** Generate import map for module resolution */
-  generateImportMap(base2 = "/node_modules/sibu/") {
-    const map2 = {};
-    for (const [category, modules] of Object.entries(this.modules)) {
-      for (const mod of modules) {
-        const dir = category === "hooks" ? "core" : category;
-        map2[`sibu/${mod}`] = `${base2}src/${dir}/${mod}.js`;
+var DEFER_IDLE_TIMEOUT_MS = 2e3;
+function deferNonCritical(tasks) {
+  if (tasks.length === 0) return;
+  const schedule = typeof requestIdleCallback !== "undefined" ? (cb) => {
+    requestIdleCallback(cb, { timeout: DEFER_IDLE_TIMEOUT_MS });
+  } : (cb) => {
+    setTimeout(cb, 1);
+  };
+  const queue = [...tasks];
+  let index = 0;
+  function processNext(deadline) {
+    let ranOne = false;
+    while (index < queue.length) {
+      if (ranOne && deadline && deadline.timeRemaining() < 1) {
+        schedule(processNext);
+        return;
+      }
+      try {
+        queue[index]();
+      } catch (e) {
+        reportError(e, { phase: "scheduler", name: "deferNonCritical" });
       }
+      index++;
+      ranOne = true;
     }
-    return map2;
   }
-};
-function healthCheck() {
-  const checks = [];
-  const hasDOM = typeof document !== "undefined";
-  checks.push({
-    name: "DOM Environment",
-    passed: hasDOM,
-    message: hasDOM ? "DOM is available" : "No DOM environment (SSR mode)"
-  });
-  const hasRAF = typeof requestAnimationFrame !== "undefined";
-  checks.push({
-    name: "requestAnimationFrame",
-    passed: hasRAF,
-    message: hasRAF ? "Available" : "Not available (polyfill may be needed)"
-  });
-  const hasMO = typeof MutationObserver !== "undefined";
-  checks.push({
-    name: "MutationObserver",
-    passed: hasMO,
-    message: hasMO ? "Available" : "Not available (lifecycle hooks may not work)"
-  });
-  const allPassed = checks.every((c) => c.passed);
-  return {
-    status: allPassed ? "ok" : "warning",
-    checks
-  };
+  schedule(processNext);
+}
+function createBootSequence() {
+  const criticalTasks = [];
+  const deferredTasks = [];
+  return {
+    /** Add a critical task that runs immediately during boot */
+    critical(name, task) {
+      criticalTasks.push({ name, task });
+    },
+    /** Add a deferred task that runs after all critical tasks complete */
+    defer(name, task) {
+      deferredTasks.push({ name, task });
+    },
+    /** Execute the boot sequence: critical tasks first, then deferred */
+    async boot() {
+      const timing = {};
+      const errors = [];
+      for (const entry of criticalTasks) {
+        const start = Date.now();
+        try {
+          await entry.task();
+        } catch (e) {
+          errors.push({
+            name: entry.name,
+            error: e instanceof Error ? e : new Error(String(e))
+          });
+        }
+        timing[entry.name] = Date.now() - start;
+      }
+      for (const entry of deferredTasks) {
+        const start = Date.now();
+        try {
+          await entry.task();
+        } catch (e) {
+          errors.push({
+            name: entry.name,
+            error: e instanceof Error ? e : new Error(String(e))
+          });
+        }
+        timing[entry.name] = Date.now() - start;
+      }
+      return { timing, errors };
+    }
+  };
 }
-var env = {
-  /** True when running in a browser with a DOM */
-  isBrowser: typeof window !== "undefined" && typeof document !== "undefined",
-  /** True when running in Node.js */
-  isNode: typeof process !== "undefined" && !!process.versions?.node,
-  /** True when running inside a Web Worker */
-  isWorker: typeof self !== "undefined" && typeof self.importScripts === "function",
-  /** True when running inside Deno */
-  isDeno: typeof globalThis.Deno !== "undefined",
-  /** True when running inside Bun */
-  isBun: typeof globalThis.Bun !== "undefined",
-  /** True when no window object is available (server-side rendering) */
-  isSSR: typeof window === "undefined",
-  /** True when NODE_ENV is not "production" */
-  isDev: typeof process !== "undefined" && process.env?.NODE_ENV !== "production",
-  /** True when NODE_ENV is "test" or VITEST is set */
-  isTest: typeof process !== "undefined" && (process.env?.NODE_ENV === "test" || process.env?.VITEST === "true")
-};
 
 // src/plugins/versioning.ts
 init_globalSingleton();
-var VERSION = true ? "4.12.0" : "dev";
+var VERSION = true ? "4.13.1" : "dev";
 var NUM = "(?:0|[1-9]\\d*)";
 var PRE_ID = `(?:${NUM}|\\d*[a-zA-Z-][0-9a-zA-Z-]*)`;
 var BUILD_ID = "[0-9a-zA-Z-]+";
@@ -6806,251 +7473,6 @@ function extractRangeTarget(range) {
   const match = range.match(/[\d]+\.[\d]+\.[\d]+(?:-[\w.]+)?/);
   return match ? match[0] : null;
 }
-
-// src/plugins/startup.ts
-init_errors();
-init_ssr();
-init_sanitize();
-function preloadCritical(resources) {
-  if (typeof document === "undefined") return;
-  for (const resource of resources) {
-    const href = sanitizeUrl(resource.href);
-    if (!href) continue;
-    const safeHref = typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(href) : href.replace(/["\\]/g, "\\$&");
-    const existing = document.querySelector(`link[rel="preload"][href="${safeHref}"]`);
-    if (existing) continue;
-    const link2 = document.createElement("link");
-    link2.rel = "preload";
-    link2.href = href;
-    link2.setAttribute("as", resource.as);
-    if (resource.type) {
-      link2.type = resource.type;
-    }
-    if (resource.crossOrigin) {
-      link2.crossOrigin = resource.crossOrigin;
-    }
-    document.head.appendChild(link2);
-  }
-}
-function assertCacheSize(name, value) {
-  if (!Number.isInteger(value) || value < 0) {
-    throw new RangeError(`[Startup] ${name} must be a non-negative integer, got ${value}`);
-  }
-}
-function makeRoomFor(cache, key, maxSize, isValid) {
-  if (maxSize === 0) return false;
-  if (cache.has(key)) return true;
-  if (cache.size < maxSize) return true;
-  for (const [k, entry] of cache) {
-    if (!isValid(entry)) cache.delete(k);
-  }
-  while (cache.size >= maxSize) {
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [k, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = k;
-      }
-    }
-    if (oldestKey === null) break;
-    cache.delete(oldestKey);
-  }
-  return true;
-}
-function prerenderRoutes(routes, options) {
-  const maxCacheSize = options?.maxCacheSize ?? 50;
-  const cacheTTL = options?.cacheTTL ?? 0;
-  assertCacheSize("maxCacheSize", maxCacheSize);
-  const cache = /* @__PURE__ */ new Map();
-  function isValid(entry) {
-    if (cacheTTL === 0) return true;
-    return Date.now() - entry.timestamp < cacheTTL;
-  }
-  for (const route2 of routes) {
-    if (!makeRoomFor(cache, route2.path, maxCacheSize, isValid)) break;
-    const html2 = renderToString(route2.component());
-    cache.set(route2.path, { html: html2, timestamp: Date.now() });
-  }
-  return {
-    /** Get cached HTML for a route, or undefined if not cached or expired */
-    get(path2) {
-      const entry = cache.get(path2);
-      if (!entry) return void 0;
-      if (!isValid(entry)) {
-        cache.delete(path2);
-        return void 0;
-      }
-      return entry.html;
-    },
-    /** Check if a route has been prerendered and is still valid */
-    has(path2) {
-      const entry = cache.get(path2);
-      if (!entry) return false;
-      if (!isValid(entry)) {
-        cache.delete(path2);
-        return false;
-      }
-      return true;
-    },
-    /** Invalidate a cached route */
-    invalidate(path2) {
-      cache.delete(path2);
-    },
-    /** Clear all cached routes */
-    clear() {
-      cache.clear();
-    },
-    /** Get cache statistics */
-    stats() {
-      if (cacheTTL > 0) {
-        for (const [key, entry] of cache) {
-          if (!isValid(entry)) {
-            cache.delete(key);
-          }
-        }
-      }
-      return {
-        size: cache.size,
-        routes: Array.from(cache.keys())
-      };
-    }
-  };
-}
-function createSSRCache(config) {
-  const maxSize = config?.maxSize ?? 100;
-  const defaultTTL = config?.defaultTTL ?? 6e4;
-  assertCacheSize("maxSize", maxSize);
-  const cache = /* @__PURE__ */ new Map();
-  let hits = 0;
-  let misses = 0;
-  function isValid(entry) {
-    if (entry.ttl === 0) return true;
-    return Date.now() - entry.timestamp < entry.ttl;
-  }
-  return {
-    /** Get cached HTML for a key, or undefined if not cached or expired */
-    get(key) {
-      const entry = cache.get(key);
-      if (!entry) {
-        misses++;
-        return void 0;
-      }
-      if (!isValid(entry)) {
-        cache.delete(key);
-        misses++;
-        return void 0;
-      }
-      hits++;
-      return entry.html;
-    },
-    /** Cache an HTML string with an optional TTL override */
-    set(key, html2, ttl) {
-      if (!makeRoomFor(cache, key, maxSize, isValid)) return;
-      cache.set(key, {
-        html: html2,
-        timestamp: Date.now(),
-        ttl: ttl ?? defaultTTL
-      });
-    },
-    /** Check if a key exists in the cache and is still valid */
-    has(key) {
-      const entry = cache.get(key);
-      if (!entry) return false;
-      if (!isValid(entry)) {
-        cache.delete(key);
-        return false;
-      }
-      return true;
-    },
-    /** Invalidate a cached entry */
-    invalidate(key) {
-      cache.delete(key);
-    },
-    /** Clear all cached entries and reset statistics */
-    clear() {
-      cache.clear();
-      hits = 0;
-      misses = 0;
-    },
-    /** Get cache statistics including hit/miss counts */
-    stats() {
-      return { size: cache.size, hits, misses };
-    }
-  };
-}
-var DEFER_IDLE_TIMEOUT_MS = 2e3;
-function deferNonCritical(tasks) {
-  if (tasks.length === 0) return;
-  const schedule = typeof requestIdleCallback !== "undefined" ? (cb) => {
-    requestIdleCallback(cb, { timeout: DEFER_IDLE_TIMEOUT_MS });
-  } : (cb) => {
-    setTimeout(cb, 1);
-  };
-  const queue = [...tasks];
-  let index = 0;
-  function processNext(deadline) {
-    let ranOne = false;
-    while (index < queue.length) {
-      if (ranOne && deadline && deadline.timeRemaining() < 1) {
-        schedule(processNext);
-        return;
-      }
-      try {
-        queue[index]();
-      } catch (e) {
-        reportError(e, { phase: "scheduler", name: "deferNonCritical" });
-      }
-      index++;
-      ranOne = true;
-    }
-  }
-  schedule(processNext);
-}
-function createBootSequence() {
-  const criticalTasks = [];
-  const deferredTasks = [];
-  return {
-    /** Add a critical task that runs immediately during boot */
-    critical(name, task) {
-      criticalTasks.push({ name, task });
-    },
-    /** Add a deferred task that runs after all critical tasks complete */
-    defer(name, task) {
-      deferredTasks.push({ name, task });
-    },
-    /** Execute the boot sequence: critical tasks first, then deferred */
-    async boot() {
-      const timing = {};
-      const errors = [];
-      for (const entry of criticalTasks) {
-        const start = Date.now();
-        try {
-          await entry.task();
-        } catch (e) {
-          errors.push({
-            name: entry.name,
-            error: e instanceof Error ? e : new Error(String(e))
-          });
-        }
-        timing[entry.name] = Date.now() - start;
-      }
-      for (const entry of deferredTasks) {
-        const start = Date.now();
-        try {
-          await entry.task();
-        } catch (e) {
-          errors.push({
-            name: entry.name,
-            error: e instanceof Error ? e : new Error(String(e))
-          });
-        }
-        timing[entry.name] = Date.now() - start;
-      }
-      return { timing, errors };
-    }
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeepAliveRoute,
@@ -7117,10 +7539,13 @@ function createBootSequence() {
   renderRouteToString,
   replace,
   resetPlugins,
+  resolveRouteHead,
   resolveServerRoute,
   route,
+  routeHeadToHTML,
   router,
   routerPlugin,
+  routerReady,
   routerState,
   satisfies,
   serializeRouteState,