sibujs 4.13.1 → 4.14.1

package/dist/extras.cjs

@@ -41,6 +41,7 @@ __export(extras_exports, {
   announce: () => announce,
   antdAdapter: () => antdAdapter,
   aria: () => aria,
+  assembleDocument: () => assembleDocument,
   assertType: () => assertType,
   battery: () => battery,
   bindAttrs: () => bindAttrs,
@@ -237,6 +238,7 @@ __export(extras_exports, {
   renderToReadableStream: () => renderToReadableStream,
   renderToStream: () => renderToStream,
   renderToString: () => renderToString,
+  renderToStringWith: () => renderToStringWith,
   renderToSuspenseStream: () => renderToSuspenseStream,
   renderWithLoader: () => renderWithLoader,
   required: () => required,
@@ -315,6 +317,7 @@ __export(extras_exports, {
   withRetry: () => withRetry,
   withScopedStyle: () => withScopedStyle,
   withWrapper: () => withWrapper,
+  withholdTransfer: () => withholdTransfer,
   worker: () => worker,
   workerFn: () => workerFn,
   yieldToMain: () => yieldToMain,
@@ -399,13 +402,13 @@ function claimedByBoundary(error, context) {
   }
 }
 function resolveEventTarget(node) {
-  const ELEMENT_NODE = 1;
-  let current = node;
-  while (current) {
-    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
-      return current;
+  const ELEMENT_NODE2 = 1;
+  let current2 = node;
+  while (current2) {
+    if (current2.nodeType === ELEMENT_NODE2 && typeof current2.dispatchEvent === "function") {
+      return current2;
     }
-    current = current.parentNode;
+    current2 = current2.parentNode;
   }
   const self2 = node;
   return typeof self2.dispatchEvent === "function" ? self2 : null;
@@ -414,10 +417,21 @@ function defaultReport(error, context) {
   if (typeof console === "undefined") return;
   console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
 }
+function requestErrorSink() {
+  const shared = globalThis[/* @__PURE__ */ Symbol.for("sibujs.ssr.v1")];
+  if (!shared) return void 0;
+  const store = shared.als ? shared.als.getStore() : shared.fallbackDepth > 0 ? shared.fallbackStore : void 0;
+  return store?.errors;
+}
 function reportError(error, context) {
   const err = normalizeError(error);
   untrackedRun(() => {
     if (claimedByBoundary(err, context)) return;
+    const sink = requestErrorSink();
+    if (sink) {
+      sink.push({ error: err, context });
+      return;
+    }
     const s2 = state();
     const handler = s2.handler;
     if (handler && s2.handlerDepth === 0) {
@@ -438,6 +452,110 @@ function reportError(error, context) {
   });
 }
 
+// src/core/rendering/adoptScope.ts
+var current = null;
+function inAdoptScope() {
+  return current?.s.on === true;
+}
+function currentSink() {
+  return current?.s.on ? current.s : null;
+}
+function createScopedElement(tag, ns) {
+  const c = current;
+  if (c?.s.on) {
+    const el = c.s.el(tag, ns, c.p + (c.n++).toString(36));
+    if (el) return el;
+  }
+  return ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+}
+function captureScope() {
+  const c = current;
+  return c?.s.on ? { p: `${c.p}${(c.n++).toString(36)}.`, n: 0, s: c.s } : null;
+}
+function inScope(scope, fn) {
+  const prev = current;
+  if (!scope && !prev) return fn();
+  current = scope?.s.on ? { p: scope.p, n: 0, s: scope.s } : null;
+  try {
+    return fn();
+  } finally {
+    current = prev;
+  }
+}
+
+// src/core/rendering/hydrationHooks.ts
+var _a;
+var slot = globalThis[_a = /* @__PURE__ */ Symbol.for("sibujs.hydration.v2")] ?? (globalThis[_a] = { a: /* @__PURE__ */ new Set(), c: null });
+function isHydrating() {
+  return slot.a.size > 0;
+}
+function ownSession() {
+  return currentSink()?.h ?? slot.c;
+}
+function hydrationOwners() {
+  const own = ownSession();
+  return own ? own.open ? [own] : [] : Array.from(slot.a);
+}
+function notify(session) {
+  for (const wake of Array.from(session.wake)) wake();
+}
+function holdHydration(sessions, entry) {
+  for (const s2 of sessions) s2.pending.add(entry);
+  return () => {
+    for (const s2 of sessions) if (s2.pending.delete(entry)) notify(s2);
+  };
+}
+function inHydration(session, fn) {
+  const prev = slot.c;
+  slot.c = session;
+  try {
+    return fn();
+  } finally {
+    slot.c = prev;
+  }
+}
+function beginHydration() {
+  const own = ownSession();
+  const session = {
+    done: [],
+    pending: /* @__PURE__ */ new Set(),
+    wake: /* @__PURE__ */ new Set(),
+    up: own?.open ? own : null,
+    open: true,
+    end() {
+      if (!session.open) return;
+      session.open = false;
+      slot.a.delete(session);
+      session.pending.clear();
+      notify(session);
+      const up = session.up;
+      session.up = null;
+      const callbacks = session.done.splice(0);
+      if (up?.open) {
+        up.done.push(...callbacks);
+        if (up.pending.delete(session)) notify(up);
+        return;
+      }
+      let failed = false;
+      let error;
+      inHydration(session, () => {
+        for (const fn of callbacks) {
+          try {
+            fn();
+          } catch (err) {
+            if (!failed) error = err;
+            failed = true;
+          }
+        }
+      });
+      if (failed) throw error;
+    }
+  };
+  if (session.up) session.up.pending.add(session);
+  slot.a.add(session);
+  return session;
+}
+
 // src/core/rendering/dispose.ts
 var elementDisposers = /* @__PURE__ */ new WeakMap();
 var MAX_DRAIN_TEARDOWNS = 1e4;
@@ -534,9 +652,9 @@ function dispose(node) {
   const stack = [node];
   const order = [];
   while (stack.length > 0) {
-    const current = stack.pop();
-    order.push(current);
-    const children = Array.from(current.childNodes);
+    const current2 = stack.pop();
+    order.push(current2);
+    const children = Array.from(current2.childNodes);
     for (let i2 = 0; i2 < children.length; i2++) {
       stack.push(children[i2]);
     }
@@ -575,13 +693,27 @@ function disposeNodeOwn(node) {
   }
 }
 function replaceChildrenSafely(parent, ...next) {
+  if (isHydrating() && next.length > 0 && next[0] === parent.firstChild) {
+    let ok = true;
+    for (let i2 = 1; i2 < next.length && ok; i2++) ok = next[i2 - 1].nextSibling === next[i2];
+    if (ok) {
+      let rest = next[next.length - 1].nextSibling;
+      while (rest) {
+        const following = rest.nextSibling;
+        dispose(rest);
+        parent.removeChild(rest);
+        rest = following;
+      }
+      return;
+    }
+  }
   for (let i2 = 0; i2 < next.length; i2++) {
     const node = next[i2];
     node.parentNode?.removeChild(node);
   }
-  const current = Array.from(parent.childNodes);
-  for (let i2 = 0; i2 < current.length; i2++) {
-    dispose(current[i2]);
+  const current2 = Array.from(parent.childNodes);
+  for (let i2 = 0; i2 < current2.length; i2++) {
+    dispose(current2[i2]);
   }
   parent.replaceChildren(...next);
 }
@@ -1154,7 +1286,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.13.1" : "dev";
+var _runtimeVersion = true ? "4.14.1" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -1336,6 +1468,25 @@ function derived(getter, options) {
   return computedGetter;
 }
 
+// src/core/rendering/streamBoundary.ts
+var _a2;
+var slot2 = globalThis[_a2 = /* @__PURE__ */ Symbol.for("sibujs.streamBoundary.v1")] ?? (globalThis[_a2] = { hook: null, current: null });
+function currentBoundary() {
+  return slot2.current;
+}
+function runInBoundary(boundary, fn) {
+  const prev = slot2.current;
+  slot2.current = boundary;
+  try {
+    return fn();
+  } finally {
+    slot2.current = prev;
+  }
+}
+function setBoundaryHook(hook) {
+  slot2.hook = hook;
+}
+
 // src/core/ssr-context.ts
 var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
 function detectSSRShared() {
@@ -1351,6 +1502,8 @@ function detectSSRShared() {
       }
       if (mod) detected = new mod.AsyncLocalStorage();
     }
+    const globalAls = globalThis.AsyncLocalStorage;
+    if (!detected && typeof globalAls === "function") detected = new globalAls();
   } catch {
     detected = null;
   }
@@ -1364,6 +1517,23 @@ var _shared = globalThis[SSR_KEY] ?? (globalThis[SSR_KEY] = detectSSRShared());
 var als = _shared.als;
 var fallbackStore = _shared.fallbackStore;
 _shared.fallbackDepth ?? (_shared.fallbackDepth = 0);
+var _alsWarned = false;
+function warnMissingAsyncLocalStorage() {
+  if (_alsWarned || als) return;
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  if (!isNode) return;
+  _alsWarned = true;
+  const version = process.versions.node;
+  devWarn(
+    `SSR request isolation is UNAVAILABLE on this runtime (Node ${version}). AsyncLocalStorage could not be loaded, so concurrent requests share one SSR store: request state and the query cache can bleed between them. Node >= 22.3 is required for isolated SSR under ESM; the CommonJS build works on older versions. A fully synchronous render is unaffected.`
+  );
+}
+function assertRequestIsolation(api) {
+  if (als || typeof window !== "undefined") return;
+  throw new Error(
+    `[SibuJS SSR] ${api} needs AsyncLocalStorage to keep concurrent requests apart, and this runtime has none. Use Node >= 22.3 (or the CommonJS build on older Node), Deno or Bun, or enable AsyncLocalStorage on your edge runtime (Cloudflare Workers: the nodejs_compat flag).`
+  );
+}
 function getSSRStore() {
   if (als) {
     const s2 = als.getStore();
@@ -1389,6 +1559,63 @@ function getRequestScopedCache(name) {
   }
   return c;
 }
+function requestSlot(name, create) {
+  const store = getRequestStore();
+  if (!store) return void 0;
+  const slots = store.slots ?? (store.slots = /* @__PURE__ */ new Map());
+  if (!slots.has(name) && create) slots.set(name, create());
+  return slots.get(name);
+}
+var PRERENDER_HOST = /* @__PURE__ */ Symbol.for("sibujs.prerender.v1");
+function isServer() {
+  return getSSRStore().ssr || globalThis[PRERENDER_HOST] !== void 0;
+}
+function runInSSRContext(fn) {
+  const store = {
+    ssr: true,
+    suspenseIdCounter: 0,
+    idCounter: 0,
+    locale: void 0,
+    pending: /* @__PURE__ */ new Set(),
+    wake: null
+  };
+  if (als) {
+    return als.run(store, fn);
+  }
+  warnMissingAsyncLocalStorage();
+  const prev = { ...fallbackStore };
+  Object.assign(fallbackStore, store);
+  _shared.fallbackDepth++;
+  try {
+    return fn();
+  } finally {
+    _shared.fallbackDepth--;
+    for (const key of Object.keys(fallbackStore)) {
+      if (!(key in prev)) delete fallbackStore[key];
+    }
+    Object.assign(fallbackStore, prev);
+  }
+}
+function trackPending(promise, label2, hydration = true) {
+  const store = getRequestStore();
+  const pending = store?.pending;
+  const sessions = pending || !hydration ? [] : hydrationOwners();
+  if (!pending && sessions.length === 0) return promise;
+  const entry = { label: label2, since: Date.now(), boundary: currentBoundary() ?? void 0 };
+  pending?.add(entry);
+  const release = holdHydration(sessions, entry);
+  const done = () => {
+    pending?.delete(entry);
+    store?.wake?.();
+    release();
+  };
+  try {
+    Promise.resolve(promise).then(done, done);
+  } catch {
+    done();
+  }
+  return promise;
+}
 
 // src/core/signals/effect.ts
 var _g = globalThis;
@@ -1454,7 +1681,7 @@ function disposeEffect(ctx) {
 }
 function effect(effectFn, options) {
   devAssert(typeof effectFn === "function", "effect: argument must be a function.");
-  if (isSSR()) return () => {
+  if (isSSR() && !options?.server) return () => {
   };
   const ctx = {
     fn: effectFn,
@@ -1651,6 +1878,98 @@ function globalSingleton(key, create) {
   return g2[key] ?? (g2[key] = create());
 }
 
+// src/utils/guards.ts
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isUnsafeKey(key) {
+  return UNSAFE_KEYS.has(key);
+}
+function readOwnGlobal(key) {
+  if (typeof window === "undefined") return void 0;
+  if (!Object.hasOwn(window, key)) return void 0;
+  const value = window[key];
+  if (typeof Node !== "undefined" && value instanceof Node) return void 0;
+  return value;
+}
+function stripUnsafeKeys(obj) {
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    if (!isUnsafeKey(k)) out[k] = obj[k];
+  }
+  return out;
+}
+
+// src/utils/transfer.ts
+var TRANSFER_GLOBAL = "__SIBU_TRANSFER__";
+var TRANSFER_VERSION = 1;
+var REGISTRY_KEY2 = /* @__PURE__ */ Symbol.for("sibujs.transfer.v1");
+function registry() {
+  const g2 = globalThis;
+  let r = g2[REGISTRY_KEY2];
+  if (!r) {
+    r = { collectors: /* @__PURE__ */ new Map(), payload: void 0 };
+    g2[REGISTRY_KEY2] = r;
+  }
+  return r;
+}
+function registerTransferCollector(section2, collect) {
+  registry().collectors.set(section2, collect);
+}
+function collectTransfer() {
+  if (!getRequestStore()) return null;
+  const out = {};
+  let any = false;
+  for (const [section2, collect] of registry().collectors) {
+    const entries = collect();
+    if (!entries) continue;
+    const safe = {};
+    for (const key of Object.keys(entries)) if (!isUnsafeKey(key)) safe[key] = entries[key];
+    if (Object.keys(safe).length > 0) {
+      out[section2] = safe;
+      any = true;
+    }
+  }
+  if (!any) return null;
+  out.v = TRANSFER_VERSION;
+  return out;
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function readPayload() {
+  const r = registry();
+  if (r.payload !== void 0) return r.payload;
+  r.payload = null;
+  if (typeof window === "undefined" || getRequestStore()) return null;
+  const raw = readOwnGlobal(TRANSFER_GLOBAL);
+  if (!isPlainRecord(raw) || raw.v !== TRANSFER_VERSION) return null;
+  const sections = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(raw)) {
+    const section2 = raw[key];
+    if (key === "v" || isUnsafeKey(key) || !isPlainRecord(section2)) continue;
+    const entries = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(section2)) if (!isUnsafeKey(k)) entries[k] = section2[k];
+    sections[key] = entries;
+  }
+  r.payload = sections;
+  return sections;
+}
+function takeTransferred(section2, key) {
+  const entries = readPayload()?.[section2];
+  if (!entries || !Object.hasOwn(entries, key)) return void 0;
+  const value = entries[key];
+  delete entries[key];
+  return value;
+}
+function takeTransferredSection(section2) {
+  const payload = readPayload();
+  const entries = payload?.[section2];
+  if (!payload || !entries) return {};
+  delete payload[section2];
+  return entries;
+}
+
 // src/data/abort.ts
 function isAbortError(error) {
   return typeof error === "object" && error !== null && error.name === "AbortError";
@@ -1845,8 +2164,34 @@ function sharedView(entry) {
 }
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
-  return getRequestScopedCache("query") ?? globalQueryCache;
-}
+  const requestCache = getRequestScopedCache("query");
+  if (requestCache) return requestCache;
+  primeFromTransfer();
+  return globalQueryCache;
+}
+var SERVER_EFFECT = { server: true };
+function primeFromTransfer() {
+  const entries = takeTransferredSection("q");
+  const now = Date.now();
+  for (const key of Object.keys(entries)) {
+    const record = entries[key];
+    if (!record || typeof record !== "object" || record.d === void 0) continue;
+    if (globalQueryCache.has(key)) continue;
+    const entry = getOrCreateEntry(globalQueryCache, key, record.d);
+    const t = typeof record.t === "number" && Number.isFinite(record.t) ? record.t : now;
+    entry.dataUpdatedAt = Math.min(t, now);
+  }
+}
+registerTransferCollector("q", () => {
+  const cache = getRequestScopedCache("query");
+  if (!cache) return void 0;
+  const out = {};
+  for (const [key, entry] of cache) {
+    if (entry.noTransfer || entry.data === void 0 || entry.error) continue;
+    out[key] = { d: entry.data, t: entry.dataUpdatedAt };
+  }
+  return out;
+});
 function abandonEntry(entry) {
   if (entry.gcTimer) clearTimeout(entry.gcTimer);
   entry.gcTimer = null;
@@ -1892,11 +2237,13 @@ function query(key, fetcher, options = {}) {
     onError,
     onSettled,
     select: select3,
-    structuralSharing = true
+    structuralSharing = true,
+    ssr = true
   } = options;
+  const onServer = isSSR();
   const resolveKey = typeof key === "function" ? key : () => key;
   const enabledGate = typeof enabled === "function" ? derived(() => Boolean(enabled())) : null;
-  const isEnabled = enabledGate ?? (() => Boolean(enabled));
+  const isEnabled = onServer && !ssr ? () => false : enabledGate ?? (() => Boolean(enabled));
   const cache = getActiveQueryCache();
   const [data2, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
@@ -1970,7 +2317,7 @@ function query(key, fetcher, options = {}) {
     selectedEntry = entry;
     selectedValue = value;
     setData(value);
-  }) : null;
+  }, SERVER_EFFECT) : null;
   function detachFromEntry() {
     const entry = attachedEntry;
     const key2 = attachedKey;
@@ -1984,9 +2331,9 @@ function query(key, fetcher, options = {}) {
     if (cache.get(key2) !== entry) return;
     if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
     entry.gcTimer = setTimeout(() => {
-      const current = cache.get(key2);
-      if (current === entry && current.subscribers <= 0) {
-        abandonEntry(current);
+      const current2 = cache.get(key2);
+      if (current2 === entry && current2.subscribers <= 0) {
+        abandonEntry(current2);
         cache.delete(key2);
       }
     }, cacheTime);
@@ -2053,7 +2400,7 @@ function query(key, fetcher, options = {}) {
       runCallback("query onSettled", () => onSettled?.());
       return;
     }
-    entry.promise = promise;
+    entry.promise = trackPending(promise, `query:${key2}`, false);
     try {
       const result = await promise;
       if (entry.generation !== generation) return;
@@ -2125,6 +2472,7 @@ function query(key, fetcher, options = {}) {
       return;
     }
     const entry = getOrCreateEntry(cache, key2, initialData);
+    if (!ssr) entry.noTransfer = true;
     const reattached = attachedEntry !== entry;
     attachToEntry(entry, key2);
     if (keyChanged) setIsFetching(entry.promise !== null);
@@ -2146,15 +2494,15 @@ function query(key, fetcher, options = {}) {
     if (on && (entry.data === void 0 || isDataStale)) {
       doFetch();
     }
-  });
-  if (refetchInterval && refetchInterval > 0) {
+  }, SERVER_EFFECT);
+  if (!onServer && refetchInterval && refetchInterval > 0) {
     intervalTimer = setInterval(() => {
       if (!disposed && currentKey) doFetch();
     }, refetchInterval);
   }
   let focusHandler = null;
   let onlineHandler = null;
-  if (typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
+  if (!onServer && typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
     if (refetchOnWindowFocus) {
       focusHandler = () => {
         if (!disposed && currentKey) doFetch();
@@ -2498,12 +2846,12 @@ function infiniteQuery(key, fetcher, options) {
 // src/data/previous.ts
 function previous(getter) {
   const [previous2, setPrevious] = signal(void 0);
-  let current = getter();
+  let current2 = getter();
   const stop2 = effect(() => {
     const next = getter();
-    if (!Object.is(next, current)) {
-      setPrevious(current);
-      current = next;
+    if (!Object.is(next, current2)) {
+      setPrevious(current2);
+      current2 = next;
     }
   });
   Object.defineProperty(previous2, "dispose", {
@@ -2583,6 +2931,28 @@ function throttle(getter, interval) {
 }
 
 // src/data/resource.ts
+function transferSlot() {
+  return requestSlot("resource:transfer", () => /* @__PURE__ */ new Map());
+}
+function withheldSlot() {
+  return requestSlot("resource:transfer:withheld", () => /* @__PURE__ */ new Set());
+}
+registerTransferCollector("r", () => {
+  const slot4 = transferSlot();
+  if (!slot4 || slot4.size === 0) return void 0;
+  const withheld = withheldSlot();
+  const out = {};
+  let any = false;
+  for (const [key, value] of slot4) {
+    if (withheld?.has(key)) continue;
+    out[key] = value;
+    any = true;
+  }
+  return any ? out : void 0;
+});
+function withholdTransfer(key) {
+  withheldSlot()?.add(key);
+}
 function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
   let source2 = null;
   let fetcher;
@@ -2596,10 +2966,14 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     fetcher = (_source, info) => rawFetcher(info);
     options = fetcherOrOptions ?? {};
   }
-  const [data2, setData] = signal(options.initialValue);
+  const transferred = options.key !== void 0 ? takeTransferred("r", options.key) : void 0;
+  const hydrated = transferred !== void 0;
+  const initialValue = hydrated ? transferred : options.initialValue;
+  const onServer = isSSR();
+  const [data2, setData] = signal(initialValue);
   const [loading, setLoading] = signal(false);
   const [error, setError] = signal(void 0);
-  let currentData = options.initialValue;
+  let currentData = initialValue;
   function commitData(next, explicit) {
     const sharing = options.structuralSharing ?? true;
     const shared = untracked2(
@@ -2607,6 +2981,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     );
     currentData = shared.ok ? shared.value : next;
     setData(currentData);
+    if (onServer && options.key !== void 0) transferSlot()?.set(options.key, currentData);
     return currentData;
   }
   let abortController = null;
@@ -2652,19 +3027,28 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       }
     }
   }
+  const run = (sourceValue) => trackPending(doFetch(sourceValue), "resource", false);
   if (source2) {
-    effectCleanup = effect(() => {
-      const sourceValue = source2();
-      doFetch(sourceValue);
-    });
-  } else if (options.immediate !== false) {
-    doFetch(void 0);
+    let skipFirst = hydrated;
+    effectCleanup = effect(
+      () => {
+        const sourceValue = source2();
+        if (skipFirst) {
+          skipFirst = false;
+          return;
+        }
+        run(sourceValue);
+      },
+      { server: true }
+    );
+  } else if (options.immediate !== false && !hydrated) {
+    run(void 0);
   }
   return {
     data: data2,
     loading,
     error,
-    refetch: () => doFetch(source2 ? source2() : void 0),
+    refetch: () => run(source2 ? source2() : void 0),
     mutate: (value) => {
       const newValue = typeof value === "function" ? value(currentData) : value;
       commitData(newValue, true);
@@ -2965,8 +3349,27 @@ function currentScope() {
   }
   return scope;
 }
+function automaticKey(loader, context) {
+  const key = `loader:${context.path}${loader.name ? `:${loader.name}` : ""}`;
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return key;
+  let owners = cache.get("owners");
+  if (!owners) {
+    owners = /* @__PURE__ */ new Map();
+    cache.set("owners", owners);
+  }
+  const owner = owners.get(key);
+  if (owner === void 0) {
+    owners.set(key, loader);
+    return key;
+  }
+  if (owner === loader) return key;
+  withholdTransfer(key);
+  return void 0;
+}
 function executeLoader(loader, context, options) {
-  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const key = options?.key ?? automaticKey(loader, context);
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), { ...options, key });
   const disposeResource = res.dispose;
   res.dispose = () => {
     _disposed.add(res);
@@ -3241,19 +3644,19 @@ function sanitizeSrcset(value) {
     if (url.endsWith(",")) {
       url = url.replace(/,+$/, "");
     } else {
-      let current = "";
+      let current2 = "";
       let inParens = false;
       while (i2 < n) {
         const ch = input2[i2];
         if (inParens) {
-          current += ch;
+          current2 += ch;
           if (ch === ")") inParens = false;
           i2++;
           continue;
         }
         if (isSrcsetWhitespace(ch)) {
-          if (current) descriptors.push(current);
-          current = "";
+          if (current2) descriptors.push(current2);
+          current2 = "";
           i2++;
           continue;
         }
@@ -3262,10 +3665,10 @@ function sanitizeSrcset(value) {
           break;
         }
         if (ch === "(") inParens = true;
-        current += ch;
+        current2 += ch;
         i2++;
       }
-      if (current) descriptors.push(current);
+      if (current2) descriptors.push(current2);
     }
     if (url === "") continue;
     if (descriptors.length > 1) continue;
@@ -4016,26 +4419,6 @@ function clipboard() {
   return { text: text2, copy, copied, dispose: dispose2 };
 }
 
-// src/utils/guards.ts
-var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function isUnsafeKey(key) {
-  return UNSAFE_KEYS.has(key);
-}
-function readOwnGlobal(key) {
-  if (typeof window === "undefined") return void 0;
-  if (!Object.hasOwn(window, key)) return void 0;
-  const value = window[key];
-  if (typeof Node !== "undefined" && value instanceof Node) return void 0;
-  return value;
-}
-function stripUnsafeKeys(obj) {
-  const out = {};
-  for (const k of Object.keys(obj)) {
-    if (!isUnsafeKey(k)) out[k] = obj[k];
-  }
-  return out;
-}
-
 // src/browser/dragDrop.ts
 function resolveTarget2(target) {
   return typeof target === "function" ? target : () => target.current;
@@ -4689,7 +5072,7 @@ function wakeLock() {
     };
   }
   const api = navigator.wakeLock;
-  let current = null;
+  let current2 = null;
   let desire = false;
   let generation = 0;
   let inflight = null;
@@ -4699,8 +5082,8 @@ function wakeLock() {
     setActive(value);
   }
   function syncReleasedState() {
-    if (current?.released) {
-      current = null;
+    if (current2?.released) {
+      current2 = null;
       publishActive(false);
     }
   }
@@ -4714,7 +5097,7 @@ function wakeLock() {
     if (disposed) return;
     desire = true;
     syncReleasedState();
-    if (current && !current.released) {
+    if (current2 && !current2.released) {
       publishActive(true);
       return;
     }
@@ -4733,8 +5116,8 @@ function wakeLock() {
         }
         try {
           sentinel.addEventListener("release", () => {
-            if (current !== sentinel) return;
-            current = null;
+            if (current2 !== sentinel) return;
+            current2 = null;
             publishActive(false);
           });
         } catch (listenerError) {
@@ -4747,7 +5130,7 @@ function wakeLock() {
           publishActive(false);
           return;
         }
-        current = sentinel;
+        current2 = sentinel;
         publishActive(true);
       } catch (err) {
         if (generation === myGeneration) publishActive(false);
@@ -4765,8 +5148,8 @@ function wakeLock() {
     desire = false;
     generation++;
     inflight = null;
-    const held = current;
-    current = null;
+    const held = current2;
+    current2 = null;
     publishActive(false);
     if (held && !held.released) {
       await held.release();
@@ -4774,7 +5157,7 @@ function wakeLock() {
   }
   const onVisibility = () => {
     syncReleasedState();
-    if (!desire || current || document.hidden) return;
+    if (!desire || current2 || document.hidden) return;
     request().catch((err) => {
       reportError(err, { phase: "async", name: "wakeLock(visibility re-acquire)" });
     });
@@ -4786,8 +5169,8 @@ function wakeLock() {
     generation++;
     inflight = null;
     document.removeEventListener("visibilitychange", onVisibility);
-    const held = current;
-    current = null;
+    const held = current2;
+    current2 = null;
     setActive(false);
     disposed = true;
     if (held && !held.released) {
@@ -5302,7 +5685,7 @@ function imageLoader(src) {
       }
     };
   }
-  let current = null;
+  let current2 = null;
   let currentSettled = false;
   let disposed = false;
   let startToken = 0;
@@ -5315,9 +5698,9 @@ function imageLoader(src) {
     });
   }
   function abandonCurrent() {
-    if (!current) return;
-    const prev = current;
-    current = null;
+    if (!current2) return;
+    const prev = current2;
+    current2 = null;
     prev.onload = null;
     prev.onerror = null;
     if (!currentSettled) prev.src = "";
@@ -5333,10 +5716,10 @@ function imageLoader(src) {
       return;
     }
     const img2 = new Image();
-    current = img2;
+    current2 = img2;
     currentSettled = false;
     img2.onload = () => {
-      if (disposed || current !== img2) return;
+      if (disposed || current2 !== img2) return;
       currentSettled = true;
       batch(() => {
         setImage(img2);
@@ -5346,7 +5729,7 @@ function imageLoader(src) {
       });
     };
     img2.onerror = () => {
-      if (disposed || current !== img2) return;
+      if (disposed || current2 !== img2) return;
       currentSettled = true;
       setStatus("error");
     };
@@ -5500,10 +5883,10 @@ function persisted(key, initial, options = {}) {
   const [value, setValue] = signal(restored);
   let applyingFromStorage = false;
   const stopPersistEffect = effect(() => {
-    const current = value();
+    const current2 = value();
     if (applyingFromStorage) return;
     try {
-      let serialized = serialize(current);
+      let serialized = serialize(current2);
       if (encrypt) serialized = encrypt(serialized);
       storage?.setItem(key, serialized);
     } catch {
@@ -5850,9 +6233,9 @@ function timeline(initial, maxHistory = 100) {
   const canUndo = derived(() => index() > 0);
   const canRedo = derived(() => index() < history2().length - 1);
   function set(next) {
-    const current = value();
-    const newValue = typeof next === "function" ? next(current) : next;
-    if (Object.is(newValue, current)) return;
+    const current2 = value();
+    const newValue = typeof next === "function" ? next(current2) : next;
+    if (Object.is(newValue, current2)) return;
     const hist = history2();
     const idx = index();
     const newHistory = hist.slice(0, idx + 1);
@@ -6095,10 +6478,10 @@ function globalStore(config) {
     const actionFn = config.actions[action];
     if (!actionFn) throw new Error(`Unknown action: ${String(action)}`);
     const execute = () => {
-      const current = getState();
-      const rawPatch = actionFn(current, payload);
+      const current2 = getState();
+      const rawPatch = actionFn(current2, payload);
       const patch = stripUnsafeKeys(rawPatch);
-      setState({ ...current, ...patch });
+      setState({ ...current2, ...patch });
       notifyListeners2(getState());
     };
     perform(() => {
@@ -6757,7 +7140,7 @@ function springSignal(initial, options) {
   const damping = options?.damping ?? 0.8;
   const precision = options?.precision ?? 0.01;
   const [value, setValue] = signal(initial);
-  let current = initial;
+  let current2 = initial;
   let velocity = 0;
   let target = initial;
   let rafId = null;
@@ -6774,18 +7157,18 @@ function springSignal(initial, options) {
     lastTime = now;
     const dt2 = Number.isFinite(rawDt) && rawDt > 0 ? rawDt : REF_DT_MS;
     const ratio = Math.min(MAX_STEP_RATIO, Math.max(0.1, dt2 / REF_DT_MS));
-    const force = -stiffness * (current - target);
+    const force = -stiffness * (current2 - target);
     const dampingForce = -damping * velocity;
     velocity += (force + dampingForce) * ratio;
-    current += velocity * ratio;
-    if (Math.abs(current - target) < precision && Math.abs(velocity) < precision) {
-      current = target;
+    current2 += velocity * ratio;
+    if (Math.abs(current2 - target) < precision && Math.abs(velocity) < precision) {
+      current2 = target;
       velocity = 0;
       lastTime = 0;
-      setValue(current);
+      setValue(current2);
       return;
     }
-    setValue(current);
+    setValue(current2);
     if (disposed || rafId !== null) return;
     rafId = requestAnimationFrame(tick);
   }
@@ -6799,11 +7182,11 @@ function springSignal(initial, options) {
     if (disposed) return;
     target = newTarget;
     if (!canAnimate() || prefersReducedMotion()) {
-      current = newTarget;
+      current2 = newTarget;
       velocity = 0;
       cancelFrame();
       lastTime = 0;
-      setValue(current);
+      setValue(current2);
       return;
     }
     if (rafId === null) {
@@ -6998,7 +7381,7 @@ function form(config) {
     }
     return false;
   };
-  const isDirty = derived(() => {
+  const isDirty2 = derived(() => {
     for (const [name, cfg] of fieldEntries) {
       if (!valueEquals(fieldMap[name].value(), cfg.initial)) return true;
     }
@@ -7062,7 +7445,7 @@ function form(config) {
     disposed = true;
     errors.dispose();
     isValid.dispose();
-    isDirty.dispose();
+    isDirty2.dispose();
     touchedState.dispose();
     values.dispose();
     for (const error of fieldErrors) error.dispose();
@@ -7071,7 +7454,7 @@ function form(config) {
     fields: fieldMap,
     errors,
     isValid,
-    isDirty,
+    isDirty: isDirty2,
     submitting,
     touched: touchedState,
     values,
@@ -8036,8 +8419,8 @@ function commitSafeAttribute(el, name, value, options) {
     else el.removeAttribute(name);
     return true;
   }
-  const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
-  if (current === safe) return true;
+  const current2 = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
+  if (current2 === safe) return true;
   if (ns) el.setAttributeNS(ns, name, safe);
   else el.setAttribute(name, safe);
   return true;
@@ -8874,9 +9257,9 @@ function narrowEmbedAllow(value) {
 function getEmbedRecord(frame) {
   return state2.frames.get(frame);
 }
-function intersect(current, permitted, separator) {
+function intersect(current2, permitted, separator) {
   const allowed = permitted.split(separator);
-  return current.split(separator).filter((token) => token && allowed.includes(token)).join(separator);
+  return current2.split(separator).filter((token) => token && allowed.includes(token)).join(separator);
 }
 function embedSerializedAttribute(record, seen, name, value) {
   switch (name) {
@@ -8980,67 +9363,2906 @@ function escapeHeadAttrValue(value) {
 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 serializePlannedHeadEntry(tag, plan.attributes);
+}
+function serializePlannedHeadEntry(tag, attributes) {
+  const pairs = Array.from(attributes, ([name, value]) => `${name}="${escapeHeadAttrValue(value)}"`).join(" ");
   return `<${tag} ${pairs} />`;
 }
 
-// src/platform/ssr.ts
-function isForbiddenSsrAttr(lowerName) {
-  return isHtmlContentAttribute(lowerName);
-}
-var SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-function isSafeAttrName(name) {
-  return SAFE_ATTR_NAME.test(name);
-}
-function ssrErrorComment(err) {
-  if (DEV) {
-    const msg = escapeHtml(err instanceof Error ? err.message : String(err));
-    return `<!--SSR error: ${safeCommentText(msg)}-->`;
+// src/platform/serverDom.ts
+var HTML_NS3 = "http://www.w3.org/1999/xhtml";
+var SVG_NS3 = "http://www.w3.org/2000/svg";
+var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var ELEMENT_NODE = 1;
+var ATTRIBUTE_NODE = 2;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
+var DOCUMENT_NODE = 9;
+var DOCUMENT_FRAGMENT_NODE = 11;
+function callerFrame() {
+  const stack = new Error().stack ?? "";
+  const lines = stack.split("\n").slice(1);
+  for (const line2 of lines) {
+    if (line2.includes("serverDom")) continue;
+    const trimmed = line2.trim();
+    if (trimmed) return trimmed.replace(/^at\s+/, "");
+  }
+  return "(unknown caller)";
+}
+var warnedSites = /* @__PURE__ */ new Set();
+function reportBrowserApi(api) {
+  const frame = callerFrame();
+  const entry = `${api} at ${frame}`;
+  requestSlot("browserApis", () => /* @__PURE__ */ new Set())?.add(entry);
+  if (DEV && !warnedSites.has(entry) && warnedSites.size < 200) {
+    warnedSites.add(entry);
+    console.warn(
+      `[SibuJS SSR] ${api} was used during a server render (${frame}). It only exists in a browser: move the code into onMount() or an effect, or render it with ClientOnly().`
+    );
   }
-  return "<!--SSR error-->";
+  return frame;
 }
-function safeCommentText(text2) {
-  return text2.replace(/-->/g, "--&gt;").replace(/--!>/g, "--!&gt;").replace(/<!--/g, "&lt;!--").replace(/--$/g, "--&#45;");
+function unavailable(api) {
+  const frame = reportBrowserApi(api);
+  throw new Error(
+    `[SibuJS SSR] ${api} is not available in the SibuJS server DOM (called from ${frame}). It needs a browser: call it from onMount() or an effect, or render the component with ClientOnly().`
+  );
 }
-var VOID_ELEMENTS = /* @__PURE__ */ new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-function findNativeGetter(proto, name) {
-  for (let p2 = proto; p2; p2 = Object.getPrototypeOf(p2)) {
-    const get = Object.getOwnPropertyDescriptor(p2, name)?.get;
-    if (get) return get;
-  }
-  return null;
+function invalidCharacter(name) {
+  const Ctor = globalThis.DOMException;
+  const message = `"${name}" did not match the Name production`;
+  throw Ctor ? new Ctor(message, "InvalidCharacterError") : new Error(message);
 }
-var nativeAccessorsByRealm = /* @__PURE__ */ new WeakMap();
-function nativeAccessors() {
-  const realm = Element;
-  let accessors = nativeAccessorsByRealm.get(realm);
-  if (!accessors) {
-    accessors = {
-      attributes: findNativeGetter(Element.prototype, "attributes"),
-      tagName: findNativeGetter(Element.prototype, "tagName"),
-      childNodes: findNativeGetter(Node.prototype, "childNodes"),
-      getAttribute: Element.prototype.getAttribute
+var NAME_RE = /^[A-Za-z_:][-A-Za-z0-9_.:·À-￿]*$/;
+var ServerNodeList = class extends Array {
+  static get [Symbol.species]() {
+    return Array;
+  }
+  item(index) {
+    return this[index] ?? null;
+  }
+};
+var observations = [];
+function queueRecord(record) {
+  if (observations.length === 0) return;
+  for (const obs of observations) {
+    const o = obs.options;
+    const wants = record.type === "childList" ? o.childList : record.type === "attributes" ? o.attributes : o.characterData;
+    if (!wants) continue;
+    if (obs.target !== record.target && !(o.subtree && obs.target.contains(record.target))) continue;
+    obs.observer._enqueue(record);
+  }
+}
+var ServerMutationObserver = class {
+  constructor(callback) {
+    this.callback = callback;
+    this.records = [];
+    this.scheduled = false;
+  }
+  observe(target, options = {}) {
+    const opts = { ...options };
+    if (opts.attributeFilter || opts.attributeOldValue) opts.attributes ?? (opts.attributes = true);
+    if (opts.characterDataOldValue) opts.characterData ?? (opts.characterData = true);
+    const existing = observations.find((o) => o.observer === this && o.target === target);
+    if (existing) existing.options = opts;
+    else observations.push({ observer: this, target, options: opts });
+  }
+  disconnect() {
+    for (let i2 = observations.length - 1; i2 >= 0; i2--) if (observations[i2].observer === this) observations.splice(i2, 1);
+    this.records = [];
+  }
+  takeRecords() {
+    const out = this.records;
+    this.records = [];
+    return out;
+  }
+  /** @internal */
+  _enqueue(record) {
+    this.records.push(record);
+    if (this.scheduled) return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      const records = this.takeRecords();
+      if (records.length > 0) this.callback(records, this);
+    });
+  }
+};
+var _ServerNode = class _ServerNode {
+  constructor(ownerDocument) {
+    this.ownerDocument = ownerDocument;
+    /** @internal */
+    this._parent = null;
+    /** @internal */
+    this._prev = null;
+    /** @internal */
+    this._next = null;
+    /** @internal */
+    this._first = null;
+    /** @internal */
+    this._last = null;
+    /** @internal */
+    this._count = 0;
+    /** @internal */
+    this._list = null;
+    /** @internal */
+    this._listeners = null;
+  }
+  get nodeType() {
+    return 0;
+  }
+  get nodeName() {
+    return "";
+  }
+  get nodeValue() {
+    return null;
+  }
+  set nodeValue(_value) {
+  }
+  get parentNode() {
+    return this._parent;
+  }
+  get parentElement() {
+    return this._parent instanceof ServerElement ? this._parent : null;
+  }
+  get firstChild() {
+    return this._first;
+  }
+  get lastChild() {
+    return this._last;
+  }
+  get nextSibling() {
+    return this._next;
+  }
+  get previousSibling() {
+    return this._prev;
+  }
+  get childNodes() {
+    if (!this._list) {
+      const list = new ServerNodeList();
+      for (let n = this._first; n; n = n._next) list.push(n);
+      this._list = list;
+    }
+    return this._list;
+  }
+  hasChildNodes() {
+    return this._first !== null;
+  }
+  get isConnected() {
+    let n = this;
+    while (n) {
+      if (n.nodeType === DOCUMENT_NODE) return true;
+      n = n._parent;
+    }
+    return false;
+  }
+  getRootNode() {
+    let n = this;
+    while (n._parent) n = n._parent;
+    return n;
+  }
+  get textContent() {
+    let out = "";
+    for (let n = this._first; n; n = n._next) {
+      if (n.nodeType === TEXT_NODE) out += n.data;
+      else if (n.nodeType === ELEMENT_NODE || n.nodeType === DOCUMENT_FRAGMENT_NODE) out += n.textContent ?? "";
+    }
+    return out;
+  }
+  set textContent(value) {
+    while (this._first) this.removeChild(this._first);
+    const text2 = value == null ? "" : String(value);
+    if (text2 !== "") this.appendChild(new ServerText(this.ownerDocument, text2));
+  }
+  contains(other) {
+    for (let n = other; n; n = n._parent) if (n === this) return true;
+    return false;
+  }
+  compareDocumentPosition(other) {
+    if (other === this) return 0;
+    if (this.getRootNode() !== other.getRootNode()) return 1 | 32;
+    if (this.contains(other)) return 16 | 4;
+    if (other.contains(this)) return 8 | 2;
+    const chain = (n) => {
+      const out = [];
+      for (let c = n; c; c = c._parent) out.unshift(c);
+      return out;
     };
-    nativeAccessorsByRealm.set(realm, accessors);
+    const a2 = chain(this);
+    const b2 = chain(other);
+    let i2 = 0;
+    while (a2[i2] === b2[i2]) i2++;
+    for (let n = a2[i2]._next; n; n = n._next) if (n === b2[i2]) return 4;
+    return 2;
+  }
+  // ── Mutation ──
+  /** @internal */
+  _assertParentOf(node) {
+    if (!(node instanceof _ServerNode))
+      throw new TypeError("Failed to execute on Node: parameter is not of type 'Node'.");
+    if (node.contains(this)) {
+      const Ctor = globalThis.DOMException;
+      const message = "The new child element contains the parent.";
+      throw Ctor ? new Ctor(message, "HierarchyRequestError") : new Error(message);
+    }
+  }
+  insertBefore(node, ref) {
+    if (ref && ref._parent !== this) {
+      const Ctor = globalThis.DOMException;
+      const message = "The node before which the new node is to be inserted is not a child of this node.";
+      throw Ctor ? new Ctor(message, "NotFoundError") : new Error(message);
+    }
+    if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+      const moved = [];
+      while (node._first) {
+        const child = node._first;
+        node._unlink(child, true);
+        moved.push(child);
+      }
+      for (const child of moved) this._link(child, ref, true);
+      if (moved.length > 0) this._recordChildList(moved, [], moved[0]._prev, ref);
+      return node;
+    }
+    this._assertParentOf(node);
+    if (ref === node) ref = node._next;
+    if (node._parent) node._parent.removeChild(node);
+    this._link(node, ref, false);
+    this._recordChildList([node], [], node._prev, node._next);
+    return node;
+  }
+  appendChild(node) {
+    return this.insertBefore(node, null);
+  }
+  removeChild(node) {
+    if (node._parent !== this) {
+      const Ctor = globalThis.DOMException;
+      const message = "The node to be removed is not a child of this node.";
+      throw Ctor ? new Ctor(message, "NotFoundError") : new Error(message);
+    }
+    const prev = node._prev;
+    const next = node._next;
+    this._unlink(node, false);
+    this._recordChildList([], [node], prev, next);
+    return node;
+  }
+  replaceChild(node, old) {
+    if (node === old) return old;
+    const next = old._next === node ? node._next : old._next;
+    this.removeChild(old);
+    this.insertBefore(node, next);
+    return old;
+  }
+  /** @internal */
+  _link(node, ref, quiet) {
+    node._parent = this;
+    if (ref) {
+      node._prev = ref._prev;
+      node._next = ref;
+      if (ref._prev) ref._prev._next = node;
+      else this._first = node;
+      ref._prev = node;
+    } else {
+      node._prev = this._last;
+      node._next = null;
+      if (this._last) this._last._next = node;
+      else this._first = node;
+      this._last = node;
+    }
+    this._count++;
+    this._list = null;
+    void quiet;
+  }
+  /** @internal */
+  _unlink(node, quiet) {
+    if (node._prev) node._prev._next = node._next;
+    else this._first = node._next;
+    if (node._next) node._next._prev = node._prev;
+    else this._last = node._prev;
+    node._parent = null;
+    node._prev = null;
+    node._next = null;
+    this._count--;
+    this._list = null;
+    void quiet;
+  }
+  /** @internal */
+  _recordChildList(added, removed, prev, next) {
+    if (observations.length === 0) return;
+    queueRecord({
+      type: "childList",
+      target: this,
+      addedNodes: added,
+      removedNodes: removed,
+      previousSibling: prev,
+      nextSibling: next,
+      attributeName: null,
+      attributeNamespace: null,
+      oldValue: null
+    });
   }
-  return accessors;
+  // ── ChildNode / ParentNode ──
+  remove() {
+    this._parent?.removeChild(this);
+  }
+  replaceWith(...nodes) {
+    const parent = this._parent;
+    if (!parent) return;
+    const next = this._next;
+    parent.removeChild(this);
+    for (const n of nodes) parent.insertBefore(toNode(this.ownerDocument, n), next);
+  }
+  before(...nodes) {
+    const parent = this._parent;
+    if (!parent) return;
+    for (const n of nodes) parent.insertBefore(toNode(this.ownerDocument, n), this);
+  }
+  after(...nodes) {
+    const parent = this._parent;
+    if (!parent) return;
+    const next = this._next;
+    for (const n of nodes) parent.insertBefore(toNode(this.ownerDocument, n), next);
+  }
+  append(...nodes) {
+    for (const n of nodes) this.appendChild(toNode(this.ownerDocument, n));
+  }
+  prepend(...nodes) {
+    const first = this._first;
+    for (const n of nodes) this.insertBefore(toNode(this.ownerDocument, n), first);
+  }
+  replaceChildren(...nodes) {
+    while (this._first) this.removeChild(this._first);
+    this.append(...nodes);
+  }
+  get children() {
+    const list = new ServerNodeList();
+    for (let n = this._first; n; n = n._next) if (n.nodeType === ELEMENT_NODE) list.push(n);
+    return list;
+  }
+  get childElementCount() {
+    let c = 0;
+    for (let n = this._first; n; n = n._next) if (n.nodeType === ELEMENT_NODE) c++;
+    return c;
+  }
+  get firstElementChild() {
+    for (let n = this._first; n; n = n._next) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  get lastElementChild() {
+    for (let n = this._last; n; n = n._prev) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  get nextElementSibling() {
+    for (let n = this._next; n; n = n._next) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  get previousElementSibling() {
+    for (let n = this._prev; n; n = n._prev) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  querySelector(selector) {
+    const sel = compileSelector(selector);
+    let found = null;
+    walkElements(this, (el) => {
+      if (matchesCompiled(el, sel, this)) {
+        found = el;
+        return true;
+      }
+      return false;
+    });
+    return found;
+  }
+  querySelectorAll(selector) {
+    const sel = compileSelector(selector);
+    const out = new ServerNodeList();
+    walkElements(this, (el) => {
+      if (matchesCompiled(el, sel, this)) out.push(el);
+      return false;
+    });
+    return out;
+  }
+  getElementsByTagName(name) {
+    return this.querySelectorAll(name === "*" ? "*" : name);
+  }
+  getElementsByClassName(names) {
+    const selector = names.trim().split(/\s+/).filter(Boolean).map((n) => `.${n}`).join("");
+    return selector ? this.querySelectorAll(selector) : new ServerNodeList();
+  }
+  cloneNode(deep = false) {
+    const copy = this._shallowClone();
+    if (deep) for (let n = this._first; n; n = n._next) copy.appendChild(n.cloneNode(true));
+    return copy;
+  }
+  /** @internal */
+  _shallowClone() {
+    return new _ServerNode(this.ownerDocument);
+  }
+  isEqualNode(other) {
+    return !!other && serializeForDebug(this) === serializeForDebug(other);
+  }
+  isSameNode(other) {
+    return other === this;
+  }
+  normalize() {
+    for (let n = this._first; n; ) {
+      const next = n._next;
+      if (n.nodeType === TEXT_NODE) {
+        const text2 = n;
+        if (text2.data === "") this.removeChild(n);
+        else
+          while (text2._next && text2._next.nodeType === TEXT_NODE) {
+            text2.data += text2._next.data;
+            this.removeChild(text2._next);
+          }
+      } else n.normalize();
+      n = n._parent === this ? n._next : next;
+    }
+  }
+  // ── EventTarget ──
+  addEventListener(type, fn, options) {
+    if (!fn) return;
+    const capture = typeof options === "boolean" ? options : !!options?.capture;
+    const once = typeof options === "object" && !!options?.once;
+    const map2 = this._listeners ?? (this._listeners = /* @__PURE__ */ new Map());
+    const list = map2.get(type) ?? [];
+    if (list.some((l) => l.fn === fn && l.capture === capture)) return;
+    list.push({ fn, capture, once });
+    map2.set(type, list);
+    const signal2 = typeof options === "object" ? options?.signal : void 0;
+    signal2?.addEventListener("abort", () => this.removeEventListener(type, fn, options), { once: true });
+  }
+  removeEventListener(type, fn, options) {
+    const list = this._listeners?.get(type);
+    if (!list || !fn) return;
+    const capture = typeof options === "boolean" ? options : !!options?.capture;
+    const i2 = list.findIndex((l) => l.fn === fn && l.capture === capture);
+    if (i2 !== -1) list.splice(i2, 1);
+  }
+  dispatchEvent(event) {
+    const ev = event;
+    let stopped = false;
+    let stoppedNow = false;
+    const ownStop = ev.stopPropagation.bind(ev);
+    const ownStopNow = ev.stopImmediatePropagation.bind(ev);
+    defineOwn(ev, "stopPropagation", () => {
+      stopped = true;
+      ownStop();
+    });
+    defineOwn(ev, "stopImmediatePropagation", () => {
+      stopped = true;
+      stoppedNow = true;
+      ownStopNow();
+    });
+    defineOwn(ev, "target", this);
+    const path2 = [];
+    for (let n = this; n; n = n._parent) path2.push(n);
+    const phase = (node, capture) => {
+      const list = node._listeners?.get(ev.type);
+      if (!list) return;
+      defineOwn(ev, "currentTarget", node);
+      for (const l of list.slice()) {
+        if (capture !== null && l.capture !== capture) continue;
+        if (l.once) node.removeEventListener(ev.type, l.fn, l.capture);
+        if (typeof l.fn === "function") l.fn.call(node, event);
+        else l.fn.handleEvent(event);
+        if (stoppedNow) return;
+      }
+    };
+    for (let i2 = path2.length - 1; i2 > 0 && !stopped; i2--) phase(path2[i2], true);
+    if (!stopped) phase(this, null);
+    if (ev.bubbles) for (let i2 = 1; i2 < path2.length && !stopped; i2++) phase(path2[i2], false);
+    defineOwn(ev, "currentTarget", null);
+    return !ev.defaultPrevented;
+  }
+};
+_ServerNode.ELEMENT_NODE = ELEMENT_NODE;
+_ServerNode.ATTRIBUTE_NODE = ATTRIBUTE_NODE;
+_ServerNode.TEXT_NODE = TEXT_NODE;
+_ServerNode.COMMENT_NODE = COMMENT_NODE;
+_ServerNode.DOCUMENT_NODE = DOCUMENT_NODE;
+_ServerNode.DOCUMENT_FRAGMENT_NODE = DOCUMENT_FRAGMENT_NODE;
+_ServerNode.DOCUMENT_POSITION_DISCONNECTED = 1;
+_ServerNode.DOCUMENT_POSITION_PRECEDING = 2;
+_ServerNode.DOCUMENT_POSITION_FOLLOWING = 4;
+_ServerNode.DOCUMENT_POSITION_CONTAINS = 8;
+_ServerNode.DOCUMENT_POSITION_CONTAINED_BY = 16;
+var ServerNode = _ServerNode;
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, configurable: true, writable: true });
 }
-function attributesOf(el) {
+function toNode(doc, n) {
+  return typeof n === "string" ? new ServerText(doc, n) : n;
+}
+function walkElements(root, visit) {
+  for (let n = root._first; n; n = n._next) {
+    if (n.nodeType === ELEMENT_NODE) {
+      if (visit(n)) return true;
+      if (walkElements(n, visit)) return true;
+    } else if (n.nodeType === DOCUMENT_FRAGMENT_NODE && walkElements(n, visit)) return true;
+  }
+  return false;
+}
+var ServerCharacterData = class extends ServerNode {
+  constructor(doc, data2) {
+    super(doc);
+    this._data = data2;
+  }
+  get data() {
+    return this._data;
+  }
+  set data(value) {
+    const old = this._data;
+    this._data = value == null ? "" : String(value);
+    if (observations.length > 0) {
+      queueRecord({
+        type: "characterData",
+        target: this,
+        addedNodes: [],
+        removedNodes: [],
+        previousSibling: null,
+        nextSibling: null,
+        attributeName: null,
+        attributeNamespace: null,
+        oldValue: old
+      });
+    }
+  }
+  get length() {
+    return this._data.length;
+  }
+  get nodeValue() {
+    return this._data;
+  }
+  set nodeValue(value) {
+    this.data = value ?? "";
+  }
+  get textContent() {
+    return this._data;
+  }
+  set textContent(value) {
+    this.data = value ?? "";
+  }
+  appendChild(_node) {
+    throw new TypeError("This node type does not support this method.");
+  }
+  insertBefore(_node, _ref) {
+    throw new TypeError("This node type does not support this method.");
+  }
+};
+var ServerText = class _ServerText extends ServerCharacterData {
+  get nodeType() {
+    return TEXT_NODE;
+  }
+  get nodeName() {
+    return "#text";
+  }
+  get wholeText() {
+    return this._data;
+  }
+  splitText(offset) {
+    const rest = new _ServerText(this.ownerDocument, this._data.slice(offset));
+    this.data = this._data.slice(0, offset);
+    this._parent?.insertBefore(rest, this._next);
+    return rest;
+  }
+  _shallowClone() {
+    return new _ServerText(this.ownerDocument, this._data);
+  }
+};
+var ServerComment = class _ServerComment extends ServerCharacterData {
+  get nodeType() {
+    return COMMENT_NODE;
+  }
+  get nodeName() {
+    return "#comment";
+  }
+  _shallowClone() {
+    return new _ServerComment(this.ownerDocument, this._data);
+  }
+};
+var ServerDocumentFragment = class _ServerDocumentFragment extends ServerNode {
+  get nodeType() {
+    return DOCUMENT_FRAGMENT_NODE;
+  }
+  get nodeName() {
+    return "#document-fragment";
+  }
+  getElementById(id) {
+    return this.querySelector(`#${cssEscapeIdent(id)}`);
+  }
+  _shallowClone() {
+    return new _ServerDocumentFragment(this.ownerDocument);
+  }
+};
+var ServerAttr = class {
+  constructor(ownerElement, namespaceURI, prefix, localName, value) {
+    this.ownerElement = ownerElement;
+    this.namespaceURI = namespaceURI;
+    this.prefix = prefix;
+    this.localName = localName;
+    this.nodeType = ATTRIBUTE_NODE;
+    this.specified = true;
+    this._value = value;
+  }
+  get name() {
+    return this.prefix ? `${this.prefix}:${this.localName}` : this.localName;
+  }
+  get nodeName() {
+    return this.name;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (this.ownerElement) this.ownerElement.setAttributeNS(this.namespaceURI, this.name, v);
+    else this._value = String(v);
+  }
+  get nodeValue() {
+    return this._value;
+  }
+  set nodeValue(v) {
+    this.value = v;
+  }
+  get textContent() {
+    return this._value;
+  }
+  set textContent(v) {
+    this.value = v;
+  }
+};
+var ServerNamedNodeMap = class extends Array {
+  static get [Symbol.species]() {
+    return Array;
+  }
+  item(index) {
+    return this[index] ?? null;
+  }
+  getNamedItem(name) {
+    return this.find((a2) => a2.name === name) ?? null;
+  }
+  getNamedItemNS(ns, localName) {
+    return this.find((a2) => a2.namespaceURI === (ns || null) && a2.localName === localName) ?? null;
+  }
+};
+function splitDeclarations(text2) {
+  const out = [];
+  let depth = 0;
+  let quote2 = "";
+  let start = 0;
+  for (let i2 = 0; i2 < text2.length; i2++) {
+    const c = text2[i2];
+    if (quote2) {
+      if (c === "\\") i2++;
+      else if (c === quote2) quote2 = "";
+    } else if (c === '"' || c === "'") quote2 = c;
+    else if (c === "(") depth++;
+    else if (c === ")") depth = Math.max(0, depth - 1);
+    else if (c === ";" && depth === 0) {
+      out.push(text2.slice(start, i2));
+      start = i2 + 1;
+    }
+  }
+  out.push(text2.slice(start));
+  return out;
+}
+var CAMEL_EXCEPTIONS = { cssFloat: "float" };
+function toKebab(prop) {
+  if (prop.startsWith("--")) return prop;
+  if (Object.hasOwn(CAMEL_EXCEPTIONS, prop)) return CAMEL_EXCEPTIONS[prop];
+  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`).replace(/^(webkit|moz|ms)-/, "-$1-");
+}
+var ServerStyle = class {
+  constructor(el) {
+    this.el = el;
+    /** @internal */
+    this._decls = /* @__PURE__ */ new Map();
+    /** @internal */
+    this._parsedFrom = null;
+  }
+  /** @internal */
+  _sync() {
+    const attr = this.el.getAttribute("style");
+    if (attr === this._parsedFrom) return;
+    this._decls = /* @__PURE__ */ new Map();
+    this._parsedFrom = attr;
+    if (!attr) return;
+    for (const decl of splitDeclarations(attr)) {
+      const colon = decl.indexOf(":");
+      if (colon === -1) continue;
+      const name = decl.slice(0, colon).trim();
+      let value = decl.slice(colon + 1).trim();
+      if (!name || !value) continue;
+      let priority = "";
+      const bang = value.lastIndexOf("!");
+      if (bang !== -1 && /^!\s*important$/i.test(value.slice(bang))) {
+        priority = "important";
+        value = value.slice(0, bang).trim();
+      }
+      this._decls.set(name.startsWith("--") ? name : name.toLowerCase(), { value, priority });
+    }
+  }
+  /** @internal */
+  _commit() {
+    const text2 = this.cssText;
+    this._parsedFrom = text2 === "" ? null : text2;
+    if (text2 === "") this.el.removeAttribute("style");
+    else this.el.setAttribute("style", text2);
+    this._parsedFrom = this.el.getAttribute("style");
+  }
+  get cssText() {
+    this._sync();
+    const parts = [];
+    for (const [name, d] of this._decls) parts.push(`${name}: ${d.value}${d.priority ? " !important" : ""};`);
+    return parts.join(" ");
+  }
+  set cssText(text2) {
+    this.el.setAttribute("style", String(text2 ?? ""));
+    this._sync();
+    if (this._decls.size === 0) this.el.removeAttribute("style");
+    else this._commit();
+  }
+  get length() {
+    this._sync();
+    return this._decls.size;
+  }
+  item(index) {
+    this._sync();
+    return Array.from(this._decls.keys())[index] ?? "";
+  }
+  getPropertyValue(name) {
+    this._sync();
+    return this._decls.get(name.startsWith("--") ? name : name.toLowerCase())?.value ?? "";
+  }
+  getPropertyPriority(name) {
+    this._sync();
+    return this._decls.get(name.startsWith("--") ? name : name.toLowerCase())?.priority ?? "";
+  }
+  setProperty(name, value, priority = "") {
+    this._sync();
+    const key = name.startsWith("--") ? name : name.toLowerCase();
+    const v = value == null ? "" : String(value).trim();
+    if (v === "") {
+      this.removeProperty(key);
+      return;
+    }
+    this._decls.set(key, { value: v, priority: priority === "important" ? "important" : "" });
+    this._commit();
+  }
+  removeProperty(name) {
+    this._sync();
+    const key = name.startsWith("--") ? name : name.toLowerCase();
+    const old = this._decls.get(key)?.value ?? "";
+    if (this._decls.delete(key)) this._commit();
+    return old;
+  }
+  *[Symbol.iterator]() {
+    this._sync();
+    yield* this._decls.keys();
+  }
+};
+function styleProxy(style2) {
+  return new Proxy(style2, {
+    get(target, key, receiver) {
+      if (typeof key === "string" && !(key in target)) {
+        if (/^\d+$/.test(key)) return target.item(Number(key));
+        return target.getPropertyValue(toKebab(key));
+      }
+      return Reflect.get(target, key, receiver);
+    },
+    set(target, key, value, receiver) {
+      if (typeof key === "string" && !(key in target)) {
+        target.setProperty(toKebab(key), value == null ? "" : String(value));
+        return true;
+      }
+      return Reflect.set(target, key, value, receiver);
+    }
+  });
+}
+var ServerTokenList = class {
+  constructor(el, attr) {
+    this.el = el;
+    this.attr = attr;
+  }
+  tokens() {
+    return (this.el.getAttribute(this.attr) ?? "").split(/\s+/).filter(Boolean);
+  }
+  write(tokens) {
+    this.el.setAttribute(this.attr, Array.from(new Set(tokens)).join(" "));
+  }
+  get length() {
+    return new Set(this.tokens()).size;
+  }
+  get value() {
+    return this.el.getAttribute(this.attr) ?? "";
+  }
+  set value(v) {
+    this.el.setAttribute(this.attr, v);
+  }
+  item(i2) {
+    return Array.from(new Set(this.tokens()))[i2] ?? null;
+  }
+  contains(token) {
+    return this.tokens().includes(token);
+  }
+  add(...tokens) {
+    this.write([...this.tokens(), ...tokens]);
+  }
+  remove(...tokens) {
+    this.write(this.tokens().filter((t) => !tokens.includes(t)));
+  }
+  toggle(token, force) {
+    const has = this.contains(token);
+    const want = force === void 0 ? !has : force;
+    if (want && !has) this.add(token);
+    else if (!want && has) this.remove(token);
+    return want;
+  }
+  replace(oldToken, newToken) {
+    const tokens = this.tokens();
+    const i2 = tokens.indexOf(oldToken);
+    if (i2 === -1) return false;
+    tokens[i2] = newToken;
+    this.write(tokens);
+    return true;
+  }
+  forEach(fn) {
+    Array.from(new Set(this.tokens())).forEach(fn);
+  }
+  [Symbol.iterator]() {
+    return new Set(this.tokens()).values();
+  }
+  toString() {
+    return this.value;
+  }
+};
+function datasetKeyToAttr(key) {
+  return `data-${key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+}
+var ServerElement = class _ServerElement extends ServerNode {
+  constructor(doc, localName, namespaceURI, prefix = null) {
+    super(doc);
+    this.localName = localName;
+    this.namespaceURI = namespaceURI;
+    this.prefix = prefix;
+    /** @internal */
+    this._attrs = new ServerNamedNodeMap();
+    /** @internal */
+    this._style = null;
+    /** @internal */
+    this._classList = null;
+    this.scrollTop = 0;
+    this.scrollLeft = 0;
+  }
+  get nodeType() {
+    return ELEMENT_NODE;
+  }
+  get isHtml() {
+    return this.namespaceURI === HTML_NS3;
+  }
+  get tagName() {
+    const q2 = this.prefix ? `${this.prefix}:${this.localName}` : this.localName;
+    return this.isHtml ? q2.toUpperCase() : q2;
+  }
+  get nodeName() {
+    return this.tagName;
+  }
+  get attributes() {
+    return this._attrs;
+  }
+  findAttr(name) {
+    const n = this.isHtml ? name.toLowerCase() : name;
+    return this._attrs.find((a2) => a2.name === n);
+  }
+  getAttribute(name) {
+    return this.findAttr(String(name))?.value ?? null;
+  }
+  getAttributeNames() {
+    return this._attrs.map((a2) => a2.name);
+  }
+  hasAttribute(name) {
+    return this.findAttr(String(name)) !== void 0;
+  }
+  hasAttributes() {
+    return this._attrs.length > 0;
+  }
+  setAttribute(name, value) {
+    name = String(name);
+    if (!NAME_RE.test(name)) invalidCharacter(name);
+    const v = String(value);
+    const existing = this.findAttr(name);
+    const old = existing ? existing._value : null;
+    if (existing) existing._value = v;
+    else this._attrs.push(new ServerAttr(this, null, null, this.isHtml ? name.toLowerCase() : name, v));
+    this._recordAttr(this.isHtml ? name.toLowerCase() : name, null, old);
+  }
+  removeAttribute(name) {
+    const attr = this.findAttr(String(name));
+    if (!attr) return;
+    this._attrs.splice(this._attrs.indexOf(attr), 1);
+    this._recordAttr(attr.name, attr.namespaceURI, attr._value);
+  }
+  toggleAttribute(name, force) {
+    const has = this.hasAttribute(name);
+    const want = force === void 0 ? !has : force;
+    if (want && !has) this.setAttribute(name, "");
+    else if (!want && has) this.removeAttribute(name);
+    return want;
+  }
+  getAttributeNS(ns, localName) {
+    return this._attrs.getNamedItemNS(ns, localName)?.value ?? null;
+  }
+  hasAttributeNS(ns, localName) {
+    return this._attrs.getNamedItemNS(ns, localName) !== null;
+  }
+  setAttributeNS(ns, qualifiedName, value) {
+    if (!NAME_RE.test(qualifiedName)) invalidCharacter(qualifiedName);
+    const colon = qualifiedName.indexOf(":");
+    const prefix = colon === -1 ? null : qualifiedName.slice(0, colon);
+    const localName = colon === -1 ? qualifiedName : qualifiedName.slice(colon + 1);
+    const namespace = ns || null;
+    if (namespace === null) {
+      this.setAttribute(qualifiedName, value);
+      return;
+    }
+    const existing = this._attrs.getNamedItemNS(namespace, localName);
+    const old = existing ? existing._value : null;
+    if (existing) existing._value = String(value);
+    else this._attrs.push(new ServerAttr(this, namespace, prefix, localName, String(value)));
+    this._recordAttr(localName, namespace, old);
+  }
+  removeAttributeNS(ns, localName) {
+    const attr = this._attrs.getNamedItemNS(ns, localName);
+    if (!attr) return;
+    this._attrs.splice(this._attrs.indexOf(attr), 1);
+    this._recordAttr(localName, attr.namespaceURI, attr._value);
+  }
+  getAttributeNode(name) {
+    return this.findAttr(name) ?? null;
+  }
+  /** @internal */
+  _recordAttr(name, ns, oldValue) {
+    if (observations.length === 0) return;
+    queueRecord({
+      type: "attributes",
+      target: this,
+      addedNodes: [],
+      removedNodes: [],
+      previousSibling: null,
+      nextSibling: null,
+      attributeName: name,
+      attributeNamespace: ns,
+      oldValue
+    });
+  }
+  get id() {
+    return this.getAttribute("id") ?? "";
+  }
+  set id(v) {
+    this.setAttribute("id", v);
+  }
+  get className() {
+    return this.getAttribute("class") ?? "";
+  }
+  set className(v) {
+    this.setAttribute("class", v);
+  }
+  get classList() {
+    this._classList ?? (this._classList = new ServerTokenList(this, "class"));
+    return this._classList;
+  }
+  get style() {
+    this._style ?? (this._style = styleProxy(new ServerStyle(this)));
+    return this._style;
+  }
+  set style(v) {
+    this.style.cssText = v;
+  }
+  get dataset() {
+    return new Proxy(
+      {},
+      {
+        get: (_t, key) => typeof key === "string" ? this.getAttribute(datasetKeyToAttr(key)) ?? void 0 : void 0,
+        set: (_t, key, value) => {
+          if (typeof key === "string") this.setAttribute(datasetKeyToAttr(key), String(value));
+          return true;
+        },
+        deleteProperty: (_t, key) => {
+          if (typeof key === "string") this.removeAttribute(datasetKeyToAttr(key));
+          return true;
+        },
+        has: (_t, key) => typeof key === "string" && this.hasAttribute(datasetKeyToAttr(key)),
+        ownKeys: () => this._attrs.filter((a2) => a2.name.startsWith("data-")).map((a2) => a2.name.slice(5).replace(/-([a-z])/g, (_m, c) => c.toUpperCase())),
+        getOwnPropertyDescriptor: (_t, key) => typeof key === "string" && this.hasAttribute(datasetKeyToAttr(key)) ? { enumerable: true, configurable: true, value: this.getAttribute(datasetKeyToAttr(key)) } : void 0
+      }
+    );
+  }
+  get innerHTML() {
+    let out = "";
+    for (let n = this._first; n; n = n._next) out += serializeForDebug(n);
+    return out;
+  }
+  set innerHTML(_value) {
+    unavailable("Element.innerHTML assignment (the server DOM has no HTML parser)");
+  }
+  get outerHTML() {
+    return serializeForDebug(this);
+  }
+  insertAdjacentHTML() {
+    unavailable("Element.insertAdjacentHTML()");
+  }
+  matches(selector) {
+    return matchesCompiled(this, compileSelector(selector), null);
+  }
+  closest(selector) {
+    const sel = compileSelector(selector);
+    for (let n = this; n; n = n._parent) {
+      if (n instanceof _ServerElement && matchesCompiled(n, sel, null)) return n;
+    }
+    return null;
+  }
+  // ── Layout and focus: no-ops on a server ──
+  focus() {
+  }
+  blur() {
+  }
+  click() {
+    const Ctor = globalThis.Event;
+    if (Ctor) this.dispatchEvent(new Ctor("click", { bubbles: true, cancelable: true }));
+  }
+  scrollIntoView() {
+  }
+  scrollTo() {
+  }
+  scrollBy() {
+  }
+  getBoundingClientRect() {
+    return { x: 0, y: 0, width: 0, height: 0, top: 0, right: 0, bottom: 0, left: 0, toJSON: () => ({}) };
+  }
+  getClientRects() {
+    return [];
+  }
+  get offsetWidth() {
+    return 0;
+  }
+  get offsetHeight() {
+    return 0;
+  }
+  get offsetTop() {
+    return 0;
+  }
+  get offsetLeft() {
+    return 0;
+  }
+  get offsetParent() {
+    return null;
+  }
+  get clientWidth() {
+    return 0;
+  }
+  get clientHeight() {
+    return 0;
+  }
+  get scrollWidth() {
+    return 0;
+  }
+  get scrollHeight() {
+    return 0;
+  }
+  // ── Browser-only APIs: a clear error instead of "is not a function" ──
+  animate() {
+    return unavailable("Element.animate()");
+  }
+  getAnimations() {
+    return unavailable("Element.getAnimations()");
+  }
+  attachShadow() {
+    return unavailable("Element.attachShadow()");
+  }
+  requestFullscreen() {
+    return unavailable("Element.requestFullscreen()");
+  }
+  requestPointerLock() {
+    return unavailable("Element.requestPointerLock()");
+  }
+  setPointerCapture() {
+    return unavailable("Element.setPointerCapture()");
+  }
+  _shallowClone() {
+    const copy = this.ownerDocument ? this.ownerDocument.createElementNS(
+      this.namespaceURI,
+      this.prefix ? `${this.prefix}:${this.localName}` : this.localName
+    ) : new _ServerElement(null, this.localName, this.namespaceURI, this.prefix);
+    for (const a2 of this._attrs)
+      copy._attrs.push(new ServerAttr(copy, a2.namespaceURI, a2.prefix, a2.localName, a2._value));
+    return copy;
+  }
+};
+var ServerHTMLElement = class extends ServerElement {
+  get hidden() {
+    return this.hasAttribute("hidden");
+  }
+  set hidden(v) {
+    this.toggleAttribute("hidden", !!v);
+  }
+  get title() {
+    return this.getAttribute("title") ?? "";
+  }
+  set title(v) {
+    this.setAttribute("title", v);
+  }
+  get lang() {
+    return this.getAttribute("lang") ?? "";
+  }
+  set lang(v) {
+    this.setAttribute("lang", v);
+  }
+  get dir() {
+    return this.getAttribute("dir") ?? "";
+  }
+  set dir(v) {
+    this.setAttribute("dir", v);
+  }
+  get tabIndex() {
+    const v = Number.parseInt(this.getAttribute("tabindex") ?? "", 10);
+    return Number.isNaN(v) ? -1 : v;
+  }
+  set tabIndex(v) {
+    this.setAttribute("tabindex", String(v));
+  }
+  get innerText() {
+    return this.textContent ?? "";
+  }
+  set innerText(v) {
+    this.textContent = v;
+  }
+};
+function reflectDisabled(proto) {
+  Object.defineProperty(proto, "disabled", {
+    get() {
+      return this.hasAttribute("disabled");
+    },
+    set(v) {
+      this.toggleAttribute("disabled", !!v);
+    },
+    configurable: true
+  });
+}
+var ServerInputElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._value = null;
+    /** @internal */
+    this._checked = null;
+  }
+  get value() {
+    return this._value ?? this.getAttribute("value") ?? "";
+  }
+  set value(v) {
+    this._value = v == null ? "" : String(v);
+  }
+  get defaultValue() {
+    return this.getAttribute("value") ?? "";
+  }
+  set defaultValue(v) {
+    this.setAttribute("value", v);
+  }
+  get checked() {
+    return this._checked ?? this.hasAttribute("checked");
+  }
+  set checked(v) {
+    this._checked = !!v;
+  }
+  get defaultChecked() {
+    return this.hasAttribute("checked");
+  }
+  /** Reflects to the `checked` attribute; `checked` follows it until written (dirty checkedness). */
+  set defaultChecked(v) {
+    this.toggleAttribute("checked", !!v);
+  }
+  get type() {
+    return (this.getAttribute("type") ?? "text").toLowerCase();
+  }
+  set type(v) {
+    this.setAttribute("type", v);
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(v) {
+    this.setAttribute("name", v);
+  }
+  select() {
+  }
+  setSelectionRange() {
+  }
+  checkValidity() {
+    return true;
+  }
+  reportValidity() {
+    return true;
+  }
+};
+reflectDisabled(ServerInputElement.prototype);
+var ServerTextAreaElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._value = null;
+  }
+  get value() {
+    return this._value ?? this.textContent ?? "";
+  }
+  set value(v) {
+    this._value = v == null ? "" : String(v);
+  }
+  get defaultValue() {
+    return this.textContent ?? "";
+  }
+  set defaultValue(v) {
+    this.textContent = v;
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(v) {
+    this.setAttribute("name", v);
+  }
+  select() {
+  }
+  setSelectionRange() {
+  }
+};
+reflectDisabled(ServerTextAreaElement.prototype);
+var ServerOptionElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** Selectedness; `null` while it follows the `selected` attribute. @internal */
+    this._selected = null;
+    /** Set by a `selected` write: the attribute no longer decides selectedness. @internal */
+    this._dirty = false;
+  }
+  get value() {
+    return this.getAttribute("value") ?? this.text;
+  }
+  set value(v) {
+    this.setAttribute("value", v);
+  }
+  get text() {
+    return (this.textContent ?? "").replace(/\s+/g, " ").trim();
+  }
+  set text(v) {
+    this.textContent = v;
+  }
+  get label() {
+    return this.getAttribute("label") ?? this.text;
+  }
+  set label(v) {
+    this.setAttribute("label", v);
+  }
+  get selected() {
+    return this._selected ?? this.hasAttribute("selected");
+  }
+  set selected(v) {
+    this._selected = !!v;
+    this._dirty = true;
+    const select3 = singleSelectOf(this);
+    if (select3 && v) {
+      for (const o of select3.options) if (o !== this) o._selected = false;
+    }
+  }
+  get defaultSelected() {
+    return this.hasAttribute("selected");
+  }
+  /** Reflects to the `selected` attribute; `selected` follows it unless written. */
+  set defaultSelected(v) {
+    this.toggleAttribute("selected", !!v);
+    if (this._dirty) return;
+    this._selected = null;
+    const select3 = singleSelectOf(this);
+    if (!select3) return;
+    let last = null;
+    for (const o of select3.options) if (o.selected) last = o;
+    for (const o of select3.options) if (o !== last && o.selected) o._selected = false;
+  }
+};
+function singleSelectOf(option2) {
+  let parent = option2.parentNode;
+  if (parent instanceof ServerElement && parent.localName === "optgroup") parent = parent.parentNode;
+  return parent instanceof ServerSelectElement && !parent.hasAttribute("multiple") ? parent : null;
+}
+reflectDisabled(ServerOptionElement.prototype);
+var ServerSelectElement = class extends ServerHTMLElement {
+  get multiple() {
+    return this.hasAttribute("multiple");
+  }
+  set multiple(v) {
+    this.toggleAttribute("multiple", !!v);
+  }
+  get options() {
+    return this.querySelectorAll("option");
+  }
+  get selectedIndex() {
+    const opts = this.options;
+    for (let i2 = 0; i2 < opts.length; i2++) if (opts[i2].selected) return i2;
+    return opts.length > 0 && !this.hasAttribute("multiple") ? 0 : -1;
+  }
+  set selectedIndex(i2) {
+    this.options.forEach((o, j) => {
+      o.selected = j === i2;
+    });
+  }
+  get value() {
+    const i2 = this.selectedIndex;
+    return i2 === -1 ? "" : this.options[i2].value;
+  }
+  set value(v) {
+    this.options.forEach((o) => {
+      o.selected = o.value === String(v);
+    });
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(v) {
+    this.setAttribute("name", v);
+  }
+};
+reflectDisabled(ServerSelectElement.prototype);
+var ServerButtonElement = class extends ServerHTMLElement {
+  get type() {
+    return (this.getAttribute("type") ?? "submit").toLowerCase();
+  }
+  set type(v) {
+    this.setAttribute("type", v);
+  }
+  get value() {
+    return this.getAttribute("value") ?? "";
+  }
+  set value(v) {
+    this.setAttribute("value", v);
+  }
+};
+reflectDisabled(ServerButtonElement.prototype);
+var ServerDisableableElement = class extends ServerHTMLElement {
+};
+reflectDisabled(ServerDisableableElement.prototype);
+var ServerCanvasElement = class extends ServerHTMLElement {
+  get width() {
+    return Number(this.getAttribute("width") ?? 300);
+  }
+  set width(v) {
+    this.setAttribute("width", String(v));
+  }
+  get height() {
+    return Number(this.getAttribute("height") ?? 150);
+  }
+  set height(v) {
+    this.setAttribute("height", String(v));
+  }
+  /** No drawing context on a server: warns and returns `null`, as a browser does for an unsupported context. */
+  getContext() {
+    reportBrowserApi("HTMLCanvasElement.getContext()");
+    return null;
+  }
+  toDataURL() {
+    return unavailable("HTMLCanvasElement.toDataURL()");
+  }
+  toBlob() {
+    return unavailable("HTMLCanvasElement.toBlob()");
+  }
+};
+var ServerDialogElement = class extends ServerHTMLElement {
+  get open() {
+    return this.hasAttribute("open");
+  }
+  set open(v) {
+    this.toggleAttribute("open", !!v);
+  }
+  showModal() {
+    return unavailable("HTMLDialogElement.showModal()");
+  }
+  show() {
+    this.open = true;
+  }
+  close() {
+    this.open = false;
+  }
+};
+var ServerMediaElement = class extends ServerHTMLElement {
+  play() {
+    return unavailable("HTMLMediaElement.play()");
+  }
+  pause() {
+  }
+  load() {
+  }
+};
+var ServerTemplateElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._content = null;
+  }
+  get content() {
+    this._content ?? (this._content = new ServerDocumentFragment(this.ownerDocument));
+    return this._content;
+  }
+};
+var ServerSVGElement = class extends ServerElement {
+};
+var ServerMathMLElement = class extends ServerElement {
+};
+var HTML_CLASSES = {
+  input: ServerInputElement,
+  textarea: ServerTextAreaElement,
+  select: ServerSelectElement,
+  option: ServerOptionElement,
+  button: ServerButtonElement,
+  fieldset: ServerDisableableElement,
+  optgroup: ServerDisableableElement,
+  canvas: ServerCanvasElement,
+  dialog: ServerDialogElement,
+  video: ServerMediaElement,
+  audio: ServerMediaElement,
+  template: ServerTemplateElement
+};
+var NODE_FILTER = {
+  FILTER_ACCEPT: 1,
+  FILTER_REJECT: 2,
+  FILTER_SKIP: 3,
+  SHOW_ALL: 4294967295,
+  SHOW_ELEMENT: 1,
+  SHOW_ATTRIBUTE: 2,
+  SHOW_TEXT: 4,
+  SHOW_COMMENT: 128,
+  SHOW_DOCUMENT: 256,
+  SHOW_DOCUMENT_FRAGMENT: 1024
+};
+var ServerTreeWalker = class {
+  constructor(root, whatToShow, filter) {
+    this.root = root;
+    this.whatToShow = whatToShow;
+    this.filter = filter;
+    this.currentNode = root;
+  }
+  accept(node) {
+    if (!(1 << node.nodeType - 1 & this.whatToShow)) return NODE_FILTER.FILTER_SKIP;
+    if (!this.filter) return NODE_FILTER.FILTER_ACCEPT;
+    return typeof this.filter === "function" ? this.filter(node) : this.filter.acceptNode(node);
+  }
+  nextNode() {
+    let node = this.currentNode;
+    for (; ; ) {
+      let next = null;
+      if (node._first) next = node._first;
+      else {
+        let n = node;
+        while (n && n !== this.root && !n._next) n = n._parent;
+        next = n && n !== this.root ? n._next : null;
+      }
+      if (!next) return null;
+      node = next;
+      if (this.accept(node) === NODE_FILTER.FILTER_ACCEPT) {
+        this.currentNode = node;
+        return node;
+      }
+    }
+  }
+  firstChild() {
+    for (let n = this.currentNode._first; n; n = n._next) {
+      if (this.accept(n) === NODE_FILTER.FILTER_ACCEPT) {
+        this.currentNode = n;
+        return n;
+      }
+    }
+    return null;
+  }
+  nextSibling() {
+    for (let n = this.currentNode._next; n; n = n._next) {
+      if (this.accept(n) === NODE_FILTER.FILTER_ACCEPT) {
+        this.currentNode = n;
+        return n;
+      }
+    }
+    return null;
+  }
+  parentNode() {
+    const p2 = this.currentNode === this.root ? null : this.currentNode._parent;
+    if (p2) this.currentNode = p2;
+    return p2;
+  }
+};
+var ServerDocument = class extends ServerNode {
+  constructor() {
+    super(null);
+    this.defaultView = null;
+    this.readyState = "complete";
+    this.contentType = "text/html";
+    this.characterSet = "UTF-8";
+    this.compatMode = "CSS1Compat";
+    this.visibilityState = "visible";
+    this.hidden = false;
+    this.cookie = "";
+    this.ownerDocument = null;
+    this.documentElement = this.createElement("html");
+    this.head = this.createElement("head");
+    this.body = this.createElement("body");
+    this.documentElement.appendChild(this.head);
+    this.documentElement.appendChild(this.body);
+    this.appendChild(this.documentElement);
+  }
+  get nodeType() {
+    return DOCUMENT_NODE;
+  }
+  get nodeName() {
+    return "#document";
+  }
+  get activeElement() {
+    return this.body;
+  }
+  get title() {
+    return this.head.querySelector("title")?.textContent ?? "";
+  }
+  set title(v) {
+    let el = this.head.querySelector("title");
+    if (!el) {
+      el = this.createElement("title");
+      this.head.appendChild(el);
+    }
+    el.textContent = v;
+  }
+  /** Font loading does not exist on a server: recorded as a browser-only read, answers `undefined`. */
+  get fonts() {
+    reportBrowserApi("document.fonts");
+    return void 0;
+  }
+  createElement(name) {
+    name = String(name);
+    if (!NAME_RE.test(name)) invalidCharacter(name);
+    const local = name.toLowerCase();
+    const Ctor = Object.hasOwn(HTML_CLASSES, local) ? HTML_CLASSES[local] : ServerHTMLElement;
+    return new Ctor(this, local, HTML_NS3);
+  }
+  createElementNS(ns, qualifiedName) {
+    if (!NAME_RE.test(qualifiedName)) invalidCharacter(qualifiedName);
+    const namespace = ns || null;
+    if (namespace === HTML_NS3) return this.createElement(qualifiedName);
+    const colon = qualifiedName.indexOf(":");
+    const prefix = colon === -1 ? null : qualifiedName.slice(0, colon);
+    const local = colon === -1 ? qualifiedName : qualifiedName.slice(colon + 1);
+    if (namespace === SVG_NS3) return new ServerSVGElement(this, local, namespace, prefix);
+    if (namespace === MATHML_NS) return new ServerMathMLElement(this, local, namespace, prefix);
+    return new ServerElement(this, local, namespace, prefix);
+  }
+  createTextNode(data2) {
+    return new ServerText(this, String(data2));
+  }
+  createComment(data2) {
+    return new ServerComment(this, String(data2));
+  }
+  createDocumentFragment() {
+    return new ServerDocumentFragment(this);
+  }
+  createTreeWalker(root, whatToShow = NODE_FILTER.SHOW_ALL, filter = null) {
+    return new ServerTreeWalker(root, whatToShow, filter);
+  }
+  createEvent() {
+    return unavailable("document.createEvent() (construct `new Event(type)` instead)");
+  }
+  getElementById(id) {
+    return this.querySelector(`#${cssEscapeIdent(id)}`);
+  }
+  hasFocus() {
+    return false;
+  }
+  getSelection() {
+    return null;
+  }
+  elementFromPoint() {
+    return null;
+  }
+  execCommand() {
+    return unavailable("document.execCommand()");
+  }
+};
+var selectorCache = /* @__PURE__ */ new Map();
+function cssEscapeIdent(value) {
+  return value.replace(/([^A-Za-z0-9_-])/g, "\\$1");
+}
+function unescapeIdent(value) {
+  return value.replace(/\\(.)/g, "$1");
+}
+function compileSelector(selector) {
+  const cached = selectorCache.get(selector);
+  if (cached) return cached;
+  const groups = [];
+  for (const part of splitTopLevel(selector, ",")) {
+    const text2 = part.trim();
+    if (!text2) throw syntaxError(selector);
+    const tokens = text2.match(/(?:\\.|\[[^\]]*\]|[^\s>])+|>/g) ?? [];
+    const compounds = [];
+    const combinators = [];
+    let pending = " ";
+    let scoped = false;
+    for (const token of tokens) {
+      if (token === ">") {
+        pending = ">";
+        continue;
+      }
+      if (token === ":scope") {
+        scoped = true;
+        pending = " ";
+        continue;
+      }
+      if (compounds.length > 0) combinators.unshift(pending);
+      compounds.unshift(parseCompound(token, selector));
+      pending = " ";
+    }
+    if (compounds.length === 0) throw syntaxError(selector);
+    groups.push({ compounds, combinators, scoped });
+  }
+  if (selectorCache.size > 500) selectorCache.clear();
+  selectorCache.set(selector, groups);
+  return groups;
+}
+function splitTopLevel(text2, sep) {
+  const out = [];
+  let depth = 0;
+  let quote2 = "";
+  let start = 0;
+  for (let i2 = 0; i2 < text2.length; i2++) {
+    const c = text2[i2];
+    if (quote2) {
+      if (c === "\\") i2++;
+      else if (c === quote2) quote2 = "";
+    } else if (c === '"' || c === "'") quote2 = c;
+    else if (c === "\\") i2++;
+    else if (c === "[" || c === "(") depth++;
+    else if (c === "]" || c === ")") depth--;
+    else if (c === sep && depth === 0) {
+      out.push(text2.slice(start, i2));
+      start = i2 + 1;
+    }
+  }
+  out.push(text2.slice(start));
+  return out;
+}
+function syntaxError(selector) {
+  const Ctor = globalThis.DOMException;
+  const message = `'${selector}' is not a valid selector (the SibuJS server DOM supports tag, #id, .class, [attr], [attr=value], descendant and > combinators)`;
+  return Ctor ? new Ctor(message, "SyntaxError") : new Error(message);
+}
+function parseCompound(token, selector) {
+  const c = { tag: null, id: null, classes: [], attrs: [] };
+  const re = /(\\.|[^#.[\\])+|#((?:\\.|[^#.[\\])+)|\.((?:\\.|[^#.[\\])+)|\[([^\]]*)\]/gy;
+  let consumed = 0;
+  for (let m = re.exec(token); m; m = re.exec(token)) {
+    consumed = re.lastIndex;
+    if (m[2] !== void 0) c.id = unescapeIdent(m[2]);
+    else if (m[3] !== void 0) c.classes.push(unescapeIdent(m[3]));
+    else if (m[4] !== void 0) {
+      const am = /^\s*([^\s~|^$*=]+)\s*(?:([~|^$*]?=)\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s"']+)))?\s*$/.exec(
+        m[4]
+      );
+      if (!am) throw syntaxError(selector);
+      c.attrs.push({
+        name: am[1].toLowerCase(),
+        op: am[2] ?? null,
+        value: unescapeIdent(am[3] ?? am[4] ?? am[5] ?? "")
+      });
+    } else {
+      const t = m[0];
+      if (t.startsWith(":")) throw syntaxError(selector);
+      c.tag = t === "*" ? null : unescapeIdent(t);
+    }
+    if (re.lastIndex === token.length) break;
+  }
+  if (consumed !== token.length) throw syntaxError(selector);
+  return c;
+}
+function matchesCompound(el, c) {
+  if (c.tag !== null) {
+    const isHtml = el.namespaceURI === HTML_NS3;
+    if (isHtml ? el.localName !== c.tag.toLowerCase() : el.localName !== c.tag) return false;
+  }
+  if (c.id !== null && el.getAttribute("id") !== c.id) return false;
+  if (c.classes.length > 0) {
+    const tokens = (el.getAttribute("class") ?? "").split(/\s+/);
+    for (const cls of c.classes) if (!tokens.includes(cls)) return false;
+  }
+  for (const a2 of c.attrs) {
+    const v = el.getAttribute(a2.name);
+    if (v === null) return false;
+    if (a2.op === null) continue;
+    if (a2.op === "=" && v !== a2.value) return false;
+    if (a2.op === "~=" && !v.split(/\s+/).includes(a2.value)) return false;
+    if (a2.op === "|=" && v !== a2.value && !v.startsWith(`${a2.value}-`)) return false;
+    if (a2.op === "^=" && (!a2.value || !v.startsWith(a2.value))) return false;
+    if (a2.op === "$=" && (!a2.value || !v.endsWith(a2.value))) return false;
+    if (a2.op === "*=" && (!a2.value || !v.includes(a2.value))) return false;
+  }
+  return true;
+}
+function matchesCompiled(el, groups, scope) {
+  for (const g2 of groups) if (matchesComplex(el, g2, 0, scope)) return true;
+  return false;
+}
+function matchesComplex(el, g2, i2, scope) {
+  if (!matchesCompound(el, g2.compounds[i2])) return false;
+  if (i2 === g2.compounds.length - 1) {
+    if (!g2.scoped || !scope) return true;
+    return el._parent === scope || (g2.combinators.length === 0 ? false : scope.contains(el));
+  }
+  const comb = g2.combinators[i2];
+  for (let p2 = el._parent; p2 && p2 instanceof ServerElement; p2 = p2._parent) {
+    if (scope && p2 === scope && g2.scoped) return false;
+    if (matchesComplex(p2, g2, i2 + 1, scope)) return true;
+    if (comb === ">") return false;
+  }
+  return false;
+}
+var VOID = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+function escapeText(s2) {
+  return s2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeForDebug(node) {
+  if (node.nodeType === TEXT_NODE) return escapeText(node.data);
+  if (node.nodeType === COMMENT_NODE) return `<!--${node.data}-->`;
+  if (node.nodeType !== ELEMENT_NODE) {
+    let out2 = "";
+    for (let n = node._first; n; n = n._next) out2 += serializeForDebug(n);
+    return out2;
+  }
+  const el = node;
+  const tag = el.prefix ? `${el.prefix}:${el.localName}` : el.localName;
+  let out = `<${tag}`;
+  for (const a2 of el._attrs) out += ` ${a2.name}="${escapeText(a2._value).replace(/"/g, "&quot;")}"`;
+  out += ">";
+  if (el.namespaceURI === HTML_NS3 && VOID.has(el.localName)) return out;
+  for (let n = el._first; n; n = n._next) out += serializeForDebug(n);
+  return `${out}</${tag}>`;
+}
+var INSTALLED = /* @__PURE__ */ Symbol.for("sibujs.serverDom.v1");
+function isServerDom() {
+  return typeof document !== "undefined" && document instanceof ServerDocument;
+}
+function installServerDom(options = {}) {
+  const g2 = globalThis;
+  if (typeof g2.document !== "undefined" && !options.force) return () => {
+  };
+  const globals = {
+    document: new ServerDocument(),
+    Node: ServerNode,
+    Element: ServerElement,
+    HTMLElement: ServerHTMLElement,
+    SVGElement: ServerSVGElement,
+    MathMLElement: ServerMathMLElement,
+    HTMLInputElement: ServerInputElement,
+    HTMLTextAreaElement: ServerTextAreaElement,
+    HTMLSelectElement: ServerSelectElement,
+    HTMLOptionElement: ServerOptionElement,
+    HTMLButtonElement: ServerButtonElement,
+    HTMLCanvasElement: ServerCanvasElement,
+    HTMLDialogElement: ServerDialogElement,
+    HTMLTemplateElement: ServerTemplateElement,
+    Text: ServerText,
+    Comment: ServerComment,
+    CharacterData: ServerCharacterData,
+    DocumentFragment: ServerDocumentFragment,
+    Document: ServerDocument,
+    Attr: ServerAttr,
+    MutationObserver: ServerMutationObserver,
+    NodeFilter: NODE_FILTER
+  };
+  const previous2 = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(globals)) {
+    previous2.set(key, Object.getOwnPropertyDescriptor(g2, key));
+    Object.defineProperty(g2, key, { value, configurable: true, writable: true, enumerable: false });
+  }
+  g2[INSTALLED] = true;
+  return () => {
+    for (const [key, desc] of previous2) {
+      if (desc) Object.defineProperty(g2, key, desc);
+      else delete g2[key];
+    }
+    delete g2[INSTALLED];
+  };
+}
+var BROWSER_GLOBALS = [
+  "matchMedia",
+  "requestAnimationFrame",
+  "localStorage",
+  "sessionStorage",
+  "IntersectionObserver",
+  "ResizeObserver"
+];
+var WATCHED = /* @__PURE__ */ Symbol.for("sibujs.serverDom.watched.v1");
+function inServerRender() {
+  const shared = globalThis[/* @__PURE__ */ Symbol.for("sibujs.ssr.v1")];
+  return !!shared?.als?.getStore()?.ssr;
+}
+function watchProperty(target, key, api) {
+  const desc = Object.getOwnPropertyDescriptor(target, key);
+  if (!desc || !desc.configurable) return;
+  const read = desc.get ? () => desc.get?.call(target) : () => desc.value;
+  let value = desc.value;
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: desc.enumerable,
+    get() {
+      if (inServerRender()) reportBrowserApi(api);
+      return desc.get ? read() : value;
+    },
+    set(v) {
+      if (desc.set) desc.set.call(target, v);
+      else value = v;
+    }
+  });
+}
+function watchBrowserApis() {
+  if (!DEV || isServerDom()) return;
+  const g2 = globalThis;
+  if (g2[WATCHED]) return;
+  g2[WATCHED] = true;
+  const win = g2.window;
+  for (const key of BROWSER_GLOBALS) {
+    if (Object.hasOwn(g2, key)) watchProperty(g2, key, key);
+    if (win && win !== g2 && Object.hasOwn(win, key)) watchProperty(win, key, `window.${key}`);
+  }
+  const Doc = g2.Document;
+  if (Doc && "fonts" in Doc.prototype) watchProperty(Doc.prototype, "fonts", "document.fonts");
+  const Canvas = g2.HTMLCanvasElement;
+  const getContext = Canvas?.prototype.getContext;
+  if (Canvas && getContext) {
+    Canvas.prototype.getContext = function(...args) {
+      if (inServerRender()) reportBrowserApi("HTMLCanvasElement.getContext()");
+      return getContext.apply(this, args);
+    };
+  }
+}
+var BROWSER_ONLY_NAMES = /^(window|self|localStorage|sessionStorage|requestAnimationFrame|cancelAnimationFrame|matchMedia|IntersectionObserver|ResizeObserver|getComputedStyle|location|history|screen|innerWidth|innerHeight|scrollY|scrollX|devicePixelRatio) is not defined$/;
+function explainServerError(err) {
+  if (!(err instanceof ReferenceError)) return err;
+  const m = BROWSER_ONLY_NAMES.exec(err.message);
+  if (!m) return err;
+  const site = (err.stack ?? "").split("\n")[1]?.trim().replace(/^at\s+/, "") ?? "(unknown site)";
+  return new Error(
+    `[SibuJS SSR] browser-only API \`${m[1]}\` used during a server render (${site}). Move the code into onMount() or an effect, or render the component with ClientOnly().`,
+    { cause: err }
+  );
+}
+function ensureServerDom() {
+  if (typeof document === "undefined") installServerDom();
+}
+
+// src/platform/serverHead.ts
+function headSlot() {
+  return requestSlot("head", () => ({ layers: [] }));
+}
+function recordServerHead(source2) {
+  const slot4 = headSlot();
+  if (!slot4) return null;
+  const entry = { source: source2 };
+  slot4.layers.push(entry);
+  return () => {
+    if (entry.source === null) return;
+    entry.source = null;
+    const index = slot4.layers.indexOf(entry);
+    if (index !== -1) slot4.layers.splice(index, 1);
+  };
+}
+function collectServerHead() {
+  const slot4 = headSlot();
+  if (!slot4 || slot4.layers.length === 0) return "";
+  let title3;
+  const order = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of slot4.layers.slice()) {
+    const source2 = entry.source;
+    if (source2 === null) continue;
+    let layer;
+    try {
+      layer = typeof source2 === "function" ? untracked2(source2) : source2;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`[SibuJS SSR] a head value threw while the page head was collected: ${message}`, {
+        cause: err
+      });
+    }
+    if (!layer) continue;
+    if (layer.title !== void 0) title3 = layer.title;
+    for (const tag of layer.tags) {
+      if (!byKey.has(tag.key)) order.push(tag.key);
+      byKey.set(tag.key, tag.html);
+    }
+  }
+  const out = [];
+  if (title3 != null) out.push(`<title>${escapeText2(title3)}</title>`);
+  for (const key of order) out.push(byKey.get(key));
+  return out.join("\n    ");
+}
+function escapeText2(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/platform/ssrAsync.ts
+var DEFAULT_TRANSFER_MAX_BYTES = 1024 * 1024;
+function describeNodePath(node) {
+  const parts = [];
+  let current2 = node;
+  while (current2 && parts.length < 8) {
+    if (current2.nodeType === 1) {
+      const el = current2;
+      let part = el.localName;
+      const id = el.getAttribute("id");
+      if (id) part += `#${id}`;
+      const cls = el.getAttribute("class")?.trim().split(/\s+/)[0];
+      if (cls) part += `.${cls}`;
+      parts.unshift(part);
+    }
+    current2 = current2.parentNode;
+  }
+  return parts.length > 0 ? parts.join(" > ") : "(detached)";
+}
+function renderFailure(entry) {
+  const error = explainServerError(entry.error);
+  const message = error instanceof Error ? error.message : String(error);
+  const where = entry.context.node ? describeNodePath(entry.context.node) : "(unknown position)";
+  const label2 = entry.context.name ? ` in ${entry.context.name}` : "";
+  return new Error(`[SibuJS SSR] render failed${label2} at ${where}: ${message}`, { cause: error });
+}
+
+// src/platform/hydrateAdopt.ts
+var ADOPT_ID_ATTR = "data-sibu-h";
+function createServerAdoptScope(ids) {
+  const sink = {
+    on: true,
+    el(tag, ns, id) {
+      const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+      ids.set(el, id);
+      return el;
+    }
+  };
+  return { p: "", n: 0, s: sink };
+}
+var STICKY = {
+  img: ["src", "srcset", "sizes"],
+  source: ["src", "srcset", "sizes"],
+  video: ["src", "poster"],
+  audio: ["src"],
+  track: ["src"],
+  iframe: ["src"],
+  embed: ["src"],
+  object: ["data"],
+  input: ["value", "checked", "type"],
+  textarea: [],
+  select: [],
+  option: ["value", "selected"],
+  details: ["open"],
+  dialog: ["open"]
+};
+function snapshotSelect(select3) {
+  const options = Array.from(select3.options);
+  const seen = /* @__PURE__ */ new Map();
+  const chosen = [];
+  for (const node of options) {
+    const occurrence = seen.get(node.value) ?? 0;
+    seen.set(node.value, occurrence + 1);
+    if (node.selected) chosen.push({ node, value: node.value, occurrence });
+  }
+  return { chosen, server: new Set(options) };
+}
+var nativeAppend = (parent, child) => Node.prototype.appendChild.call(parent, child);
+var nativeInsert = (parent, child, ref) => Node.prototype.insertBefore.call(parent, child, ref);
+var nativeReplace = (parent, child, old) => Node.prototype.replaceChild.call(parent, child, old);
+function sameKind(a2, b2) {
+  return a2.nodeType === b2.nodeType && (a2.nodeType === 3 || a2.nodeType === 8);
+}
+function isOptionDisabled(option2) {
+  const parent = option2.parentElement;
+  return option2.disabled || parent?.localName === "optgroup" && parent.hasAttribute("disabled");
+}
+function defaultSelection(select3) {
+  const options = Array.from(select3.options);
+  const parsed = reparsedSelection(select3, options);
+  if (parsed) return parsed;
+  const marked = options.filter((o) => o.hasAttribute("selected"));
+  if (select3.multiple) return new Set(marked);
+  if (marked.length > 0) return /* @__PURE__ */ new Set([marked[marked.length - 1]]);
+  if (select3.size > 1) return /* @__PURE__ */ new Set();
+  const first = options.find((o) => !isOptionDisabled(o));
+  return new Set(first ? [first] : []);
+}
+function reparsedSelection(select3, options) {
+  if (typeof DOMParser !== "function") return null;
+  try {
+    const doc = new DOMParser().parseFromString(`<!doctype html><body>${select3.outerHTML}`, "text/html");
+    const copy = doc.querySelector("select");
+    if (!copy || copy.options.length !== options.length) return null;
+    const chosen = /* @__PURE__ */ new Set();
+    Array.from(copy.options).forEach((o, i2) => {
+      if (o.selected) chosen.add(options[i2]);
+    });
+    return chosen;
+  } catch {
+    return null;
+  }
+}
+function isDirty(el) {
+  const tag = el.localName;
+  if (tag === "input") {
+    const input2 = el;
+    if (input2.type === "checkbox" || input2.type === "radio") return input2.checked !== input2.hasAttribute("checked");
+    return input2.value !== (input2.getAttribute("value") ?? "");
+  }
+  if (tag === "textarea") return el.value !== (el.textContent ?? "");
+  if (tag === "select") {
+    const select3 = el;
+    const initial = defaultSelection(select3);
+    return Array.from(select3.options).some((o) => o.selected !== initial.has(o));
+  }
+  return false;
+}
+var AdoptSession = class {
+  constructor(root, options) {
+    this.root = root;
+    this.options = options;
+    this.byId = /* @__PURE__ */ new Map();
+    this.server = /* @__PURE__ */ new WeakSet();
+    this.claimed = /* @__PURE__ */ new Map();
+    this.cursors = /* @__PURE__ */ new WeakMap();
+    this.patched = [];
+    this.touched = /* @__PURE__ */ new Set();
+    this.mismatches = [];
+    /**
+     * The selection of each `<select>` the user changed before takeover. Taken
+     * before any client code runs: the client builds a select's options BEFORE
+     * the select, and an option's `selected` write changes the selection long
+     * before the select itself is claimed. Session-scoped: the references go
+     * with the session.
+     */
+    this.selections = /* @__PURE__ */ new Map();
+    /**
+     * Checkboxes and radios the user changed before takeover, and their state —
+     * for the same reason: checking a radio unchecks its group, so the client
+     * writing a sibling (or a sibling joining the group) changes this one first.
+     */
+    this.checks = /* @__PURE__ */ new Map();
+    /** Form controls whose state differed from their markup when the session started: the user's. */
+    this.dirty = /* @__PURE__ */ new Set();
+    this.created = 0;
+    this.removed = 0;
+    /** AdoptSink: numbering and claiming are on for the length of the session. */
+    this.on = true;
+    /** AdoptSink: the hydration session work built in this sink's scopes belongs to. */
+    this.h = null;
+    this.restored = false;
+    const walk = (node) => {
+      for (let child = node.firstChild; child; child = child.nextSibling) {
+        this.server.add(child);
+        if (child.nodeType === 1) {
+          const id = child.getAttribute(ADOPT_ID_ATTR);
+          if (id !== null && !this.byId.has(id)) this.byId.set(id, child);
+          const tag = child.localName;
+          if ((tag === "select" || tag === "input" || tag === "textarea") && isDirty(child)) {
+            this.dirty.add(child);
+            if (tag === "select") {
+              this.selections.set(child, snapshotSelect(child));
+            } else if (tag === "input") {
+              const input2 = child;
+              if (input2.type === "checkbox" || input2.type === "radio") this.checks.set(input2, input2.checked);
+            }
+          }
+          walk(child);
+        }
+      }
+    };
+    walk(root);
+    this.patchParent(root);
+  }
+  report(m) {
+    const message = m.kind === "tag" ? `server rendered <${m.serverValue}>, the client built <${m.clientValue}> \u2014 the subtree is replaced` : m.kind === "missing" ? `the client built <${m.clientValue}>, which the server did not render` : m.kind === "extra" ? `the server rendered ${m.serverValue}, which the client did not build \u2014 removed` : `text differs: server "${m.serverValue}", client "${m.clientValue}"`;
+    const report = { ...m, message };
+    this.mismatches.push(report);
+    if (this.options.onMismatch) this.options.onMismatch(report);
+    else if (DEV && this.mismatches.length <= 10) {
+      console.warn(
+        `[SibuJS hydration] adopt mismatch at ${m.path}${m.id ? ` (id ${m.id})` : ""}: ${message}.
+  Likely cause: ${m.cause}`
+      );
+    }
+  }
+  // ── AdoptSink: claim the server element with this id ──
+  el(tag, ns, id) {
+    if (!this.on) return null;
+    const candidate = this.byId.get(id);
+    const want = ns ?? "http://www.w3.org/1999/xhtml";
+    if (candidate && candidate.localName === tag && (candidate.namespaceURI ?? want) === want && !this.claimed.has(candidate)) {
+      this.byId.delete(id);
+      this.claim(candidate);
+      return candidate;
+    }
+    this.created++;
+    if (candidate) {
+      this.report({
+        kind: "tag",
+        path: describeNodePath(candidate),
+        id,
+        serverValue: candidate.localName,
+        clientValue: tag,
+        cause: "the server and the client took different branches: a browser-only read (window, matchMedia, storage) during render, data that differs between them, or a non-deterministic render (Date.now(), Math.random()). Render browser-only content with ClientOnly()."
+      });
+    } else {
+      this.report({
+        kind: "missing",
+        path: "(new element)",
+        id,
+        serverValue: "(none)",
+        clientValue: tag,
+        cause: "the client built more than the server: data the server did not have (a query with ssr: false, a timed-out fetch), or a branch that depends on the browser. ClientOnly() renders it after takeover."
+      });
+    }
+    return null;
+  }
+  claim(el) {
+    el.removeAttribute(ADOPT_ID_ATTR);
+    const keep = STICKY[el.localName] ?? [];
+    const sticky = /* @__PURE__ */ new Set();
+    for (const attr of Array.from(el.attributes)) {
+      if (keep.includes(attr.name)) {
+        const safe = resolveAttributeValue(attr.name, attr.value, { element: el });
+        if (safe === null) el.removeAttribute(attr.name);
+        else {
+          if (safe !== attr.value) el.setAttribute(attr.name, safe);
+          sticky.add(attr.name);
+        }
+      } else el.removeAttribute(attr.name);
+    }
+    this.claimed.set(el, { sticky });
+    if (this.dirty.has(el)) this.touched.add(el);
+    this.patchParent(el);
+  }
+  /**
+   * Instance overrides on an adopted parent for the length of the session —
+   * the core's own `appendChild` / `insertBefore` calls then place children
+   * on the server nodes instead of moving them. Removed when the session ends.
+   */
+  patchParent(parent) {
+    const session = this;
+    const record = this.claimed.get(parent);
+    this.cursors.set(parent, parent.firstChild);
+    this.patched.push(parent);
+    const own = parent;
+    own.appendChild = function(child) {
+      if (inAdoptScope() || child.nodeType === 11) return session.place(this, child);
+      return nativeAppend(this, child);
+    };
+    own.insertBefore = function(child, ref) {
+      return session.insertAt(this, child, ref);
+    };
+    own.replaceChildren = function(...nodes) {
+      session.cursors.set(this, this.firstChild);
+      for (const n of nodes) session.place(this, typeof n === "string" ? document.createTextNode(n) : n);
+      let rest = session.cursors.get(this) ?? null;
+      while (rest) {
+        const next = rest.nextSibling;
+        this.removeChild(rest);
+        rest = next;
+      }
+    };
+    const textDesc = Object.getOwnPropertyDescriptor(Node.prototype, "textContent");
+    if (textDesc?.set && textDesc.get) {
+      Object.defineProperty(parent, "textContent", {
+        configurable: true,
+        get() {
+          return textDesc.get?.call(this);
+        },
+        set(value) {
+          const text2 = value == null ? "" : String(value);
+          const only = this.firstChild;
+          if (only && only === this.lastChild && only.nodeType === 3 && only.data === text2) {
+            session.server.delete(only);
+            return;
+          }
+          textDesc.set?.call(this, value);
+        }
+      });
+    }
+    if (record) {
+      const note = (name) => record.sticky.delete(String(name).toLowerCase());
+      const { getAttribute, setAttribute, removeAttribute } = Element.prototype;
+      own.getAttribute = function(name) {
+        note(name);
+        return getAttribute.call(this, name);
+      };
+      own.setAttribute = function(name, value) {
+        note(name);
+        return setAttribute.call(this, name, value);
+      };
+      own.removeAttribute = function(name) {
+        note(name);
+        return removeAttribute.call(this, name);
+      };
+      if (this.touched.has(parent) && parent.localName !== "select") {
+        for (const prop of ["value", "checked"]) {
+          if (prop in parent) {
+            Object.defineProperty(parent, prop, {
+              configurable: true,
+              get() {
+                const desc = findDescriptor(Object.getPrototypeOf(this), prop);
+                return desc?.get?.call(this);
+              },
+              set() {
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  /** Put `child` at the cursor of `parent`. */
+  place(parent, child) {
+    if (child.nodeType === 11) {
+      for (const n of Array.from(child.childNodes)) this.place(parent, n);
+      return child;
+    }
+    let cur = this.cursors.has(parent) ? this.cursors.get(parent) ?? null : null;
+    if (child === cur) {
+      this.cursors.set(parent, child.nextSibling);
+      return child;
+    }
+    if (child.parentNode === parent && this.claimed.has(child) && this.follows(cur, child)) {
+      this.cursors.set(parent, child.nextSibling);
+      return child;
+    }
+    if (!child.parentNode && (child.nodeType === 3 || child.nodeType === 8)) {
+      const match = this.findCounterpart(cur, child);
+      if (match) cur = match;
+    }
+    if (cur && this.server.has(cur) && !this.claimed.has(cur) && sameKind(cur, child) && !child.parentNode) {
+      if (child.nodeType === 3) {
+        const serverText = cur;
+        const clientText = child.data;
+        if (clientText !== "" && serverText.data !== clientText && serverText.data.startsWith(clientText)) {
+          serverText.data = serverText.data.slice(clientText.length);
+          nativeInsert(parent, child, serverText);
+          return child;
+        }
+        if (serverText.data !== clientText) {
+          this.report({
+            kind: "text",
+            path: describeNodePath(parent),
+            id: null,
+            serverValue: serverText.data.slice(0, 80),
+            clientValue: clientText.slice(0, 80),
+            cause: "the text was computed differently: a non-deterministic value (Date.now(), Math.random(), a locale-dependent format) or data that changed between render and takeover. The client text is kept."
+          });
+        }
+      }
+      this.server.delete(cur);
+      this.cursors.set(parent, cur.nextSibling);
+      nativeReplace(parent, child, cur);
+      return child;
+    }
+    nativeInsert(parent, child, cur);
+    return child;
+  }
+  /** Is `node` at or after `from` among its siblings? */
+  follows(from, node) {
+    for (let n = from; n; n = n.nextSibling) if (n === node) return true;
+    return false;
+  }
+  /**
+   * The server node a fresh text / comment child stands for: the first
+   * unconsumed server node of the same kind from `from` on (a comment must
+   * carry the same text), skipping unclaimed server nodes in between — a
+   * preceding directive's branch content — but never an adopted element.
+   */
+  findCounterpart(from, child) {
+    for (let n = from; n; n = n.nextSibling) {
+      if (!this.server.has(n)) return null;
+      if (n.nodeType === 1 && this.claimed.has(n)) return null;
+      if (n.nodeType !== child.nodeType) continue;
+      if (n.nodeType === 8 && n.data !== child.data) continue;
+      return n;
+    }
+    return null;
+  }
+  /** `insertBefore` on an adopted parent: no-op when already in place; a fresh text/comment takes the server one's place. */
+  insertAt(parent, child, ref) {
+    if (child === ref || child.parentNode === parent && child.nextSibling === ref) return child;
+    if (child.nodeType === 11) {
+      for (const n of Array.from(child.childNodes)) this.insertAt(parent, n, ref);
+      return child;
+    }
+    if (ref && !child.parentNode && this.server.has(ref) && sameKind(ref, child)) {
+      if (child.nodeType === 3 && ref.data !== child.data) {
+        this.report({
+          kind: "text",
+          path: describeNodePath(parent),
+          id: null,
+          serverValue: ref.data.slice(0, 80),
+          clientValue: child.data.slice(0, 80),
+          cause: "the text was computed differently: a non-deterministic value (Date.now(), Math.random(), a locale-dependent format) or data that changed between render and takeover. The client text is kept."
+        });
+      }
+      this.server.delete(ref);
+      if (this.cursors.get(parent) === ref) this.cursors.set(parent, ref.nextSibling);
+      nativeReplace(parent, child, ref);
+      return child;
+    }
+    return nativeInsert(parent, child, ref);
+  }
+  /** Remove every instance override; idempotent, and also run when the build throws. */
+  restore() {
+    this.on = false;
+    if (this.restored) return;
+    this.restored = true;
+    for (const node of this.patched) {
+      const own = node;
+      for (const key of [
+        "appendChild",
+        "insertBefore",
+        "replaceChildren",
+        "textContent",
+        "getAttribute",
+        "setAttribute",
+        "removeAttribute",
+        "value",
+        "checked"
+      ]) {
+        if (Object.hasOwn(own, key)) delete own[key];
+      }
+    }
+  }
+  /** End of the session: restore the instances, release unclaimed server nodes, replay input. */
+  finish() {
+    this.restore();
+    const sweep = (node) => {
+      for (let child = node.firstChild; child; ) {
+        const next = child.nextSibling;
+        if (this.server.has(child) && !this.claimed.has(child)) {
+          if (child.nodeType === 1 && child.hasAttribute(ADOPT_ID_ATTR)) {
+            this.report({
+              kind: "extra",
+              path: describeNodePath(child),
+              id: child.getAttribute(ADOPT_ID_ATTR),
+              serverValue: `<${child.localName}>`,
+              clientValue: "(none)",
+              cause: "the client built less than the server, or built it under another scope: a branch that renders differently in the browser, or a component whose structure depends on timing."
+            });
+          }
+          child.parentNode?.removeChild(child);
+          this.removed++;
+        } else if (child.nodeType === 1) sweep(child);
+        child = next;
+      }
+    };
+    sweep(this.root);
+    for (const [el, record] of this.claimed) {
+      for (const name of record.sticky) el.removeAttribute(name);
+    }
+    reselect(this);
+    for (const el of this.touched) {
+      el.dispatchEvent(new Event("input", { bubbles: true }));
+      el.dispatchEvent(new Event("change", { bubbles: true }));
+    }
+  }
+};
+function survivingSelection(select3, snapshot) {
+  const options = Array.from(select3.options);
+  const present = new Set(options);
+  const result = /* @__PURE__ */ new Set();
+  const rebuilt = /* @__PURE__ */ new Map();
+  for (const o of options) {
+    if (snapshot.server.has(o)) continue;
+    const list = rebuilt.get(o.value);
+    if (list) list.push(o);
+    else rebuilt.set(o.value, [o]);
+  }
+  const lost = [];
+  for (const entry of snapshot.chosen) {
+    if (present.has(entry.node) && entry.node.value === entry.value) result.add(entry.node);
+    else lost.push(entry);
+  }
+  for (const entry of lost) {
+    const candidates = rebuilt.get(entry.value);
+    if (!candidates) continue;
+    const atOccurrence = candidates[entry.occurrence];
+    const match = atOccurrence && !result.has(atOccurrence) ? atOccurrence : candidates.find((o) => !result.has(o));
+    if (match) result.add(match);
+  }
+  return result;
+}
+function reselect(session) {
+  for (const [select3, snapshot] of session.selections) {
+    if (!session.claimed.has(select3) || !session.root.contains(select3)) {
+      session.touched.delete(select3);
+      continue;
+    }
+    if (snapshot.chosen.length === 0) {
+      select3.selectedIndex = -1;
+      continue;
+    }
+    const keep = survivingSelection(select3, snapshot);
+    if (keep.size === 0) {
+      session.touched.delete(select3);
+      continue;
+    }
+    if (select3.multiple) for (const o of Array.from(select3.options)) o.selected = keep.has(o);
+    else keep.values().next().value.selected = true;
+  }
+  const live = Array.from(session.checks).filter(([el]) => session.claimed.has(el) && session.root.contains(el));
+  for (const [el, checked] of live) if (!checked) el.checked = false;
+  for (const [el, checked] of live) if (checked) el.checked = true;
+}
+function findDescriptor(proto, key) {
+  for (let p2 = proto; p2; p2 = Object.getPrototypeOf(p2)) {
+    const d = Object.getOwnPropertyDescriptor(p2, key);
+    if (d) return d;
+  }
+  return void 0;
+}
+var macrotask = () => new Promise((resolve) => {
+  if (typeof MessageChannel === "function") {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => {
+      channel.port1.close();
+      resolve();
+    };
+    channel.port2.postMessage(null);
+  } else setTimeout(resolve, 0);
+});
+async function hydrateAdopt(component, container, options = {}) {
+  const hydration = beginHydration();
+  const session = new AdoptSession(container, options);
+  session.h = hydration;
+  const rootScope = { p: "", n: 0, s: session };
+  let replacedRoot = false;
+  try {
+    const tree = inHydration(hydration, () => inScope(rootScope, component));
+    if (tree.parentNode !== container) {
+      if (tree.nodeType === 1 && !session.claimed.has(tree)) {
+        replacedRoot = true;
+        if (DEV && !options.onMismatch) {
+          console.warn(
+            '[SibuJS hydration] adopt: the root element did not match the server markup, so the whole tree is replaced. Was the server render made with { hydration: "adopt" } and the same root component?'
+          );
+        }
+      }
+      inScope(rootScope, () => session.place(container, tree));
+    }
+    const deadline = Date.now() + (options.timeout ?? 1e4);
+    const { pending, wake } = hydration;
+    for (; ; ) {
+      await macrotask();
+      if (pending.size === 0) {
+        await macrotask();
+        if (pending.size === 0) break;
+        continue;
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(timer);
+          wake.delete(done);
+          resolve();
+        };
+        const timer = setTimeout(done, remaining);
+        wake.add(done);
+      });
+    }
+    session.finish();
+  } finally {
+    session.restore();
+    hydration.end();
+  }
+  container.setAttribute("data-sibu-hydrated", "adopt");
+  return {
+    adopted: session.claimed.size,
+    created: session.created,
+    removed: session.removed,
+    mismatches: session.mismatches,
+    replacedRoot
+  };
+}
+
+// src/platform/componentIsland.ts
+var ISLAND_PROPS_ATTR = "data-sibu-props";
+var SAFE_NAME = /^[A-Za-z0-9_-]+$/;
+function componentIsland(name, component, props, options = {}) {
+  if (!SAFE_NAME.test(name)) {
+    throw new Error(`[SibuJS SSR] island: name must match [A-Za-z0-9_-]+ (got: ${JSON.stringify(name.slice(0, 32))})`);
+  }
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-sibu-island", name);
+  if (options.load) wrapper.setAttribute("data-sibu-load", options.load);
+  if (options.media) wrapper.setAttribute("data-sibu-media", options.media);
+  wrapper.setAttribute("style", "display: contents");
+  let json;
+  try {
+    json = JSON.stringify(props ?? null);
+  } catch (err) {
+    throw new Error(`[SibuJS SSR] island "${name}": props must be JSON-serializable`, { cause: err });
+  }
+  wrapper.setAttribute(ISLAND_PROPS_ATTR, json);
+  const scope = isServer() ? {
+    p: "",
+    n: 0,
+    s: {
+      on: true,
+      el(tag, ns, id) {
+        const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+        el.setAttribute(ADOPT_ID_ATTR, id);
+        return el;
+      }
+    }
+  } : null;
+  wrapper.appendChild(inScope(scope, () => component(props)));
+  return wrapper;
+}
+
+// src/platform/ssrStream.ts
+var hookInstalled = false;
+function installHook() {
+  if (hookInstalled) return;
+  hookInstalled = true;
+  setBoundaryHook((container) => {
+    const state3 = requestSlot("stream");
+    const store = getRequestStore();
+    if (!state3 || !store) return null;
+    const id = `sibu-sus-${store.suspenseIdCounter++}`;
+    container.setAttribute("data-sibu-suspense-id", id);
+    const record = {
+      id,
+      container,
+      done: false,
+      emitted: false,
+      fallbackHtml: null,
+      api: {
+        enter: (fn) => {
+          if (record.fallbackHtml === null && state3.serialize) {
+            record.fallbackHtml = Array.from(container.childNodes, (n) => state3.serialize?.(n) ?? "").join("");
+          }
+          return runInBoundary(record.api, fn);
+        },
+        done: () => {
+          record.done = true;
+          store.wake?.();
+        }
+      }
+    };
+    state3.boundaries.push(record);
+    return record.api;
+  });
+}
+function createChannel() {
+  const chunks = [];
+  let taken = null;
+  let arrived = null;
+  let ended = false;
+  let cancelled = false;
+  let error;
+  return {
+    get cancelled() {
+      return cancelled;
+    },
+    async push(chunk) {
+      if (cancelled || chunk === "") return;
+      chunks.push(chunk);
+      arrived?.();
+      arrived = null;
+      await new Promise((resolve) => {
+        taken = resolve;
+      });
+    },
+    end() {
+      ended = true;
+      arrived?.();
+    },
+    fail(err) {
+      error = err;
+      ended = true;
+      arrived?.();
+    },
+    /** Called on cancel, so a renderer waiting for a boundary stops at once. */
+    onCancel: null,
+    cancel() {
+      cancelled = true;
+      taken?.();
+      this.onCancel?.();
+    },
+    async take() {
+      for (; ; ) {
+        if (chunks.length > 0) {
+          const value = chunks.shift();
+          const release = taken;
+          taken = null;
+          release?.();
+          return { value, done: false };
+        }
+        if (error !== void 0) throw error;
+        if (ended) return { done: true };
+        await new Promise((resolve) => {
+          arrived = resolve;
+        });
+      }
+    }
+  };
+}
+var macrotask2 = () => new Promise((resolve) => {
+  if (typeof setImmediate === "function") setImmediate(resolve);
+  else setTimeout(resolve, 0);
+});
+async function waitFor(ready, deadline, stop2) {
+  const store = getRequestStore();
+  for (; ; ) {
+    await macrotask2();
+    if (stop2()) return false;
+    if (ready()) {
+      await macrotask2();
+      if (ready()) return true;
+      continue;
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return false;
+    await new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        if (store && store.wake === done) store.wake = null;
+        resolve();
+      };
+      const timer = setTimeout(done, Math.min(remaining, 50));
+      if (store) store.wake = done;
+    });
+  }
+}
+function pendingFor(pending, boundary) {
+  if (!pending) return false;
+  for (const work of pending) if (work.boundary === boundary) return true;
+  return false;
+}
+function streamPage(input2, options = {}) {
+  assertRequestIsolation("renderToReadableStream()");
+  installHook();
+  const channel = createChannel();
+  const nonce = options.nonce;
+  const doc = options.document === false ? null : options.document ?? {};
+  const MARK_BODY = "<sibu-stream-body>";
+  const MARK_END = "<sibu-stream-end>";
+  void runInSSRContext(async () => {
+    const store = getRequestStore();
+    const state3 = { boundaries: [], serialize: null };
+    requestSlot("stream", () => state3);
+    const errors = [];
+    if (store) store.errors = errors;
+    let holder = null;
+    channel.onCancel = () => store?.wake?.();
+    const failIfErrored = () => {
+      if (errors.length > 0) throw renderFailure(errors[0]);
+    };
+    const stopWaiting = () => errors.length > 0 || channel.cancelled;
+    try {
+      ensureServerDom();
+      watchBrowserApis();
+      const ids = options.hydration === "adopt" ? /* @__PURE__ */ new WeakMap() : null;
+      const scope = ids ? createServerAdoptScope(ids) : null;
+      let root;
+      try {
+        root = inScope(scope, input2);
+      } catch (err) {
+        throw explainServerError(err);
+      }
+      const serialize = (node) => renderToStringWith(node, { marker: options.marker ?? "root", ids });
+      state3.serialize = serialize;
+      holder = document.createDocumentFragment();
+      holder.appendChild(root);
+      const ready = (b2) => b2.done && !pendingFor(store?.pending, b2.api);
+      const serializeWithFallbacks = (node) => {
+        const held = [];
+        for (const b2 of state3.boundaries) {
+          if (ready(b2) || b2.container === node || !node.contains(b2.container)) continue;
+          if (held.some((h) => h.b.container.contains(b2.container))) continue;
+          const nodes = Array.from(b2.container.childNodes);
+          for (const n of nodes) b2.container.removeChild(n);
+          const mark2 = document.createComment(`sibu-fallback:${b2.id}`);
+          b2.container.appendChild(mark2);
+          held.push({ b: b2, nodes, mark: mark2 });
+        }
+        let html2 = serialize(node);
+        for (const { b: b2, nodes, mark: mark2 } of held) {
+          b2.container.removeChild(mark2);
+          for (const n of nodes) b2.container.appendChild(n);
+          const fallback = b2.fallbackHtml ?? "";
+          html2 = html2.replace(`<!--sibu-fallback:${b2.id}-->`, () => fallback);
+        }
+        return html2;
+      };
+      const shellDeadline = Date.now() + (options.shellTimeout ?? 5e3);
+      await waitFor(() => !pendingFor(store?.pending, void 0), shellDeadline, stopWaiting);
+      failIfErrored();
+      if (channel.cancelled) return;
+      for (const b2 of state3.boundaries) {
+        const inline = (x) => x.done && !pendingFor(store?.pending, x.api);
+        const enclosing = state3.boundaries.filter((a2) => a2 !== b2 && a2.container.contains(b2.container));
+        if (inline(b2) && enclosing.every(inline)) b2.emitted = true;
+      }
+      const shell = serializeWithFallbacks(holder);
+      const head2 = collectServerHead();
+      let after = "";
+      let between = "";
+      if (doc) {
+        const page = assembleDocument(MARK_BODY, doc, head2, MARK_END);
+        const bodyAt = page.indexOf(MARK_BODY);
+        const endAt = page.indexOf(MARK_END, bodyAt + MARK_BODY.length);
+        const start = page.slice(0, bodyAt);
+        between = page.slice(bodyAt + MARK_BODY.length, endAt);
+        after = page.slice(endAt + MARK_END.length);
+        await channel.push(start + shell);
+      } else {
+        await channel.push(shell);
+      }
+      if (channel.cancelled) return;
+      failIfErrored();
+      const deadline = Date.now() + (options.timeout ?? 1e4);
+      const outstanding = () => state3.boundaries.filter((b2) => !b2.emitted);
+      const ancestorsOf = (b2) => state3.boundaries.filter((a2) => a2 !== b2 && a2.container.contains(b2.container));
+      const emittable = (b2) => ready(b2) && ancestorsOf(b2).every((a2) => a2.emitted);
+      let bodyClosed = false;
+      for (; ; ) {
+        if (outstanding().length === 0) break;
+        const next = outstanding().find(emittable);
+        if (!next) {
+          const progressed = await waitFor(
+            () => outstanding().some(emittable) || outstanding().length === 0,
+            deadline,
+            stopWaiting
+          );
+          if (channel.cancelled) return;
+          failIfErrored();
+          if (!progressed) break;
+          continue;
+        }
+        failIfErrored();
+        if (!bodyClosed && doc) {
+          await channel.push(between);
+          bodyClosed = true;
+          if (channel.cancelled) return;
+          failIfErrored();
+        }
+        for (const b2 of state3.boundaries) {
+          if (b2 === next || !next.container.contains(b2.container) || !ready(b2)) continue;
+          const between2 = ancestorsOf(b2).filter((a2) => a2 !== next && next.container.contains(a2.container));
+          if (between2.every(ready)) b2.emitted = true;
+        }
+        next.emitted = true;
+        if (!next.container.isConnected && !holder.contains(next.container)) continue;
+        let html2 = "";
+        for (const child of Array.from(next.container.childNodes)) html2 += serializeWithFallbacks(child);
+        await channel.push(
+          `<div hidden id="sibu-resolved-${next.id}">${html2}</div>${suspenseSwapScript(next.id, nonce)}`
+        );
+        if (channel.cancelled) return;
+        failIfErrored();
+      }
+      if (DEV && outstanding().length > 0) {
+        console.warn(
+          `[SibuJS SSR] streaming: ${outstanding().length} Suspense boundar${outstanding().length === 1 ? "y" : "ies"} did not resolve within ${options.timeout ?? 1e4} ms and kept the fallback.`
+        );
+      }
+      failIfErrored();
+      let stateScript = "";
+      if (options.transfer !== false) {
+        const data2 = collectTransfer();
+        if (data2) {
+          try {
+            stateScript = serializeState(data2, nonce, {
+              maxBytes: options.maxStateBytes ?? DEFAULT_TRANSFER_MAX_BYTES,
+              global: "__SIBU_TRANSFER__"
+            });
+          } catch (err) {
+            if (DEV) console.warn("[SibuJS SSR] streaming: transferred state left out:", err);
+          }
+        }
+      }
+      if (doc) {
+        await channel.push((bodyClosed ? "" : between) + stateScript + after);
+      } else if (stateScript) {
+        await channel.push(stateScript);
+      }
+      channel.end();
+    } catch (err) {
+      channel.fail(err);
+    } finally {
+      if (store) store.errors = void 0;
+      if (holder) for (const child of Array.from(holder.childNodes)) dispose(child);
+    }
+  });
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await channel.take();
+      if (done) controller.close();
+      else controller.enqueue(value);
+    },
+    cancel() {
+      channel.cancel();
+    }
+  });
+}
+
+// src/platform/ssr.ts
+function isForbiddenSsrAttr(lowerName) {
+  return isHtmlContentAttribute(lowerName);
+}
+var SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
+function isSafeAttrName(name) {
+  return SAFE_ATTR_NAME.test(name);
+}
+function ssrErrorComment(err) {
+  if (DEV) {
+    const msg = escapeHtml(err instanceof Error ? err.message : String(err));
+    return `<!--SSR error: ${safeCommentText(msg)}-->`;
+  }
+  return "<!--SSR error-->";
+}
+function safeCommentText(text2) {
+  return text2.replace(/-->/g, "--&gt;").replace(/--!>/g, "--!&gt;").replace(/<!--/g, "&lt;!--").replace(/^(-?)>/, "$1&gt;").replace(/<!-$/, "&lt;!-").replace(/--$/g, "--&#45;");
+}
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function findNativeGetter(proto, name) {
+  for (let p2 = proto; p2; p2 = Object.getPrototypeOf(p2)) {
+    const get = Object.getOwnPropertyDescriptor(p2, name)?.get;
+    if (get) return get;
+  }
+  return null;
+}
+var nativeAccessorsByRealm = /* @__PURE__ */ new WeakMap();
+function nativeAccessors() {
+  const realm = Element;
+  let accessors = nativeAccessorsByRealm.get(realm);
+  if (!accessors) {
+    accessors = {
+      attributes: findNativeGetter(Element.prototype, "attributes"),
+      tagName: findNativeGetter(Element.prototype, "tagName"),
+      childNodes: findNativeGetter(Node.prototype, "childNodes"),
+      getAttribute: Element.prototype.getAttribute
+    };
+    nativeAccessorsByRealm.set(realm, accessors);
+  }
+  return accessors;
+}
+function attributesOf(el) {
   const get = nativeAccessors().attributes;
   return get ? get.call(el) : el.attributes;
 }
@@ -9055,8 +12277,8 @@ function childNodesOf(node) {
 function getAttributeOf(el, name) {
   return nativeAccessors().getAttribute.call(el, name);
 }
-var SVG_NS3 = "http://www.w3.org/2000/svg";
-var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var SVG_NS4 = "http://www.w3.org/2000/svg";
+var MATHML_NS2 = "http://www.w3.org/1998/Math/MathML";
 var XLINK_NS2 = "http://www.w3.org/1999/xlink";
 var XML_NS2 = "http://www.w3.org/XML/1998/namespace";
 var XMLNS_NS = "http://www.w3.org/2000/xmlns/";
@@ -9111,21 +12333,21 @@ function isBreakout(lowerName, element) {
   return lowerName === "font" && (element.hasAttribute("color") || element.hasAttribute("face") || element.hasAttribute("size"));
 }
 function fitsParseContext(ns, lowerName, element, context) {
-  if (ns === SVG_NS3) {
+  if (ns === SVG_NS4) {
     if (context === 1 /* Svg */) return !isBreakout(lowerName, element);
     return lowerName === "svg" && (context === 0 /* Html */ || context === 3 /* Annotation */);
   }
-  if (ns === MATHML_NS) {
+  if (ns === MATHML_NS2) {
     if (context === 2 /* Math */ || context === 3 /* Annotation */) return !isBreakout(lowerName, element);
     return lowerName === "math" && context === 0 /* Html */;
   }
   return context === 0 /* Html */;
 }
 function childParseContext(ns, lowerName, element) {
-  if (ns === SVG_NS3) {
+  if (ns === SVG_NS4) {
     return lowerName === "foreignobject" || lowerName === "desc" || lowerName === "title" ? 0 /* Html */ : 1 /* Svg */;
   }
-  if (ns === MATHML_NS) {
+  if (ns === MATHML_NS2) {
     if (lowerName === "mi" || lowerName === "mo" || lowerName === "mn" || lowerName === "ms" || lowerName === "mtext") {
       return 0 /* Html */;
     }
@@ -9144,7 +12366,8 @@ function foreignAttrName(attr) {
   if (ns === XMLNS_NS) return attr.localName === "xmlns" ? "xmlns" : `xmlns:${attr.localName}`;
   return attr.name;
 }
-function serializeOpenTag(element, tag, foreign) {
+var LEGACY_SERIALIZE = { marker: "all", ids: null };
+function serializeOpenTag(element, tag, foreign, opts, depth) {
   let html2 = `<${tag}`;
   const meta2 = tag === "meta" && !foreign ? /* @__PURE__ */ new Map() : null;
   const embed2 = tag === "iframe" && !foreign ? getEmbedRecord(element) : void 0;
@@ -9173,18 +12396,20 @@ function serializeOpenTag(element, tag, foreign) {
     if (tail === null) return null;
     html2 += tail;
   }
-  if (!getAttributeOf(element, "data-sibu-hydrate")) {
+  const hid = opts.ids?.get(element);
+  if (hid !== void 0) html2 += ` data-sibu-h="${hid}"`;
+  if ((opts.marker === "all" || opts.marker === "root" && depth === 0) && !getAttributeOf(element, "data-sibu-hydrate")) {
     html2 += ` data-sibu-ssr="true"`;
   }
   return html2;
 }
-function serializeNode(node, context) {
+function serializeNode(node, context, opts = LEGACY_SERIALIZE, depth = 0) {
   if (node.nodeType === 3) return escapeHtml(node.textContent || "");
   if (node.nodeType === 8) return `<!--${safeCommentText(node.textContent || "")}-->`;
   let foreign = false;
   if (!(node instanceof HTMLElement)) {
     const ns2 = node.nodeType === 1 ? node.namespaceURI : null;
-    if (ns2 !== SVG_NS3 && ns2 !== MATHML_NS) return escapeHtml(node.textContent || "");
+    if (ns2 !== SVG_NS4 && ns2 !== MATHML_NS2) return escapeHtml(node.textContent || "");
     foreign = true;
   }
   const element = node;
@@ -9194,7 +12419,7 @@ function serializeNode(node, context) {
   const ns = foreign ? element.namespaceURI : null;
   const lowerName = tag.toLowerCase();
   if (!fitsParseContext(ns, lowerName, element, context)) return DEV ? `<!--ssr:${tag}-misplaced-->` : "";
-  const openTag = serializeOpenTag(element, tag, foreign);
+  const openTag = serializeOpenTag(element, tag, foreign, opts, depth);
   if (openTag === null) return DEV ? `<!--ssr:${tag}-stripped-->` : "";
   const children = childNodesOf(element);
   if (foreign ? children.length === 0 : VOID_ELEMENTS.has(tag)) return `${openTag} />`;
@@ -9206,31 +12431,45 @@ function serializeNode(node, context) {
   };
 }
 function renderToString(element) {
-  return renderNodeToString(element, 0 /* Html */);
+  return renderNodeToString(element, 0 /* Html */, LEGACY_SERIALIZE, 0);
 }
-function renderNodeToString(element, context) {
+function renderToStringWith(element, opts) {
+  return renderNodeToString(element, 0 /* Html */, opts, 0);
+}
+function renderNodeToString(element, context, opts, depth) {
   if (element instanceof DocumentFragment) {
+    let prevText2 = false;
     return Array.from(element.childNodes).map((child) => {
+      const isText = child.nodeType === 3;
+      const sep = opts.ids && isText && prevText2 ? "<!--|-->" : "";
+      prevText2 = isText;
       try {
-        return renderNodeToString(child, context);
+        return sep + renderNodeToString(child, context, opts, depth);
       } catch (err) {
         return ssrErrorComment(err);
       }
     }).join("");
   }
-  const frame = serializeNode(element, context);
+  const frame = serializeNode(element, context, opts, depth);
   if (typeof frame === "string") return frame;
   let html2 = frame.open;
+  let prevText = false;
   for (const child of frame.children) {
+    const isText = child.nodeType === 3;
+    if (opts.ids && isText && prevText) html2 += "<!--|-->";
+    prevText = isText;
     try {
-      html2 += renderNodeToString(child, frame.context);
+      html2 += renderNodeToString(child, frame.context, opts, depth + 1);
     } catch (err) {
       html2 += ssrErrorComment(err);
     }
   }
   return html2 + frame.close;
 }
-function hydrate(component, container, options = {}) {
+function hydrate(component, target, input2 = {}) {
+  if (input2.strategy === "adopt") return hydrateAdopt(component, target, input2);
+  const options = input2;
+  const container = target;
   const clientTree = component();
   if (options.diagnostics) {
     const mismatches = [];
@@ -9386,6 +12625,9 @@ function renderToDocument(component, options = {}) {
   } catch (err) {
     content = ssrErrorComment(err);
   }
+  return assembleDocument(content, options, "", "");
+}
+function assembleDocument(content, options, head2, bodyEnd) {
   const metaTags = (options.meta || []).map((attrs) => serializeHeadEntry("meta", attrs)).filter(Boolean).join("\n    ");
   const linkTags = (options.links || []).map((attrs) => serializeHeadEntry("link", attrs)).filter(Boolean).join("\n    ");
   const scriptTags = (options.scripts || []).map((src) => {
@@ -9403,10 +12645,12 @@ function renderToDocument(component, options = {}) {
     ${options.title != null ? `<title>${escapeHtml(options.title)}</title>` : ""}
     ${metaTags}
     ${linkTags}
-    ${options.headExtra || ""}
+    ${options.headExtra || ""}${head2 ? `
+    ${head2}` : ""}
   </head>
   <body${bodyAttrs}>
-    <div id="app">${content}</div>
+    <div id="app">${content}</div>${bodyEnd ? `
+    ${bodyEnd}` : ""}
     ${scriptTags}
   </body>
 </html>`;
@@ -9447,7 +12691,8 @@ async function collectStream(stream2) {
   }
   return result;
 }
-function renderToReadableStream(element) {
+function renderToReadableStream(element, options) {
+  if (typeof element === "function") return streamPage(element, options);
   const generator = renderToStream(element);
   return new ReadableStream({
     async pull(controller) {
@@ -9464,7 +12709,8 @@ function renderToReadableStream(element) {
   });
 }
 var SAFE_ID = /^[A-Za-z0-9_-]+$/;
-function island(id, component) {
+function island(id, component, ...rest) {
+  if (rest.length > 0) return componentIsland(id, component, rest[0], rest[1]);
   if (!SAFE_ID.test(id)) {
     throw new Error(`[SibuJS SSR] island: id must match [A-Za-z0-9_-]+ (got: ${JSON.stringify(id.slice(0, 32))})`);
   }
@@ -9598,16 +12844,22 @@ function escapeScriptJson(json) {
   return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
+var SAFE_GLOBAL_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function serializeState(state3, nonce, options) {
+  const globalName = options?.global ?? SSR_DATA_ATTR;
+  if (!SAFE_GLOBAL_NAME.test(globalName)) {
+    throw new Error(`[SibuJS SSR] serializeState: global must be an identifier (got: ${JSON.stringify(globalName)})`);
+  }
   const rawJson = JSON.stringify(state3);
   const maxBytes = options?.maxBytes ?? DEFAULT_MAX_SSR_BYTES;
   const byteLen = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(rawJson).byteLength : Buffer.byteLength(rawJson, "utf8");
   if (byteLen > maxBytes) {
     throw new Error(`[SibuJS SSR] serializeState: payload (${byteLen} bytes) exceeds maxBytes (${maxBytes})`);
   }
-  const json = escapeScriptJson(rawJson);
+  const value = rawJson.includes('"__proto__":') ? `JSON.parse(${JSON.stringify(rawJson)})` : rawJson;
+  const json = escapeScriptJson(value);
   const nonceAttr = nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
-  return `<script${nonceAttr}>window.${SSR_DATA_ATTR}=${json}</script>`;
+  return `<script${nonceAttr}>window.${globalName}=${json}</script>`;
 }
 function deserializeState(validate) {
   if (typeof window === "undefined") return void 0;
@@ -9657,14 +12909,14 @@ function block(factory) {
 function dict(source2) {
   const out = /* @__PURE__ */ Object.create(null);
   if (source2) {
-    for (const key of Object.keys(source2)) defineOwn(out, key, source2[key]);
+    for (const key of Object.keys(source2)) defineOwn2(out, key, source2[key]);
   }
   return out;
 }
 function ownGet(obj, key) {
   return obj !== void 0 && Object.hasOwn(obj, key) ? obj[key] : void 0;
 }
-function defineOwn(obj, key, value) {
+function defineOwn2(obj, key, value) {
   Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
 }
 function readEntityId(entity, idKey, typeName) {
@@ -9687,7 +12939,7 @@ function normalizedStore(schema) {
     setState((prev) => {
       const ids = Object.hasOwn(prev.entities, id) ? prev.ids : [...prev.ids, id];
       const entities = dict(prev.entities);
-      defineOwn(entities, id, entity);
+      defineOwn2(entities, id, entity);
       return { ids, entities };
     });
   }
@@ -9701,7 +12953,7 @@ function normalizedStore(schema) {
         if (!Object.hasOwn(nextEntities, id)) {
           nextIds.push(id);
         }
-        defineOwn(nextEntities, id, entity);
+        defineOwn2(nextEntities, id, entity);
       });
       return { ids: nextIds, entities: nextEntities };
     });
@@ -9724,12 +12976,12 @@ function normalizedStore(schema) {
         );
       }
     }
-    setState((current) => {
-      const existing = ownGet(current.entities, id);
-      if (!existing) return current;
-      const entities = dict(current.entities);
-      defineOwn(entities, id, { ...existing, ...partial });
-      return { ids: current.ids, entities };
+    setState((current2) => {
+      const existing = ownGet(current2.entities, id);
+      if (!existing) return current2;
+      const entities = dict(current2.entities);
+      defineOwn2(entities, id, { ...existing, ...partial });
+      return { ids: current2.ids, entities };
     });
   }
   function remove(id) {
@@ -9755,7 +13007,7 @@ function normalize(data2, schema) {
     let table2 = ownGet(entities, name);
     if (!table2) {
       table2 = dict();
-      defineOwn(entities, name, table2);
+      defineOwn2(entities, name, table2);
     }
     return table2;
   }
@@ -9770,17 +13022,17 @@ function normalize(data2, schema) {
         if (value == null) continue;
         const relSchema = { name: relationType };
         if (Array.isArray(value)) {
-          defineOwn(
+          defineOwn2(
             flat,
             field,
             value.map((item) => normalizeEntity(item, relSchema))
           );
         } else if (typeof value === "object") {
-          defineOwn(flat, field, normalizeEntity(value, relSchema));
+          defineOwn2(flat, field, normalizeEntity(value, relSchema));
         }
       }
     }
-    defineOwn(table2, id, flat);
+    defineOwn2(table2, id, flat);
     return id;
   }
   if (Array.isArray(data2)) {
@@ -9802,13 +13054,13 @@ function denormalize(id, entities, schema) {
       if (value == null) continue;
       const relSchema = { name: relationType };
       if (Array.isArray(value)) {
-        defineOwn(
+        defineOwn2(
           result,
           field,
           value.map((relId) => denormalize(relId, entities, relSchema))
         );
       } else if (typeof value === "string") {
-        defineOwn(result, field, denormalize(value, entities, relSchema));
+        defineOwn2(result, field, denormalize(value, entities, relSchema));
       }
     }
   }
@@ -9836,7 +13088,7 @@ function createChunkRegistry(config = {}) {
   const cache = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
   const preloaded = /* @__PURE__ */ new Map();
-  function notify(name, run) {
+  function notify2(name, run) {
     try {
       run();
     } catch (err) {
@@ -9908,7 +13160,7 @@ function createChunkRegistry(config = {}) {
     const entry = { promise: outcome };
     pending.set(id, entry);
     const owns = () => pending.get(id) === entry;
-    notify("onLoadStart", () => onLoadStart?.(id));
+    notify2("onLoadStart", () => onLoadStart?.(id));
     void loadWithRetry(id, loader).then(
       (value) => {
         if (owns()) {
@@ -9917,13 +13169,13 @@ function createChunkRegistry(config = {}) {
           const now = Date.now();
           cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
         }
-        notify("onLoadEnd", () => onLoadEnd?.(id));
+        notify2("onLoadEnd", () => onLoadEnd?.(id));
         resolveOuter(value);
       },
       (err) => {
         if (owns()) pending.delete(id);
         const error = err instanceof Error ? err : new Error(String(err));
-        notify("onLoadError", () => onLoadError?.(id, error));
+        notify2("onLoadError", () => onLoadError?.(id, error));
         rejectOuter(error);
       }
     ).catch((internal) => {
@@ -10009,9 +13261,9 @@ function createChunkRegistry(config = {}) {
     }
   };
 }
-function lazyChunk(id, loader, registry, fallback) {
+function lazyChunk(id, loader, registry2, fallback) {
   return () => {
-    const cached = registry.get(id);
+    const cached = registry2.get(id);
     if (cached) return cached();
     const container = document.createElement("div");
     container.setAttribute("data-chunk", id);
@@ -10022,7 +13274,7 @@ function lazyChunk(id, loader, registry, fallback) {
     registerDisposer(container, () => {
       disposed = true;
     });
-    registry.load(id, async () => {
+    registry2.load(id, async () => {
       const mod = await loader();
       return typeof mod === "function" ? mod : mod.default;
     }).then(
@@ -10073,18 +13325,18 @@ var CLIENT_RESOLVER = {
   isReactiveValue: (value) => typeof value === "function"
 };
 function applyMetaEntry(metaProps, managedElements) {
-  let current = null;
+  let current2 = null;
   const retract = () => {
-    if (!current) return;
-    const index = managedElements.indexOf(current);
+    if (!current2) return;
+    const index = managedElements.indexOf(current2);
     if (index !== -1) managedElements.splice(index, 1);
-    current.remove();
-    current = null;
+    current2.remove();
+    current2 = null;
   };
   const alreadyPublished = (attributes) => {
-    if (!current || current.attributes.length !== attributes.size) return false;
+    if (!current2 || current2.attributes.length !== attributes.size) return false;
     for (const [name, value] of attributes) {
-      if (current.getAttribute(name) !== value) return false;
+      if (current2.getAttribute(name) !== value) return false;
     }
     return true;
   };
@@ -10092,16 +13344,16 @@ function applyMetaEntry(metaProps, managedElements) {
     if (alreadyPublished(attributes)) return;
     const next = document.createElement("meta");
     for (const [name, value] of attributes) next.setAttribute(name, value);
-    const index = current ? managedElements.indexOf(current) : -1;
-    if (current?.parentNode) {
-      current.replaceWith(next);
+    const index = current2 ? managedElements.indexOf(current2) : -1;
+    if (current2?.parentNode) {
+      current2.replaceWith(next);
     } else {
-      current?.remove();
+      current2?.remove();
       document.head.appendChild(next);
     }
     if (index !== -1) managedElements[index] = next;
     else managedElements.push(next);
-    current = next;
+    current2 = next;
   };
   const stopEffect = effect(() => {
     const plan = planMetaEntry(metaProps, CLIENT_RESOLVER);
@@ -10116,8 +13368,43 @@ function applyMetaEntry(metaProps, managedElements) {
     retract();
   };
 }
+function headEntryKey(tag, attrs) {
+  const lower = (v) => (v ?? "").toLowerCase();
+  if (tag === "meta") {
+    if (attrs.name) return `meta:name:${lower(attrs.name)}`;
+    if (attrs.property) return `meta:property:${lower(attrs.property)}`;
+    if (attrs["http-equiv"]) return `meta:http-equiv:${lower(attrs["http-equiv"])}`;
+    return `meta:${JSON.stringify(attrs)}`;
+  }
+  const rel = lower(attrs.rel);
+  if (rel === "canonical") return "link:rel:canonical";
+  if (rel === "alternate" && attrs.hreflang) return `link:hreflang:${lower(attrs.hreflang)}`;
+  return `link:${rel}:${attrs.href ?? ""}`;
+}
+function resolveHeadForServer(props) {
+  const layer = { tags: [] };
+  if (props.title != null) layer.title = CLIENT_RESOLVER.resolveValue("title", props.title);
+  for (const entry of props.meta ?? []) {
+    const plan = planMetaEntry(entry, CLIENT_RESOLVER);
+    if (plan.kind === "drop") continue;
+    const attrs = Object.fromEntries(plan.attributes);
+    layer.tags.push({ key: headEntryKey("meta", attrs), html: serializePlannedHeadEntry("meta", plan.attributes) });
+  }
+  for (const attrs of props.link ?? []) {
+    const html2 = serializeHeadEntry("link", attrs);
+    if (html2) layer.tags.push({ key: headEntryKey("link", attrs), html: html2 });
+  }
+  return layer;
+}
+function recordHeadForServer(props, anchor) {
+  const withdraw = recordServerHead(() => resolveHeadForServer(props));
+  if (!withdraw) return false;
+  registerDisposer(anchor, withdraw);
+  return true;
+}
 function Head(props) {
   const anchor = document.createComment("sibu-head");
+  if (getRequestStore()?.ssr && recordHeadForServer(props, anchor)) return anchor;
   const managedElements = [];
   const effectCleanups = [];
   const cleanup3 = () => {
@@ -10207,7 +13494,7 @@ function setCanonical(url) {
 }
 
 // src/platform/customElement.ts
-var SVG_NS4 = "http://www.w3.org/2000/svg";
+var SVG_NS5 = "http://www.w3.org/2000/svg";
 var MAX_RENDER_PASSES = 10;
 var ABANDONED_RENDER = /* @__PURE__ */ Symbol("sibujs.defineElement.abandonedRender");
 function defineElement(name, component, options = {}) {
@@ -10359,7 +13646,7 @@ function svgElement(tag, props = {}, ...nodes) {
   if (isBlockedElement(tag)) {
     throw new Error(`svgElement: refusing to create <${tag}> \u2014 tag is blocked for security reasons.`);
   }
-  const el = document.createElementNS(SVG_NS4, tag);
+  const el = document.createElementNS(SVG_NS5, tag);
   for (const [key, value] of Object.entries(props)) {
     if (key === "nodes") continue;
     if (typeof value === "function" && isEventHandlerAttr(key)) {
@@ -10553,7 +13840,7 @@ function createWorkerPool(workerFn2, poolSize) {
   }
   function dispatchOne(idx) {
     const w = workers[idx];
-    const slot2 = queues[idx].shift();
+    const slot4 = queues[idx].shift();
     const onMsg = (e) => {
       if (!firedOnce) {
         firedOnce = true;
@@ -10562,7 +13849,7 @@ function createWorkerPool(workerFn2, poolSize) {
       w.removeEventListener("message", onMsg);
       w.removeEventListener("error", onErr);
       inflight[idx] = null;
-      slot2.resolve(e.data);
+      slot4.resolve(e.data);
       dispatchNext(idx);
     };
     const onErr = (e) => {
@@ -10573,16 +13860,16 @@ function createWorkerPool(workerFn2, poolSize) {
       w.removeEventListener("message", onMsg);
       w.removeEventListener("error", onErr);
       inflight[idx] = null;
-      slot2.reject(new Error(e.message || "Worker error"));
+      slot4.reject(new Error(e.message || "Worker error"));
       dispatchNext(idx);
     };
     try {
-      w.postMessage(slot2.data);
+      w.postMessage(slot4.data);
     } catch (err) {
-      slot2.reject(toError(err));
+      slot4.reject(toError(err));
       return;
     }
-    inflight[idx] = { ...slot2, onMsg, onErr };
+    inflight[idx] = { ...slot4, onMsg, onErr };
     w.addEventListener("message", onMsg);
     w.addEventListener("error", onErr);
   }
@@ -10922,10 +14209,11 @@ function restoreFocusWithin(snapshot, nodes, where, policy) {
 // src/reactivity/bindChildNode.ts
 function bindChildNode(placeholder, getter) {
   let lastNodes = [];
+  const scope = captureScope();
   function commit() {
     let result;
     try {
-      result = getter();
+      result = inScope(scope, getter);
     } catch (err) {
       reportError(err, { phase: "binding", name: "bindChildNode", node: placeholder });
       return;
@@ -11001,7 +14289,7 @@ function noDocument() {
 }
 
 // src/core/rendering/tagFactory.ts
-var SVG_NS5 = "http://www.w3.org/2000/svg";
+var SVG_NS6 = "http://www.w3.org/2000/svg";
 var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "config",
   "location",
@@ -11019,7 +14307,7 @@ var warnedLoneStrings = /* @__PURE__ */ new Set();
 var MAX_WARNED_LONE_STRINGS = 100;
 var loneStringCapAnnounced = false;
 var kebabCache = /* @__PURE__ */ new Map();
-function toKebab(prop) {
+function toKebab2(prop) {
   let cached = kebabCache.get(prop);
   if (cached !== void 0) return cached;
   cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
@@ -11049,7 +14337,7 @@ function applyStyle(el, style2) {
         if (!Object.hasOwn(value, prop)) continue;
         const val = value[prop];
         if (val == null) continue;
-        const name = toKebab(prop);
+        const name = toKebab2(prop);
         next.push(name);
         decl.setProperty(name, sanitizeCSSDeclaration(name, String(val), { element: el }));
       }
@@ -11069,7 +14357,7 @@ function applyStyle(el, style2) {
   for (const prop in style2) {
     if (!Object.hasOwn(style2, prop)) continue;
     const val = style2[prop];
-    const name = toKebab(prop);
+    const name = toKebab2(prop);
     if (typeof val === "function") {
       const getter = val;
       const teardown = reactiveBinding2(() => {
@@ -11181,7 +14469,7 @@ function tagFactory(tag, ns) {
       throw new Error(`tagFactory: refusing to create <${tag}> \u2014 tag is blocked for security reasons.`);
     }
     if (typeof document === "undefined") noDocument();
-    const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+    const el = createScopedElement(tag, ns);
     if (first === void 0) return el;
     if (typeof first === "string") {
       if (second !== void 0) {
@@ -11356,7 +14644,7 @@ var param = tagFactory("param");
 var picture = tagFactory("picture");
 var portal = tagFactory("portal");
 var source = tagFactory("source");
-var svg = tagFactory("svg", SVG_NS5);
+var svg = tagFactory("svg", SVG_NS6);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -11391,32 +14679,32 @@ var details = tagFactory("details");
 var dialog2 = tagFactory("dialog");
 var menu = tagFactory("menu");
 var summary = tagFactory("summary");
-var slot = tagFactory("slot");
+var slot3 = tagFactory("slot");
 var template = tagFactory("template");
 var base = tagFactory("base");
 var link = tagFactory("link");
 var meta = tagFactory("meta");
 var style = tagFactory("style");
-var circle = tagFactory("circle", SVG_NS5);
-var ellipse = tagFactory("ellipse", SVG_NS5);
-var g = tagFactory("g", SVG_NS5);
-var line = tagFactory("line", SVG_NS5);
-var path = tagFactory("path", SVG_NS5);
-var polygon = tagFactory("polygon", SVG_NS5);
-var polyline = tagFactory("polyline", SVG_NS5);
-var rect = tagFactory("rect", SVG_NS5);
-var text = tagFactory("text", SVG_NS5);
-var tspan = tagFactory("tspan", SVG_NS5);
-var defs = tagFactory("defs", SVG_NS5);
-var clipPath = tagFactory("clipPath", SVG_NS5);
-var mask = tagFactory("mask", SVG_NS5);
-var pattern = tagFactory("pattern", SVG_NS5);
-var linearGradient = tagFactory("linearGradient", SVG_NS5);
-var radialGradient = tagFactory("radialGradient", SVG_NS5);
-var stop = tagFactory("stop", SVG_NS5);
-var use = tagFactory("use", SVG_NS5);
-var symbol = tagFactory("symbol", SVG_NS5);
-var marker = tagFactory("marker", SVG_NS5);
+var circle = tagFactory("circle", SVG_NS6);
+var ellipse = tagFactory("ellipse", SVG_NS6);
+var g = tagFactory("g", SVG_NS6);
+var line = tagFactory("line", SVG_NS6);
+var path = tagFactory("path", SVG_NS6);
+var polygon = tagFactory("polygon", SVG_NS6);
+var polyline = tagFactory("polyline", SVG_NS6);
+var rect = tagFactory("rect", SVG_NS6);
+var text = tagFactory("text", SVG_NS6);
+var tspan = tagFactory("tspan", SVG_NS6);
+var defs = tagFactory("defs", SVG_NS6);
+var clipPath = tagFactory("clipPath", SVG_NS6);
+var mask = tagFactory("mask", SVG_NS6);
+var pattern = tagFactory("pattern", SVG_NS6);
+var linearGradient = tagFactory("linearGradient", SVG_NS6);
+var radialGradient = tagFactory("radialGradient", SVG_NS6);
+var stop = tagFactory("stop", SVG_NS6);
+var use = tagFactory("use", SVG_NS6);
+var symbol = tagFactory("symbol", SVG_NS6);
+var marker = tagFactory("marker", SVG_NS6);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -11762,13 +15050,13 @@ function createISR(options) {
     if (inFlight) return inFlight;
     let resolve;
     let reject;
-    const current = new Promise((res, rej) => {
+    const current2 = new Promise((res, rej) => {
       resolve = res;
       reject = rej;
     });
-    inFlight = current;
+    inFlight = current2;
     const release = () => {
-      if (inFlight === current) inFlight = null;
+      if (inFlight === current2) inFlight = null;
     };
     run().then(
       () => {
@@ -11780,7 +15068,7 @@ function createISR(options) {
         reject(err);
       }
     );
-    return current;
+    return current2;
   };
   if (initialData === void 0) {
     revalidate().catch((err) => {
@@ -11951,7 +15239,7 @@ function createMiddlewareChain() {
 
 // src/plugins/plugin.ts
 var CANCELLED_BRAND = /* @__PURE__ */ Symbol.for("sibujs.plugins.installCancelled.v1");
-var _a;
+var _a3;
 var PluginInstallCancelledError = class extends Error {
   constructor(pluginName) {
     super(`[Plugin] Installation of "${pluginName}" was cancelled before it was committed (registry reset).`);
@@ -11960,11 +15248,11 @@ var PluginInstallCancelledError = class extends Error {
      * 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[_a3] = true;
     this.name = "PluginInstallCancelledError";
     this.pluginName = pluginName;
   }
-  static [(_a = CANCELLED_BRAND, Symbol.hasInstance)](value) {
+  static [(_a3 = CANCELLED_BRAND, Symbol.hasInstance)](value) {
     return isPluginInstallCancelledError(value);
   }
 };
@@ -11978,7 +15266,7 @@ function createPluginRegistry() {
   const installStack = /* @__PURE__ */ new Set();
   const pendingInstalls = /* @__PURE__ */ new Map();
   let generation = 0;
-  const registry = {
+  const registry2 = {
     installedPlugins,
     hooks,
     provided,
@@ -12118,7 +15406,7 @@ function createPluginRegistry() {
       provided.clear();
     }
   };
-  return registry;
+  return registry2;
 }
 var _defaults = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.plugins.defaultRegistry.v1"), () => ({
   registry: createPluginRegistry(),
@@ -12147,13 +15435,13 @@ function resetPlugins() {
   _defaults.registry.reset();
   _defaults.touched = false;
 }
-function setDefaultPluginRegistry(registry) {
+function setDefaultPluginRegistry(registry2) {
   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.registry = registry2;
   _defaults.touched = true;
 }
 
@@ -12300,6 +15588,7 @@ var MODULE_ENTRY_POINTS = {
   ui: "./ui.ts",
   widgets: "./widgets.ts",
   ssr: "./ssr.ts",
+  "ssr/dom": "./ssr-dom.ts",
   devtools: "./devtools.ts",
   performance: "./performance.ts",
   ecosystem: "./ecosystem.ts",
@@ -12316,7 +15605,7 @@ var CDN_ENTRY_POINTS = {
 };
 var packageInfo = {
   name: "sibujs",
-  version: true ? "4.13.1" : "dev",
+  version: true ? "4.14.1" : "dev",
   entryPoints: MODULE_ENTRY_POINTS,
   /**
    * Generate the package.json `exports` map. Module entries resolve to the
@@ -12461,7 +15750,7 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = true ? "4.13.1" : "dev";
+var VERSION = true ? "4.14.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-]+";
@@ -15873,9 +19162,9 @@ function componentAdapter(config) {
     components[name] = (props = {}, children) => {
       const { variant, size, class: userClass, ...rest } = props;
       const themeClasses = () => {
-        const current = theme.config();
-        const overrides = current.classOverrides ?? {};
-        const pick = (key, fallback) => Object.hasOwn(overrides, key) ? overrides[key] : reprefix(fallback, current.prefix);
+        const current2 = theme.config();
+        const overrides = current2.classOverrides ?? {};
+        const pick = (key, fallback) => Object.hasOwn(overrides, key) ? overrides[key] : reprefix(fallback, current2.prefix);
         const classes = [pick(name, mapping.baseClass)];
         const variantClass = ownString(mapping.variants, variant);
         if (variant && variantClass) {
@@ -16129,6 +19418,7 @@ var materialAdapter = componentAdapter(materialConfig);
   announce,
   antdAdapter,
   aria,
+  assembleDocument,
   assertType,
   battery,
   bindAttrs,
@@ -16325,6 +19615,7 @@ var materialAdapter = componentAdapter(materialConfig);
   renderToReadableStream,
   renderToStream,
   renderToString,
+  renderToStringWith,
   renderToSuspenseStream,
   renderWithLoader,
   required,
@@ -16403,6 +19694,7 @@ var materialAdapter = componentAdapter(materialConfig);
   withRetry,
   withScopedStyle,
   withWrapper,
+  withholdTransfer,
   worker,
   workerFn,
   yieldToMain,