sibujs 4.13.0 → 4.14.0

package/dist/chunk-BOYKGGVD.js

@@ -0,0 +1,2015 @@
+import {
+  ensureServerDom,
+  explainServerError,
+  watchBrowserApis
+} from "./chunk-CNPT6NKV.js";
+import {
+  embedSerializationTail,
+  embedSerializedAttribute,
+  getEmbedRecord
+} from "./chunk-LJMX4SQ7.js";
+import {
+  collectTransfer
+} from "./chunk-3HZOSMPX.js";
+import {
+  readOwnGlobal
+} from "./chunk-62BDYGAG.js";
+import {
+  isCodeTextElement,
+  isForbiddenMetaEntry,
+  isForbiddenMetaSnapshot,
+  isRefusedAnimationAttribute,
+  resolveMetaRefreshPolicy
+} from "./chunk-RVWJGWCL.js";
+import {
+  canonicalAttrName,
+  isEventHandlerAttr,
+  isHtmlContentAttribute,
+  resolveAttributeValue,
+  sanitizeUrl
+} from "./chunk-B3HOT4TK.js";
+import {
+  assertRequestIsolation,
+  getRequestStore,
+  getSSRStore,
+  isServer,
+  requestSlot,
+  runInBoundary,
+  runInSSRContext,
+  setBoundaryHook
+} from "./chunk-UYTYNCMZ.js";
+import {
+  untracked
+} from "./chunk-MIRKTVH4.js";
+import {
+  dispose,
+  replaceChildrenSafely
+} from "./chunk-S37PZD6I.js";
+import {
+  DEV,
+  beginHydration,
+  inAdoptScope,
+  inHydration,
+  inScope
+} from "./chunk-NT3ZYB5S.js";
+
+// src/utils/headEntry.ts
+var SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
+function isEmittableHeadAttrName(name) {
+  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
+  const canonical = canonicalAttrName(name);
+  if (isEventHandlerAttr(canonical)) return false;
+  if (isHtmlContentAttribute(canonical)) return false;
+  return true;
+}
+function sanitizeHeadAttrValue(canonical, value) {
+  return resolveAttributeValue(canonical, value);
+}
+function findDuplicateAttributeName(names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const canonical = canonicalAttrName(name);
+    if (seen.has(canonical)) return canonical;
+    seen.add(canonical);
+  }
+  return null;
+}
+function planEntry(props, resolver, applyRefreshPolicy) {
+  const rawNames = Object.keys(props);
+  const duplicate = findDuplicateAttributeName(rawNames);
+  if (duplicate !== null) {
+    return { kind: "drop", reason: `duplicate case-insensitive attribute ${JSON.stringify(duplicate)}` };
+  }
+  const attributes = /* @__PURE__ */ new Map();
+  let reactive = false;
+  for (const name of rawNames) {
+    if (!Object.hasOwn(props, name)) continue;
+    if (!isEmittableHeadAttrName(name)) continue;
+    const authored = props[name];
+    if (resolver.isReactiveValue?.(authored)) reactive = true;
+    const canonical = canonicalAttrName(name);
+    const sanitized = sanitizeHeadAttrValue(canonical, resolver.resolveValue(name, authored));
+    if (sanitized === null) continue;
+    attributes.set(canonical, sanitized);
+  }
+  if (attributes.size === 0) return { kind: "drop", reason: "no effective attributes remain" };
+  const refresh = applyRefreshPolicy ? resolveMetaRefreshPolicy(attributes) : { kind: "not-refresh" };
+  if (refresh.kind === "forbidden") return { kind: "drop", reason: refresh.reason };
+  if (reactive && (refresh.kind === "allowed" || refresh.kind === "delay-only")) {
+    return { kind: "drop", reason: "a reactive meta entry may not publish a native refresh directive" };
+  }
+  return { kind: "publish", attributes, refresh };
+}
+function planMetaEntry(props, resolver) {
+  return planEntry(props, resolver, true);
+}
+function planHeadElementEntry(props, resolver) {
+  return planEntry(props, resolver, false);
+}
+var STATIC_VALUE_RESOLVER = {
+  resolveValue: (_name, value) => String(value)
+};
+function escapeHeadAttrValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeHeadEntry(tag, attrs) {
+  const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
+  if (plan.kind === "drop") return "";
+  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/serverHead.ts
+function headSlot() {
+  return requestSlot("head", () => ({ layers: [] }));
+}
+function recordServerHead(source) {
+  const slot = headSlot();
+  if (!slot) return null;
+  const entry = { source };
+  slot.layers.push(entry);
+  return () => {
+    if (entry.source === null) return;
+    entry.source = null;
+    const index = slot.layers.indexOf(entry);
+    if (index !== -1) slot.layers.splice(index, 1);
+  };
+}
+function collectServerHead() {
+  const slot = headSlot();
+  if (!slot || slot.layers.length === 0) return "";
+  let title;
+  const order = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of slot.layers.slice()) {
+    const source = entry.source;
+    if (source === null) continue;
+    let layer;
+    try {
+      layer = typeof source === "function" ? untracked(source) : source;
+    } 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) title = 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 (title != null) out.push(`<title>${escapeText(title)}</title>`);
+  for (const key of order) out.push(byKey.get(key));
+  return out.join("\n    ");
+}
+function escapeText(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/platform/ssrAsync.ts
+var DEFAULT_SETTLE_TIMEOUT = 5e3;
+var DEFAULT_TRANSFER_MAX_BYTES = 1024 * 1024;
+var TRANSFER_GLOBAL = "__SIBU_TRANSFER__";
+var macrotask = () => new Promise((resolve) => {
+  if (typeof setImmediate === "function") setImmediate(resolve);
+  else setTimeout(resolve, 0);
+});
+async function settled(_root, options = {}) {
+  const store = getRequestStore();
+  const timeout = options.timeout ?? DEFAULT_SETTLE_TIMEOUT;
+  const deadline = Date.now() + timeout;
+  for (; ; ) {
+    await macrotask();
+    const pending = store?.pending;
+    if (!pending || pending.size === 0) {
+      await macrotask();
+      if (!pending || pending.size === 0) return { timedOut: false, pending: [] };
+      continue;
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return { timedOut: true, pending: describePending(pending) };
+    await new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        if (store && store.wake === done) store.wake = null;
+        resolve();
+      };
+      const timer = setTimeout(done, remaining);
+      if (store) store.wake = done;
+    });
+  }
+}
+function describePending(pending) {
+  const now = Date.now();
+  return Array.from(pending, (work) => `${work.label} (${now - work.since} ms)`);
+}
+function formatRenderDiagnostics(d, label = "render") {
+  const lines = [
+    `[SibuJS SSR] ${label}: ${d.durationMs} ms, ${d.timedOut ? "TIMED OUT (serialized with fallbacks)" : "settled"}`
+  ];
+  if (d.pending.length > 0) lines.push(`  pending at the timeout: ${d.pending.join(", ")}`);
+  if (d.browserApis.length > 0) lines.push(`  browser-only APIs read: ${d.browserApis.join("; ")}`);
+  if (d.stateBytes > 0) {
+    lines.push(
+      `  transferred state: ${d.stateBytes} B; largest: ${d.largestState.map((e) => `${e.key} (${e.bytes} B)`).join(", ")}`
+    );
+  }
+  if (d.droppedState.length > 0) lines.push(`  left out of the state: ${d.droppedState.join(", ")}`);
+  return lines.join("\n");
+}
+function describeNodePath(node) {
+  const parts = [];
+  let current = node;
+  while (current && parts.length < 8) {
+    if (current.nodeType === 1) {
+      const el = current;
+      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);
+    }
+    current = current.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 label = entry.context.name ? ` in ${entry.context.name}` : "";
+  return new Error(`[SibuJS SSR] render failed${label} at ${where}: ${message}`, { cause: error });
+}
+function byteLength(text) {
+  return typeof TextEncoder !== "undefined" ? new TextEncoder().encode(text).byteLength : text.length;
+}
+function buildTransfer(data, maxBytes, nonce) {
+  var _a;
+  const entries = [];
+  const dropped = [];
+  for (const section of Object.keys(data)) {
+    if (section === "v") continue;
+    const sectionEntries = data[section];
+    for (const key of Object.keys(sectionEntries)) {
+      let json;
+      try {
+        json = JSON.stringify(sectionEntries[key]);
+      } catch {
+        json = void 0;
+      }
+      if (json === void 0) {
+        dropped.push(`${section}:${key}`);
+        continue;
+      }
+      entries.push({ section, key, value: sectionEntries[key], bytes: byteLength(json) + byteLength(key) + 4 });
+    }
+  }
+  entries.sort((a, b) => b.bytes - a.bytes);
+  const largest = entries.slice(0, 5).map((e) => ({ key: `${e.section}:${e.key}`, bytes: e.bytes }));
+  let total = entries.reduce((sum, e) => sum + e.bytes, 0);
+  let start = 0;
+  while (total > maxBytes && start < entries.length) {
+    dropped.push(`${entries[start].section}:${entries[start].key}`);
+    total -= entries[start].bytes;
+    start++;
+  }
+  const kept = entries.slice(start);
+  if (dropped.length > 0 && DEV) {
+    console.warn(
+      `[SibuJS SSR] transferred state exceeded ${maxBytes} bytes or was not serializable; left out: ${dropped.join(", ")}. Largest entries: ${largest.map((e) => `${e.key} (${e.bytes} B)`).join(", ")}. Those queries fetch again in the browser. Raise \`maxStateBytes\` or mark them \`ssr: false\`.`
+    );
+  }
+  if (kept.length === 0) return { script: "", data: null, bytes: 0, largest, dropped };
+  const out = { v: data.v };
+  for (const e of kept) {
+    const section = out[_a = e.section] ?? (out[_a] = /* @__PURE__ */ Object.create(null));
+    section[e.key] = e.value;
+  }
+  const script = serializeState(out, nonce, { maxBytes: Math.max(maxBytes * 2, 1024), global: TRANSFER_GLOBAL });
+  return { script, data: out, bytes: total, largest, dropped };
+}
+async function renderCore(input, options) {
+  const started = Date.now();
+  const store = getRequestStore();
+  const errors = [];
+  if (store) store.errors = errors;
+  ensureServerDom();
+  watchBrowserApis();
+  const ids = options.hydration === "adopt" ? /* @__PURE__ */ new WeakMap() : null;
+  const scope = ids ? createServerAdoptScope(ids) : null;
+  let root;
+  try {
+    root = typeof input === "function" ? inScope(scope, input) : input;
+  } catch (err) {
+    if (store) store.errors = void 0;
+    throw explainServerError(err);
+  }
+  const holder = document.createDocumentFragment();
+  holder.appendChild(root);
+  const settle = await settled(holder, { timeout: options.timeout });
+  if (store) store.errors = void 0;
+  const releaseTree = () => {
+    for (const child of Array.from(holder.childNodes)) dispose(child);
+  };
+  if (errors.length > 0) {
+    releaseTree();
+    throw renderFailure(errors[0]);
+  }
+  if (settle.timedOut && DEV) {
+    console.warn(
+      `[SibuJS SSR] render did not settle within ${options.timeout ?? DEFAULT_SETTLE_TIMEOUT} ms; serialized with fallbacks for: ${settle.pending.join(", ")}`
+    );
+  }
+  const content = renderToStringWith(holder, { marker: options.marker ?? "root", ids });
+  let head;
+  try {
+    head = collectServerHead();
+  } catch (err) {
+    releaseTree();
+    throw err;
+  }
+  let state = "";
+  let stateData = null;
+  let stateBytes = 0;
+  let largestState = [];
+  let droppedState = [];
+  if (options.transfer !== false) {
+    const collected = collectTransfer();
+    if (collected) {
+      const built = buildTransfer(collected, options.maxStateBytes ?? DEFAULT_TRANSFER_MAX_BYTES, options.nonce);
+      state = built.script;
+      stateData = built.data;
+      stateBytes = built.bytes;
+      largestState = built.largest;
+      droppedState = built.dropped;
+    }
+  }
+  releaseTree();
+  const browserApis = Array.from(store?.slots?.get("browserApis") ?? []);
+  const diagnostics = {
+    timedOut: settle.timedOut,
+    pending: settle.pending,
+    browserApis,
+    stateBytes,
+    largestState,
+    droppedState,
+    durationMs: Date.now() - started
+  };
+  if (DEV && options.log) {
+    console.info(formatRenderDiagnostics(diagnostics, typeof options.log === "string" ? options.log : void 0));
+  }
+  return { content, result: { head, state, stateData, status: 200, diagnostics } };
+}
+function inRequest(api, fn) {
+  try {
+    assertRequestIsolation(api);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+  return getRequestStore() ? fn() : runInSSRContext(fn);
+}
+function renderToStringAsync(input, options = {}) {
+  return inRequest("renderToStringAsync()", async () => {
+    const { content, result } = await renderCore(input, options);
+    return { html: content, ...result };
+  });
+}
+function renderToDocumentAsync(input, options = {}) {
+  return inRequest("renderToDocumentAsync()", async () => {
+    const { content, result } = await renderCore(input, options);
+    return { html: assembleDocument(content, options, result.head, result.state), ...result };
+  });
+}
+
+// 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(select) {
+  const options = Array.from(select.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(a, b) {
+  return a.nodeType === b.nodeType && (a.nodeType === 3 || a.nodeType === 8);
+}
+function isOptionDisabled(option) {
+  const parent = option.parentElement;
+  return option.disabled || parent?.localName === "optgroup" && parent.hasAttribute("disabled");
+}
+function defaultSelection(select) {
+  const options = Array.from(select.options);
+  const parsed = reparsedSelection(select, options);
+  if (parsed) return parsed;
+  const marked = options.filter((o) => o.hasAttribute("selected"));
+  if (select.multiple) return new Set(marked);
+  if (marked.length > 0) return /* @__PURE__ */ new Set([marked[marked.length - 1]]);
+  if (select.size > 1) return /* @__PURE__ */ new Set();
+  const first = options.find((o) => !isOptionDisabled(o));
+  return new Set(first ? [first] : []);
+}
+function reparsedSelection(select, options) {
+  if (typeof DOMParser !== "function") return null;
+  try {
+    const doc = new DOMParser().parseFromString(`<!doctype html><body>${select.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, i) => {
+      if (o.selected) chosen.add(options[i]);
+    });
+    return chosen;
+  } catch {
+    return null;
+  }
+}
+function isDirty(el) {
+  const tag = el.localName;
+  if (tag === "input") {
+    const input = el;
+    if (input.type === "checkbox" || input.type === "radio") return input.checked !== input.hasAttribute("checked");
+    return input.value !== (input.getAttribute("value") ?? "");
+  }
+  if (tag === "textarea") return el.value !== (el.textContent ?? "");
+  if (tag === "select") {
+    const select = el;
+    const initial = defaultSelection(select);
+    return Array.from(select.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 input = child;
+              if (input.type === "checkbox" || input.type === "radio") this.checks.set(input, input.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 text = value == null ? "" : String(value);
+          const only = this.firstChild;
+          if (only && only === this.lastChild && only.nodeType === 3 && only.data === text) {
+            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(select, snapshot) {
+  const options = Array.from(select.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 [select, snapshot] of session.selections) {
+    if (!session.claimed.has(select) || !session.root.contains(select)) {
+      session.touched.delete(select);
+      continue;
+    }
+    if (snapshot.chosen.length === 0) {
+      select.selectedIndex = -1;
+      continue;
+    }
+    const keep = survivingSelection(select, snapshot);
+    if (keep.size === 0) {
+      session.touched.delete(select);
+      continue;
+    }
+    if (select.multiple) for (const o of Array.from(select.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 p = proto; p; p = Object.getPrototypeOf(p)) {
+    const d = Object.getOwnPropertyDescriptor(p, key);
+    if (d) return d;
+  }
+  return void 0;
+}
+var macrotask2 = () => 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 macrotask2();
+      if (pending.size === 0) {
+        await macrotask2();
+        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;
+}
+function readProps(root) {
+  const raw = root.getAttribute(ISLAND_PROPS_ATTR);
+  if (raw === null) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function islandComponent(component, validate) {
+  return (ctx) => {
+    const props = readProps(ctx.root);
+    if (validate && !validate(props)) {
+      throw new Error(`[SibuJS islands] props of "${ctx.root.getAttribute("data-sibu-island")}" failed validation`);
+    }
+    let disposed = false;
+    const settle = () => {
+      if (disposed) for (const child of Array.from(ctx.root.childNodes)) dispose(child);
+    };
+    hydrateAdopt(() => component(props), ctx.root).then(settle, (err) => {
+      settle();
+      if (typeof console !== "undefined") {
+        console.error(`[SibuJS islands] "${ctx.root.getAttribute("data-sibu-island")}" failed to hydrate:`, err);
+      }
+    });
+    return () => {
+      disposed = true;
+      for (const child of Array.from(ctx.root.childNodes)) dispose(child);
+    };
+  };
+}
+
+// src/platform/ssrStream.ts
+var hookInstalled = false;
+function installHook() {
+  if (hookInstalled) return;
+  hookInstalled = true;
+  setBoundaryHook((container) => {
+    const state = requestSlot("stream");
+    const store = getRequestStore();
+    if (!state || !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 && state.serialize) {
+            record.fallbackHtml = Array.from(container.childNodes, (n) => state.serialize?.(n) ?? "").join("");
+          }
+          return runInBoundary(record.api, fn);
+        },
+        done: () => {
+          record.done = true;
+          store.wake?.();
+        }
+      }
+    };
+    state.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 macrotask3 = () => new Promise((resolve) => {
+  if (typeof setImmediate === "function") setImmediate(resolve);
+  else setTimeout(resolve, 0);
+});
+async function waitFor(ready, deadline, stop) {
+  const store = getRequestStore();
+  for (; ; ) {
+    await macrotask3();
+    if (stop()) return false;
+    if (ready()) {
+      await macrotask3();
+      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(input, 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 state = { boundaries: [], serialize: null };
+    requestSlot("stream", () => state);
+    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, input);
+      } catch (err) {
+        throw explainServerError(err);
+      }
+      const serialize = (node) => renderToStringWith(node, { marker: options.marker ?? "root", ids });
+      state.serialize = serialize;
+      holder = document.createDocumentFragment();
+      holder.appendChild(root);
+      const ready = (b) => b.done && !pendingFor(store?.pending, b.api);
+      const serializeWithFallbacks = (node) => {
+        const held = [];
+        for (const b of state.boundaries) {
+          if (ready(b) || b.container === node || !node.contains(b.container)) continue;
+          if (held.some((h) => h.b.container.contains(b.container))) continue;
+          const nodes = Array.from(b.container.childNodes);
+          for (const n of nodes) b.container.removeChild(n);
+          const mark = document.createComment(`sibu-fallback:${b.id}`);
+          b.container.appendChild(mark);
+          held.push({ b, nodes, mark });
+        }
+        let html = serialize(node);
+        for (const { b, nodes, mark } of held) {
+          b.container.removeChild(mark);
+          for (const n of nodes) b.container.appendChild(n);
+          const fallback = b.fallbackHtml ?? "";
+          html = html.replace(`<!--sibu-fallback:${b.id}-->`, () => fallback);
+        }
+        return html;
+      };
+      const shellDeadline = Date.now() + (options.shellTimeout ?? 5e3);
+      await waitFor(() => !pendingFor(store?.pending, void 0), shellDeadline, stopWaiting);
+      failIfErrored();
+      if (channel.cancelled) return;
+      for (const b of state.boundaries) {
+        const inline = (x) => x.done && !pendingFor(store?.pending, x.api);
+        const enclosing = state.boundaries.filter((a) => a !== b && a.container.contains(b.container));
+        if (inline(b) && enclosing.every(inline)) b.emitted = true;
+      }
+      const shell = serializeWithFallbacks(holder);
+      const head = collectServerHead();
+      let after = "";
+      let between = "";
+      if (doc) {
+        const page = assembleDocument(MARK_BODY, doc, head, 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 = () => state.boundaries.filter((b) => !b.emitted);
+      const ancestorsOf = (b) => state.boundaries.filter((a) => a !== b && a.container.contains(b.container));
+      const emittable = (b) => ready(b) && ancestorsOf(b).every((a) => a.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 b of state.boundaries) {
+          if (b === next || !next.container.contains(b.container) || !ready(b)) continue;
+          const between2 = ancestorsOf(b).filter((a) => a !== next && next.container.contains(a.container));
+          if (between2.every(ready)) b.emitted = true;
+        }
+        next.emitted = true;
+        if (!next.container.isConnected && !holder.contains(next.container)) continue;
+        let html = "";
+        for (const child of Array.from(next.container.childNodes)) html += serializeWithFallbacks(child);
+        await channel.push(
+          `<div hidden id="sibu-resolved-${next.id}">${html}</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 data = collectTransfer();
+        if (data) {
+          try {
+            stateScript = serializeState(data, 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(text) {
+  return text.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 p = proto; p; p = Object.getPrototypeOf(p)) {
+    const get = Object.getOwnPropertyDescriptor(p, 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;
+}
+function tagNameOf(el) {
+  const get = nativeAccessors().tagName;
+  return get ? get.call(el) : el.tagName;
+}
+function childNodesOf(node) {
+  const get = nativeAccessors().childNodes;
+  return get ? get.call(node) : node.childNodes;
+}
+function getAttributeOf(el, name) {
+  return nativeAccessors().getAttribute.call(el, name);
+}
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var XMLNS_NS = "http://www.w3.org/2000/xmlns/";
+var BREAKOUT_TAGS = /* @__PURE__ */ new Set([
+  "b",
+  "big",
+  "blockquote",
+  "body",
+  "br",
+  "center",
+  "code",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "hr",
+  "i",
+  "img",
+  "li",
+  "listing",
+  "menu",
+  "meta",
+  "nobr",
+  "ol",
+  "p",
+  "pre",
+  "ruby",
+  "s",
+  "small",
+  "span",
+  "strong",
+  "strike",
+  "sub",
+  "sup",
+  "table",
+  "tt",
+  "u",
+  "ul",
+  "var"
+]);
+function isBreakout(lowerName, element) {
+  if (BREAKOUT_TAGS.has(lowerName)) return true;
+  return lowerName === "font" && (element.hasAttribute("color") || element.hasAttribute("face") || element.hasAttribute("size"));
+}
+function fitsParseContext(ns, lowerName, element, context) {
+  if (ns === SVG_NS) {
+    if (context === 1 /* Svg */) return !isBreakout(lowerName, element);
+    return lowerName === "svg" && (context === 0 /* Html */ || context === 3 /* Annotation */);
+  }
+  if (ns === MATHML_NS) {
+    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_NS) {
+    return lowerName === "foreignobject" || lowerName === "desc" || lowerName === "title" ? 0 /* Html */ : 1 /* Svg */;
+  }
+  if (ns === MATHML_NS) {
+    if (lowerName === "mi" || lowerName === "mo" || lowerName === "mn" || lowerName === "ms" || lowerName === "mtext") {
+      return 0 /* Html */;
+    }
+    if (lowerName === "annotation-xml") {
+      const encoding = (element.getAttribute("encoding") ?? "").toLowerCase();
+      return encoding === "text/html" || encoding === "application/xhtml+xml" ? 0 /* Html */ : 3 /* Annotation */;
+    }
+    return 2 /* Math */;
+  }
+  return 0 /* Html */;
+}
+function foreignAttrName(attr) {
+  const ns = attr.namespaceURI;
+  if (ns === XLINK_NS) return `xlink:${attr.localName}`;
+  if (ns === XML_NS) return `xml:${attr.localName}`;
+  if (ns === XMLNS_NS) return attr.localName === "xmlns" ? "xmlns" : `xmlns:${attr.localName}`;
+  return attr.name;
+}
+var LEGACY_SERIALIZE = { marker: "all", ids: null };
+function serializeOpenTag(element, tag, foreign, opts, depth) {
+  let html = `<${tag}`;
+  const meta = tag === "meta" && !foreign ? /* @__PURE__ */ new Map() : null;
+  const embed = tag === "iframe" && !foreign ? getEmbedRecord(element) : void 0;
+  const embedSeen = embed ? { sandbox: false, referrer: false, title: false, fullscreen: false } : null;
+  const attrs = attributesOf(element);
+  for (let i = 0; i < attrs.length; i++) {
+    const attr = attrs[i];
+    const rawName = foreign ? foreignAttrName(attr) : attr.name;
+    if (!isSafeAttrName(rawName)) continue;
+    if (isEventHandlerAttr(rawName)) continue;
+    if (isForbiddenSsrAttr(rawName)) continue;
+    const lowerName = rawName.toLowerCase();
+    let value = resolveAttributeValue(lowerName, attr.value);
+    if (value === null) continue;
+    if (foreign && isRefusedAnimationAttribute(element, rawName, value)) continue;
+    if (embed && embedSeen) {
+      value = embedSerializedAttribute(embed, embedSeen, lowerName, value);
+      if (value === null) continue;
+    }
+    meta?.set(rawName, value);
+    html += ` ${rawName}="${escapeAttr(value)}"`;
+  }
+  if (meta && isForbiddenMetaSnapshot(meta)) return null;
+  if (embed && embedSeen) {
+    const tail = embedSerializationTail(embed, embedSeen);
+    if (tail === null) return null;
+    html += tail;
+  }
+  const hid = opts.ids?.get(element);
+  if (hid !== void 0) html += ` data-sibu-h="${hid}"`;
+  if ((opts.marker === "all" || opts.marker === "root" && depth === 0) && !getAttributeOf(element, "data-sibu-hydrate")) {
+    html += ` data-sibu-ssr="true"`;
+  }
+  return html;
+}
+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_NS && ns2 !== MATHML_NS) return escapeHtml(node.textContent || "");
+    foreign = true;
+  }
+  const element = node;
+  const tag = foreign ? element.localName : tagNameOf(element).toLowerCase();
+  if (isCodeTextElement(tag)) return DEV ? `<!--ssr:${tag}-stripped-->` : "";
+  if (!/^[a-z][a-z0-9-]*$/i.test(tag)) return DEV ? "<!--ssr:invalid-tag-->" : "";
+  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, 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} />`;
+  return {
+    open: `${openTag}>`,
+    close: `</${tag}>`,
+    children: Array.from(children),
+    context: childParseContext(ns, lowerName, element)
+  };
+}
+function renderToString(element) {
+  return renderNodeToString(element, 0 /* Html */, LEGACY_SERIALIZE, 0);
+}
+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 sep + renderNodeToString(child, context, opts, depth);
+      } catch (err) {
+        return ssrErrorComment(err);
+      }
+    }).join("");
+  }
+  const frame = serializeNode(element, context, opts, depth);
+  if (typeof frame === "string") return frame;
+  let html = frame.open;
+  let prevText = false;
+  for (const child of frame.children) {
+    const isText = child.nodeType === 3;
+    if (opts.ids && isText && prevText) html += "<!--|-->";
+    prevText = isText;
+    try {
+      html += renderNodeToString(child, frame.context, opts, depth + 1);
+    } catch (err) {
+      html += ssrErrorComment(err);
+    }
+  }
+  return html + frame.close;
+}
+function hydrate(component, target, input = {}) {
+  if (input.strategy === "adopt") return hydrateAdopt(component, target, input);
+  const options = input;
+  const container = target;
+  const clientTree = component();
+  if (options.diagnostics) {
+    const mismatches = [];
+    collectMismatches(container.firstElementChild, clientTree, "", mismatches);
+    if (mismatches.length > 0) {
+      const first = mismatches[0];
+      if (options.onMismatch) {
+        options.onMismatch(first);
+      } else if (DEV) {
+        console.warn(
+          `[SibuJS hydration] ${first.message}
+  at ${first.path}
+  server: ${first.serverValue}
+  client: ${first.clientValue}`
+        );
+      }
+    }
+  }
+  replaceChildrenSafely(container, clientTree);
+  container.setAttribute("data-sibu-hydrated", "true");
+}
+function directTextOf(node) {
+  let out = "";
+  for (const child of Array.from(node.childNodes)) {
+    if (child.nodeType === 3) out += child.nodeValue ?? "";
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function disposeAndReplace(outgoing, next) {
+  dispose(outgoing);
+  outgoing.replaceWith(next);
+}
+function collectMismatches(serverNode, clientNode, path, out, max = 5) {
+  if (out.length >= max) return;
+  const nodePath = path || clientNode?.tagName?.toLowerCase() || "(root)";
+  if (!serverNode && clientNode) {
+    out.push({
+      kind: "child-count",
+      path: nodePath,
+      serverValue: "(missing)",
+      clientValue: clientNode.tagName.toLowerCase(),
+      message: "Client rendered a node that the server did not emit."
+    });
+    return;
+  }
+  if (serverNode && !clientNode) {
+    out.push({
+      kind: "child-count",
+      path: nodePath,
+      serverValue: serverNode.tagName.toLowerCase(),
+      clientValue: "(missing)",
+      message: "Server rendered a node that the client did not produce."
+    });
+    return;
+  }
+  if (!serverNode || !clientNode) return;
+  if (serverNode.tagName !== clientNode.tagName) {
+    out.push({
+      kind: "tag",
+      path: nodePath,
+      serverValue: serverNode.tagName.toLowerCase(),
+      clientValue: clientNode.tagName.toLowerCase(),
+      message: "Element tag mismatch \u2014 server and client disagree on the element type."
+    });
+    return;
+  }
+  const skipAttrs = /* @__PURE__ */ new Set(["data-sibu-ssr", "data-sibu-hydrated", "data-sibu-island"]);
+  const serverAttrs = /* @__PURE__ */ new Map();
+  for (const a of Array.from(serverNode.attributes)) {
+    if (!skipAttrs.has(a.name)) serverAttrs.set(a.name, a.value);
+  }
+  const clientAttrs = /* @__PURE__ */ new Map();
+  for (const a of Array.from(clientNode.attributes)) {
+    if (!skipAttrs.has(a.name)) clientAttrs.set(a.name, a.value);
+  }
+  for (const [name, value] of serverAttrs) {
+    if (out.length >= max) return;
+    if (!clientAttrs.has(name)) {
+      out.push({
+        kind: "attribute",
+        path: `${nodePath}[${name}]`,
+        serverValue: value,
+        clientValue: "(missing)",
+        message: `Attribute "${name}" present on server but missing on client.`
+      });
+    } else if (clientAttrs.get(name) !== value) {
+      out.push({
+        kind: "attribute",
+        path: `${nodePath}[${name}]`,
+        serverValue: value,
+        clientValue: clientAttrs.get(name) ?? "",
+        message: `Attribute "${name}" differs between server and client.`
+      });
+    }
+  }
+  for (const [name, value] of clientAttrs) {
+    if (out.length >= max) return;
+    if (!serverAttrs.has(name)) {
+      out.push({
+        kind: "attribute",
+        path: `${nodePath}[${name}]`,
+        serverValue: "(missing)",
+        clientValue: value,
+        message: `Attribute "${name}" present on client but missing on server.`
+      });
+    }
+  }
+  const serverText = directTextOf(serverNode);
+  const clientText = directTextOf(clientNode);
+  if (serverText !== clientText) {
+    out.push({
+      kind: "text",
+      path: nodePath,
+      serverValue: serverText,
+      clientValue: clientText,
+      message: "Text content differs between server and client."
+    });
+    if (out.length >= max) return;
+  }
+  const serverChildren = Array.from(serverNode.children);
+  const clientChildren = Array.from(clientNode.children);
+  const max2 = Math.max(serverChildren.length, clientChildren.length);
+  for (let i = 0; i < max2; i++) {
+    if (out.length >= max) return;
+    const childPath = `${nodePath} > ${clientChildren[i]?.tagName?.toLowerCase() ?? serverChildren[i]?.tagName?.toLowerCase() ?? "?"}:nth-child(${i + 1})`;
+    collectMismatches(serverChildren[i] ?? null, clientChildren[i] ?? null, childPath, out, max);
+  }
+}
+function trustHTML(html) {
+  return html;
+}
+function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
+  if (!attrs) return "";
+  const out = [];
+  for (const rawKey of Object.keys(attrs)) {
+    if (!Object.hasOwn(attrs, rawKey)) continue;
+    if (!isSafeAttrName(rawKey)) continue;
+    if (!allowEventHandlers && isEventHandlerAttr(rawKey)) continue;
+    if (isForbiddenSsrAttr(rawKey)) continue;
+    const value = resolveAttributeValue(rawKey.toLowerCase(), String(attrs[rawKey]));
+    if (value === null) continue;
+    out.push(`${rawKey}="${escapeAttr(value)}"`);
+  }
+  return out.join(" ");
+}
+function isDangerousMetaRefresh(metaProps) {
+  return isForbiddenMetaEntry(metaProps);
+}
+function renderToDocument(component, options = {}) {
+  let content;
+  try {
+    content = renderToString(component());
+  } catch (err) {
+    content = ssrErrorComment(err);
+  }
+  return assembleDocument(content, options, "", "");
+}
+function assembleDocument(content, options, head, 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) => {
+    const safe = sanitizeUrl(String(src));
+    if (!safe) return "";
+    return `<script src="${escapeAttr(safe)}"></script>`;
+  }).filter(Boolean).join("\n    ");
+  const bodyAttrPairs = buildAttrString(options.bodyAttrs);
+  const bodyAttrs = bodyAttrPairs ? ` ${bodyAttrPairs}` : "";
+  return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    ${options.title != null ? `<title>${escapeHtml(options.title)}</title>` : ""}
+    ${metaTags}
+    ${linkTags}
+    ${options.headExtra || ""}${head ? `
+    ${head}` : ""}
+  </head>
+  <body${bodyAttrs}>
+    <div id="app">${content}</div>${bodyEnd ? `
+    ${bodyEnd}` : ""}
+    ${scriptTags}
+  </body>
+</html>`;
+}
+function renderToStream(element) {
+  return streamNode(element, 0 /* Html */);
+}
+async function* streamNode(element, context) {
+  if (element instanceof DocumentFragment) {
+    for (const child of Array.from(element.childNodes)) {
+      try {
+        yield* streamNode(child, context);
+      } catch (err) {
+        yield ssrErrorComment(err);
+      }
+    }
+    return;
+  }
+  const frame = serializeNode(element, context);
+  if (typeof frame === "string") {
+    if (frame) yield frame;
+    return;
+  }
+  yield frame.open;
+  for (const child of frame.children) {
+    try {
+      yield* streamNode(child, frame.context);
+    } catch (err) {
+      yield ssrErrorComment(err);
+    }
+  }
+  yield frame.close;
+}
+async function collectStream(stream) {
+  let result = "";
+  for await (const chunk of stream) {
+    result += chunk;
+  }
+  return result;
+}
+function renderToReadableStream(element, options) {
+  if (typeof element === "function") return streamPage(element, options);
+  const generator = renderToStream(element);
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await generator.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    async cancel() {
+      await generator.return(void 0);
+    }
+  });
+}
+var SAFE_ID = /^[A-Za-z0-9_-]+$/;
+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))})`);
+  }
+  const el = component();
+  el.setAttribute("data-sibu-island", id);
+  return el;
+}
+function isAlreadyHydrated(element) {
+  return element.hasAttribute("data-sibu-hydrated");
+}
+function hydrateIslands(container, islands) {
+  const markers = container.querySelectorAll("[data-sibu-island]");
+  for (const marker of Array.from(markers)) {
+    if (isAlreadyHydrated(marker)) continue;
+    const id = marker.getAttribute("data-sibu-island") ?? "";
+    if (!Object.hasOwn(islands, id)) continue;
+    const factory = islands[id];
+    if (typeof factory !== "function") continue;
+    const clientTree = factory();
+    clientTree.setAttribute("data-sibu-island", id);
+    clientTree.setAttribute("data-sibu-hydrated", "true");
+    disposeAndReplace(marker, clientTree);
+  }
+  container.setAttribute("data-sibu-hydrated", "partial");
+}
+function hydrateProgressively(container, islands, options) {
+  const markers = container.querySelectorAll("[data-sibu-island]");
+  const cleanups = [];
+  for (const marker of Array.from(markers)) {
+    if (isAlreadyHydrated(marker)) continue;
+    const id = marker.getAttribute("data-sibu-island") ?? "";
+    if (!Object.hasOwn(islands, id)) continue;
+    const factory = islands[id];
+    if (typeof factory !== "function") continue;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            observer.disconnect();
+            if (isAlreadyHydrated(marker) || marker.parentNode === null) break;
+            const clientTree = factory();
+            clientTree.setAttribute("data-sibu-island", id);
+            clientTree.setAttribute("data-sibu-hydrated", "true");
+            disposeAndReplace(marker, clientTree);
+            break;
+          }
+        }
+      },
+      { rootMargin: "200px", ...options }
+    );
+    observer.observe(marker);
+    cleanups.push(() => observer.disconnect());
+  }
+  container.setAttribute("data-sibu-hydrated", "progressive");
+  return () => {
+    for (const cleanup of cleanups) cleanup();
+  };
+}
+function resetSSRState() {
+  getSSRStore().suspenseIdCounter = 0;
+}
+function noop() {
+}
+function ssrSuspense(props) {
+  const store = getSSRStore();
+  const id = `sibu-sus-${store.suspenseIdCounter++}`;
+  const timeoutMs = props.timeoutMs ?? 3e4;
+  const fallbackEl = props.fallback();
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-sibu-suspense-id", id);
+  wrapper.appendChild(fallbackEl);
+  const fallbackHtml = renderToString(fallbackEl);
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`[SibuJS SSR] ssrSuspense timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  let contentPromise;
+  try {
+    contentPromise = Promise.resolve(props.content());
+  } catch (err) {
+    contentPromise = Promise.reject(err);
+  }
+  const toFallback = (err) => {
+    if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
+    return { id, html: fallbackHtml };
+  };
+  const clearTimer = () => {
+    if (timer !== void 0) clearTimeout(timer);
+  };
+  const raced = Promise.race([contentPromise, timeoutPromise]);
+  const promise = raced.then(
+    (resolvedEl) => {
+      clearTimer();
+      try {
+        return { id, html: renderToString(resolvedEl) };
+      } catch (err) {
+        return toFallback(err);
+      }
+    },
+    (err) => {
+      clearTimer();
+      return toFallback(err);
+    }
+  );
+  promise.catch(noop);
+  return { element: wrapper, promise };
+}
+var SAFE_SUSPENSE_ID = /^[A-Za-z0-9_-]+$/;
+function suspenseSwapScript(id, nonce) {
+  if (!SAFE_SUSPENSE_ID.test(id)) {
+    throw new Error(
+      `[SibuJS SSR] suspenseSwapScript: id must match [A-Za-z0-9_-]+ (got: ${JSON.stringify(id.slice(0, 32))})`
+    );
+  }
+  const nonceAttr = nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<script${nonceAttr}>(function(){var t=document.getElementById("sibu-resolved-${id}");var f=document.querySelector('[data-sibu-suspense-id="${id}"]');if(t&&f){while(f.firstChild)f.removeChild(f.firstChild);while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
+}
+async function* renderToSuspenseStream(element, pendingBoundaries = [], options) {
+  yield* renderToStream(element);
+  if (pendingBoundaries.length > 0) {
+    const resolved = await Promise.all(pendingBoundaries);
+    for (const { id, html } of resolved) {
+      if (!SAFE_SUSPENSE_ID.test(id)) continue;
+      yield `<div hidden id="sibu-resolved-${id}">${html}</div>`;
+      yield suspenseSwapScript(id, options?.nonce);
+    }
+  }
+}
+var SSR_DATA_ATTR = "__SIBU_SSR_DATA__";
+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(state, 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(state);
+  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 value = rawJson.includes('"__proto__":') ? `JSON.parse(${JSON.stringify(rawJson)})` : rawJson;
+  const json = escapeScriptJson(value);
+  const nonceAttr = nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<script${nonceAttr}>window.${globalName}=${json}</script>`;
+}
+function deserializeState(validate) {
+  if (typeof window === "undefined") return void 0;
+  if (DEV && !validate) {
+    console.warn(
+      "[SibuJS SSR] deserializeState() called without a validate guard \u2014 tampered SSR payloads will not be detected."
+    );
+  }
+  const raw = readOwnGlobal(SSR_DATA_ATTR);
+  if (raw === void 0) return void 0;
+  if (validate && !validate(raw)) return void 0;
+  return raw;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export {
+  planMetaEntry,
+  planHeadElementEntry,
+  STATIC_VALUE_RESOLVER,
+  serializeHeadEntry,
+  serializePlannedHeadEntry,
+  recordServerHead,
+  collectServerHead,
+  DEFAULT_SETTLE_TIMEOUT,
+  DEFAULT_TRANSFER_MAX_BYTES,
+  settled,
+  formatRenderDiagnostics,
+  describeNodePath,
+  renderFailure,
+  renderToStringAsync,
+  renderToDocumentAsync,
+  ADOPT_ID_ATTR,
+  ISLAND_PROPS_ATTR,
+  componentIsland,
+  islandComponent,
+  renderToString,
+  renderToStringWith,
+  hydrate,
+  trustHTML,
+  isDangerousMetaRefresh,
+  renderToDocument,
+  assembleDocument,
+  renderToStream,
+  collectStream,
+  renderToReadableStream,
+  island,
+  hydrateIslands,
+  hydrateProgressively,
+  resetSSRState,
+  ssrSuspense,
+  suspenseSwapScript,
+  renderToSuspenseStream,
+  escapeScriptJson,
+  serializeState,
+  deserializeState
+};