sibujs 4.13.1 → 4.14.1

package/dist/build.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,362 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/build/prerenderServer.ts
+var prerenderServer_exports = {};
+__export(prerenderServer_exports, {
+  assertPrerendered: () => assertPrerendered,
+  buildSitemap: () => buildSitemap,
+  expandRoutes: () => expandRoutes,
+  injectIntoShell: () => injectIntoShell,
+  prerenderFromServerEntry: () => prerenderFromServerEntry
+});
+function joinPath(parent, child) {
+  if (child === "*" || child.startsWith("/*")) return child;
+  const p2 = parent.replace(/\/+$/, "");
+  const c = child.startsWith("/") ? child : `/${child}`;
+  return (p2 + c).replace(/\/{2,}/g, "/") || "/";
+}
+async function expandRoutes(routes) {
+  const out = [];
+  const visit = async (records, parent) => {
+    for (const record of records) {
+      if (!record || typeof record.path !== "string") continue;
+      const full = parent ? joinPath(parent, record.path) : record.path;
+      if (record.children?.length) await visit(record.children, full);
+      if (full.includes("*")) continue;
+      if ("redirect" in record && record.redirect !== void 0) {
+        if (!/:/.test(full)) out.push(full);
+        continue;
+      }
+      if (/:/.test(full)) {
+        if (typeof record.getStaticPaths !== "function") continue;
+        let entries;
+        try {
+          entries = await record.getStaticPaths();
+        } catch (err) {
+          throw new Error(
+            `[sibu prerender] getStaticPaths() of "${full}" failed: ${err instanceof Error ? err.message : String(err)}. If it reads an API, start it and point \`prerender.fetch\` at it.`,
+            { cause: err }
+          );
+        }
+        for (const entry of entries) {
+          if (typeof entry === "string") {
+            out.push(entry);
+            continue;
+          }
+          let path2 = full;
+          for (const [key, value] of Object.entries(entry)) {
+            path2 = path2.replace(new RegExp(`:${key}(?=[/?#]|$)`, "g"), encodeURIComponent(String(value)));
+          }
+          if (/:[A-Za-z_]/.test(path2)) {
+            throw new Error(
+              `[sibu prerender] getStaticPaths() of "${full}" returned ${JSON.stringify(entry)}, which leaves a param unset`
+            );
+          }
+          out.push(path2);
+        }
+        continue;
+      }
+      if (record.children?.length) continue;
+      out.push(full);
+    }
+  };
+  await visit(routes, "");
+  return Array.from(new Set(out));
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function decodeTitleText(text2) {
+  const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0" };
+  return text2.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (ref2, body2) => {
+    if (body2[0] !== "#") return named[body2.toLowerCase()] ?? ref2;
+    const code2 = body2[1] === "x" || body2[1] === "X" ? Number.parseInt(body2.slice(2), 16) : Number(body2.slice(1));
+    return code2 > 0 && code2 <= 1114111 ? String.fromCodePoint(code2) : ref2;
+  });
+}
+function injectIntoShell(shell, parts, container = "app") {
+  let html3 = shell;
+  const shellTitle = /<title>([\s\S]*?)<\/title>/i.exec(html3)?.[1] ?? "";
+  if (parts.head) {
+    let head2 = parts.head;
+    if (/<title>/i.test(head2)) {
+      html3 = html3.replace(/\s*<title>[\s\S]*?<\/title>/i, () => "");
+      const baseTitle = `<title data-sibu-base-title="${escapeAttr(decodeTitleText(shellTitle))}">`;
+      head2 = head2.replace(/<title>/i, () => baseTitle);
+    }
+    const headHtml = head2;
+    html3 = html3.replace(/<\/head>/i, () => `    ${headHtml}
+  </head>`);
+  }
+  if (parts.body) {
+    const id = container.replace(/[^A-Za-z0-9_-]/g, "");
+    const open = new RegExp(`(<([a-z][a-z0-9-]*)\\b[^>]*\\bid\\s*=\\s*["']${id}["'][^>]*>)([\\s\\S]*?)(</\\2>)`, "i");
+    if (!open.test(html3))
+      throw new Error(`[sibu prerender] the built index.html has no element with id="${id}" to render into`);
+    html3 = html3.replace(
+      open,
+      (_m, openTag, _tag, _inner, close) => `${openTag}${parts.body}${close}`
+    );
+  }
+  if (parts.state) html3 = html3.replace(/<\/body>/i, () => `  ${parts.state}
+  </body>`);
+  return html3;
+}
+function assertPrerendered(url, result, failures, timeout) {
+  if (failures.length > 0) {
+    throw new Error(
+      `[sibu prerender] ${url}: ${failures[0]}. The page needs data from an API that is not reachable at build time \u2014 start it and point \`prerender.fetch\` at it, or skip the request with isPrerendering().`
+    );
+  }
+  const pending = result.diagnostics.pending.join(", ");
+  if (result.failure === "timeout") {
+    throw new Error(
+      `[sibu prerender] ${url}: the route did not render within ${timeout} ms (pending: ${pending}). A lazy import, a guard or a route load did not finish in time; fix it or raise \`prerender.timeout\`.`
+    );
+  }
+  if (result.diagnostics.timedOut) {
+    throw new Error(`[sibu prerender] ${url}: did not settle within ${timeout} ms (pending: ${pending})`);
+  }
+}
+function buildSitemap(origin, paths) {
+  const urls = paths.map((p2) => `  <url><loc>${escapeXml(origin + p2)}</loc></url>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+}
+async function prerenderFromServerEntry(options, ctx, helpers) {
+  const fs = await import("fs/promises");
+  const path2 = await import("path");
+  const { pathToFileURL } = await import("url");
+  const { AsyncLocalStorage } = await import("async_hooks");
+  const outDir = options.outDir ? path2.resolve(ctx.root, options.outDir) : ctx.outDir;
+  const origin = (options.origin ?? "http://localhost").replace(/\/+$/, "");
+  const serverEntry = path2.resolve(ctx.root, String(options.server).replace(/^\//, ""));
+  const keptShell = path2.join(ctx.outDir, typeof options.shell === "string" ? options.shell : "200.html");
+  const shellPath = await fs.access(keptShell).then(() => keptShell).catch(() => path2.join(ctx.outDir, "index.html"));
+  const shell = await fs.readFile(shellPath, "utf8");
+  const tmpDir = path2.join(
+    outDir,
+    `.sibu-prerender-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`
+  );
+  await fs.rm(tmpDir, { recursive: true, force: true });
+  const viteBuild = await helpers.loadViteBuild();
+  const driverSource = `import { renderRoute } from "sibujs/ssr";
+import * as entry from ${JSON.stringify(serverEntry.split(path2.sep).join("/"))};
+export { renderRoute, entry };
+`;
+  const prev = process.env[helpers.childEnv];
+  process.env[helpers.childEnv] = "1";
+  try {
+    await viteBuild({
+      configFile: ctx.configFile,
+      root: ctx.root,
+      mode: ctx.mode,
+      logLevel: "warn",
+      plugins: [
+        {
+          name: "sibu-prerender-driver",
+          resolveId: (id) => id === DRIVER_ID ? DRIVER_RESOLVED : null,
+          load: (id) => id === DRIVER_RESOLVED ? driverSource : null
+        }
+      ],
+      build: {
+        ssr: true,
+        outDir: tmpDir,
+        emptyOutDir: true,
+        copyPublicDir: false,
+        minify: false,
+        sourcemap: false,
+        rollupOptions: { input: DRIVER_ID, output: { format: "es", entryFileNames: "driver.mjs" } }
+      }
+    });
+  } finally {
+    if (prev === void 0) delete process.env[helpers.childEnv];
+    else process.env[helpers.childEnv] = prev;
+  }
+  await fs.writeFile(path2.join(tmpDir, "package.json"), '{ "type": "module" }\n', "utf8");
+  const currentRoute = new AsyncLocalStorage();
+  const realFetch = globalThis.fetch;
+  const custom = typeof options.fetch === "function" ? options.fetch : null;
+  const apiBase = typeof options.fetch === "string" ? options.fetch.replace(/\/+$/, "") : origin;
+  const buildFetch = (async (input2, init) => {
+    const raw = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.href : input2.url;
+    const url = /^[a-z][a-z0-9+.-]*:/i.test(raw) ? raw : apiBase + (raw.startsWith("/") ? raw : `/${raw}`);
+    try {
+      return await (custom ?? realFetch)(
+        typeof input2 === "object" && !(input2 instanceof URL) ? new Request(url, input2) : url,
+        init
+      );
+    } catch (err) {
+      const store2 = currentRoute.getStore();
+      const reason = err instanceof Error ? err.message : String(err);
+      store2?.failures.push(`GET ${url} failed (${reason})`);
+      throw err;
+    }
+  });
+  const driverUrl = pathToFileURL(path2.join(tmpDir, "driver.mjs")).href;
+  const results = [];
+  globalThis.fetch = buildFetch;
+  try {
+    const driver = await import(driverUrl);
+    const entry = driver.entry;
+    if (!Array.isArray(entry.routes)) {
+      throw new Error(
+        `[sibu prerender] the server entry ${options.server} must export \`routes\` (the app's route table)`
+      );
+    }
+    const explicit = Array.isArray(options.routes) ? options.routes : null;
+    const auto = explicit === null;
+    const listed = (explicit ? explicit.map((r) => typeof r === "string" ? { path: r } : r) : (await expandRoutes(entry.routes)).map((p2) => ({ path: p2 }))).filter((r) => r.path !== options.notFound);
+    const trailingSlash = options.trailingSlash === "never" ? "never" : "always";
+    const planned = listed.map((route) => ({ route, file: helpers.outputFileFor(route, trailingSlash) }));
+    const seen = /* @__PURE__ */ new Map();
+    for (const { route, file } of planned) {
+      helpers.resolveInsideOutDir(path2, outDir, file);
+      const other = seen.get(file);
+      if (other !== void 0) {
+        throw new Error(
+          `[sibu prerender] "${other}" and "${route.path}" would both be written to ${file}; a query variant needs its own \`output\` file.`
+        );
+      }
+      seen.set(file, route.path);
+    }
+    const renderOptions = {
+      router: { ...entry.routerOptions ?? {}, head: entry.head },
+      app: entry.app,
+      timeout: options.timeout ?? 15e3,
+      // A per-request page is written as the shell plus its route head: it is
+      // never rendered at build time, so its request-only fetches never run.
+      headOnly: ["ssr"],
+      hydration: options.hydration,
+      nonce: options.nonce,
+      maxStateBytes: options.maxStateBytes
+    };
+    const render = async (url) => {
+      const store2 = { route: url, failures: [] };
+      const result = await currentRoute.run(store2, () => driver.renderRoute(entry.routes, url, renderOptions));
+      assertPrerendered(url, result, store2.failures, renderOptions.timeout);
+      return result;
+    };
+    if (options.shell !== false) await fs.writeFile(path2.join(outDir, options.shell ?? "200.html"), shell, "utf8");
+    const redirects = [];
+    const indexable = [];
+    const queue = [...planned];
+    const concurrency = Math.max(1, options.concurrency ?? 4);
+    const write = async (file, html3) => {
+      const target = helpers.resolveInsideOutDir(path2, outDir, file);
+      await fs.mkdir(path2.dirname(target), { recursive: true });
+      await fs.writeFile(target, html3, "utf8");
+    };
+    await Promise.all(
+      Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+        for (let job = queue.shift(); job; job = queue.shift()) {
+          const { route, file } = job;
+          const started = Date.now();
+          const result = await render(route.path);
+          if (result.location !== null && result.redirectBy === "guard") {
+            results.push({
+              route: route.path,
+              file: "",
+              ms: Date.now() - started,
+              status: result.status,
+              kind: "skipped"
+            });
+            continue;
+          }
+          if (result.location !== null) {
+            redirects.push({ from: route.path, to: result.location, status: result.status });
+            results.push({
+              route: route.path,
+              file: "",
+              ms: Date.now() - started,
+              status: result.status,
+              kind: "redirect"
+            });
+            continue;
+          }
+          if (auto && result.failure === "guard") {
+            results.push({
+              route: route.path,
+              file: "",
+              ms: Date.now() - started,
+              status: result.status,
+              kind: "skipped"
+            });
+            continue;
+          }
+          if (result.status >= 400) {
+            throw new Error(
+              `[sibu prerender] ${route.path} answered ${result.status}${result.failure ? ` (${result.failure})` : ""}; list only pages that exist (the \`*\` route becomes 404.html through \`notFound\`).`
+            );
+          }
+          const body2 = result.render === "client" || result.render === "ssr" ? "" : result.html;
+          const state2 = body2 ? result.state : "";
+          await write(file, injectIntoShell(shell, { body: body2, head: result.head, state: state2 }, options.container));
+          if (!result.noindex && result.render !== "client") {
+            const pathname = route.path.split(/[?#]/)[0];
+            indexable.push(
+              trailingSlash === "always" && pathname !== "/" ? `${pathname.replace(/\/+$/, "")}/` : pathname
+            );
+          }
+          results.push({
+            route: route.path,
+            file,
+            ms: Date.now() - started,
+            status: result.status,
+            kind: body2 ? "page" : "shell"
+          });
+        }
+      })
+    );
+    const notFound = options.notFound ?? "/404";
+    if (notFound) {
+      const started = Date.now();
+      const result = await render(notFound);
+      if (result.status === 404) {
+        await write(
+          "404.html",
+          injectIntoShell(shell, { body: result.html, head: result.head, state: result.state }, options.container)
+        );
+        results.push({ route: notFound, file: "404.html", ms: Date.now() - started, status: 404, kind: "not-found" });
+      }
+    }
+    if (redirects.length > 0) await write("redirects.json", `${JSON.stringify(redirects, null, 2)}
+`);
+    if (options.sitemap !== false && indexable.length > 0) {
+      indexable.sort();
+      await write("sitemap.xml", buildSitemap(origin, indexable));
+    }
+    if (options.robots) {
+      const extra = typeof options.robots === "string" ? `${options.robots.trim()}
+` : "";
+      const sitemapLine = options.sitemap !== false && indexable.length > 0 ? `Sitemap: ${origin}/sitemap.xml
+` : "";
+      await write("robots.txt", `User-agent: *
+Allow: /
+${extra}${sitemapLine}`);
+    }
+  } finally {
+    globalThis.fetch = realFetch;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+  return results;
+}
+var DRIVER_ID, DRIVER_RESOLVED;
+var init_prerenderServer = __esm({
+  "src/build/prerenderServer.ts"() {
+    "use strict";
+    DRIVER_ID = "virtual:sibu-prerender-driver";
+    DRIVER_RESOLVED = `\0${DRIVER_ID}`;
+  }
+});
+
 // build.ts
 var build_exports = {};
 __export(build_exports, {
@@ -237,6 +596,7 @@ function estimateImportSize(imports) {
 // index.ts
 var index_exports = {};
 __export(index_exports, {
+  ClientOnly: () => ClientOnly,
   DynamicComponent: () => DynamicComponent,
   ErrorBoundary: () => ErrorBoundary,
   ErrorDisplay: () => ErrorDisplay,
@@ -342,7 +702,9 @@ __export(index_exports, {
   input: () => input,
   ins: () => ins,
   isBatching: () => isBatching,
+  isClient: () => isClient,
   isSSR: () => isSSR,
+  isServer: () => isServer,
   kbd: () => kbd,
   label: () => label,
   lazy: () => lazy,
@@ -416,7 +778,7 @@ __export(index_exports, {
   setRuntimeErrorHandler: () => setRuntimeErrorHandler,
   show: () => show,
   signal: () => signal,
-  slot: () => slot,
+  slot: () => slot2,
   small: () => small,
   source: () => source,
   span: () => span,
@@ -524,12 +886,12 @@ function claimedByBoundary(error, context2) {
 }
 function resolveEventTarget(node) {
   const ELEMENT_NODE = 1;
-  let current = node;
-  while (current) {
-    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
-      return current;
+  let current2 = node;
+  while (current2) {
+    if (current2.nodeType === ELEMENT_NODE && typeof current2.dispatchEvent === "function") {
+      return current2;
     }
-    current = current.parentNode;
+    current2 = current2.parentNode;
   }
   const self = node;
   return typeof self.dispatchEvent === "function" ? self : null;
@@ -538,10 +900,21 @@ function defaultReport(error, context2) {
   if (typeof console === "undefined") return;
   console.error(`[SibuJS] Uncaught error during ${describe(context2)}: ${error.message}`, error);
 }
+function requestErrorSink() {
+  const shared = globalThis[/* @__PURE__ */ Symbol.for("sibujs.ssr.v1")];
+  if (!shared) return void 0;
+  const store2 = shared.als ? shared.als.getStore() : shared.fallbackDepth > 0 ? shared.fallbackStore : void 0;
+  return store2?.errors;
+}
 function reportError(error, context2) {
   const err = normalizeError(error);
   untrackedRun(() => {
     if (claimedByBoundary(err, context2)) return;
+    const sink = requestErrorSink();
+    if (sink) {
+      sink.push({ error: err, context: context2 });
+      return;
+    }
     const s2 = state();
     const handler = s2.handler;
     if (handler && s2.handlerDepth === 0) {
@@ -589,6 +962,78 @@ function devWarn(message) {
   }
 }
 
+// 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 keyedScope(scope, key) {
+  if (!scope?.s.on) return null;
+  const type = typeof key;
+  if (type !== "string" && type !== "number") {
+    throw new TypeError(`[SibuJS] adopt: a key must be a string or a number, not ${type}`);
+  }
+  const text2 = String(key).replace(/[^\w-]/g, (c) => `~${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  return { p: `${scope.p}${type === "string" ? "_" : "-"}${text2}.`, n: 0, s: scope.s };
+}
+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 afterHydration(fn) {
+  const owners = hydrationOwners();
+  let left = owners.length;
+  const once = () => {
+    if (--left < 1) fn();
+  };
+  if (left) for (const s2 of owners) s2.done.push(once);
+  else fn();
+}
+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);
+  };
+}
+
 // src/core/rendering/dispose.ts
 var elementDisposers = /* @__PURE__ */ new WeakMap();
 var MAX_DRAIN_TEARDOWNS = 1e4;
@@ -685,9 +1130,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]);
     }
@@ -726,13 +1171,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);
 }
@@ -804,19 +1263,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;
         }
@@ -825,10 +1284,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;
@@ -1401,8 +1860,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;
@@ -1990,7 +2449,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;
@@ -2211,10 +2670,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;
@@ -2473,7 +2933,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) {
@@ -2683,7 +3143,7 @@ var details = tagFactory("details");
 var dialog = tagFactory("dialog");
 var menu = tagFactory("menu");
 var summary = tagFactory("summary");
-var slot = tagFactory("slot");
+var slot2 = tagFactory("slot");
 var template = tagFactory("template");
 var base = tagFactory("base");
 var link = tagFactory("link");
@@ -2714,6 +3174,152 @@ var font = tagFactory("font");
 var marquee = tagFactory("marquee");
 var customElement = (tagName) => tagFactory(tagName);
 
+// src/core/rendering/streamBoundary.ts
+var _a2;
+var slot3 = globalThis[_a2 = /* @__PURE__ */ Symbol.for("sibujs.streamBoundary.v1")] ?? (globalThis[_a2] = { hook: null, current: null });
+function openBoundary(container) {
+  return slot3.hook ? slot3.hook(container) : null;
+}
+function currentBoundary() {
+  return slot3.current;
+}
+
+// src/core/ssr-context.ts
+var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
+function detectSSRShared() {
+  let detected = null;
+  try {
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      let mod = null;
+      const getBuiltin = process.getBuiltinModule;
+      if (typeof getBuiltin === "function") {
+        mod = getBuiltin("node:async_hooks");
+      } else if (typeof require === "function") {
+        mod = require("async_hooks");
+      }
+      if (mod) detected = new mod.AsyncLocalStorage();
+    }
+    const globalAls = globalThis.AsyncLocalStorage;
+    if (!detected && typeof globalAls === "function") detected = new globalAls();
+  } catch {
+    detected = null;
+  }
+  return {
+    als: detected,
+    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
+    fallbackDepth: 0
+  };
+}
+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 getSSRStore() {
+  if (als) {
+    const s2 = als.getStore();
+    if (s2) return s2;
+  }
+  return fallbackStore;
+}
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
+function isSSR() {
+  return getSSRStore().ssr;
+}
+function getRequestScopedCache(name) {
+  if (!isSSR()) return null;
+  const store2 = getSSRStore();
+  const caches = store2.caches ?? (store2.caches = /* @__PURE__ */ new Map());
+  let c = caches.get(name);
+  if (!c) {
+    c = /* @__PURE__ */ new Map();
+    caches.set(name, c);
+  }
+  return c;
+}
+var PRERENDER_HOST = /* @__PURE__ */ Symbol.for("sibujs.prerender.v1");
+function isServer() {
+  return getSSRStore().ssr || globalThis[PRERENDER_HOST] !== void 0;
+}
+function isClient() {
+  return !isServer();
+}
+function enableSSR() {
+  getSSRStore().ssr = true;
+}
+function disableSSR() {
+  getSSRStore().ssr = false;
+}
+function runInSSRContext(fn) {
+  const store2 = {
+    ssr: true,
+    suspenseIdCounter: 0,
+    idCounter: 0,
+    locale: void 0,
+    pending: /* @__PURE__ */ new Set(),
+    wake: null
+  };
+  if (als) {
+    return als.run(store2, fn);
+  }
+  warnMissingAsyncLocalStorage();
+  const prev = { ...fallbackStore };
+  Object.assign(fallbackStore, store2);
+  _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 store2 = getRequestStore();
+  const pending = store2?.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);
+    store2?.wake?.();
+    release();
+  };
+  try {
+    Promise.resolve(promise).then(done, done);
+  } catch {
+    done();
+  }
+  return promise;
+}
+function withSSR(fn) {
+  const store2 = getSSRStore();
+  const wasSSR = store2.ssr;
+  store2.ssr = true;
+  try {
+    return fn();
+  } finally {
+    if (!wasSSR) store2.ssr = false;
+  }
+}
+
 // src/core/rendering/lazy.ts
 var PENDING_ERROR = "__sibuPendingError";
 function dispatchPropagate(node, error) {
@@ -2740,18 +3346,28 @@ function takePendingError(node) {
 function lazy(importFn) {
   let cached = null;
   return function LazyComponent() {
-    if (cached) {
+    if (cached && !inAdoptScope()) {
       return cached();
     }
     const container = div({ class: "sibu-lazy" });
+    const scope = captureScope();
+    const boundary = currentBoundary();
     let disposed = false;
-    importFn().then(
+    const loading = inScope(null, () => span("sibu-lazy-loading", "Loading..."));
+    if (cached) {
+      const loaded = cached;
+      replaceChildrenSafely(container, inScope(scope, () => loaded()));
+      return container;
+    }
+    trackPending(importFn(), "lazy").then(
       // The component renders after the import resolves, in the owner scope
       // of whoever rendered the placeholder.
       bindOwnerScope2((mod) => {
         if (disposed) return;
         cached = mod.default;
-        const rendered = cached();
+        const component = cached;
+        const build = () => inScope(scope, () => component());
+        const rendered = boundary ? boundary.enter(build) : build();
         replaceChildrenSafely(container, rendered);
       })
     ).catch((err) => {
@@ -2763,7 +3379,7 @@ function lazy(importFn) {
       );
       dispatchPropagate(container, errorObj);
     });
-    container.appendChild(span("sibu-lazy-loading", "Loading..."));
+    if (!(isHydrating() && container.firstChild)) container.appendChild(loading);
     registerDisposer(container, () => {
       disposed = true;
     });
@@ -2772,8 +3388,15 @@ function lazy(importFn) {
 }
 function Suspense({ nodes, fallback }) {
   const container = div({ class: "sibu-suspense" });
-  const fallbackEl = fallback();
-  container.appendChild(fallbackEl);
+  const scope = captureScope();
+  const boundary = openBoundary(container);
+  const commit = (el) => {
+    replaceChildrenSafely(container, el);
+    boundary?.done();
+  };
+  const fallbackEl = inScope(null, fallback);
+  if (isHydrating() && container.firstChild) dispose(fallbackEl);
+  else container.appendChild(fallbackEl);
   let suspenseDisposed = false;
   let observer = null;
   let childEl = null;
@@ -2788,11 +3411,11 @@ function Suspense({ nodes, fallback }) {
   const renderContent = bindOwnerScope2(() => {
     if (suspenseDisposed) return;
     try {
-      const el = nodes();
+      const el = boundary ? boundary.enter(() => inScope(scope, nodes)) : inScope(scope, nodes);
       childEl = el;
       if (el.classList.contains("sibu-lazy")) {
         if (!el.querySelector(".sibu-lazy-loading")) {
-          replaceChildrenSafely(container, el);
+          commit(el);
           return;
         }
         observer = new MutationObserver(() => {
@@ -2801,12 +3424,12 @@ function Suspense({ nodes, fallback }) {
           if (!loading) {
             observer?.disconnect();
             observer = null;
-            replaceChildrenSafely(container, el);
+            commit(el);
           }
         });
         observer.observe(el, { childList: true, subtree: true });
       } else {
-        replaceChildrenSafely(container, el);
+        commit(el);
       }
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
@@ -2996,7 +3619,7 @@ function registerUnmountWatcher(element, cb) {
   };
 }
 function onMount(callback, element) {
-  if (typeof document === "undefined") return;
+  if (typeof document === "undefined" || isSSR()) return;
   const scope = getOwnerScope2();
   callback = pinScope(scope, callback);
   if (element) {
@@ -3031,7 +3654,7 @@ function onMount(callback, element) {
   }
 }
 function onUnmount(callback, element) {
-  if (typeof document === "undefined") return;
+  if (typeof document === "undefined" || isSSR()) return;
   watchUnmount(pinScope(getOwnerScope2(), callback), element);
 }
 function watchUnmount(callback, element) {
@@ -3068,112 +3691,6 @@ function emitDevtools(hook, event, payload) {
   }
 }
 
-// src/core/ssr-context.ts
-var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
-function detectSSRShared() {
-  let detected = null;
-  try {
-    if (typeof process !== "undefined" && process.versions && process.versions.node) {
-      let mod = null;
-      const getBuiltin = process.getBuiltinModule;
-      if (typeof getBuiltin === "function") {
-        mod = getBuiltin("node:async_hooks");
-      } else if (typeof require === "function") {
-        mod = require("async_hooks");
-      }
-      if (mod) detected = new mod.AsyncLocalStorage();
-    }
-  } catch {
-    detected = null;
-  }
-  return {
-    als: detected,
-    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
-    fallbackDepth: 0
-  };
-}
-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 getSSRStore() {
-  if (als) {
-    const s2 = als.getStore();
-    if (s2) return s2;
-  }
-  return fallbackStore;
-}
-function getRequestStore() {
-  if (als) return als.getStore() ?? null;
-  return _shared.fallbackDepth > 0 ? fallbackStore : null;
-}
-function isSSR() {
-  return getSSRStore().ssr;
-}
-function getRequestScopedCache(name) {
-  if (!isSSR()) return null;
-  const store2 = getSSRStore();
-  const caches = store2.caches ?? (store2.caches = /* @__PURE__ */ new Map());
-  let c = caches.get(name);
-  if (!c) {
-    c = /* @__PURE__ */ new Map();
-    caches.set(name, c);
-  }
-  return c;
-}
-function enableSSR() {
-  getSSRStore().ssr = true;
-}
-function disableSSR() {
-  getSSRStore().ssr = false;
-}
-function runInSSRContext(fn) {
-  const store2 = { ssr: true, suspenseIdCounter: 0, idCounter: 0, locale: void 0 };
-  if (als) {
-    return als.run(store2, fn);
-  }
-  warnMissingAsyncLocalStorage();
-  const prevSSR = fallbackStore.ssr;
-  const prevCounter = fallbackStore.suspenseIdCounter;
-  const prevIdCounter = fallbackStore.idCounter;
-  const prevLocale = fallbackStore.locale;
-  fallbackStore.ssr = true;
-  fallbackStore.suspenseIdCounter = 0;
-  fallbackStore.idCounter = 0;
-  fallbackStore.locale = void 0;
-  _shared.fallbackDepth++;
-  try {
-    return fn();
-  } finally {
-    _shared.fallbackDepth--;
-    fallbackStore.ssr = prevSSR;
-    fallbackStore.suspenseIdCounter = prevCounter;
-    fallbackStore.idCounter = prevIdCounter;
-    fallbackStore.locale = prevLocale;
-  }
-}
-function withSSR(fn) {
-  const store2 = getSSRStore();
-  const wasSSR = store2.ssr;
-  store2.ssr = true;
-  try {
-    return fn();
-  } finally {
-    if (!wasSSR) store2.ssr = false;
-  }
-}
-
 // src/core/signals/effect.ts
 var _g = globalThis;
 function on(deps, handler) {
@@ -3254,7 +3771,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,
@@ -4060,21 +4577,21 @@ function ErrorBoundary(optionsOrChildren, maybeChildren) {
     stopResetKeysWatcher();
     let baseline = null;
     resetKeysTeardown = effect(() => {
-      const current = readResetKeyValues(keys);
+      const current2 = readResetKeyValues(keys);
       if (baseline === null) {
-        baseline = current;
+        baseline = current2;
         return;
       }
-      let changed = current.length !== baseline.length;
+      let changed = current2.length !== baseline.length;
       if (!changed) {
-        for (let i2 = 0; i2 < current.length; i2++) {
-          if (!Object.is(current[i2], baseline[i2])) {
+        for (let i2 = 0; i2 < current2.length; i2++) {
+          if (!Object.is(current2[i2], baseline[i2])) {
             changed = true;
             break;
           }
         }
       }
-      baseline = current;
+      baseline = current2;
       if (changed) retry();
     });
   };
@@ -4466,68 +4983,6 @@ function setGlobalErrorHandler(handler) {
   globalErrorHandler = handler;
 }
 
-// src/core/rendering/context.ts
-function context(defaultValue) {
-  const [getValue, setValue] = signal(defaultValue);
-  const warnIfSSR = (method) => {
-    if (!DEV || !isSSR()) return;
-    devWarn(
-      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
-    );
-  };
-  const ctx = {
-    provide(value) {
-      warnIfSSR("provide");
-      const previous = getValue();
-      setValue(value);
-      return () => setValue(previous);
-    },
-    use() {
-      return getValue;
-    },
-    get() {
-      return getValue();
-    },
-    set(value) {
-      warnIfSSR("set");
-      setValue(value);
-    },
-    withContext(value, fn) {
-      warnIfSSR("withContext");
-      const previous = getValue();
-      setValue(value);
-      try {
-        const result = fn();
-        if (DEV && result !== null && typeof result?.then === "function") {
-          devWarn(
-            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
-          );
-        }
-        return result;
-      } finally {
-        setValue(previous);
-      }
-    }
-  };
-  return ctx;
-}
-
-// src/core/rendering/createId.ts
-var COUNTER_KEY = /* @__PURE__ */ Symbol.for("sibujs.createId.v1");
-var _counter = globalThis[COUNTER_KEY] ?? (globalThis[COUNTER_KEY] = { n: 0 });
-function createId(prefix = "sibu") {
-  const request = getRequestStore();
-  if (request) {
-    request.idCounter = (request.idCounter ?? 0) + 1;
-    return `${prefix}-${request.idCounter}`;
-  }
-  _counter.n++;
-  return `${prefix}-${_counter.n}`;
-}
-function __resetIdCounter() {
-  _counter.n = 0;
-}
-
 // src/core/rendering/directives.ts
 function show(condition, element) {
   const resolved = typeof element === "function" ? element() : element;
@@ -4553,7 +5008,7 @@ function attachBranch(parent, anchor, branch, attachedOnce, where) {
       () => `${where}: ${handedIn ? "a branch was given as an element rather than a function" : "a branch factory returned a node it had already returned"}, so the SAME node is being re-attached \u2014 any state it accumulated while detached (input value, scroll position, classes set imperatively) comes back with it. Its reactive bindings are left intact rather than disposed, because the node is not this directive's to tear down. Return a FRESH node per call (\`() => div(\u2026)\`) for rebuild semantics, or keep this form deliberately when the reuse is what you want.`
     );
   }
-  parent.insertBefore(node, anchor.nextSibling);
+  if (anchor.nextSibling !== node) parent.insertBefore(node, anchor.nextSibling);
   return { node, owned };
 }
 function releaseBranchNode(node, owned) {
@@ -4569,6 +5024,7 @@ function when(condition, thenBranch, elseBranch, options) {
   const elseNode = elseBranch;
   const focusPolicy = options?.focus;
   const anchor = document.createComment("when");
+  const scope = captureScope();
   let currentNode = null;
   let lastCondition;
   let initialized = false;
@@ -4588,7 +5044,7 @@ function when(condition, thenBranch, elseBranch, options) {
       currentNode = null;
     }
     const branch = show2 ? thenBranch : elseNode !== void 0 ? elseNode : null;
-    const attached = untracked2(() => attachBranch(parent, anchor, branch, attachedOnce, "when"));
+    const attached = untracked2(() => inScope(scope, () => attachBranch(parent, anchor, branch, attachedOnce, "when")));
     currentNode = attached.node;
     currentNodeOwned = attached.owned;
     restoreFocusWithin(focused, currentNode ? [currentNode] : [], "when", focusPolicy);
@@ -4619,6 +5075,7 @@ function match(value, cases, fallback, options) {
   const fallbackNode = fallback;
   const focusPolicy = options?.focus;
   const anchor = document.createComment("match");
+  const scope = captureScope();
   let currentNode = null;
   let lastKey;
   let initialized = false;
@@ -4638,7 +5095,9 @@ function match(value, cases, fallback, options) {
       currentNode = null;
     }
     const branch = Object.hasOwn(cases, key) ? cases[key] : fallbackNode;
-    const attached = untracked2(() => attachBranch(parent, anchor, branch ?? null, attachedOnce, "match"));
+    const attached = untracked2(
+      () => inScope(scope, () => attachBranch(parent, anchor, branch ?? null, attachedOnce, "match"))
+    );
     currentNode = attached.node;
     currentNodeOwned = attached.owned;
     restoreFocusWithin(focused, currentNode ? [currentNode] : [], "match", focusPolicy);
@@ -4661,6 +5120,76 @@ function match(value, cases, fallback, options) {
   return anchor;
 }
 
+// src/core/rendering/clientOnly.ts
+function ClientOnly(content, options = {}) {
+  const server = isServer();
+  const [ready, setReady] = signal(!server && !isHydrating());
+  if (!server && !ready()) afterHydration(() => setReady(true));
+  return when(ready, content, options.fallback);
+}
+
+// src/core/rendering/context.ts
+function context(defaultValue) {
+  const [getValue, setValue] = signal(defaultValue);
+  const warnIfSSR = (method) => {
+    if (!DEV || !isSSR()) return;
+    devWarn(
+      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
+    );
+  };
+  const ctx = {
+    provide(value) {
+      warnIfSSR("provide");
+      const previous = getValue();
+      setValue(value);
+      return () => setValue(previous);
+    },
+    use() {
+      return getValue;
+    },
+    get() {
+      return getValue();
+    },
+    set(value) {
+      warnIfSSR("set");
+      setValue(value);
+    },
+    withContext(value, fn) {
+      warnIfSSR("withContext");
+      const previous = getValue();
+      setValue(value);
+      try {
+        const result = fn();
+        if (DEV && result !== null && typeof result?.then === "function") {
+          devWarn(
+            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
+          );
+        }
+        return result;
+      } finally {
+        setValue(previous);
+      }
+    }
+  };
+  return ctx;
+}
+
+// src/core/rendering/createId.ts
+var COUNTER_KEY = /* @__PURE__ */ Symbol.for("sibujs.createId.v1");
+var _counter = globalThis[COUNTER_KEY] ?? (globalThis[COUNTER_KEY] = { n: 0 });
+function createId(prefix = "sibu") {
+  const request = getRequestStore();
+  if (request) {
+    request.idCounter = (request.idCounter ?? 0) + 1;
+    return `${prefix}-${request.idCounter}`;
+  }
+  _counter.n++;
+  return `${prefix}-${_counter.n}`;
+}
+function __resetIdCounter() {
+  _counter.n = 0;
+}
+
 // src/utils/globalSingleton.ts
 function globalSingleton(key, create) {
   const g2 = globalThis;
@@ -4762,6 +5291,7 @@ function each(getArray, render, options) {
   );
   requireDocument();
   const anchor = document.createComment("each:anchor");
+  const scope = captureScope();
   const end = document.createComment("each:end");
   const oldKeysBufA = [];
   const oldKeysBufB = [];
@@ -4791,7 +5321,9 @@ function each(getArray, render, options) {
     const parent = anchor.parentNode;
     if (!parent) return;
     if (!sentinelInserted) {
-      parent.insertBefore(end, anchor.nextSibling);
+      const serverEnd = isHydrating() ? findServerEnd(anchor) : null;
+      if (serverEnd) parent.replaceChild(end, serverEnd);
+      else parent.insertBefore(end, anchor.nextSibling);
       sentinelInserted = true;
     }
     if (newKeysBuf.length < newLen) {
@@ -4832,7 +5364,7 @@ function each(getArray, render, options) {
         try {
           suspendTracking2();
           try {
-            node = resolveNodeChild(render(itemGetter, indexGetter));
+            node = resolveNodeChild(inScope(keyedScope(scope, key), () => render(itemGetter, indexGetter)));
           } finally {
             resumeTracking2();
           }
@@ -4966,6 +5498,19 @@ function each(getArray, render, options) {
   }
   return anchor;
 }
+function findServerEnd(anchor) {
+  let depth = 0;
+  for (let n = anchor.nextSibling; n; n = n.nextSibling) {
+    if (n.nodeType !== 8) continue;
+    const data2 = n.data;
+    if (data2 === "each:anchor") depth++;
+    else if (data2 === "each:end") {
+      if (depth === 0) return n;
+      depth--;
+    }
+  }
+  return null;
+}
 
 // src/core/rendering/fragment.ts
 function Fragment(nodes) {
@@ -5089,19 +5634,19 @@ function parseTemplate(strings) {
       pos++;
       const statics = [];
       const exprs = [];
-      let current = "";
+      let current2 = "";
       while (pos < len && template2[pos] !== quote2) {
         const innerIdx = tryExprIdx();
         if (innerIdx >= 0) {
-          statics.push(current);
-          current = "";
+          statics.push(current2);
+          current2 = "";
           exprs.push(innerIdx);
         } else {
-          current += template2[pos++];
+          current2 += template2[pos++];
         }
       }
       if (pos < len) pos++;
-      statics.push(current);
+      statics.push(current2);
       if (exprs.length === 0) {
         return { kind: "static", value: statics[0] };
       }
@@ -5110,20 +5655,20 @@ function parseTemplate(strings) {
     {
       const statics = [];
       const exprs = [];
-      let current = "";
+      let current2 = "";
       while (pos < len) {
         const c = template2.charCodeAt(pos);
         if (c === 32 || c === 9 || c === 10 || c === 13 || c === 62) break;
         const innerIdx = tryExprIdx();
         if (innerIdx >= 0) {
-          statics.push(current);
-          current = "";
+          statics.push(current2);
+          current2 = "";
           exprs.push(innerIdx);
         } else {
-          current += template2[pos++];
+          current2 += template2[pos++];
         }
       }
-      statics.push(current);
+      statics.push(current2);
       if (exprs.length === 0) {
         return { kind: "static", value: statics[0] };
       }
@@ -5247,7 +5792,7 @@ function parseTemplate(strings) {
   return parseChildren();
 }
 function executeElement(tmpl, values) {
-  const el = tmpl.svg ? document.createElementNS(SVG_NS3, tmpl.tag) : document.createElement(tmpl.tag);
+  const el = createScopedElement(tmpl.tag, tmpl.svg ? SVG_NS3 : void 0);
   for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
     const attr = tmpl.attrs[i2];
     switch (attr.t) {
@@ -5340,7 +5885,7 @@ function renderTemplate(tmpl, values) {
   if (tmpl.length === 1 && tmpl[0].t === 0) {
     return executeElement(tmpl[0].el, values);
   }
-  const wrapper = document.createElement("div");
+  const wrapper = createScopedElement("div");
   for (let i2 = 0; i2 < tmpl.length; i2++) {
     const child = tmpl[i2];
     switch (child.t) {
@@ -5584,8 +6129,8 @@ function Portal(nodes, target) {
 // src/core/rendering/slots.ts
 function getSlot(slots, name = "default") {
   if (slots == null || !Object.hasOwn(slots, name)) return void 0;
-  const slot2 = slots[name];
-  return typeof slot2 === "function" ? slot2 : void 0;
+  const slot4 = slots[name];
+  return typeof slot4 === "function" ? slot4 : void 0;
 }
 
 // src/core/signals/array.ts
@@ -5669,7 +6214,7 @@ function reactiveArray(initial = []) {
   let data2 = [...initial];
   let snapshot = null;
   const signal2 = { __v: 0 };
-  function notify() {
+  function notify2() {
     snapshot = null;
     signal2.__v++;
     if (!enqueueBatchedSignal(signal2)) {
@@ -5688,52 +6233,52 @@ function reactiveArray(initial = []) {
     push(...items) {
       if (items.length === 0) return;
       data2.push(...items);
-      notify();
+      notify2();
     },
     pop() {
       if (data2.length === 0) return void 0;
       const removed = data2.pop();
-      notify();
+      notify2();
       return removed;
     },
     shift() {
       if (data2.length === 0) return void 0;
       const removed = data2.shift();
-      notify();
+      notify2();
       return removed;
     },
     unshift(...items) {
       if (items.length === 0) return;
       data2.unshift(...items);
-      notify();
+      notify2();
     },
     splice(start, ...rest) {
       const removed = nativeSplice(data2, start, rest);
       if (removed.length > 0 || rest.length > 1) {
-        notify();
+        notify2();
       }
       return removed;
     },
     remove(index) {
       if (index < 0 || index >= data2.length) return;
       data2.splice(index, 1);
-      notify();
+      notify2();
     },
     removeWhere(predicate) {
       const idx = data2.findIndex(predicate);
       if (idx === -1) return;
       data2.splice(idx, 1);
-      notify();
+      notify2();
     },
     set(items) {
       data2 = [...items];
-      notify();
+      notify2();
     },
     update(index, value) {
       if (index < 0 || index >= data2.length) return;
       if (Object.is(data2[index], value)) return;
       data2[index] = value;
-      notify();
+      notify2();
     },
     updateWhere(predicate, updater) {
       let changed = false;
@@ -5746,23 +6291,23 @@ function reactiveArray(initial = []) {
           }
         }
       }
-      if (changed) notify();
+      if (changed) notify2();
     },
     sort(compareFn) {
       if (data2.length <= 1) return;
       data2.sort(compareFn);
-      notify();
+      notify2();
     },
     reverse() {
       if (data2.length <= 1) return;
       data2.reverse();
-      notify();
+      notify2();
     },
     filter(predicate) {
       const filtered = data2.filter(predicate);
       if (filtered.length === data2.length) return;
       data2 = filtered;
-      notify();
+      notify2();
     },
     map(transform) {
       let changed = false;
@@ -5773,12 +6318,12 @@ function reactiveArray(initial = []) {
           changed = true;
         }
       }
-      if (changed) notify();
+      if (changed) notify2();
     },
     clear() {
       if (data2.length === 0) return;
       data2 = [];
-      notify();
+      notify2();
     }
   };
   return [get, actions];
@@ -6116,8 +6661,8 @@ function store(initialState) {
     return snapshot;
   };
   const setState = (patch) => {
-    const current = getSnapshot();
-    const nextState = typeof patch === "function" ? patch(current) : patch;
+    const current2 = getSnapshot();
+    const nextState = typeof patch === "function" ? patch(current2) : patch;
     batch(() => {
       Object.entries(nextState).forEach(([key, value]) => {
         if (Object.hasOwn(signals, key)) {
@@ -6154,18 +6699,18 @@ function store(initialState) {
     let prev;
     let first = true;
     return effect(() => {
-      const current = signals[key][0]();
+      const current2 = signals[key][0]();
       if (first) {
-        prev = current;
+        prev = current2;
         first = false;
         return;
       }
-      if (!Object.is(current, prev)) {
+      if (!Object.is(current2, prev)) {
         const oldPrev = prev;
-        prev = current;
+        prev = current2;
         suspendTracking2();
         try {
-          callback(current, oldPrev);
+          callback(current2, oldPrev);
         } finally {
           resumeTracking2();
         }
@@ -6802,6 +7347,7 @@ var SUBPATH_ENTRIES = [
   "ui",
   "widgets",
   "ssr",
+  "ssr/dom",
   "devtools",
   "performance",
   "ecosystem",
@@ -6876,7 +7422,7 @@ function generateImportMap(baseUrl) {
     [PACKAGE_NAME]: `${base2}/dist/index.js`
   };
   for (const entry of SUBPATH_ENTRIES) {
-    imports[`${PACKAGE_NAME}/${entry}`] = `${base2}/dist/${entry}.js`;
+    imports[`${PACKAGE_NAME}/${entry}`] = `${base2}/dist/${entry.replace("/", "-")}.js`;
   }
   return {
     imports,
@@ -7692,38 +8238,38 @@ function parseTemplate2(strings) {
       pos++;
       const statics2 = [];
       const exprs2 = [];
-      let current2 = "";
+      let current3 = "";
       while (pos < len && template2[pos] !== quote2) {
         const innerIdx = tryExprIdx();
         if (innerIdx >= 0) {
-          statics2.push(current2);
-          current2 = "";
+          statics2.push(current3);
+          current3 = "";
           exprs2.push(innerIdx);
         } else {
-          current2 += template2[pos++];
+          current3 += template2[pos++];
         }
       }
       if (pos < len) pos++;
-      statics2.push(current2);
+      statics2.push(current3);
       if (exprs2.length === 0) return { kind: "static", value: statics2[0] };
       return { kind: "mixed", statics: statics2, exprs: exprs2 };
     }
     const statics = [];
     const exprs = [];
-    let current = "";
+    let current2 = "";
     while (pos < len) {
       const c = template2.charCodeAt(pos);
       if (c === 32 || c === 9 || c === 10 || c === 13 || c === 62) break;
       const innerIdx = tryExprIdx();
       if (innerIdx >= 0) {
-        statics.push(current);
-        current = "";
+        statics.push(current2);
+        current2 = "";
         exprs.push(innerIdx);
       } else {
-        current += template2[pos++];
+        current2 += template2[pos++];
       }
     }
-    statics.push(current);
+    statics.push(current2);
     if (exprs.length === 0) return { kind: "static", value: statics[0] };
     return { kind: "mixed", statics, exprs };
   }
@@ -9129,7 +9675,7 @@ function findEntryInHtml(html3) {
   const m = MODULE_SCRIPT.exec(html3) ?? MODULE_SCRIPT_SRC_FIRST.exec(html3);
   return m ? m[1] : null;
 }
-function outputFileFor(route) {
+function outputFileFor(route, trailingSlash = "always") {
   if (route.output) {
     const output2 = route.output;
     if (/^[A-Za-z]:/.test(output2) || output2.includes("\0")) {
@@ -9159,6 +9705,10 @@ function outputFileFor(route) {
     }
     return decoded;
   });
+  if (trailingSlash === "never" && segments.length > 0) {
+    const last = segments.pop();
+    return [...segments, `${last}.html`].join("/");
+  }
   return [...segments, "index.html"].join("/");
 }
 function resolveInsideOutDir(path2, outDir, file) {
@@ -9174,17 +9724,36 @@ async function prerender(options, ctx) {
   const path2 = await import("path");
   const { pathToFileURL } = await import("url");
   const { createRequire } = await import("module");
+  const requireFromRoot = createRequire(path2.join(ctx.root, "package.json"));
+  if (options.server) {
+    const { prerenderFromServerEntry: prerenderFromServerEntry2 } = await Promise.resolve().then(() => (init_prerenderServer(), prerenderServer_exports));
+    return prerenderFromServerEntry2(options, ctx, {
+      outputFileFor,
+      resolveInsideOutDir,
+      loadViteBuild: () => loadViteBuild(requireFromRoot, fs, path2, pathToFileURL),
+      childEnv: PRERENDER_CHILD_ENV
+    });
+  }
+  if (options.routes === void 0 || options.routes === "auto") {
+    throw new Error(
+      '[sibu prerender] `routes: "auto"` needs a server entry (`prerender.server`); list the routes instead.'
+    );
+  }
   const routes = options.routes.map((r) => typeof r === "string" ? { path: r } : r);
+  if (options.notFound) routes.push({ path: options.notFound, output: "404.html" });
   if (routes.length === 0) return [];
+  const trailingSlash = options.trailingSlash === "never" ? "never" : "always";
+  const outDir = options.outDir ? path2.resolve(ctx.root, options.outDir) : ctx.outDir;
   const planned = routes.map((route) => {
-    const file = outputFileFor(route);
-    resolveInsideOutDir(path2, ctx.outDir, file);
+    const file = outputFileFor(route, trailingSlash);
+    resolveInsideOutDir(path2, outDir, file);
     return { route, file };
   });
   const origin = (options.origin ?? "http://localhost").replace(/\/+$/, "");
   const timeout = options.timeout ?? 15e3;
   const settle = options.settle ?? 50;
-  const templatePath = path2.join(ctx.outDir, "index.html");
+  const keptShell = path2.join(ctx.outDir, typeof options.shell === "string" ? options.shell : "200.html");
+  const templatePath = await fs.access(keptShell).then(() => keptShell).catch(() => path2.join(ctx.outDir, "index.html"));
   const template2 = await fs.readFile(templatePath, "utf8");
   let entry = options.entry;
   if (!entry) {
@@ -9202,7 +9771,7 @@ async function prerender(options, ctx) {
   } catch {
     throw new Error("[sibu prerender] needs jsdom to render routes. Install it: npm i -D jsdom");
   }
-  const tmpDir = path2.join(ctx.outDir, ".sibu-prerender");
+  const tmpDir = path2.join(outDir, ".sibu-prerender");
   await fs.rm(tmpDir, { recursive: true, force: true });
   const viteBuild = await loadViteBuild(requireFromApp, fs, path2, pathToFileURL);
   const prev = process.env[PRERENDER_CHILD_ENV];
@@ -9232,10 +9801,12 @@ async function prerender(options, ctx) {
   await fs.writeFile(workerFile, WORKER_SOURCE, "utf8");
   const entryUrl = pathToFileURL(path2.join(tmpDir, "entry.mjs")).href;
   const jsdomUrl = pathToFileURL(jsdomPath).href;
+  await fs.mkdir(outDir, { recursive: true });
   if (options.shell !== false) {
-    await fs.writeFile(path2.join(ctx.outDir, options.shell ?? "200.html"), template2, "utf8");
+    await fs.writeFile(path2.join(outDir, options.shell ?? "200.html"), template2, "utf8");
   }
   const results = [];
+  const indexable = [];
   const queue = [...planned];
   const concurrency = Math.max(1, options.concurrency ?? 4);
   try {
@@ -9253,16 +9824,35 @@ async function prerender(options, ctx) {
             timeout,
             settle
           });
-          const target = resolveInsideOutDir(path2, ctx.outDir, file);
+          const target = resolveInsideOutDir(path2, outDir, file);
           await fs.mkdir(path2.dirname(target), { recursive: true });
           await fs.writeFile(target, html3, "utf8");
           results.push({ route: route.path, file, ms: Date.now() - started });
+          if (file !== "404.html" && !/<meta\b[^>]*name=["']robots["'][^>]*content=["'][^"']*noindex/i.test(html3)) {
+            const pathname = route.path.split(/[?#]/)[0];
+            indexable.push(
+              trailingSlash === "always" && pathname !== "/" ? `${pathname.replace(/\/+$/, "")}/` : pathname
+            );
+          }
         }
       })
     );
   } finally {
     await fs.rm(tmpDir, { recursive: true, force: true });
   }
+  if (options.sitemap && indexable.length > 0) {
+    const { buildSitemap: buildSitemap2 } = await Promise.resolve().then(() => (init_prerenderServer(), prerenderServer_exports));
+    await fs.writeFile(path2.join(outDir, "sitemap.xml"), buildSitemap2(origin, indexable.sort()), "utf8");
+  }
+  if (options.robots) {
+    const extra = typeof options.robots === "string" ? `${options.robots.trim()}
+` : "";
+    const sitemapLine = options.sitemap && indexable.length > 0 ? `Sitemap: ${origin}/sitemap.xml
+` : "";
+    await fs.writeFile(path2.join(outDir, "robots.txt"), `User-agent: *
+Allow: /
+${extra}${sitemapLine}`, "utf8");
+  }
   return results;
 }
 function esmEntryOf(entry) {
@@ -9297,6 +9887,7 @@ async function loadViteBuild(requireFromApp, fs, path2, pathToFileURL) {
   }
   return build;
 }
+var STARTUP_TIMEOUT = 6e4;
 async function renderInWorker(workerFile, input2) {
   const { Worker } = await import("worker_threads");
   return new Promise((resolve, reject) => {
@@ -9308,12 +9899,14 @@ async function renderInWorker(workerFile, input2) {
       fn();
       void worker.terminate();
     };
-    const timer = setTimeout(
-      () => finish(() => reject(new Error(`[sibu prerender] ${input2.route}: worker did not respond`))),
-      input2.timeout + 5e3
-    );
-    worker.once("message", (msg) => {
+    const backstop = (ms, what) => setTimeout(() => finish(() => reject(new Error(`[sibu prerender] ${input2.route}: ${what}`))), ms);
+    let timer = backstop(Math.max(STARTUP_TIMEOUT, input2.timeout + 5e3), "worker did not load the app");
+    worker.on("message", (msg) => {
       clearTimeout(timer);
+      if (msg.loaded) {
+        timer = backstop(input2.timeout + 5e3, "worker did not respond");
+        return;
+      }
       if (typeof msg.html === "string") finish(() => resolve(msg.html));
       else finish(() => reject(new Error(`[sibu prerender] ${input2.route}: ${msg.error}`)));
     });
@@ -9426,6 +10019,8 @@ try {
   process.on("unhandledRejection", (reason) => errors.push(reason));
 
   await import(entryUrl);
+  // The route's timeout starts now; the parent's backstop restarts with it.
+  parentPort.postMessage({ loaded: true });
 
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
   const started = Date.now();
@@ -9640,7 +10235,7 @@ function parserSafeText(s2) {
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function escapeAttr(str) {
+function escapeAttr2(str) {
   return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function attributeHtml(name, lit) {
@@ -9656,7 +10251,7 @@ function attributeHtml(name, lit) {
     return on2 ? `${lower}=""` : "";
   }
   if (!parserSafeText(lit.value)) return null;
-  return `${lower}="${escapeAttr(lit.value)}"`;
+  return `${lower}="${escapeAttr2(lit.value)}"`;
 }
 function parseCall(code2, list, i2) {
   const at = (k2) => list[k2];
@@ -9731,8 +10326,8 @@ function parseCall(code2, list, i2) {
 }
 function toHtml(tag, call) {
   const attrs = [];
-  if (call.cls !== null) attrs.push(`class="${escapeAttr(call.cls)}"`);
-  if (call.id !== null) attrs.push(`id="${escapeAttr(call.id)}"`);
+  if (call.cls !== null) attrs.push(`class="${escapeAttr2(call.cls)}"`);
+  if (call.id !== null) attrs.push(`id="${escapeAttr2(call.id)}"`);
   attrs.push(...call.attrs);
   const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
   if (VOID_ELEMENTS3.has(tag)) {
@@ -9832,6 +10427,7 @@ function sibuVitePlugin(options = {}) {
   return {
     name: "sibu-vite-plugin",
     enforce: "pre",
+    api: { prerender: prerenderOptions },
     config(_userConfig, env) {
       isDevMode = resolveDevMode(devMode, env);
       return {
@@ -9872,7 +10468,10 @@ function sibuVitePlugin(options = {}) {
       const target = prerenderTarget;
       prerenderTarget = null;
       const results = await prerender(prerenderOptions, target);
-      for (const r of results) console.log(`[sibu prerender] ${r.route} \u2192 ${r.file} (${r.ms} ms)`);
+      for (const r of results) {
+        const what = r.kind === "redirect" ? `redirect ${r.status} (redirects.json)` : r.kind === "skipped" ? `skipped (${r.status})` : r.file;
+        console.log(`[sibu prerender] ${r.route} \u2192 ${what} (${r.ms} ms)`);
+      }
     },
     transform(code2, id) {
       if (!matchesPattern(id, include) || matchesPattern(id, exclude)) {