sibujs 4.6.0 → 4.8.0

package/dist/build.cjs

@@ -59,8 +59,1310 @@ __export(build_exports, {
 });
 module.exports = __toCommonJS(build_exports);
 
-// src/build/compileTemplates.ts
+// src/build/sourceEdit.ts
+function isLineBreak(c) {
+  return c === 10 || c === 13 || c === 8232 || c === 8233;
+}
+function lineBreaksIn(code2, start, end) {
+  let out = "";
+  for (let i2 = start; i2 < end; i2++) {
+    if (isLineBreak(code2.charCodeAt(i2))) out += code2[i2];
+  }
+  return out;
+}
+var LINE_SEPARATOR = String.fromCharCode(8232);
+var PARAGRAPH_SEPARATOR = String.fromCharCode(8233);
+function jsStringLiteral(value) {
+  const json = JSON.stringify(value);
+  if (!json.includes(LINE_SEPARATOR) && !json.includes(PARAGRAPH_SEPARATOR)) return json;
+  const bs = "\\";
+  return json.split(LINE_SEPARATOR).join(`${bs}u2028`).split(PARAGRAPH_SEPARATOR).join(`${bs}u2029`);
+}
+function normalizeEdits(edits) {
+  const sorted = edits.map((edit, order) => ({ edit, order })).sort(
+    (a2, b2) => a2.edit.start - b2.edit.start || a2.edit.end - a2.edit.start - (b2.edit.end - b2.edit.start) || a2.order - b2.order
+  ).map((x) => x.edit);
+  for (let i2 = 1; i2 < sorted.length; i2++) {
+    if (sorted[i2].start < sorted[i2 - 1].end) return null;
+  }
+  return sorted;
+}
+function applyEdits(code2, edits, append = "") {
+  let out = "";
+  let pos = 0;
+  for (const edit of edits) {
+    out += code2.slice(pos, edit.start) + edit.text;
+    pos = edit.end;
+  }
+  return out + code2.slice(pos) + append;
+}
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function vlq(value) {
+  let v = value < 0 ? -value << 1 | 1 : value << 1;
+  let out = "";
+  do {
+    let digit = v & 31;
+    v >>>= 5;
+    if (v > 0) digit |= 32;
+    out += BASE64[digit];
+  } while (v > 0);
+  return out;
+}
+function isWordStart(c) {
+  return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c === 95 || c === 36 || c > 127 || c >= 48 && c <= 57;
+}
+function editsSourceMap(code2, edits, append, source2) {
+  const lineStarts = [0];
+  for (let i2 = 0; i2 < code2.length; i2++) if (code2.charCodeAt(i2) === 10) lineStarts.push(i2 + 1);
+  const origLine = (offset) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  };
+  const lines = [[]];
+  let col2 = 0;
+  const mark2 = (offset) => {
+    const line2 = lines[lines.length - 1];
+    const last = line2[line2.length - 1];
+    if (last && last[0] === col2) return;
+    const ol2 = origLine(offset);
+    line2.push([col2, ol2, offset - lineStarts[ol2]]);
+  };
+  const newline = () => {
+    lines.push([]);
+    col2 = 0;
+  };
+  const emitOriginal = (from, to) => {
+    for (let i2 = from; i2 < to; i2++) {
+      const c = code2.charCodeAt(i2);
+      if (c === 10) {
+        newline();
+        continue;
+      }
+      if (i2 === from || col2 === 0 || isWordStart(c) && !isWordStart(code2.charCodeAt(i2 - 1))) mark2(i2);
+      col2++;
+    }
+  };
+  const emitReplacement = (edit) => {
+    let origOffset = edit.start;
+    let pending = true;
+    for (let i2 = 0; i2 < edit.text.length; i2++) {
+      if (edit.text.charCodeAt(i2) === 10) {
+        newline();
+        const nl = code2.indexOf("\n", origOffset);
+        if (nl !== -1 && nl < edit.end) {
+          origOffset = nl + 1;
+          pending = true;
+        } else {
+          pending = false;
+        }
+        continue;
+      }
+      if (pending) {
+        mark2(origOffset);
+        pending = false;
+      }
+      col2++;
+    }
+  };
+  let pos = 0;
+  for (const edit of edits) {
+    emitOriginal(pos, edit.start);
+    emitReplacement(edit);
+    pos = edit.end;
+  }
+  emitOriginal(pos, code2.length);
+  for (let i2 = 0; i2 < append.length; i2++) {
+    if (append.charCodeAt(i2) === 10) newline();
+  }
+  let prevLine = 0;
+  let prevCol = 0;
+  let prevSource = 0;
+  const mappings = lines.map((segments) => {
+    let prevGen = 0;
+    return segments.map(([gen, ol2, oc]) => {
+      const s2 = vlq(gen - prevGen) + vlq(0 - prevSource) + vlq(ol2 - prevLine) + vlq(oc - prevCol);
+      prevGen = gen;
+      prevSource = 0;
+      prevLine = ol2;
+      prevCol = oc;
+      return s2;
+    }).join(",");
+  }).join(";");
+  return { version: 3, sources: [source2], sourcesContent: [code2], names: [], mappings };
+}
+
+// src/build/sourceScan.ts
+var REGEX_AFTER_KEYWORD = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+function isIdentStart(c) {
+  return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c === 95 || c === 36 || c > 127;
+}
+function isIdentPart(c) {
+  return isIdentStart(c) || c >= 48 && c <= 57;
+}
+function isDigit(c) {
+  return c >= 48 && c <= 57;
+}
+var ScanError = class extends Error {
+};
+var scanStats = { tokenize: 0 };
+function tokenize(code2) {
+  scanStats.tokenize++;
+  let pos = 0;
+  const len = code2.length;
+  if (code2.startsWith("#!")) {
+    const nl = code2.indexOf("\n");
+    pos = nl === -1 ? len : nl;
+  }
+  function regexAllowed(prev) {
+    if (!prev) return true;
+    switch (prev.type) {
+      case "number":
+      case "string":
+      case "regex":
+      case "template":
+        return false;
+      case "ident":
+        return REGEX_AFTER_KEYWORD.has(prev.value);
+      case "punct":
+        return prev.value !== ")" && prev.value !== "]";
+    }
+  }
+  function skipTrivia() {
+    while (pos < len) {
+      const c = code2.charCodeAt(pos);
+      if (c === 32 || c === 9 || c === 10 || c === 13 || c === 11 || c === 12 || c === 160 || c === 65279) {
+        pos++;
+      } else if (c === 8232 || c === 8233) {
+        pos++;
+      } else if (c === 47 && code2.charCodeAt(pos + 1) === 47) {
+        pos += 2;
+        while (pos < len) {
+          const d = code2.charCodeAt(pos);
+          if (d === 10 || d === 13 || d === 8232 || d === 8233) break;
+          pos++;
+        }
+      } else if (c === 47 && code2.charCodeAt(pos + 1) === 42) {
+        const end = code2.indexOf("*/", pos + 2);
+        if (end === -1) throw new ScanError("unterminated comment");
+        pos = end + 2;
+      } else {
+        break;
+      }
+    }
+  }
+  function readString() {
+    const start = pos;
+    const quote2 = code2[pos];
+    pos++;
+    while (pos < len) {
+      const c = code2[pos];
+      if (c === "\\") {
+        pos += 2;
+        continue;
+      }
+      if (c === quote2) {
+        pos++;
+        return { type: "string", start, end: pos };
+      }
+      if (c === "\n" || c === "\r") throw new ScanError("line break in string");
+      pos++;
+    }
+    throw new ScanError("unterminated string");
+  }
+  function readRegex() {
+    const start = pos;
+    pos++;
+    let inClass = false;
+    while (pos < len) {
+      const c = code2[pos];
+      if (c === "\\") {
+        pos += 2;
+        continue;
+      }
+      if (c === "\n" || c === "\r") throw new ScanError("line break in regex");
+      if (inClass) {
+        if (c === "]") inClass = false;
+      } else if (c === "[") {
+        inClass = true;
+      } else if (c === "/") {
+        pos++;
+        while (pos < len && isIdentPart(code2.charCodeAt(pos))) pos++;
+        return { type: "regex", start, end: pos };
+      }
+      pos++;
+    }
+    throw new ScanError("unterminated regex");
+  }
+  function readTemplate() {
+    const start = pos;
+    pos++;
+    const quasis = [];
+    const exprs = [];
+    let quasiStart = pos;
+    while (pos < len) {
+      const c = code2[pos];
+      if (c === "\\") {
+        pos += 2;
+        continue;
+      }
+      if (c === "`") {
+        quasis.push({ start: quasiStart, end: pos });
+        pos++;
+        return { type: "template", start, end: pos, quasis, exprs };
+      }
+      if (c === "$" && code2[pos + 1] === "{") {
+        quasis.push({ start: quasiStart, end: pos });
+        pos += 2;
+        const exprStart = pos;
+        const tokens = readList(true);
+        exprs.push({ start: exprStart, end: pos, tokens });
+        pos++;
+        quasiStart = pos;
+        continue;
+      }
+      pos++;
+    }
+    throw new ScanError("unterminated template");
+  }
+  function readList(inTemplateExpr) {
+    const tokens = [];
+    let depth = 0;
+    for (; ; ) {
+      skipTrivia();
+      if (pos >= len) {
+        if (inTemplateExpr || depth !== 0) throw new ScanError("unexpected end of input");
+        return tokens;
+      }
+      const c = code2.charCodeAt(pos);
+      const prev = tokens[tokens.length - 1];
+      if (c === 34 || c === 39) {
+        tokens.push(readString());
+      } else if (c === 96) {
+        tokens.push(readTemplate());
+      } else if (isIdentStart(c) || c === 92) {
+        const start = pos;
+        pos++;
+        while (pos < len) {
+          const d = code2.charCodeAt(pos);
+          if (isIdentPart(d)) pos++;
+          else if (d === 92) pos += 2;
+          else break;
+        }
+        tokens.push({ type: "ident", start, end: pos, value: code2.slice(start, pos) });
+      } else if (isDigit(c) || c === 46 && isDigit(code2.charCodeAt(pos + 1))) {
+        const start = pos;
+        pos++;
+        while (pos < len) {
+          const d = code2.charCodeAt(pos);
+          if (isIdentPart(d) || d === 46) pos++;
+          else break;
+        }
+        tokens.push({ type: "number", start, end: pos, value: code2.slice(start, pos) });
+      } else if (c === 47 && regexAllowed(prev)) {
+        tokens.push(readRegex());
+      } else {
+        const start = pos;
+        let value = code2[pos];
+        if (code2.startsWith("...", pos)) value = "...";
+        else if (code2.startsWith("?.", pos) && !isDigit(code2.charCodeAt(pos + 2))) value = "?.";
+        else if (code2.startsWith("=>", pos)) value = "=>";
+        pos += value.length;
+        if (value === "{") {
+          depth++;
+        } else if (value === "}") {
+          if (depth === 0) {
+            if (inTemplateExpr) {
+              pos = start;
+              return tokens;
+            }
+            throw new ScanError("unbalanced brace");
+          }
+          depth--;
+        }
+        tokens.push({ type: "punct", start, end: pos, value });
+      }
+    }
+  }
+  try {
+    return readList(false);
+  } catch (err) {
+    if (err instanceof ScanError) return null;
+    throw err;
+  }
+}
+function cookEscapes(raw) {
+  let out = "";
+  let i2 = 0;
+  const n = raw.length;
+  while (i2 < n) {
+    const ch = raw[i2];
+    if (ch === "\r") {
+      out += "\n";
+      i2 += raw[i2 + 1] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (ch !== "\\") {
+      out += ch;
+      i2++;
+      continue;
+    }
+    const e = raw[i2 + 1];
+    i2 += 2;
+    switch (e) {
+      case "n":
+        out += "\n";
+        break;
+      case "t":
+        out += "	";
+        break;
+      case "r":
+        out += "\r";
+        break;
+      case "b":
+        out += "\b";
+        break;
+      case "f":
+        out += "\f";
+        break;
+      case "v":
+        out += "\v";
+        break;
+      case "0":
+        if (i2 < n && isDigit(raw.charCodeAt(i2))) return null;
+        out += "\0";
+        break;
+      case "x": {
+        const hex = raw.slice(i2, i2 + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hex)) return null;
+        out += String.fromCharCode(Number.parseInt(hex, 16));
+        i2 += 2;
+        break;
+      }
+      case "u": {
+        if (raw[i2] === "{") {
+          const close = raw.indexOf("}", i2);
+          if (close === -1) return null;
+          const hex = raw.slice(i2 + 1, close);
+          if (!/^[0-9a-fA-F]+$/.test(hex)) return null;
+          const cp = Number.parseInt(hex, 16);
+          if (cp > 1114111) return null;
+          out += String.fromCodePoint(cp);
+          i2 = close + 1;
+        } else {
+          const hex = raw.slice(i2, i2 + 4);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+          out += String.fromCharCode(Number.parseInt(hex, 16));
+          i2 += 4;
+        }
+        break;
+      }
+      case "\r":
+        if (raw[i2] === "\n") i2++;
+        break;
+      case "\n":
+      case "\u2028":
+      case "\u2029":
+        break;
+      case void 0:
+        return null;
+      default:
+        if (isDigit(e.charCodeAt(0))) return null;
+        out += e;
+    }
+  }
+  return out;
+}
+function stringTokenValue(code2, tok) {
+  if (tok.type !== "string") return null;
+  return cookEscapes(code2.slice(tok.start + 1, tok.end - 1));
+}
+function collectImports(code2, tokens) {
+  const decls = [];
+  for (let i2 = 0; i2 < tokens.length; i2++) {
+    const tok = tokens[i2];
+    if (tok.type !== "ident" || tok.value !== "import") continue;
+    const prev = tokens[i2 - 1];
+    if (prev && prev.type === "punct" && (prev.value === "." || prev.value === "?.")) continue;
+    const next = tokens[i2 + 1];
+    if (!next) return null;
+    if (next.type === "punct" && (next.value === "(" || next.value === ".")) continue;
+    let j = i2 + 1;
+    const bindings = [];
+    let typeOnly = false;
+    if (next.type === "string") {
+      const source3 = stringTokenValue(code2, next);
+      if (source3 === null) return null;
+      let end2 = next.end;
+      const semi = tokens[j + 1];
+      if (semi && semi.type === "punct" && semi.value === ";") end2 = semi.end;
+      decls.push({ source: source3, bindings, start: tok.start, end: end2 });
+      continue;
+    }
+    const at = (k) => tokens[k];
+    const isPunct = (k, v) => {
+      const t = at(k);
+      return !!t && t.type === "punct" && t.value === v;
+    };
+    const isIdent = (k, v) => {
+      const t = at(k);
+      return !!t && t.type === "ident" && (v === void 0 || t.value === v);
+    };
+    if (isIdent(j, "type") && !isIdent(j + 1, "from") && !isPunct(j + 1, ",")) {
+      typeOnly = true;
+      j++;
+    }
+    if (isIdent(j) && !isIdent(j, "from")) {
+      bindings.push({ imported: "default", local: at(j).value });
+      j++;
+      if (isPunct(j, ",")) j++;
+    }
+    if (isPunct(j, "*")) {
+      if (!isIdent(j + 1, "as") || !isIdent(j + 2)) return null;
+      bindings.push({ imported: "*", local: at(j + 2).value });
+      j += 3;
+    } else if (isPunct(j, "{")) {
+      j++;
+      while (!isPunct(j, "}")) {
+        const t = at(j);
+        if (!t) return null;
+        let specTypeOnly = false;
+        if (isIdent(j, "type") && (isIdent(j + 1) || at(j + 1)?.type === "string") && !isIdent(j + 1, "as")) {
+          specTypeOnly = true;
+          j++;
+        }
+        const nameTok = at(j);
+        let imported = null;
+        if (nameTok?.type === "ident") imported = nameTok.value;
+        else if (nameTok?.type === "string") imported = stringTokenValue(code2, nameTok);
+        if (imported === null) return null;
+        j++;
+        let local = imported;
+        if (isIdent(j, "as")) {
+          if (!isIdent(j + 1)) return null;
+          local = at(j + 1).value;
+          j += 2;
+        }
+        if (!specTypeOnly) bindings.push({ imported, local });
+        if (isPunct(j, ",")) j++;
+        else if (!isPunct(j, "}")) return null;
+      }
+      j++;
+    }
+    if (!isIdent(j, "from")) return null;
+    const srcTok = at(j + 1);
+    if (!srcTok || srcTok.type !== "string") return null;
+    const source2 = stringTokenValue(code2, srcTok);
+    if (source2 === null) return null;
+    let end = srcTok.end;
+    j += 2;
+    if (isIdent(j, "with") || isIdent(j, "assert")) {
+      if (!isPunct(j + 1, "{")) return null;
+      let k = j + 2;
+      while (at(k) && !isPunct(k, "}")) k++;
+      if (!at(k)) return null;
+      end = at(k).end;
+      j = k + 1;
+    }
+    if (isPunct(j, ";")) end = at(j).end;
+    decls.push({ source: source2, bindings: typeOnly ? [] : bindings, start: tok.start, end });
+    i2 = j;
+  }
+  return decls;
+}
+var SCAN_CACHE_SIZE = 4;
+var scanCache = /* @__PURE__ */ new Map();
+function scanModule(code2) {
+  const hit = scanCache.get(code2);
+  if (hit !== void 0) return hit;
+  const tokens = tokenize(code2);
+  const imports = tokens && collectImports(code2, tokens);
+  const scan = tokens && imports ? { tokens, imports } : null;
+  if (scanCache.size >= SCAN_CACHE_SIZE) scanCache.delete(scanCache.keys().next().value);
+  scanCache.set(code2, scan);
+  return scan;
+}
+function isSibuSource(source2) {
+  return source2 === "sibujs" || source2.startsWith("sibujs/");
+}
+function sibuBindings(imports, mainOnly = false) {
+  const out = /* @__PURE__ */ new Map();
+  for (const decl of imports) {
+    if (mainOnly ? decl.source !== "sibujs" : !isSibuSource(decl.source)) continue;
+    for (const b2 of decl.bindings) {
+      if (b2.imported === "*" || b2.imported === "default") continue;
+      out.set(b2.local, b2.imported);
+    }
+  }
+  return out;
+}
+function forEachBindingRef(tokens, imports, visit) {
+  const inImport = (offset) => imports.some((d) => offset >= d.start && offset < d.end);
+  const walk = (list) => {
+    for (let i2 = 0; i2 < list.length; i2++) {
+      const tok = list[i2];
+      if (tok.type === "template") {
+        for (const e of tok.exprs) walk(e.tokens);
+        continue;
+      }
+      if (tok.type !== "ident") continue;
+      const prev = list[i2 - 1];
+      if (prev && prev.type === "punct" && (prev.value === "." || prev.value === "?." || prev.value === "#")) continue;
+      if (inImport(tok.start)) continue;
+      visit({ tok, list, index: i2 });
+    }
+  };
+  walk(tokens);
+}
+var EXPRESSION_KEYWORDS = /* @__PURE__ */ new Set([...REGEX_AFTER_KEYWORD, "default", "extends"]);
+function isLineTerminator(c) {
+  return c === 10 || c === 13 || c === 8232 || c === 8233;
+}
+function lineBreakBetween(code2, from, to) {
+  for (let i2 = from; i2 < to; i2++) if (isLineTerminator(code2.charCodeAt(i2))) return true;
+  return false;
+}
+function endsValue(tok) {
+  if (!tok) return false;
+  switch (tok.type) {
+    case "number":
+    case "string":
+    case "regex":
+    case "template":
+      return true;
+    case "ident":
+      return !EXPRESSION_KEYWORDS.has(tok.value);
+    case "punct":
+      return tok.value === ")" || tok.value === "]";
+  }
+}
+function isDeclarationHead(code2, list, index) {
+  const tok = list[index];
+  const prev = list[index - 1];
+  if (prev?.type === "ident") {
+    if (prev.value === "function") return true;
+    if (!EXPRESSION_KEYWORDS.has(prev.value) && !lineBreakBetween(code2, prev.end, tok.start)) return true;
+  } else if (prev?.type === "punct") {
+    const before = list[index - 2];
+    if (prev.value === "*" && !endsValue(before) && !(before?.type === "ident" && before.value === "yield"))
+      return true;
+    if (prev.value === "@") return true;
+  }
+  let depth = 0;
+  let close = -1;
+  for (let k = index + 1; k < list.length; k++) {
+    const t = list[k];
+    if (t.type !== "punct") continue;
+    if (t.value === "(") depth++;
+    else if (t.value === ")" && --depth === 0) {
+      close = k;
+      break;
+    }
+  }
+  if (close === -1) return true;
+  const after = list[close + 1];
+  if (after?.type !== "punct") return false;
+  if (after.value === "{") return true;
+  if (after.value === ":") {
+    if (!prev) return true;
+    if (prev.type === "punct") return ["{", "}", ";", ",", "*"].includes(prev.value);
+    return prev.type === "ident" && !EXPRESSION_KEYWORDS.has(prev.value);
+  }
+  return false;
+}
+function bindingUses(code2, scan, names) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const bound = /* @__PURE__ */ new Map();
+  for (const decl of scan.imports) {
+    for (const b2 of decl.bindings) bound.set(b2.local, (bound.get(b2.local) ?? 0) + 1);
+  }
+  for (const name of names) if ((bound.get(name) ?? 0) > 1) shadowed.add(name);
+  const calls = [];
+  const tagged = [];
+  forEachBindingRef(scan.tokens, scan.imports, (ref2) => {
+    const { tok, list, index } = ref2;
+    if (!names.has(tok.value)) return;
+    const next = list[index + 1];
+    if (next && next.type === "punct" && next.value === "(") {
+      if (isDeclarationHead(code2, list, index)) shadowed.add(tok.value);
+      else calls.push(ref2);
+    } else if (next && next.type === "template") {
+      const prev = list[index - 1];
+      if (prev?.type === "punct" && prev.value === "@") shadowed.add(tok.value);
+      else tagged.push(ref2);
+    } else {
+      shadowed.add(tok.value);
+    }
+  });
+  return {
+    calls: calls.filter((r) => !shadowed.has(r.tok.value)),
+    tagged: tagged.filter((r) => !shadowed.has(r.tok.value)),
+    shadowed
+  };
+}
+function uniquePrefix(code2, base2 = "__sibujs") {
+  let prefix = `${base2}$`;
+  for (let n = 1; code2.includes(prefix); n++) prefix = `${base2}${n}$`;
+  return prefix;
+}
+var PURE_FACTORIES = /* @__PURE__ */ new Set([
+  "tagFactory",
+  "context",
+  "defineComponent",
+  "withProps",
+  "withDefaults",
+  "pure",
+  "noSideEffect"
+]);
+var PURE_COMMENT = "/*#__PURE__*/ ";
+function pureAnnotationEdits(code2) {
+  if (!code2.includes("sibujs")) return [];
+  const scan = scanModule(code2);
+  if (!scan) return [];
+  const candidates = /* @__PURE__ */ new Set();
+  for (const [local, imported] of sibuBindings(scan.imports)) if (PURE_FACTORIES.has(imported)) candidates.add(local);
+  if (candidates.size === 0) return [];
+  const uses = bindingUses(code2, scan, candidates);
+  const unsafe = new Set(uses.shadowed);
+  for (const ref2 of uses.tagged) unsafe.add(ref2.tok.value);
+  return uses.calls.filter(({ tok }) => {
+    if (unsafe.has(tok.value)) return false;
+    return !/\/\*\s*[#@]__PURE__\s*\*\/\s*$/.test(code2.slice(Math.max(0, tok.start - 40), tok.start));
+  }).map(({ tok }) => ({ start: tok.start, end: tok.start, text: PURE_COMMENT }));
+}
+function injectPureAnnotations(code2) {
+  const edits = normalizeEdits(pureAnnotationEdits(code2));
+  return edits && edits.length > 0 ? applyEdits(code2, edits) : code2;
+}
+function importsSibu(code2) {
+  if (!code2.includes("sibujs")) return false;
+  const scan = scanModule(code2);
+  return !!scan?.imports.some((d) => isSibuSource(d.source));
+}
+
+// src/core/dev.ts
+var DEV = typeof __SIBU_DEV__ !== "undefined" ? !!__SIBU_DEV__ : typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
+  // safe default: off in browser, on in test/dev Node
+  typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+);
+function isDev() {
+  if (typeof globalThis.__SIBU_DEV__ !== "undefined") return !!globalThis.__SIBU_DEV__;
+  if (typeof __SIBU_DEV__ !== "undefined") return !!__SIBU_DEV__;
+  return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+}
+function devAssert(condition, message) {
+  if ((typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) && !condition) {
+    throw new Error(`[SibuJS] ${message}`);
+  }
+}
+function devWarnLazy(build) {
+  if (typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) {
+    const message = build();
+    if (message) console.warn(`[SibuJS] ${message}`);
+  }
+}
+function devWarn(message) {
+  if (typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) {
+    console.warn(`[SibuJS] ${message}`);
+  }
+}
+
+// src/utils/sanitize.ts
+function stripControlChars(value) {
+  return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
+}
+var ASCII_UPPER = /[A-Z]/;
+var ASCII_UPPER_G = /[A-Z]/g;
+function canonicalAttrName(name) {
+  return ASCII_UPPER.test(name) ? name.replace(ASCII_UPPER_G, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32)) : name;
+}
+function isEventHandlerAttr(name) {
+  if (name.length < 3) return false;
+  const lower = name.toLowerCase();
+  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
+}
+var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
+var OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
+function sanitizeUrl(url) {
+  const probe = stripControlChars(url).trim();
+  if (!probe) return "";
+  const output2 = url.replace(OUTER_TRIM, "");
+  if (probe.length >= 2 && (probe[0] === "\\" || probe[0] === "/") && (probe[1] === "\\" || probe[1] === "/") && (probe[0] === "\\" || probe[1] === "\\")) {
+    return "";
+  }
+  const lower = probe.toLowerCase();
+  let schemeEnd = -1;
+  for (let i2 = 0; i2 < lower.length; i2++) {
+    const ch = lower.charCodeAt(i2);
+    if (ch === 58) {
+      schemeEnd = i2;
+      break;
+    }
+    if (ch === 47 || ch === 63 || ch === 35) break;
+  }
+  if (schemeEnd === -1) return output2;
+  const scheme = lower.slice(0, schemeEnd + 1);
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output2;
+  if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
+  return output2;
+}
+var SRCSET_DESCRIPTOR = /^\d+(\.\d+)?[wx]$/;
+function isSrcsetWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function sanitizeSrcset(value) {
+  const input2 = String(value);
+  const out = [];
+  let i2 = 0;
+  const n = input2.length;
+  while (i2 < n) {
+    while (i2 < n && (isSrcsetWhitespace(input2[i2]) || input2[i2] === ",")) i2++;
+    if (i2 >= n) break;
+    const urlStart = i2;
+    while (i2 < n && !isSrcsetWhitespace(input2[i2])) i2++;
+    let url = input2.slice(urlStart, i2);
+    const descriptors = [];
+    if (url.endsWith(",")) {
+      url = url.replace(/,+$/, "");
+    } else {
+      let current = "";
+      let inParens = false;
+      while (i2 < n) {
+        const ch = input2[i2];
+        if (inParens) {
+          current += ch;
+          if (ch === ")") inParens = false;
+          i2++;
+          continue;
+        }
+        if (isSrcsetWhitespace(ch)) {
+          if (current) descriptors.push(current);
+          current = "";
+          i2++;
+          continue;
+        }
+        if (ch === ",") {
+          i2++;
+          break;
+        }
+        if (ch === "(") inParens = true;
+        current += ch;
+        i2++;
+      }
+      if (current) descriptors.push(current);
+    }
+    if (url === "") continue;
+    if (descriptors.length > 1) continue;
+    if (descriptors.length === 1 && !SRCSET_DESCRIPTOR.test(descriptors[0])) continue;
+    const safe = sanitizeUrl(url);
+    if (!safe) continue;
+    if (safe.startsWith(",") || safe.endsWith(",")) continue;
+    out.push(descriptors.length === 1 ? `${safe} ${descriptors[0]}` : safe);
+  }
+  return out.join(", ");
+}
+var CSS_DANGER_GATE = /[(:@\\]/;
+function isCssWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function isHexDigit(ch) {
+  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+}
+function decodeCssEscapes(value) {
+  let out = "";
+  for (let i2 = 0; i2 < value.length; i2++) {
+    const ch = value[i2];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    if (i2 + 1 >= value.length) break;
+    const next = value[i2 + 1];
+    if (next === "\n" || next === "\f") {
+      i2 += 1;
+      continue;
+    }
+    if (next === "\r") {
+      i2 += value[i2 + 2] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (isHexDigit(next)) {
+      let hex = "";
+      let j = i2 + 1;
+      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
+        hex += value[j];
+        j++;
+      }
+      if (j < value.length && isCssWhitespace(value[j])) {
+        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
+      }
+      const code2 = Number.parseInt(hex, 16);
+      const invalid = code2 === 0 || code2 > 1114111 || code2 >= 55296 && code2 <= 57343;
+      out += invalid ? "\uFFFD" : String.fromCodePoint(code2);
+      i2 = j - 1;
+      continue;
+    }
+    out += next;
+    i2 += 1;
+  }
+  return out;
+}
+var BLOCKED_CSS_NEEDLES = [
+  "url(",
+  "expression(",
+  "javascript:",
+  "vbscript:",
+  "-moz-binding",
+  "behavior:",
+  "@import",
+  "image-set(",
+  "filter:progid",
+  // CSS Images 4 `image("…")` and CSS Values 5 `src("…")` take a URL as a
+  // plain STRING, so they fetch without ever spelling `url(`. Support is thin
+  // today, which is exactly when a blocklist should get ahead of it.
+  "image(",
+  "src("
+];
+var CSS_REASON_MOZ_BINDING = 4;
+var CSS_REASON_BEHAVIOR = 5;
+var CSS_REASON_PROGID = 8;
+function describeElement(el) {
+  if (!el) return "an element";
+  let out = el.tagName.toLowerCase();
+  const id = el.getAttribute("id");
+  if (id) out += `#${id}`;
+  const cls = el.getAttribute("class");
+  if (cls) out += `.${cls.trim().split(/\s+/).slice(0, 3).join(".")}`;
+  return `<${out}>`;
+}
+var warnedDeclarations = /* @__PURE__ */ new Set();
+var MAX_WARNED_DECLARATIONS = 100;
+var declarationCapAnnounced = false;
+function warnDroppedDeclaration(value, reason, ctx) {
+  devWarnLazy(() => {
+    const reasons = [
+      "url() in an inline style is an exfiltration channel: the browser fetches it immediately and the URL's path or query can carry page data off-origin",
+      "expression() executes arbitrary script in legacy engines",
+      "the javascript: scheme executes script",
+      "the vbscript: scheme executes script",
+      "-moz-binding loads and runs remote XBL",
+      "behavior: loads and runs a remote HTC script",
+      "@import pulls in a remote stylesheet",
+      "image-set() fetches remote images, the same exfiltration channel as url()",
+      "filter:progid activates legacy scriptable filters",
+      "image() fetches its string argument as a URL, the same exfiltration channel as url()",
+      "src() fetches its string argument as a URL, the same exfiltration channel as url()"
+    ];
+    const declaration = ctx?.property ? `${ctx.property}: ${value}` : value;
+    const where = describeElement(ctx?.element);
+    const key = `${where}|${declaration}`;
+    if (warnedDeclarations.has(key)) return "";
+    if (warnedDeclarations.size >= MAX_WARNED_DECLARATIONS) {
+      if (declarationCapAnnounced) return "";
+      declarationCapAnnounced = true;
+      return `${MAX_WARNED_DECLARATIONS} distinct dropped style declarations have been reported; suppressing further ones for the rest of this session so they cannot flood the console. The declarations are still dropped \u2014 only the reporting stops. Fix the reported ones and reload to see any that remain.`;
+    }
+    warnedDeclarations.add(key);
+    return `style declaration "${declaration}" was dropped by the style sanitizer on ${where} \u2014 ${reasons[reason]}. The element renders without it, which usually looks like a missing image rather than an error. Sanctioned alternatives: for a content image use an <img> element (or a <picture>); for decoration, put the rule in a stylesheet and set a class instead \u2014 stylesheet CSS is not sanitized, only inline style attributes are. If this declaration is not yours, it came from untrusted data and the drop just prevented an exfiltration.`;
+  });
+}
+function normalizeCssForScan(value) {
+  const normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
+  return normalized.toLowerCase().replace(/\s+/g, "");
+}
+function blockedCssReason(value) {
+  if (!CSS_DANGER_GATE.test(value)) return -1;
+  const lower = normalizeCssForScan(value);
+  for (let i2 = 0; i2 < BLOCKED_CSS_NEEDLES.length; i2++) {
+    if (lower.includes(BLOCKED_CSS_NEEDLES[i2])) return i2;
+  }
+  return -1;
+}
+function sanitizeCSSDeclaration(property, value, context2) {
+  const reason = blockedDeclarationReason(property, value);
+  if (reason === -1) return value;
+  warnDroppedDeclaration(value, reason, { property, element: context2?.element });
+  return "";
+}
+function blockedDeclarationReason(property, value) {
+  const reason = blockedCssReason(value);
+  if (reason !== -1) return reason;
+  const name = canonicalAttrName(property);
+  if (name === "behavior") return CSS_REASON_BEHAVIOR;
+  if (name === "-moz-binding") return CSS_REASON_MOZ_BINDING;
+  if ((name === "filter" || name === "-ms-filter") && normalizeCssForScan(value).includes("progid:")) {
+    return CSS_REASON_PROGID;
+  }
+  return -1;
+}
+function parseStyleDeclarations(css) {
+  const chunks = [];
+  let buf = "";
+  let depth = 0;
+  let quote2 = "";
+  for (let i2 = 0; i2 < css.length; i2++) {
+    const ch = css[i2];
+    if (quote2) {
+      buf += ch;
+      if (ch === "\\" && i2 + 1 < css.length) buf += css[++i2];
+      else if (ch === quote2) quote2 = "";
+      continue;
+    }
+    if (ch === "\\") {
+      buf += ch;
+      if (i2 + 1 < css.length) buf += css[++i2];
+      continue;
+    }
+    if (ch === "/" && css[i2 + 1] === "*") {
+      const end = css.indexOf("*/", i2 + 2);
+      if (end === -1) return null;
+      i2 = end + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote2 = ch;
+    else if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") {
+      if (--depth < 0) return null;
+    } else if (ch === "{" || ch === "}") return null;
+    else if (ch === ";" && depth === 0) {
+      chunks.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (quote2 || depth !== 0) return null;
+  chunks.push(buf);
+  const out = [];
+  for (const chunk of chunks) {
+    const colon = chunk.indexOf(":");
+    if (colon === -1) continue;
+    const rawName = chunk.slice(0, colon).trim();
+    if (!/^(--[\w-]+|-?[a-zA-Z_][\w-]*)$/.test(rawName)) continue;
+    let value = chunk.slice(colon + 1).trim();
+    const bang = /!\s*important\s*$/i.exec(value);
+    if (bang) value = value.slice(0, bang.index).trim();
+    if (value === "") continue;
+    const property = rawName.startsWith("--") ? rawName : canonicalAttrName(rawName);
+    out.push([property, value, bang !== null]);
+  }
+  return out;
+}
+function sanitizeStyleDeclarationList(cssText, context2) {
+  const input2 = String(cssText);
+  const declarations = parseStyleDeclarations(input2);
+  if (declarations === null) {
+    if (blockedCssReason(input2) !== -1) warnDroppedDeclaration(input2, blockedCssReason(input2), context2);
+    return "";
+  }
+  const kept = [];
+  for (const [property, value, important] of declarations) {
+    const reason = blockedDeclarationReason(property, value);
+    if (reason !== -1) {
+      warnDroppedDeclaration(value, reason, { property, element: context2?.element });
+      continue;
+    }
+    kept.push(`${property}: ${value}${important ? " !important" : ""}`);
+  }
+  return kept.join("; ");
+}
+function sanitizeStyleAttribute(cssText, context2) {
+  const input2 = String(cssText);
+  if (input2.trim() === "") return "";
+  if (typeof document === "undefined") return sanitizeStyleDeclarationList(input2, context2);
+  const probe = document.createElement("div");
+  try {
+    probe.style.cssText = input2;
+  } catch {
+    return "";
+  }
+  const declarations = [];
+  for (let i2 = 0; i2 < probe.style.length; i2++) {
+    const property = probe.style[i2];
+    const value = probe.style.getPropertyValue(property);
+    const reason = blockedDeclarationReason(property, value);
+    if (reason !== -1) {
+      warnDroppedDeclaration(value, reason, { property, element: context2?.element });
+      continue;
+    }
+    const priority = probe.style.getPropertyPriority(property);
+    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
+  }
+  return declarations.join("; ");
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "xlink:href",
+  "src",
+  "action",
+  "formaction",
+  "formtarget",
+  "cite",
+  "poster",
+  "background",
+  "srcset",
+  "ping",
+  "data",
+  // `<html manifest>` is a URL sink too. It was carried only by the SSR
+  // serializers' private copy of this set; folding that copy into this one would
+  // otherwise have silently dropped its coverage.
+  "manifest"
+]);
+var HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
+function isHtmlContentAttribute(name) {
+  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
+}
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr.toLowerCase());
+}
+function isPolicyAttribute(name) {
+  const lower = name.toLowerCase();
+  return lower === "style" || URL_ATTRIBUTES.has(lower);
+}
+function sanitizeAttributeString(attr, value, context2) {
+  const lower = attr.toLowerCase();
+  if (lower === "srcset") return sanitizeSrcset(value);
+  if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
+  if (lower === "style") return sanitizeStyleAttribute(value, context2);
+  return value;
+}
+function resolveAttributeValue(attr, value, context2) {
+  if (!isPolicyAttribute(attr)) return value;
+  const safe = sanitizeAttributeString(attr, value, context2);
+  return safe === "" ? null : safe;
+}
+
+// src/build/staticAnalysis.ts
+var STATIC_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "span",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "nav",
+  "main",
+  "aside",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "li",
+  "ol",
+  "ul",
+  "a",
+  "b",
+  "em",
+  "i",
+  "strong",
+  "small",
+  "code",
+  "mark",
+  "img",
+  "br",
+  "hr",
+  "input",
+  "button",
+  "form",
+  "label",
+  "details",
+  "summary",
+  "dialog"
+]);
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "br",
+  "hr",
+  "img",
+  "input",
+  "meta",
+  "link",
+  "area",
+  "base",
+  "col",
+  "embed",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SPECIAL_PROPS = /* @__PURE__ */ new Set(["style", "ref", "on", "onElement"]);
+var NON_REFLECTING_BOOLEANS = /* @__PURE__ */ new Set(["checked", "selected"]);
+function readLiteral(code2, tok) {
+  if (!tok) return null;
+  if (tok.type === "string") {
+    const value = stringTokenValue(code2, tok);
+    return value === null ? null : { kind: "string", value };
+  }
+  if (tok.type === "number" && /^(0|[1-9]\d*)(\.\d+)?$/.test(tok.value)) {
+    return { kind: "number", value: String(Number(tok.value)) };
+  }
+  if (tok.type === "ident" && ["true", "false", "null", "undefined"].includes(tok.value)) {
+    return { kind: "keyword", value: tok.value };
+  }
+  return null;
+}
+function parserSafeText(s2) {
+  return !s2.includes("\r") && !s2.includes("\0");
+}
+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, "&lt;").replace(/>/g, "&gt;");
+}
+function attributeHtml(name, lit) {
+  if (!/^[a-zA-Z][a-zA-Z0-9-]*$/.test(name)) return null;
+  const lower = name.toLowerCase();
+  if (SPECIAL_PROPS.has(name) || lower === "style" || lower === "srcset") return null;
+  if (isEventHandlerAttr(name) || isUrlAttribute(name) || isHtmlContentAttribute(name)) return null;
+  if (lit.kind === "keyword") {
+    if (lit.value === "null" || lit.value === "undefined") return "";
+    const on2 = lit.value === "true";
+    if (lower.startsWith("aria-")) return `${lower}="${on2}"`;
+    if (NON_REFLECTING_BOOLEANS.has(lower)) return null;
+    return on2 ? `${lower}=""` : "";
+  }
+  if (!parserSafeText(lit.value)) return null;
+  return `${lower}="${escapeAttr(lit.value)}"`;
+}
+function parseCall(code2, list, i2) {
+  const at = (k2) => list[k2];
+  const isPunct = (k2, v) => {
+    const t = at(k2);
+    return !!t && t.type === "punct" && t.value === v;
+  };
+  let k = i2 + 1;
+  const result = { end: 0, cls: null, id: null, attrs: [], text: null };
+  let nodesText = null;
+  if (isPunct(k, "{")) {
+    k++;
+    const seen = /* @__PURE__ */ new Set();
+    while (!isPunct(k, "}")) {
+      const keyTok = at(k);
+      let key = null;
+      if (keyTok?.type === "ident") key = keyTok.value;
+      else if (keyTok?.type === "string") key = stringTokenValue(code2, keyTok);
+      if (key === null || !isPunct(k + 1, ":")) return null;
+      if (seen.has(key.toLowerCase())) return null;
+      seen.add(key.toLowerCase());
+      const lit = readLiteral(code2, at(k + 2));
+      if (lit === null) return null;
+      k += 3;
+      if (isPunct(k, ",")) k++;
+      else if (!isPunct(k, "}")) return null;
+      if (key === "class" || key === "id") {
+        if (lit.kind !== "string" || !parserSafeText(lit.value)) return null;
+        if (key === "class") result.cls = lit.value;
+        else result.id = lit.value;
+      } else if (key === "nodes") {
+        if (lit.kind !== "string" || !parserSafeText(lit.value)) return null;
+        nodesText = lit.value;
+      } else {
+        const html3 = attributeHtml(key, lit);
+        if (html3 === null) return null;
+        if (html3) result.attrs.push(html3);
+      }
+    }
+    k++;
+    if (isPunct(k, ",")) {
+      const second = readLiteral(code2, at(k + 1));
+      if (second === null) {
+        if (!isPunct(k + 1, ")")) return null;
+        k++;
+      } else {
+        if (second.kind !== "string" || !parserSafeText(second.value)) return null;
+        result.text = second.value;
+        k += 2;
+        if (isPunct(k, ",")) k++;
+      }
+    }
+    if (result.text === null) result.text = nodesText;
+  } else {
+    const first = readLiteral(code2, at(k));
+    if (first === null || first.kind !== "string" || !parserSafeText(first.value)) return null;
+    k++;
+    if (isPunct(k, ",") && at(k + 1)?.type === "string") {
+      const second = readLiteral(code2, at(k + 1));
+      if (second === null || second.kind !== "string" || !parserSafeText(second.value)) return null;
+      result.cls = first.value;
+      result.text = second.value;
+      k += 2;
+    } else {
+      result.text = first.value;
+    }
+    if (isPunct(k, ",")) k++;
+  }
+  if (!isPunct(k, ")")) return null;
+  result.end = at(k).end;
+  return result;
+}
+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)}"`);
+  attrs.push(...call.attrs);
+  const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  if (VOID_ELEMENTS.has(tag)) {
+    if (call.text) return null;
+    return `<${tag}${attrStr} />`;
+  }
+  return `<${tag}${attrStr}>${escapeHtml(call.text ?? "")}</${tag}>`;
+}
+function analyzeStaticTemplates(code2) {
+  const none = { hasStaticPatterns: false, patterns: [] };
+  if (!code2.includes("sibujs")) return none;
+  const scan = scanModule(code2);
+  if (!scan) return none;
+  const factories = /* @__PURE__ */ new Map();
+  for (const decl of scan.imports) {
+    if (decl.source !== "sibujs") continue;
+    for (const b2 of decl.bindings) if (STATIC_TAGS.has(b2.imported)) factories.set(b2.local, b2.imported);
+  }
+  if (factories.size === 0) return none;
+  const uses = bindingUses(code2, scan, new Set(factories.keys()));
+  const unsafe = new Set(uses.shadowed);
+  for (const ref2 of uses.tagged) unsafe.add(ref2.tok.value);
+  const patterns = [];
+  for (const { tok, list, index } of uses.calls) {
+    if (unsafe.has(tok.value)) continue;
+    const tag = factories.get(tok.value);
+    const call = parseCall(code2, list, index + 1);
+    if (!call) continue;
+    const templateHtml = toHtml(tag, call);
+    if (templateHtml === null) continue;
+    const start = list[index].start;
+    patterns.push({ original: code2.slice(start, call.end), tag, templateHtml, start, end: call.end });
+  }
+  return { hasStaticPatterns: patterns.length > 0, patterns };
+}
+
+// src/build/templateCompiler.ts
+var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
+var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
   "area",
   "base",
   "br",
@@ -99,96 +1401,10 @@ var SVG_TAGS = /* @__PURE__ */ new Set([
   "symbol",
   "marker"
 ]);
-function findHtmlTemplates(code2) {
-  const results = [];
-  const tagRegex = /\bhtml\s*`/g;
-  let match2;
-  while ((match2 = tagRegex.exec(code2)) !== null) {
-    const start = match2.index;
-    const backtickStart = code2.indexOf("`", start + 4);
-    if (backtickStart === -1) continue;
-    const parsed = parseTemplateLiteral(code2, backtickStart);
-    if (!parsed) continue;
-    results.push({
-      start,
-      end: parsed.end,
-      strings: parsed.strings,
-      exprCount: parsed.exprCount
-    });
-    tagRegex.lastIndex = parsed.end;
-  }
-  return results;
-}
-function parseTemplateLiteral(code2, openBacktick) {
-  const strings = [];
-  let exprCount = 0;
-  let pos = openBacktick + 1;
-  let current = "";
-  while (pos < code2.length) {
-    const ch = code2[pos];
-    if (ch === "`") {
-      strings.push(current);
-      return { end: pos + 1, strings, exprCount };
-    }
-    if (ch === "$" && pos + 1 < code2.length && code2[pos + 1] === "{") {
-      strings.push(current);
-      current = "";
-      exprCount++;
-      pos += 2;
-      let depth = 1;
-      while (pos < code2.length && depth > 0) {
-        const c = code2[pos];
-        if (c === "{") depth++;
-        else if (c === "}") depth--;
-        else if (c === '"' || c === "'" || c === "`") {
-          pos = skipString(code2, pos);
-          continue;
-        }
-        if (depth > 0) pos++;
-      }
-      if (depth !== 0) return null;
-      pos++;
-      continue;
-    }
-    if (ch === "\\") {
-      current += code2[pos] + (code2[pos + 1] || "");
-      pos += 2;
-      continue;
-    }
-    current += ch;
-    pos++;
-  }
-  return null;
-}
-function skipString(code2, start) {
-  const quote2 = code2[start];
-  let pos = start + 1;
-  while (pos < code2.length) {
-    if (code2[pos] === "\\") {
-      pos += 2;
-      continue;
-    }
-    if (code2[pos] === quote2) return pos + 1;
-    if (quote2 === "`" && code2[pos] === "$" && code2[pos + 1] === "{") {
-      pos += 2;
-      let depth = 1;
-      while (pos < code2.length && depth > 0) {
-        if (code2[pos] === "{") depth++;
-        else if (code2[pos] === "}") depth--;
-        else if (code2[pos] === '"' || code2[pos] === "'" || code2[pos] === "`") {
-          pos = skipString(code2, pos);
-          continue;
-        }
-        if (depth > 0) pos++;
-      }
-      pos++;
-      continue;
-    }
-    pos++;
-  }
-  return pos;
-}
-function parseTemplateToAST(strings) {
+var SVG_NS = "http://www.w3.org/2000/svg";
+var RuntimeParseError = class extends Error {
+};
+function parseTemplate(strings) {
   const exprCount = strings.length - 1;
   let template2 = strings[0];
   for (let i2 = 0; i2 < exprCount; i2++) {
@@ -197,26 +1413,34 @@ function parseTemplateToAST(strings) {
   let pos = 0;
   const len = template2.length;
   function skipWs() {
-    while (pos < len && /\s/.test(template2[pos])) pos++;
+    while (pos < len && (template2[pos] === " " || template2[pos] === "	" || template2[pos] === "\n" || template2[pos] === "\r"))
+      pos++;
   }
   function tryExprIdx() {
-    if (template2[pos] !== "\0") return -1;
+    if (template2.charCodeAt(pos) !== 0) return -1;
     const start = pos;
     pos++;
-    let idxStr = "";
-    while (pos < len && template2[pos] !== "\0") idxStr += template2[pos++];
+    let idx = 0;
+    while (pos < len && template2.charCodeAt(pos) !== 0) {
+      idx = idx * 10 + (template2.charCodeAt(pos) - 48);
+      pos++;
+    }
     if (pos < len) pos++;
-    const idx = Number.parseInt(idxStr, 10);
-    if (Number.isNaN(idx) || idx < 0 || idx >= exprCount) {
+    if (idx < 0 || idx >= exprCount) {
       pos = start;
       return -1;
     }
     return idx;
   }
   function readTagName() {
-    let name = "";
-    while (pos < len && /[a-zA-Z0-9-]/.test(template2[pos])) name += template2[pos++];
-    return name;
+    const start = pos;
+    while (pos < len) {
+      const c = template2.charCodeAt(pos);
+      if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45) {
+        pos++;
+      } else break;
+    }
+    return template2.slice(start, pos);
   }
   function parseAttrValue() {
     skipWs();
@@ -224,51 +1448,72 @@ function parseTemplateToAST(strings) {
     pos++;
     skipWs();
     const exprIdx = tryExprIdx();
-    if (exprIdx >= 0) return { kind: "expr", index: exprIdx };
+    if (exprIdx >= 0) return { kind: "expr", idx: exprIdx };
     const quote2 = template2[pos];
     if (quote2 === '"' || quote2 === "'") {
       pos++;
-      const parts = [];
-      let current = "";
+      const statics2 = [];
+      const exprs2 = [];
+      let current2 = "";
       while (pos < len && template2[pos] !== quote2) {
         const innerIdx = tryExprIdx();
         if (innerIdx >= 0) {
-          if (current) parts.push({ kind: "static", value: current });
-          current = "";
-          parts.push({ kind: "expr", index: innerIdx });
+          statics2.push(current2);
+          current2 = "";
+          exprs2.push(innerIdx);
         } else {
-          current += template2[pos++];
+          current2 += template2[pos++];
         }
       }
       if (pos < len) pos++;
-      if (current) parts.push({ kind: "static", value: current });
-      if (parts.length === 1 && parts[0].kind === "static") {
-        return { kind: "static", value: parts[0].value };
-      }
-      if (parts.some((p2) => p2.kind === "expr")) {
-        return { kind: "mixed", parts };
+      statics2.push(current2);
+      if (exprs2.length === 0) return { kind: "static", value: statics2[0] };
+      return { kind: "mixed", statics: statics2, exprs: exprs2 };
+    }
+    const statics = [];
+    const exprs = [];
+    let current = "";
+    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 = "";
+        exprs.push(innerIdx);
+      } else {
+        current += template2[pos++];
       }
-      return { kind: "static", value: parts.map((p2) => p2.value).join("") };
     }
-    let val = "";
-    while (pos < len && !/[\s>/]/.test(template2[pos])) val += template2[pos++];
-    return { kind: "static", value: val };
+    statics.push(current);
+    if (exprs.length === 0) return { kind: "static", value: statics[0] };
+    return { kind: "mixed", statics, exprs };
   }
   function parseAttrs() {
     const attrs = [];
     while (pos < len) {
       skipWs();
       if (template2[pos] === ">" || template2[pos] === "/") break;
-      let attrName = "";
-      while (pos < len && /[a-zA-Z0-9\-:_.]/.test(template2[pos])) attrName += template2[pos++];
+      const attrStart = pos;
+      while (pos < len) {
+        const c = template2.charCodeAt(pos);
+        if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45 || c === 58 || c === 95 || c === 46) {
+          pos++;
+        } else break;
+      }
+      const attrName = template2.slice(attrStart, pos);
       if (!attrName) break;
       const val = parseAttrValue();
       if (attrName.startsWith("on:")) {
-        if (val.kind === "expr") {
-          attrs.push({ name: attrName.slice(3), value: { kind: "event", index: val.index } });
-        }
+        if (val.kind === "expr") attrs.push({ t: 3, name: attrName.slice(3), idx: val.idx });
+      } else if (val.kind === "bool") {
+        attrs.push({ t: 4, name: attrName });
+      } else if (val.kind === "static") {
+        attrs.push({ t: 0, name: attrName, value: val.value });
+      } else if (val.kind === "expr") {
+        attrs.push({ t: 1, name: attrName, idx: val.idx });
       } else {
-        attrs.push({ name: attrName, value: val });
+        attrs.push({ t: 2, name: attrName, statics: val.statics, exprs: val.exprs });
       }
     }
     return attrs;
@@ -282,40 +1527,67 @@ function parseTemplateToAST(strings) {
       const idx = tryExprIdx();
       if (idx >= 0) {
         const collapsed2 = collapseWs(text2);
-        if (collapsed2) children.push({ kind: "text", value: collapsed2 });
+        if (collapsed2) children.push({ t: 1, value: collapsed2 });
         text2 = "";
-        children.push({ kind: "expr", index: idx });
+        children.push({ t: 2, idx });
       } else {
         text2 += template2[pos++];
       }
     }
     const collapsed = collapseWs(text2);
-    if (collapsed) children.push({ kind: "text", value: collapsed });
+    if (collapsed) children.push({ t: 1, value: collapsed });
   }
   function parseChildren() {
     const children = [];
     while (pos < len) {
       if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") break;
       if (template2[pos] === "<") {
+        const next = template2[pos + 1];
+        if (next === "!") {
+          if (template2.startsWith("<!--", pos)) {
+            const end = template2.indexOf("-->", pos + 4);
+            pos = end === -1 ? len : end + 3;
+          } else if (template2.startsWith("<![CDATA[", pos)) {
+            const end = template2.indexOf("]]>", pos + 9);
+            pos = end === -1 ? len : end + 3;
+          } else {
+            const end = template2.indexOf(">", pos);
+            pos = end === -1 ? len : end + 1;
+          }
+          continue;
+        }
+        if (next === "?") {
+          const end = template2.indexOf(">", pos);
+          pos = end === -1 ? len : end + 1;
+          continue;
+        }
+        if (!(next >= "a" && next <= "z") && !(next >= "A" && next <= "Z")) {
+          children.push({ t: 1, value: "<" });
+          pos++;
+          continue;
+        }
         pos++;
         const tag = readTagName();
         const attrs = parseAttrs();
         skipWs();
-        const isVoid = VOID_ELEMENTS.has(tag);
+        const isVoid = VOID_ELEMENTS2.has(tag);
         const isSelfClosing = template2[pos] === "/";
         if (isSelfClosing) pos++;
         if (pos < len) pos++;
         if (isVoid || isSelfClosing) {
-          children.push({ kind: "element", el: { tag, attrs, children: [] } });
+          children.push({ t: 0, el: { tag, svg: SVG_TAGS.has(tag), attrs, children: [] } });
         } else {
           const inner = parseChildren();
+          if (RAW_TEXT_TAGS.has(tag.toLowerCase()) && inner.some((c) => c.t === 2)) {
+            throw new RuntimeParseError(tag);
+          }
           if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") {
             pos += 2;
             readTagName();
             skipWs();
             if (pos < len && template2[pos] === ">") pos++;
           }
-          children.push({ kind: "element", el: { tag, attrs, children: inner } });
+          children.push({ t: 0, el: { tag, svg: SVG_TAGS.has(tag), attrs, children: inner } });
         }
       } else {
         parseTextChildren(children);
@@ -325,303 +1597,270 @@ function parseTemplateToAST(strings) {
   }
   return parseChildren();
 }
-function generateElement(el, valuesVar) {
-  const tag = el.tag;
-  const isSvg = SVG_TAGS.has(tag);
-  const parts = [];
-  for (const attr of el.attrs) {
-    const v = attr.value;
-    switch (v.kind) {
-      case "static":
-        parts.push(`${JSON.stringify(attr.name)}: ${JSON.stringify(v.value)}`);
-        break;
-      case "expr":
-        parts.push(`${JSON.stringify(attr.name)}: ${valuesVar}[${v.index}]`);
-        break;
-      case "mixed": {
-        const concat = v.parts.map((p2) => p2.kind === "static" ? JSON.stringify(p2.value) : `String(${valuesVar}[${p2.index}])`).join(" + ");
-        parts.push(`${JSON.stringify(attr.name)}: ${concat}`);
-        break;
-      }
-      case "bool":
-        parts.push(`${JSON.stringify(attr.name)}: true`);
-        break;
-      case "event":
-        break;
+var IDL_SYNCED_ATTRS = /* @__PURE__ */ new Set(["value", "checked"]);
+function generateBody(roots, h) {
+  const lines = [];
+  let n = 0;
+  const q2 = jsStringLiteral;
+  const P = h.prefix;
+  function genElement(el) {
+    const tag = el.tag.toLowerCase();
+    if (tag === "meta" || tag === "link") return null;
+    for (const attr of el.attrs) {
+      if ((attr.t === 0 || attr.t === 4) && attr.name.toLowerCase() === "srcdoc") return null;
+    }
+    const v = `e${n++}`;
+    h.tags.add(el.tag);
+    if (el.svg) h.svg = true;
+    lines.push(
+      el.svg ? `const ${v} = document.createElementNS(${q2(SVG_NS)}, ${q2(el.tag)});` : `const ${v} = document.createElement(${q2(el.tag)});`
+    );
+    for (const attr of el.attrs) {
+      switch (attr.t) {
+        case 0:
+          lines.push(`${v}.setAttribute(${q2(attr.name)}, ${q2(attr.value)});`);
+          break;
+        case 4:
+          lines.push(`${v}.setAttribute(${q2(attr.name)}, "");`);
+          break;
+        case 1:
+        case 2: {
+          if (IDL_SYNCED_ATTRS.has(attr.name.toLowerCase())) return null;
+          h.used.add("attr");
+          if (attr.t === 1) {
+            lines.push(`${P}attr(${v}, ${q2(attr.name)}, v${attr.idx});`);
+          } else {
+            h.used.add("str");
+            let expr = q2(attr.statics[0]);
+            for (let j = 0; j < attr.exprs.length; j++) {
+              expr += ` + ${P}str(v${attr.exprs[j]}) + ${q2(attr.statics[j + 1])}`;
+            }
+            lines.push(`${P}attr(${v}, ${q2(attr.name)}, ${expr});`);
+          }
+          break;
+        }
+        case 3:
+          h.used.add("on");
+          lines.push(`${P}on(${v}, ${q2(attr.name)}, v${attr.idx});`);
+          break;
+      }
+    }
+    for (const child of el.children) {
+      if (child.t === 0) {
+        const c = genElement(child.el);
+        if (c === null) return null;
+        lines.push(`${v}.appendChild(${c});`);
+      } else if (child.t === 1) {
+        lines.push(`${v}.appendChild(document.createTextNode(${q2(child.value)}));`);
+      } else {
+        h.used.add("child");
+        lines.push(`${P}child(${v}, v${child.idx});`);
+      }
+    }
+    return v;
+  }
+  if (roots.length === 1 && roots[0].t === 0) {
+    const root = genElement(roots[0].el);
+    if (root === null) return null;
+    lines.push(`return ${root};`);
+    return lines.join("\n  ");
+  }
+  lines.push(`const w = document.createElement("div");`);
+  for (const root of roots) {
+    if (root.t === 0) {
+      const c = genElement(root.el);
+      if (c === null) return null;
+      lines.push(`w.appendChild(${c});`);
+    } else if (root.t === 1) {
+      lines.push(`w.appendChild(document.createTextNode(${q2(root.value)}));`);
+    } else {
+      return null;
     }
   }
-  const events = el.attrs.filter((a2) => a2.value.kind === "event");
-  if (events.length > 0) {
-    const eventEntries = events.map((a2) => {
-      const v = a2.value;
-      return `${JSON.stringify(a2.name)}: ${valuesVar}[${v.index}]`;
-    });
-    parts.push(`on: { ${eventEntries.join(", ")} }`);
+  lines.push("return w;");
+  return lines.join("\n  ");
+}
+function helperSource(h) {
+  const P = h.prefix;
+  const out = [];
+  if (h.used.has("attr")) {
+    out.push(
+      `function ${P}attr(el, name, value) {
+  const teardown = ${P}bindAttrs(el, { [name]: value });
+  if (typeof value === "function") ${P}registerDisposer(el, teardown);
+}`
+    );
   }
-  if (el.children.length > 0) {
-    const childExprs = el.children.map((c) => generateChild(c, valuesVar));
-    if (childExprs.length === 1) {
-      parts.push(`nodes: ${childExprs[0]}`);
-    } else {
-      parts.push(`nodes: [${childExprs.join(", ")}]`);
-    }
+  if (h.used.has("str")) {
+    out.push(`function ${P}str(value) {
+  return value == null ? "" : String(value);
+}`);
   }
-  const propsStr = parts.length > 0 ? `{ ${parts.join(", ")} }` : void 0;
-  if (isSvg) {
-    return propsStr ? `__sbTagFactory(${JSON.stringify(tag)}, __sbSVG_NS)(${propsStr})` : `__sbTagFactory(${JSON.stringify(tag)}, __sbSVG_NS)({})`;
+  if (h.used.has("on")) {
+    out.push(
+      `function ${P}on(el, name, handler) {
+  if (typeof handler === "function") el.addEventListener(name, handler);
+  else if (typeof __SIBU_DEV__ !== "undefined" && __SIBU_DEV__) {
+    console.warn(\`[SibuJS] html: on:\${name} handler is not a function (got \${typeof handler}). Event listener was not attached.\`);
   }
-  return propsStr ? `${tag}(${propsStr})` : `${tag}({})`;
-}
-function generateChild(child, valuesVar) {
-  switch (child.kind) {
-    case "element":
-      return generateElement(child.el, valuesVar);
-    case "text":
-      return JSON.stringify(child.value);
-    case "expr":
-      return `${valuesVar}[${child.index}]`;
+}`
+    );
   }
-}
-function compileHtmlTemplates(code2) {
-  const templates = findHtmlTemplates(code2);
-  if (templates.length === 0) {
-    return { code: null, usedTags: /* @__PURE__ */ new Set(), usesSvg: false, compiledCount: 0 };
-  }
-  const usedTags = /* @__PURE__ */ new Set();
-  let usesSvg = false;
-  let result = code2;
-  for (let i2 = templates.length - 1; i2 >= 0; i2--) {
-    const tmpl = templates[i2];
-    const ast = parseTemplateToAST(tmpl.strings);
-    collectTags(ast, usedTags);
-    if (ast.length > 1) usedTags.add("div");
-    if (Array.from(usedTags).some((t) => SVG_TAGS.has(t))) usesSvg = true;
-    const valuesVar = "__v";
-    const childExprs = ast.map((c) => generateChild(c, valuesVar));
-    const rootExpr = childExprs.length === 1 ? childExprs[0] : `div([${childExprs.join(", ")}])`;
-    let compiled;
-    if (tmpl.exprCount === 0) {
-      compiled = rootExpr;
-    } else {
-      const body2 = rootExpr;
-      const exprSource = extractExpressions(code2, tmpl.start, tmpl.end, tmpl.exprCount);
-      compiled = `((${valuesVar}) => ${body2})([${exprSource.join(", ")}])`;
-    }
-    result = result.slice(0, tmpl.start) + compiled + result.slice(tmpl.end);
+  if (h.used.has("child")) {
+    out.push(
+      `function ${P}child(el, value) {
+  if (typeof value === "function") {
+    const frag = ${P}Fragment([value]);
+    const ph = frag.firstChild;
+    el.appendChild(frag);
+    ${P}registerDisposer(el, () => ${P}dispose(ph));
+  } else if (value instanceof Node) {
+    el.appendChild(value);
+  } else if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      if (item instanceof Node) el.appendChild(item);
+      else if (item != null && typeof item !== "boolean") el.appendChild(document.createTextNode(String(item)));
+    }
+  } else if (value != null && typeof value !== "boolean") {
+    el.appendChild(document.createTextNode(String(value)));
+  }
+}`
+    );
   }
-  return { code: result, usedTags, usesSvg, compiledCount: templates.length };
+  return out.join("\n");
 }
-function collectTags(children, tags) {
-  for (const child of children) {
-    if (child.kind === "element") {
-      tags.add(child.el.tag);
-      collectTags(child.el.children, tags);
-    }
-  }
+function importSource(h) {
+  const P = h.prefix;
+  const core = [];
+  if (h.used.has("child")) core.push(`Fragment as ${P}Fragment`, `dispose as ${P}dispose`);
+  if (h.used.has("attr") || h.used.has("child")) core.push(`registerDisposer as ${P}registerDisposer`);
+  if (h.used.has("run")) core.push(`__renderParsedTemplate as ${P}run`);
+  const lines = [];
+  if (core.length > 0) lines.push(`import { ${core.join(", ")} } from "sibujs";`);
+  if (h.used.has("attr")) lines.push(`import { bindAttrs as ${P}bindAttrs } from "sibujs/ui";`);
+  return lines.join("\n");
 }
-function extractExpressions(code2, templateStart, templateEnd, count) {
-  const exprs = [];
-  const backtickStart = code2.indexOf("`", templateStart + 4);
-  let pos = backtickStart + 1;
-  for (let i2 = 0; i2 < count; i2++) {
-    while (pos < templateEnd) {
-      if (code2[pos] === "$" && code2[pos + 1] === "{") {
-        pos += 2;
-        break;
-      }
-      if (code2[pos] === "\\") {
-        pos += 2;
+function collectTags(children, h) {
+  for (const child of children) {
+    if (child.t !== 0) continue;
+    h.tags.add(child.el.tag);
+    if (child.el.svg) h.svg = true;
+    collectTags(child.el.children, h);
+  }
+}
+function planHtmlTemplates(code2) {
+  const plan = {
+    edits: [],
+    append: "",
+    usedTags: /* @__PURE__ */ new Set(),
+    usesSvg: false,
+    compiledCount: 0,
+    skippedCount: 0
+  };
+  if (!code2.includes("`") || !code2.includes("sibujs")) return plan;
+  const scan = scanModule(code2);
+  if (!scan) return plan;
+  const tagNames = /* @__PURE__ */ new Set();
+  for (const decl of scan.imports) {
+    if (!isSibuSource(decl.source)) continue;
+    for (const b2 of decl.bindings) if (b2.imported === "html") tagNames.add(b2.local);
+  }
+  if (tagNames.size === 0) return plan;
+  const uses = bindingUses(code2, scan, tagNames);
+  if (uses.shadowed.size > 0 || uses.calls.length > 0 || uses.tagged.length === 0) return plan;
+  const sites = new Set(uses.tagged.map((ref2) => ref2.tok));
+  const h = { prefix: uniquePrefix(code2), used: /* @__PURE__ */ new Set(), tags: /* @__PURE__ */ new Set(), svg: false };
+  const functions = [];
+  const compileTemplate = (tmpl) => {
+    const strings = [];
+    for (const qs of tmpl.quasis) {
+      const cooked = cookEscapes(code2.slice(qs.start, qs.end));
+      if (cooked === null) {
+        if (tmpl.quasis.length === 1) return null;
+        strings.push("undefined");
         continue;
       }
-      pos++;
+      strings.push(cooked);
     }
-    const exprStart = pos;
-    let depth = 1;
-    while (pos < templateEnd && depth > 0) {
-      const c = code2[pos];
-      if (c === "{") depth++;
-      else if (c === "}") {
-        depth--;
-        if (depth === 0) break;
-      } else if (c === '"' || c === "'" || c === "`") {
-        pos = skipString(code2, pos);
-        continue;
-      }
-      pos++;
+    const name = `${h.prefix}t${functions.length}`;
+    const params = tmpl.exprs.map((_, i2) => `v${i2}`).join(", ");
+    let roots;
+    try {
+      roots = parseTemplate(strings);
+    } catch (err) {
+      if (err instanceof RuntimeParseError) {
+        const message = `html: dynamic \${...} expressions are not allowed inside <${err.message}> (raw-text context). Build the content separately and append it as a Node.`;
+        functions.push(`function ${name}(${params}) {
+  throw new Error(${jsStringLiteral(message)});
+}`);
+        return name;
+      }
+      throw err;
+    }
+    const scratch = { prefix: h.prefix, used: /* @__PURE__ */ new Set(), tags: /* @__PURE__ */ new Set(), svg: false };
+    const body2 = generateBody(roots, scratch);
+    if (body2 === null) {
+      const tree = JSON.stringify(roots).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+      h.used.add("run");
+      collectTags(roots, h);
+      functions.push(
+        `function ${name}(${params}) {
+  return ${h.prefix}run(${name}.tree || (${name}.tree = ${tree}), [${params}]);
+}`
+      );
+      return name;
+    }
+    for (const u2 of scratch.used) h.used.add(u2);
+    for (const t of scratch.tags) h.tags.add(t);
+    if (scratch.svg) h.svg = true;
+    functions.push(`function ${name}(${params}) {
+  ${body2}
+}`);
+    return name;
+  };
+  const replaceSite = (tag, tmpl, name) => {
+    const edit = (start, end, before, after) => plan.edits.push({ start, end, text: `${before}${lineBreaksIn(code2, start, end)}${after}` });
+    const exprs = tmpl.exprs;
+    if (exprs.length === 0) {
+      edit(tag.start, tmpl.end, `${name}(`, ")");
+      return;
     }
-    exprs.push(code2.slice(exprStart, pos).trim());
-    pos++;
-  }
-  return exprs;
-}
-
-// src/build/staticAnalysis.ts
-var HTML_TAGS = /* @__PURE__ */ new Set([
-  "div",
-  "span",
-  "section",
-  "article",
-  "header",
-  "footer",
-  "nav",
-  "main",
-  "aside",
-  "p",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "blockquote",
-  "li",
-  "ol",
-  "ul",
-  "pre",
-  "a",
-  "b",
-  "em",
-  "i",
-  "strong",
-  "small",
-  "code",
-  "mark",
-  "img",
-  "br",
-  "hr",
-  "input",
-  "button",
-  "form",
-  "label",
-  "select",
-  "textarea",
-  "option",
-  "table",
-  "tbody",
-  "thead",
-  "tfoot",
-  "tr",
-  "td",
-  "th",
-  "details",
-  "summary",
-  "dialog"
-]);
-var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
-  "br",
-  "hr",
-  "img",
-  "input",
-  "meta",
-  "link",
-  "area",
-  "base",
-  "col",
-  "embed",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-function analyzeStaticTemplates(code2) {
-  const patterns = [];
-  const tagCallRegex = new RegExp(`\\b(${Array.from(HTML_TAGS).join("|")})\\s*\\(\\s*\\{([^}]*)\\}\\s*\\)`, "g");
-  let match2;
-  while ((match2 = tagCallRegex.exec(code2)) !== null) {
-    const [fullMatch, tag, propsContent] = match2;
-    const start = match2.index;
-    const end = start + fullMatch.length;
-    if (isStaticPropsContent(propsContent)) {
-      const templateHtml = propsToHtml(tag, propsContent);
-      if (templateHtml) {
-        patterns.push({ original: fullMatch, tag, templateHtml, start, end });
+    edit(tag.start, exprs[0].start, `${name}((`, "");
+    for (let i2 = 1; i2 < exprs.length; i2++) edit(exprs[i2 - 1].end, exprs[i2].start, ")", ", (");
+    edit(exprs[exprs.length - 1].end, tmpl.end, "", "))");
+  };
+  const visit = (list) => {
+    for (let i2 = 0; i2 < list.length; i2++) {
+      const tok = list[i2];
+      if (sites.has(tok)) {
+        const tmpl = list[i2 + 1];
+        for (const e of tmpl.exprs) visit(e.tokens);
+        const name = compileTemplate(tmpl);
+        if (name !== null) {
+          plan.compiledCount++;
+          replaceSite(tok, tmpl, name);
+        } else {
+          plan.skippedCount++;
+        }
+        i2++;
+      } else if (tok.type === "template") {
+        for (const e of tok.exprs) visit(e.tokens);
       }
     }
-  }
-  return {
-    hasStaticPatterns: patterns.length > 0,
-    patterns
   };
-}
-function isStaticPropsContent(propsContent) {
-  if (/=>|function\s*\(|\bref\b|\bon\s*:/.test(propsContent)) {
-    return false;
-  }
-  const props = propsContent.split(",").map((p2) => p2.trim()).filter(Boolean);
-  for (const prop of props) {
-    const colonIndex = prop.indexOf(":");
-    if (colonIndex === -1) continue;
-    const value = prop.substring(colonIndex + 1).trim();
-    if (!isStaticValue(value)) {
-      return false;
-    }
-  }
-  return true;
-}
-function isStaticValue(value) {
-  if (/^["'].*["']$/.test(value)) return true;
-  if (/^-?\d+(\.\d+)?$/.test(value)) return true;
-  if (value === "true" || value === "false") return true;
-  if (value === "null" || value === "undefined") return true;
-  return false;
-}
-function propsToHtml(tag, propsContent) {
-  const attrs = [];
-  let nodesContent = "";
-  const props = propsContent.split(",").map((p2) => p2.trim()).filter(Boolean);
-  for (const prop of props) {
-    const colonIndex = prop.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = prop.substring(0, colonIndex).trim();
-    let value = prop.substring(colonIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    if (key === "nodes") {
-      nodesContent = escapeHtml(value);
-    } else if (key === "class" || key === "id") {
-      attrs.push(`${key}="${escapeAttr(value)}"`);
-    } else if (key !== "on" && key !== "ref" && key !== "style") {
-      attrs.push(`${key}="${escapeAttr(String(value))}"`);
-    }
-  }
-  const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
-  if (VOID_ELEMENTS2.has(tag)) {
-    return `<${tag}${attrStr} />`;
-  }
-  return `<${tag}${attrStr}>${nodesContent}</${tag}>`;
-}
-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, "&lt;").replace(/>/g, "&gt;");
+  visit(scan.tokens);
+  if (plan.compiledCount === 0) return { ...plan, edits: [] };
+  const trailer = [importSource(h), helperSource(h), ...functions].filter(Boolean).join("\n");
+  plan.append = `
+${trailer}
+`;
+  plan.usedTags = h.tags;
+  plan.usesSvg = h.svg;
+  return plan;
 }
 
 // src/build/vite.ts
-var SVG_TAGS_SET = /* @__PURE__ */ new Set([
-  "svg",
-  "circle",
-  "ellipse",
-  "g",
-  "line",
-  "path",
-  "polygon",
-  "polyline",
-  "rect",
-  "text",
-  "tspan",
-  "defs",
-  "clipPath",
-  "mask",
-  "pattern",
-  "linearGradient",
-  "radialGradient",
-  "stop",
-  "use",
-  "symbol",
-  "marker"
-]);
 var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
 var DEFAULT_EXCLUDE = ["node_modules/**", "dist/**", "**/*.test.*", "**/*.spec.*"];
 function matchesPattern(filePath, patterns) {
@@ -631,30 +1870,42 @@ function matchesPattern(filePath, patterns) {
     return new RegExp(regexStr).test(normalized);
   });
 }
-function injectPureAnnotations(code2) {
-  const sibuFactories = [
-    "tagFactory",
-    "context",
-    "defineComponent",
-    "withProps",
-    "withDefaults",
-    "pure",
-    "noSideEffect"
-  ];
-  let result = code2;
-  for (const factory of sibuFactories) {
-    const pattern2 = new RegExp(`(?<!/\\*#__PURE__\\*/\\s*)\\b(${factory})\\s*\\(`, "g");
-    result = result.replace(pattern2, "/*#__PURE__*/ $1(");
+function devPrologueEdit(code2) {
+  let at = 0;
+  if (code2.startsWith("#!")) {
+    const nl = code2.indexOf("\n");
+    if (nl === -1) return null;
+    at = nl + 1;
   }
-  return result;
+  return {
+    start: at,
+    end: at,
+    text: '/* SibuJS Dev Mode */ if (typeof globalThis !== "undefined") { globalThis.__SIBU_DEV__ = true; } '
+  };
 }
-function injectDevHelpers(code2) {
-  if (code2.includes('from "sibu"') || code2.includes("from 'sibu'") || code2.includes('from "sibu/') || code2.includes("from 'sibu/")) {
-    return `/* SibuJS Dev Mode */
-if (typeof globalThis !== 'undefined') { (globalThis as unknown as Record<string, unknown>).__SIBU_DEV__ = true; }
-${code2}`;
-  }
-  return code2;
+function staticOptimizationEdits(code2) {
+  const analysis = analyzeStaticTemplates(code2);
+  if (!analysis.hasStaticPatterns) return null;
+  const P = uniquePrefix(code2);
+  const edits = analysis.patterns.map((pattern2) => ({
+    start: pattern2.start,
+    end: pattern2.end,
+    // A call spanning several lines keeps its line breaks.
+    text: `${P}static(${jsStringLiteral(pattern2.templateHtml)}${lineBreaksIn(code2, pattern2.start, pattern2.end)})`
+  }));
+  const append = `
+import { staticTemplate as ${P}staticTemplate } from "sibujs/performance";
+function ${P}static(markup) {
+  return document.adoptNode(${P}staticTemplate(markup));
+}
+`;
+  return { edits, append };
+}
+function resolveDevMode(explicit, info) {
+  if (explicit !== void 0) return explicit;
+  if (info?.command === "build") return info.mode === "development";
+  if (info?.command === "serve") return true;
+  return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
 }
 function sibuVitePlugin(options = {}) {
   const {
@@ -663,22 +1914,23 @@ function sibuVitePlugin(options = {}) {
     include = DEFAULT_INCLUDE,
     exclude = DEFAULT_EXCLUDE,
     devMode,
-    staticOptimize,
+    staticOptimize = false,
     compileTemplates
   } = options;
-  const isDevMode = devMode ?? (typeof process !== "undefined" && process.env?.NODE_ENV !== "production");
+  let isDevMode = resolveDevMode(devMode, void 0);
   return {
     name: "sibu-vite-plugin",
     enforce: "pre",
-    config() {
+    config(_userConfig, env) {
+      isDevMode = resolveDevMode(devMode, env);
       return {
-        // Optimize dependency pre-bundling for sibu
+        // Optimize dependency pre-bundling for sibujs
         optimizeDeps: {
-          include: ["sibu"]
+          include: ["sibujs"]
         },
-        // Ensure sibu is treated correctly for SSR
+        // Ensure sibujs is treated correctly for SSR
         ssr: {
-          noExternal: ["sibu"]
+          noExternal: ["sibujs"]
         },
         // Define global constants for dead code elimination
         define: {
@@ -691,69 +1943,47 @@ function sibuVitePlugin(options = {}) {
         }
       };
     },
+    configResolved(config) {
+      isDevMode = resolveDevMode(devMode, config);
+    },
     transform(code2, id) {
       if (!matchesPattern(id, include) || matchesPattern(id, exclude)) {
         return null;
       }
-      let transformed = code2;
-      let modified = false;
-      if (pureAnnotations) {
-        const annotated = injectPureAnnotations(transformed);
-        if (annotated !== transformed) {
-          transformed = annotated;
-          modified = true;
-        }
+      if (!code2.includes("sibujs")) return null;
+      if (!scanModule(code2)) return null;
+      const edits = [];
+      let append = "";
+      if (isDevMode && importsSibu(code2)) {
+        const prologue = devPrologueEdit(code2);
+        if (prologue) edits.push(prologue);
       }
-      if (isDevMode) {
-        const withDevHelpers = injectDevHelpers(transformed);
-        if (withDevHelpers !== transformed) {
-          transformed = withDevHelpers;
-          modified = true;
-        }
+      if (pureAnnotations) {
+        edits.push(...pureAnnotationEdits(code2));
       }
       const shouldCompile = compileTemplates ?? !isDevMode;
-      if (shouldCompile && transformed.includes("html`")) {
-        const compiled = compileHtmlTemplates(transformed);
-        if (compiled.code) {
-          const tagImports = Array.from(compiled.usedTags).filter((t) => !SVG_TAGS_SET.has(t));
-          const needsSvg = compiled.usesSvg;
-          const imports = [];
-          if (tagImports.length > 0) {
-            imports.push(`import { ${tagImports.join(", ")} } from "sibu";`);
-          }
-          if (needsSvg) {
-            imports.push(`import { tagFactory as __sbTagFactory, SVG_NS as __sbSVG_NS } from "sibu";`);
-          }
-          const newImports = imports.filter((imp) => !transformed.includes(imp));
-          if (newImports.length > 0) {
-            compiled.code = `${newImports.join("\n")}
-${compiled.code}`;
-          }
-          transformed = compiled.code;
-          modified = true;
+      if (shouldCompile) {
+        const plan = planHtmlTemplates(code2);
+        if (plan.compiledCount > 0) {
+          edits.push(...plan.edits);
+          append += plan.append;
         }
       }
-      const shouldOptimize = staticOptimize ?? !isDevMode;
-      if (shouldOptimize) {
-        const analysis = analyzeStaticTemplates(transformed);
-        if (analysis.hasStaticPatterns) {
-          const sorted = [...analysis.patterns].sort((a2, b2) => b2.start - a2.start);
-          for (const pattern2 of sorted) {
-            const replacement = `staticTemplate(${JSON.stringify(pattern2.templateHtml)})`;
-            transformed = transformed.slice(0, pattern2.start) + replacement + transformed.slice(pattern2.end);
-          }
-          if (!transformed.includes("import") || !transformed.includes("staticTemplate")) {
-            transformed = `import { staticTemplate } from "sibu";
-${transformed}`;
-          }
-          modified = true;
+      if (staticOptimize) {
+        const optimized = staticOptimizationEdits(code2);
+        if (optimized) {
+          edits.push(...optimized.edits);
+          append += optimized.append;
         }
       }
-      if (!modified) return null;
+      if (edits.length === 0 && append === "") return null;
+      const sorted = normalizeEdits(edits);
+      if (!sorted) return null;
+      const transformed = applyEdits(code2, sorted, append);
+      if (transformed === code2) return null;
       return {
         code: transformed,
-        map: void 0
-        // Let Vite handle source maps
+        map: editsSourceMap(code2, sorted, append, id)
       };
     },
     handleHotUpdate(ctx) {
@@ -812,7 +2042,7 @@ function createViteConfig(options = {}) {
     // SSR configuration
     ...ssr ? {
       ssr: {
-        noExternal: ["sibu"],
+        noExternal: ["sibujs"],
         target: "node"
       },
       build: {
@@ -829,8 +2059,8 @@ function createViteConfig(options = {}) {
     } : {},
     // Optimize dependency handling
     optimizeDeps: {
-      include: ["sibu"],
-      // Force pre-bundling of sibu for faster dev startup
+      include: ["sibujs"],
+      // Force pre-bundling of sibujs for faster dev startup
       force: false
     },
     // Environment variable handling
@@ -852,30 +2082,20 @@ function deepMerge(target, source2) {
   return result;
 }
 
-// src/build/webpack.ts
-var PURE_FACTORIES = [
-  "tagFactory",
-  "context",
-  "defineComponent",
-  "withProps",
-  "withDefaults",
-  "pure",
-  "noSideEffect"
-];
+// src/build/webpack.ts
 function addPureAnnotations(source2) {
-  let result = source2;
-  for (const factory of PURE_FACTORIES) {
-    const pattern2 = new RegExp(`(?<!/\\*#__PURE__\\*/\\s*)\\b(${factory})\\s*\\(`, "g");
-    result = result.replace(pattern2, "/*#__PURE__*/ $1(");
-  }
-  return result;
+  return injectPureAnnotations(source2);
 }
 function sibuWebpackPlugin(options = {}) {
-  const { pureAnnotations = true, devMode } = options;
-  const isDevMode = devMode ?? (typeof process !== "undefined" && process.env?.NODE_ENV !== "production");
+  const { devMode } = options;
   return {
     name: "SibuWebpackPlugin",
     apply(compiler) {
+      if (options.pureAnnotations === true) {
+        console.warn(
+          '[SibuWebpackPlugin] `pureAnnotations` is not applied by the plugin: webpack needs a loader file. Create sibu-pure-loader.cjs containing `module.exports = require("sibujs/build").createPureAnnotationsLoader();` and add a module rule `{ test: /\\.[cm]?[jt]sx?$/, exclude: /node_modules/, use: "./sibu-pure-loader.cjs" }`.'
+        );
+      }
       compiler.hooks?.compilation?.tap("SibuWebpackPlugin", (compilation) => {
         const comp = compilation;
         if (comp.hooks?.optimizeModules) {
@@ -883,31 +2103,6 @@ function sibuWebpackPlugin(options = {}) {
           });
         }
       });
-      if (pureAnnotations) {
-        compiler.hooks?.afterEnvironment?.tap("SibuWebpackPlugin", () => {
-          if (!compiler.options.module) {
-            compiler.options.module = { rules: [] };
-          }
-          if (!compiler.options.module.rules) {
-            compiler.options.module.rules = [];
-          }
-          compiler.options.module.rules.push({
-            test: /\.[jt]sx?$/,
-            exclude: /node_modules/,
-            enforce: "pre",
-            use: [
-              {
-                loader: {
-                  // Inline loader function
-                  ident: "sibu-pure-annotations-loader",
-                  loader: "__sibu_inline_loader__",
-                  options: {}
-                }
-              }
-            ]
-          });
-        });
-      }
       compiler.hooks?.afterResolvers?.tap("SibuWebpackPlugin", () => {
         if (!compiler.options.resolve) {
           compiler.options.resolve = {};
@@ -919,20 +2114,21 @@ function sibuWebpackPlugin(options = {}) {
           compiler.options.resolve.mainFields.unshift("module");
         }
       });
-      if (isDevMode) {
-        compiler.hooks?.done?.tap("SibuWebpackPlugin", (stats) => {
-          const statsObj = stats;
-          const info = statsObj?.toJson?.({ modules: false, chunks: false });
-          if (info) {
-            console.log(`[SibuWebpackPlugin] Build completed in ${info.time || 0}ms`);
-            const warnings = info.warnings;
-            if (warnings?.length) {
-              console.log(`[SibuWebpackPlugin] ${warnings.length} warning(s)`);
-            }
+      const tapDoneLogger = () => compiler.hooks?.done?.tap("SibuWebpackPlugin", (stats) => {
+        const statsObj = stats;
+        const info = statsObj?.toJson?.({ modules: false, chunks: false });
+        if (info) {
+          console.log(`[SibuWebpackPlugin] Build completed in ${info.time || 0}ms`);
+          const warnings = info.warnings;
+          if (warnings?.length) {
+            console.log(`[SibuWebpackPlugin] ${warnings.length} warning(s)`);
           }
-        });
-      }
+        }
+      });
+      if (devMode === true) tapDoneLogger();
       compiler.hooks?.environment?.tap("SibuWebpackPlugin", () => {
+        const isDevMode = devMode ?? resolveWebpackDevMode(compiler.options);
+        if (devMode === void 0 && isDevMode) tapDoneLogger();
         if (!compiler.options.plugins) {
           compiler.options.plugins = [];
         }
@@ -940,10 +2136,20 @@ function sibuWebpackPlugin(options = {}) {
           __SIBU_DEV__: JSON.stringify(isDevMode)
         };
         compiler.__sibuDefines = defines;
+        const DefinePlugin = compiler.webpack?.DefinePlugin;
+        if (DefinePlugin) {
+          new DefinePlugin(defines).apply(compiler);
+        }
       });
     }
   };
 }
+function resolveWebpackDevMode(options) {
+  const mode = options.mode;
+  if (mode === "development") return true;
+  if (mode === "production" || mode === void 0) return false;
+  return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+}
 function createPureAnnotationsLoader() {
   return function sibuPureAnnotationsLoader(source2) {
     return addPureAnnotations(source2);
@@ -1012,9 +2218,10 @@ function createWebpackConfig(options = {}) {
       splitChunks: isDev2 ? false : {
         chunks: "all",
         cacheGroups: {
-          // Separate sibu framework code into its own chunk
+          // Separate sibujs framework code into its own chunk (the package
+          // directory is `sibujs`; matching `sibu` never selected anything)
           sibu: {
-            test: /[\\/]node_modules[\\/]sibu[\\/]/,
+            test: /[\\/]node_modules[\\/]sibujs[\\/]/,
             name: "sibu",
             chunks: "all",
             priority: 20
@@ -1065,8 +2272,9 @@ __export(index_exports, {
   Loading: () => Loading,
   MAX_DRAIN_TEARDOWNS: () => MAX_DRAIN_TEARDOWNS,
   Portal: () => Portal,
-  SVG_NS: () => SVG_NS2,
+  SVG_NS: () => SVG_NS4,
   Suspense: () => Suspense,
+  __renderParsedTemplate: () => __renderParsedTemplate,
   __resetIdCounter: () => __resetIdCounter,
   a: () => a,
   abbr: () => abbr,
@@ -1381,33 +2589,6 @@ function reportError(error, context2) {
   });
 }
 
-// src/core/dev.ts
-var DEV = typeof __SIBU_DEV__ !== "undefined" ? !!__SIBU_DEV__ : typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
-  // safe default: off in browser, on in test/dev Node
-  typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
-);
-function isDev() {
-  if (typeof globalThis.__SIBU_DEV__ !== "undefined") return !!globalThis.__SIBU_DEV__;
-  if (typeof __SIBU_DEV__ !== "undefined") return !!__SIBU_DEV__;
-  return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
-}
-function devAssert(condition, message) {
-  if ((typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) && !condition) {
-    throw new Error(`[SibuJS] ${message}`);
-  }
-}
-function devWarnLazy(build) {
-  if (typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) {
-    const message = build();
-    if (message) console.warn(`[SibuJS] ${message}`);
-  }
-}
-function devWarn(message) {
-  if (typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : DEV) {
-    console.warn(`[SibuJS] ${message}`);
-  }
-}
-
 // src/core/rendering/dispose.ts
 var elementDisposers = /* @__PURE__ */ new WeakMap();
 var MAX_DRAIN_TEARDOWNS = 1e4;
@@ -1447,6 +2628,49 @@ function registerDisposer(node, teardown) {
   const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
   if (capture) capture.entries.push([node, teardown]);
 }
+function withDisposerRollback(build) {
+  const frame = { entries: [], closed: false };
+  const captured = frame.entries;
+  registrationCaptures.push(frame);
+  let result;
+  try {
+    result = build();
+  } catch (err) {
+    let executed = 0;
+    try {
+      while (captured.length > 0) {
+        if (executed >= MAX_DRAIN_TEARDOWNS) {
+          reportDrainRunaway("rollback", executed, captured.length);
+          break;
+        }
+        const [node, teardown] = captured.pop();
+        if (!unregisterDisposer(node, teardown)) continue;
+        executed++;
+        try {
+          teardown();
+        } catch (cleanupErr) {
+          reportError(cleanupErr, { phase: "cleanup", name: "disposer" });
+        }
+      }
+    } finally {
+      frame.closed = true;
+      captured.length = 0;
+      registrationCaptures.pop();
+    }
+    throw err;
+  }
+  frame.closed = true;
+  registrationCaptures.pop();
+  const parent = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (parent) {
+    for (const entry of captured) {
+      if (elementDisposers.get(entry[0])?.includes(entry[1])) parent.entries.push(entry);
+    }
+    frame.forwardTo = parent;
+  }
+  captured.length = 0;
+  return result;
+}
 function unregisterDisposer(node, teardown) {
   const disposers = elementDisposers.get(node);
   if (!disposers) return false;
@@ -1466,296 +2690,283 @@ function dispose(node) {
     const children = Array.from(current.childNodes);
     for (let i2 = 0; i2 < children.length; i2++) {
       stack.push(children[i2]);
-    }
-  }
-  for (let i2 = order.length - 1; i2 >= 0; i2--) {
-    disposeNodeOwn(order[i2]);
-  }
-}
-function disposeNodeOwn(node) {
-  if (!elementDisposers.has(node)) return;
-  let executed = 0;
-  let runaway = false;
-  while (!runaway) {
-    const pending = elementDisposers.get(node);
-    if (!pending || pending.length === 0) break;
-    const snapshot = pending.slice();
-    elementDisposers.delete(node);
-    if (DEV) activeBindingCount -= snapshot.length;
-    for (let i2 = 0; i2 < snapshot.length; i2++) {
-      if (executed >= MAX_DRAIN_TEARDOWNS) {
-        const rest = snapshot.slice(i2);
-        const added = elementDisposers.get(node);
-        elementDisposers.set(node, added ? rest.concat(added) : rest);
-        if (DEV) activeBindingCount += rest.length;
-        reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
-        runaway = true;
-        break;
-      }
-      executed++;
-      try {
-        snapshot[i2]();
-      } catch (err) {
-        reportError(err, { phase: "cleanup", name: "disposer" });
-      }
-    }
-  }
-}
-function replaceChildrenSafely(parent, ...next) {
-  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]);
-  }
-  parent.replaceChildren(...next);
-}
-function checkLeaks(warnThreshold = 0) {
-  if (!DEV) return 0;
-  if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
-    devWarn(
-      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
-    );
-  }
-  return activeBindingCount;
-}
-
-// src/utils/sanitize.ts
-function stripControlChars(value) {
-  return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
-}
-function isEventHandlerAttr(name) {
-  if (name.length < 3) return false;
-  const lower = name.toLowerCase();
-  return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
-}
-var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
-var OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
-function sanitizeUrl(url) {
-  const probe = stripControlChars(url).trim();
-  if (!probe) return "";
-  const output2 = url.replace(OUTER_TRIM, "");
-  const lower = probe.toLowerCase();
-  let schemeEnd = -1;
-  for (let i2 = 0; i2 < lower.length; i2++) {
-    const ch = lower.charCodeAt(i2);
-    if (ch === 58) {
-      schemeEnd = i2;
-      break;
-    }
-    if (ch === 47 || ch === 63 || ch === 35) break;
-  }
-  if (schemeEnd === -1) return output2;
-  const scheme = lower.slice(0, schemeEnd + 1);
-  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output2;
-  if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
-  return output2;
-}
-var SRCSET_DESCRIPTOR = /^\s+\d+(\.\d+)?[wx]$/;
-function sanitizeSrcset(value) {
-  const parts = value.split(",");
-  const out = [];
-  for (let i2 = 0; i2 < parts.length; i2++) {
-    const part = parts[i2].trim();
-    if (!part) continue;
-    const m = part.match(/^(\S+)(\s+.+)?$/);
-    if (!m) continue;
-    if (m[2] !== void 0 && !SRCSET_DESCRIPTOR.test(m[2])) continue;
-    const safe = sanitizeUrl(m[1]);
-    if (!safe) continue;
-    out.push(m[2] ? `${safe}${m[2]}` : safe);
-  }
-  return out.join(", ");
-}
-var CSS_DANGER_GATE = /[(:@\\]/;
-function isCssWhitespace(ch) {
-  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
-}
-function isHexDigit(ch) {
-  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
-}
-function decodeCssEscapes(value) {
-  let out = "";
-  for (let i2 = 0; i2 < value.length; i2++) {
-    const ch = value[i2];
-    if (ch !== "\\") {
-      out += ch;
-      continue;
-    }
-    if (i2 + 1 >= value.length) break;
-    const next = value[i2 + 1];
-    if (next === "\n" || next === "\f") {
-      i2 += 1;
-      continue;
-    }
-    if (next === "\r") {
-      i2 += value[i2 + 2] === "\n" ? 2 : 1;
-      continue;
-    }
-    if (isHexDigit(next)) {
-      let hex = "";
-      let j = i2 + 1;
-      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
-        hex += value[j];
-        j++;
-      }
-      if (j < value.length && isCssWhitespace(value[j])) {
-        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
-      }
-      const code2 = Number.parseInt(hex, 16);
-      const invalid = code2 === 0 || code2 > 1114111 || code2 >= 55296 && code2 <= 57343;
-      out += invalid ? "\uFFFD" : String.fromCodePoint(code2);
-      i2 = j - 1;
-      continue;
-    }
-    out += next;
-    i2 += 1;
-  }
-  return out;
-}
-var BLOCKED_CSS_NEEDLES = [
-  "url(",
-  "expression(",
-  "javascript:",
-  "vbscript:",
-  "-moz-binding",
-  "behavior:",
-  "@import",
-  "image-set(",
-  "filter:progid"
-];
-function describeElement(el) {
-  if (!el) return "an element";
-  let out = el.tagName.toLowerCase();
-  const id = el.getAttribute("id");
-  if (id) out += `#${id}`;
-  const cls = el.getAttribute("class");
-  if (cls) out += `.${cls.trim().split(/\s+/).slice(0, 3).join(".")}`;
-  return `<${out}>`;
-}
-var warnedDeclarations = /* @__PURE__ */ new Set();
-var MAX_WARNED_DECLARATIONS = 100;
-var declarationCapAnnounced = false;
-function warnDroppedDeclaration(value, reason, ctx) {
-  devWarnLazy(() => {
-    const reasons = [
-      "url() in an inline style is an exfiltration channel: the browser fetches it immediately and the URL's path or query can carry page data off-origin",
-      "expression() executes arbitrary script in legacy engines",
-      "the javascript: scheme executes script",
-      "the vbscript: scheme executes script",
-      "-moz-binding loads and runs remote XBL",
-      "behavior: loads and runs a remote HTC script",
-      "@import pulls in a remote stylesheet",
-      "image-set() fetches remote images, the same exfiltration channel as url()",
-      "filter:progid activates legacy scriptable filters"
-    ];
-    const declaration = ctx?.property ? `${ctx.property}: ${value}` : value;
-    const where = describeElement(ctx?.element);
-    const key = `${where}|${declaration}`;
-    if (warnedDeclarations.has(key)) return "";
-    if (warnedDeclarations.size >= MAX_WARNED_DECLARATIONS) {
-      if (declarationCapAnnounced) return "";
-      declarationCapAnnounced = true;
-      return `${MAX_WARNED_DECLARATIONS} distinct dropped style declarations have been reported; suppressing further ones for the rest of this session so they cannot flood the console. The declarations are still dropped \u2014 only the reporting stops. Fix the reported ones and reload to see any that remain.`;
-    }
-    warnedDeclarations.add(key);
-    return `style declaration "${declaration}" was dropped by the style sanitizer on ${where} \u2014 ${reasons[reason]}. The element renders without it, which usually looks like a missing image rather than an error. Sanctioned alternatives: for a content image use an <img> element (or a <picture>); for decoration, put the rule in a stylesheet and set a class instead \u2014 stylesheet CSS is not sanitized, only inline style attributes are. If this declaration is not yours, it came from untrusted data and the drop just prevented an exfiltration.`;
-  });
-}
-function blockedCssReason(value) {
-  if (!CSS_DANGER_GATE.test(value)) return -1;
-  const normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
-  const lower = normalized.toLowerCase().replace(/\s+/g, "");
-  for (let i2 = 0; i2 < BLOCKED_CSS_NEEDLES.length; i2++) {
-    if (lower.includes(BLOCKED_CSS_NEEDLES[i2])) return i2;
+    }
+  }
+  for (let i2 = order.length - 1; i2 >= 0; i2--) {
+    disposeNodeOwn(order[i2]);
   }
-  return -1;
 }
-function sanitizeCSSValue(value, context2) {
-  const reason = blockedCssReason(value);
-  if (reason === -1) return value;
-  warnDroppedDeclaration(value, reason, context2);
-  return "";
+function disposeNodeOwn(node) {
+  if (!elementDisposers.has(node)) return;
+  let executed = 0;
+  let runaway = false;
+  while (!runaway) {
+    const pending = elementDisposers.get(node);
+    if (!pending || pending.length === 0) break;
+    const snapshot = pending.slice();
+    elementDisposers.delete(node);
+    if (DEV) activeBindingCount -= snapshot.length;
+    for (let i2 = 0; i2 < snapshot.length; i2++) {
+      if (executed >= MAX_DRAIN_TEARDOWNS) {
+        const rest = snapshot.slice(i2);
+        const added = elementDisposers.get(node);
+        elementDisposers.set(node, added ? rest.concat(added) : rest);
+        if (DEV) activeBindingCount += rest.length;
+        reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+        runaway = true;
+        break;
+      }
+      executed++;
+      try {
+        snapshot[i2]();
+      } catch (err) {
+        reportError(err, { phase: "cleanup", name: "disposer" });
+      }
+    }
+  }
 }
-function sanitizeStyleAttribute(cssText, context2) {
-  const input2 = String(cssText);
-  if (input2.trim() === "") return "";
-  if (typeof document === "undefined") {
-    return sanitizeCSSValue(input2, context2) === "" ? "" : input2;
+function replaceChildrenSafely(parent, ...next) {
+  for (let i2 = 0; i2 < next.length; i2++) {
+    const node = next[i2];
+    node.parentNode?.removeChild(node);
   }
-  const probe = document.createElement("div");
-  try {
-    probe.style.cssText = input2;
-  } catch {
-    return "";
+  const current = Array.from(parent.childNodes);
+  for (let i2 = 0; i2 < current.length; i2++) {
+    dispose(current[i2]);
   }
-  const declarations = [];
-  for (let i2 = 0; i2 < probe.style.length; i2++) {
-    const property = probe.style[i2];
-    const value = probe.style.getPropertyValue(property);
-    let reason = blockedCssReason(value);
-    if (reason === -1) reason = blockedCssReason(`${property}:${value}`);
-    if (reason !== -1) {
-      warnDroppedDeclaration(value, reason, { property, element: context2?.element });
-      continue;
-    }
-    const priority = probe.style.getPropertyPriority(property);
-    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
+  parent.replaceChildren(...next);
+}
+function checkLeaks(warnThreshold = 0) {
+  if (!DEV) return 0;
+  if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
+    devWarn(
+      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
+    );
   }
-  return declarations.join("; ");
+  return activeBindingCount;
 }
-var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "href",
-  "xlink:href",
-  "src",
-  "action",
-  "formaction",
-  "formtarget",
-  "cite",
-  "poster",
-  "background",
-  "srcset",
-  "ping",
-  "data",
-  // `<html manifest>` is a URL sink too. It was carried only by the SSR
-  // serializers' private copy of this set; folding that copy into this one would
-  // otherwise have silently dropped its coverage.
-  "manifest"
-]);
-var HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
-function isHtmlContentAttribute(name) {
-  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
+
+// src/utils/metaRefresh.ts
+function isAsciiWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
 }
-function sanitizeAttributeString(attr, value, context2) {
-  const lower = attr.toLowerCase();
-  if (lower === "srcset") return sanitizeSrcset(value);
-  if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
-  if (lower === "style") return sanitizeStyleAttribute(value, context2);
-  return value;
+function trimAsciiWhitespace(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && isAsciiWhitespace(value[start])) start++;
+  while (end > start && isAsciiWhitespace(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+var forbidden = (reason) => ({ kind: "forbidden", reason });
+function parseMetaRefreshContent(content) {
+  const raw = trimAsciiWhitespace(stripControlChars(content));
+  if (raw === "") return forbidden(DEV ? "empty content" : "");
+  let i2 = 0;
+  while (i2 < raw.length && raw[i2] >= "0" && raw[i2] <= "9") i2++;
+  if (i2 === 0) return forbidden(DEV ? "missing or non-numeric delay" : "");
+  const delay = Number.parseInt(raw.slice(0, i2), 10);
+  if (!Number.isFinite(delay)) return forbidden(DEV ? "unparseable delay" : "");
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (i2 === raw.length) return { kind: "delay-only", delay };
+  if (raw[i2] !== ";" && raw[i2] !== ",") return forbidden(DEV ? "unexpected text after delay" : "");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  const keyStart = i2;
+  while (i2 < raw.length && !isAsciiWhitespace(raw[i2]) && raw[i2] !== "=") i2++;
+  const key = raw.slice(keyStart, i2).toLowerCase();
+  if (key !== "url") return forbidden(DEV ? `unsupported refresh key ${JSON.stringify(key)}` : "");
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (raw[i2] !== "=") return forbidden(DEV ? "missing '=' after url" : "");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  let destination;
+  const quote2 = raw[i2];
+  if (quote2 === '"' || quote2 === "'") {
+    const close = raw.indexOf(quote2, i2 + 1);
+    if (close === -1) return forbidden(DEV ? "unterminated quoted destination" : "");
+    destination = raw.slice(i2 + 1, close);
+    const rest = trimAsciiWhitespace(raw.slice(close + 1));
+    if (rest !== "") return forbidden(DEV ? "trailing text after quoted destination" : "");
+  } else {
+    destination = trimAsciiWhitespace(raw.slice(i2));
+    if (/[;,]/.test(destination)) return forbidden(DEV ? "multiple refresh assignments" : "");
+  }
+  if (destination === "") return forbidden(DEV ? "empty destination" : "");
+  const sanitizedDestination = sanitizeUrl(destination);
+  if (sanitizedDestination === "") return forbidden(DEV ? "destination uses a disallowed protocol" : "");
+  return { kind: "allowed", delay, destination, sanitizedDestination };
+}
+function resolveMetaRefreshPolicy(attributes) {
+  let httpEquiv;
+  let content;
+  let duplicateName;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, value] of attributes) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) duplicateName = canonical;
+    seen.add(canonical);
+    if (canonical === "http-equiv") httpEquiv = value;
+    else if (canonical === "content") content = value;
+  }
+  if (duplicateName !== void 0) {
+    return forbidden(DEV ? `duplicate case-insensitive attribute ${JSON.stringify(duplicateName)}` : "");
+  }
+  if (typeof httpEquiv !== "string") return { kind: "not-refresh" };
+  if (trimAsciiWhitespace(stripControlChars(httpEquiv)).toLowerCase() !== "refresh") {
+    return { kind: "not-refresh" };
+  }
+  if (typeof content !== "string") return { kind: "not-refresh" };
+  return parseMetaRefreshContent(content);
 }
 
-// src/utils/setSafeAttribute.ts
+// src/utils/elementPolicy.ts
 var HTML_NS = "http://www.w3.org/1999/xhtml";
-var SVG_NS = "http://www.w3.org/2000/svg";
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+var BLOCKED_ELEMENTS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
+function canonicalTagName(tag) {
+  return canonicalAttrName(tag);
+}
+function isBlockedElement(tag) {
+  return BLOCKED_ELEMENTS.has(canonicalTagName(tag));
+}
+var CODE_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style"]);
+function isCodeTextElement(tag) {
+  return CODE_TEXT_ELEMENTS.has(canonicalTagName(tag));
+}
+var ContextualRefusal = {
+  None: 0,
+  /** The element would carry a refresh directive the shared policy forbids. */
+  MetaRefreshForbidden: 1,
+  /** A `<meta>` with a reactive binding may not carry any refresh directive. */
+  MetaRefreshReactive: 2,
+  /** A runtime value may not choose which program a `<script>` runs. */
+  ScriptSource: 3,
+  /** An SVG animation may not target a URL, handler or document attribute. */
+  AnimationTarget: 4,
+  /** A runtime-written `href` may not become an applied stylesheet. */
+  StylesheetSource: 5
+};
+var SCRIPT_SOURCE_ATTRIBUTES = /* @__PURE__ */ new Set(["src", "href", "xlink:href", "type", "language"]);
+var SVG_ANIMATION_ELEMENTS = /* @__PURE__ */ new Set(["animate", "set", "animateMotion", "animateTransform", "animateColor"]);
+var reactiveMetaElements = /* @__PURE__ */ new WeakSet();
+function isHtmlNamespace(el) {
+  return el.namespaceURI === HTML_NS || el.namespaceURI === null;
+}
+function metaSnapshot(el, canonical, value) {
+  const snapshot = /* @__PURE__ */ new Map();
+  const attrs = el.attributes;
+  for (let i2 = 0; i2 < attrs.length; i2++) {
+    const attr = attrs[i2];
+    if (attr.name === canonical) continue;
+    snapshot.set(attr.name, attr.value);
+  }
+  if (canonical !== null && value !== null) snapshot.set(canonical, value);
+  return snapshot;
+}
+function claimReactiveMeta(el) {
+  if (reactiveMetaElements.has(el)) return;
+  reactiveMetaElements.add(el);
+  if (el.getAttribute("content") === null) return;
+  if (resolveMetaRefreshPolicy(metaSnapshot(el, null, null)).kind !== "not-refresh") {
+    el.removeAttribute("content");
+  }
+}
+function metaRefusal(el, name, value, origin) {
+  if (!isHtmlNamespace(el)) return ContextualRefusal.None;
+  const canonical = canonicalAttrName(name);
+  if (canonical !== "http-equiv" && canonical !== "content") return ContextualRefusal.None;
+  if (origin === "reactive") claimReactiveMeta(el);
+  if (value === null) return ContextualRefusal.None;
+  if (canonical === "content" && !el.hasAttribute("http-equiv")) return ContextualRefusal.None;
+  const decision = resolveMetaRefreshPolicy(metaSnapshot(el, canonical, value));
+  if (decision.kind === "forbidden") return ContextualRefusal.MetaRefreshForbidden;
+  if (decision.kind !== "not-refresh" && reactiveMetaElements.has(el)) return ContextualRefusal.MetaRefreshReactive;
+  return ContextualRefusal.None;
+}
+function animationRefusal(name, value) {
+  if (value === null || canonicalAttrName(name) !== "attributename") return ContextualRefusal.None;
+  const target = stripControlChars(value);
+  return isUrlAttribute(target) || isEventHandlerAttr(target) || isHtmlContentAttribute(target) ? ContextualRefusal.AnimationTarget : ContextualRefusal.None;
+}
+var runtimeHrefLinks = /* @__PURE__ */ new WeakSet();
+function relHasStylesheet(rel) {
+  if (rel === null) return false;
+  const lower = canonicalAttrName(rel);
+  if (!lower.includes("stylesheet")) return false;
+  const tokens = lower.split(/[\t\n\f\r ]+/);
+  for (let i2 = 0; i2 < tokens.length; i2++) if (tokens[i2] === "stylesheet") return true;
+  return false;
+}
+function stylesheetRefusal(el, name, value, origin) {
+  if (!isHtmlNamespace(el)) return ContextualRefusal.None;
+  const canonical = canonicalAttrName(name);
+  if (canonical === "href") {
+    if (origin === "static" || value === null) return ContextualRefusal.None;
+    if (relHasStylesheet(el.getAttribute("rel"))) return ContextualRefusal.StylesheetSource;
+    runtimeHrefLinks.add(el);
+    return ContextualRefusal.None;
+  }
+  if (canonical === "rel") {
+    if (!relHasStylesheet(value)) return ContextualRefusal.None;
+    return runtimeHrefLinks.has(el) && el.hasAttribute("href") ? ContextualRefusal.StylesheetSource : ContextualRefusal.None;
+  }
+  return ContextualRefusal.None;
+}
+function contextualAttributeRefusal(el, name, value, origin) {
+  const local = el.localName;
+  if (local === "meta") return metaRefusal(el, name, value, origin);
+  if (local === "link") return stylesheetRefusal(el, name, value, origin);
+  if (local === "script") {
+    if (origin === "static" || value === null) return ContextualRefusal.None;
+    return SCRIPT_SOURCE_ATTRIBUTES.has(canonicalAttrName(name)) ? ContextualRefusal.ScriptSource : ContextualRefusal.None;
+  }
+  if (SVG_ANIMATION_ELEMENTS.has(local) && el.namespaceURI === SVG_NS2) return animationRefusal(name, value);
+  return ContextualRefusal.None;
+}
+function settleAttributeProvenance(el, name, origin) {
+  if (el.localName !== "link" || canonicalAttrName(name) !== "href") return;
+  if (origin !== "static" && el.hasAttribute("href")) runtimeHrefLinks.add(el);
+  else runtimeHrefLinks.delete(el);
+}
+
+// src/utils/setSafeAttribute.ts
+var HTML_NS2 = "http://www.w3.org/1999/xhtml";
+var SVG_NS3 = "http://www.w3.org/2000/svg";
 var XLINK_NS = "http://www.w3.org/1999/xlink";
 var XML_NS = "http://www.w3.org/XML/1998/namespace";
 var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
 function isHtmlElement(el) {
-  return el.namespaceURI === null || el.namespaceURI === HTML_NS;
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS2;
+}
+function warnContextualRefusal(label2, name, refusal) {
+  devWarnLazy(() => {
+    const reasons = [
+      "",
+      'the element would become a <meta http-equiv="refresh"> directive the shared refresh policy forbids (a destination outside the URL allowlist, or a directive too malformed to read unambiguously)',
+      "a <meta> whose http-equiv or content is reactive may never carry a refresh directive: a browser schedules the navigation as soon as the directive is valid, and nothing can withdraw it when the state changes back",
+      "a runtime value may not choose the program a <script> runs; name the script in static template source, or load it through Head({ script }) as an explicit trust decision",
+      "an SVG animation may not target a URL, event-handler or nested-document attribute; its to / values would be written into that attribute without passing the URL policy",
+      'a runtime-chosen href may not become an applied <link rel="stylesheet">: a well-formed URL is not a trusted stylesheet. Name the stylesheet in static template source, or load a runtime-chosen one through Head({ link }) as an explicit trust decision'
+    ];
+    return `${label2}: refusing "${name}" in this element's context \u2014 ${reasons[refusal]}. The write was not performed.`;
+  });
 }
 function setProp(el, key, val) {
   el[key] = val;
 }
 function namespaceFor(el, name) {
-  if (el.namespaceURI !== SVG_NS) return null;
+  if (el.namespaceURI !== SVG_NS3) return null;
   const lower = name.toLowerCase();
   if (lower.startsWith("xlink:")) return XLINK_NS;
   if (lower.startsWith("xml:")) return XML_NS;
   return null;
 }
 function setSafeAttribute(el, name, value, options = {}) {
+  const written = commitSafeAttribute(el, name, value, options);
+  if (el.localName === "link") settleAttributeProvenance(el, name, options.reactive ? "reactive" : "runtime");
+  return written;
+}
+function commitSafeAttribute(el, name, value, options) {
   const ns = namespaceFor(el, name);
   const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
   if (isEventHandlerAttr(name)) {
@@ -1768,6 +2979,14 @@ function setSafeAttribute(el, name, value, options = {}) {
     else el.removeAttribute(name);
     return false;
   }
+  const pending = value == null || value === false ? null : value === true ? "" : String(value);
+  const refusal = contextualAttributeRefusal(el, name, pending, options.reactive ? "reactive" : "runtime");
+  if (refusal !== ContextualRefusal.None) {
+    warnContextualRefusal(options.label ?? "setSafeAttribute", name, refusal);
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
   if (value == null) {
     if (ns) el.removeAttributeNS(ns, localName);
     else el.removeAttribute(name);
@@ -1811,13 +3030,32 @@ function setSafeAttribute(el, name, value, options = {}) {
     setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
     return true;
   }
-  const safe = sanitizeAttributeString(name, str, { element: el });
+  const safe = str === "" ? "" : resolveAttributeValue(name, str, { element: el });
+  if (safe === null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
   const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
   if (current === safe) return true;
   if (ns) el.setAttributeNS(ns, name, safe);
   else el.setAttribute(name, safe);
   return true;
 }
+function setTrustedAttribute(el, name, value) {
+  if (isHtmlContentAttribute(name)) {
+    if (DEV) devWarn(`html: refusing static attribute "${name}" \u2014 the browser parses it as a nested document.`);
+    return false;
+  }
+  const refusal = contextualAttributeRefusal(el, name, value, "static");
+  if (refusal !== ContextualRefusal.None) {
+    warnContextualRefusal("html (static attribute)", name, refusal);
+    return false;
+  }
+  el.setAttribute(name, value);
+  if (el.localName === "link") settleAttributeProvenance(el, name, "static");
+  return true;
+}
 
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
@@ -2310,7 +3548,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.6.0" : "dev";
+var _runtimeVersion = true ? "4.8.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -2381,7 +3619,7 @@ function bindAttribute(el, attr, getter) {
       reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
       return;
     }
-    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")`, reactive: true });
   }
   return reactiveBinding2(commit, el);
 }
@@ -2406,7 +3644,7 @@ function bindDynamic(el, nameGetter, valueGetter) {
       el.removeAttribute(prevName);
       prevName = null;
     }
-    if (!setSafeAttribute(el, name, value, { label: "bindDynamic" })) return;
+    if (!setSafeAttribute(el, name, value, { label: "bindDynamic", reactive: true })) return;
     prevName = name;
   }
   const teardown = reactiveBinding2(commit, el);
@@ -2587,11 +3825,7 @@ function bindChildNode(placeholder, getter) {
 }
 
 // src/core/rendering/tagFactory.ts
-var SVG_NS2 = "http://www.w3.org/2000/svg";
-var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
-function isBlockedTag(tag) {
-  return BLOCKED_TAGS.has(tag.toLowerCase());
-}
+var SVG_NS4 = "http://www.w3.org/2000/svg";
 var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "config",
   "location",
@@ -2618,8 +3852,35 @@ function toKebab(prop) {
 }
 function applyStyle(el, style2) {
   if (typeof style2 === "function") {
+    const getter = style2;
+    let written = [];
+    let wroteString = false;
     const teardown = reactiveBinding2(() => {
-      el.setAttribute("style", sanitizeStyleAttribute(String(style2()), { element: el }));
+      const value = getter();
+      if (value === null || typeof value !== "object") {
+        written = [];
+        wroteString = true;
+        el.setAttribute("style", sanitizeStyleAttribute(String(value), { element: el }));
+        return;
+      }
+      const decl = el.style;
+      if (wroteString) {
+        el.removeAttribute("style");
+        wroteString = false;
+      }
+      const next = [];
+      for (const prop in value) {
+        if (!Object.hasOwn(value, prop)) continue;
+        const val = value[prop];
+        if (val == null) continue;
+        const name = toKebab(prop);
+        next.push(name);
+        decl.setProperty(name, sanitizeCSSDeclaration(name, String(val), { element: el }));
+      }
+      for (let i2 = 0; i2 < written.length; i2++) {
+        if (next.indexOf(written[i2]) === -1) decl.removeProperty(written[i2]);
+      }
+      written = next;
     }, el);
     registerDisposer(el, teardown);
     return;
@@ -2630,16 +3891,17 @@ function applyStyle(el, style2) {
   }
   const htmlEl = el;
   for (const prop in style2) {
+    if (!Object.hasOwn(style2, prop)) continue;
     const val = style2[prop];
     const name = toKebab(prop);
     if (typeof val === "function") {
       const getter = val;
       const teardown = reactiveBinding2(() => {
-        htmlEl.style.setProperty(name, sanitizeCSSValue(String(getter()), { property: name, element: el }));
+        htmlEl.style.setProperty(name, sanitizeCSSDeclaration(name, String(getter()), { element: el }));
       }, el);
       registerDisposer(el, teardown);
     } else {
-      htmlEl.style.setProperty(name, sanitizeCSSValue(String(val), { property: name, element: el }));
+      htmlEl.style.setProperty(name, sanitizeCSSDeclaration(name, String(val), { element: el }));
     }
   }
 }
@@ -2650,7 +3912,9 @@ function applyClass(el, cls) {
   }
   if (typeof cls === "function") {
     const teardown = reactiveBinding2(() => {
-      el.setAttribute("class", cls());
+      const value = cls();
+      if (value == null || value === false) el.removeAttribute("class");
+      else el.setAttribute("class", value);
     }, el);
     registerDisposer(el, teardown);
     return;
@@ -2659,6 +3923,7 @@ function applyClass(el, cls) {
   let hasReactive = false;
   let result = "";
   for (const name in obj) {
+    if (!Object.hasOwn(obj, name)) continue;
     const val = obj[name];
     if (typeof val === "function") {
       hasReactive = true;
@@ -2670,6 +3935,7 @@ function applyClass(el, cls) {
     const update = () => {
       let r = "";
       for (const name in obj) {
+        if (!Object.hasOwn(obj, name)) continue;
         const val = obj[name];
         const active = typeof val === "function" ? val() : val;
         if (active) r = r ? `${r} ${name}` : name;
@@ -2732,8 +3998,8 @@ function appendChildren(el, nodes) {
     }
   }
 }
-var tagFactory = (tag, ns) => {
-  const blocked = isBlockedTag(tag);
+function tagFactory(tag, ns) {
+  const blocked = isBlockedElement(tag);
   return (first, second) => {
     if (blocked) {
       throw new Error(`tagFactory: refusing to create <${tag}> \u2014 tag is blocked for security reasons.`);
@@ -2781,7 +4047,9 @@ var tagFactory = (tag, ns) => {
     const pClass = props.class;
     if (pClass != null) applyClass(el, pClass);
     const pId = props.id;
-    if (pId != null) {
+    if (typeof pId === "function") {
+      registerDisposer(el, bindAttribute(el, "id", pId));
+    } else if (pId != null) {
       if (DEV && typeof pId === "string" && CLOBBER_RISKY_IDS.has(pId.toLowerCase())) {
         devWarn(
           `tagFactory: element id="${pId}" matches a common global and may cause DOM clobbering. Avoid setting ids from untrusted input.`
@@ -2794,6 +4062,7 @@ var tagFactory = (tag, ns) => {
     const pOn = props.on;
     if (pOn) {
       for (const ev in pOn) {
+        if (!Object.hasOwn(pOn, ev)) continue;
         const handler = pOn[ev];
         if (typeof handler === "function") {
           el.addEventListener(ev, handler);
@@ -2820,6 +4089,7 @@ var tagFactory = (tag, ns) => {
           continue;
         // already handled above / below
         default: {
+          if (!Object.hasOwn(props, key)) continue;
           const value = props[key];
           if (value == null) continue;
           if (isEventHandlerAttr(key)) continue;
@@ -2831,12 +4101,10 @@ var tagFactory = (tag, ns) => {
         }
       }
     }
-    if (props.onElement && typeof props.onElement === "function") {
-      props.onElement(el);
-    }
+    if (typeof props.onElement === "function") props.onElement(el);
     return el;
   };
-};
+}
 
 // src/core/rendering/html.ts
 var html = tagFactory("html");
@@ -2911,7 +4179,7 @@ var param = tagFactory("param");
 var picture = tagFactory("picture");
 var portal = tagFactory("portal");
 var source = tagFactory("source");
-var svg = tagFactory("svg", SVG_NS2);
+var svg = tagFactory("svg", SVG_NS4);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -2952,26 +4220,26 @@ var base = tagFactory("base");
 var link = tagFactory("link");
 var meta = tagFactory("meta");
 var style = tagFactory("style");
-var circle = tagFactory("circle", SVG_NS2);
-var ellipse = tagFactory("ellipse", SVG_NS2);
-var g = tagFactory("g", SVG_NS2);
-var line = tagFactory("line", SVG_NS2);
-var path = tagFactory("path", SVG_NS2);
-var polygon = tagFactory("polygon", SVG_NS2);
-var polyline = tagFactory("polyline", SVG_NS2);
-var rect = tagFactory("rect", SVG_NS2);
-var text = tagFactory("text", SVG_NS2);
-var tspan = tagFactory("tspan", SVG_NS2);
-var defs = tagFactory("defs", SVG_NS2);
-var clipPath = tagFactory("clipPath", SVG_NS2);
-var mask = tagFactory("mask", SVG_NS2);
-var pattern = tagFactory("pattern", SVG_NS2);
-var linearGradient = tagFactory("linearGradient", SVG_NS2);
-var radialGradient = tagFactory("radialGradient", SVG_NS2);
-var stop = tagFactory("stop", SVG_NS2);
-var use = tagFactory("use", SVG_NS2);
-var symbol = tagFactory("symbol", SVG_NS2);
-var marker = tagFactory("marker", SVG_NS2);
+var circle = tagFactory("circle", SVG_NS4);
+var ellipse = tagFactory("ellipse", SVG_NS4);
+var g = tagFactory("g", SVG_NS4);
+var line = tagFactory("line", SVG_NS4);
+var path = tagFactory("path", SVG_NS4);
+var polygon = tagFactory("polygon", SVG_NS4);
+var polyline = tagFactory("polyline", SVG_NS4);
+var rect = tagFactory("rect", SVG_NS4);
+var text = tagFactory("text", SVG_NS4);
+var tspan = tagFactory("tspan", SVG_NS4);
+var defs = tagFactory("defs", SVG_NS4);
+var clipPath = tagFactory("clipPath", SVG_NS4);
+var mask = tagFactory("mask", SVG_NS4);
+var pattern = tagFactory("pattern", SVG_NS4);
+var linearGradient = tagFactory("linearGradient", SVG_NS4);
+var radialGradient = tagFactory("radialGradient", SVG_NS4);
+var stop = tagFactory("stop", SVG_NS4);
+var use = tagFactory("use", SVG_NS4);
+var symbol = tagFactory("symbol", SVG_NS4);
+var marker = tagFactory("marker", SVG_NS4);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -3085,10 +4353,13 @@ function safeCall(cb, hookName) {
     return void 0;
   }
 }
-function runMountCallback(callback, hookName, element) {
+function runMountCallback(callback, hookName, element, isDisposed) {
   const cleanup3 = safeCall(callback, hookName);
-  if (typeof cleanup3 === "function" && element) {
-    registerDisposer(element, cleanup3);
+  if (typeof cleanup3 !== "function") return;
+  if (isDisposed() || !element.isConnected) {
+    safeCall(cleanup3, "onUnmount");
+  } else {
+    onUnmount(cleanup3, element);
   }
 }
 var mountWatchers = /* @__PURE__ */ new WeakMap();
@@ -3250,25 +4521,26 @@ function onMount(callback, element) {
   if (typeof document === "undefined") return;
   if (element) {
     let disposed = false;
+    const isDisposed = () => disposed;
     registerDisposer(element, () => {
       disposed = true;
     });
     if (element.isConnected) {
       queueMicrotask(() => {
         if (disposed) return;
-        runMountCallback(callback, "onMount", element);
+        runMountCallback(callback, "onMount", element, isDisposed);
       });
       return;
     }
     queueMicrotask(() => {
       if (disposed) return;
       if (element.isConnected) {
-        runMountCallback(callback, "onMount", element);
+        runMountCallback(callback, "onMount", element, isDisposed);
         return;
       }
       const unregister = registerMountWatcher(element, () => {
         if (disposed) return;
-        runMountCallback(callback, "onMount", element);
+        runMountCallback(callback, "onMount", element, isDisposed);
       });
       registerDisposer(element, unregister);
     });
@@ -3305,6 +4577,14 @@ function onCleanup(callback, element) {
   registerDisposer(element, callback);
 }
 
+// src/core/devtoolsHook.ts
+function emitDevtools(hook, event, payload) {
+  try {
+    hook.emit(event, payload);
+  } catch {
+  }
+}
+
 // src/core/ssr-context.ts
 var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
 function detectSSRShared() {
@@ -3542,12 +4822,17 @@ function effect(effectFn, options) {
   try {
     retrack2(ctx.bodyFn, ctx.subscriber);
     if (ctx.rerunPending) drainReruns(ctx);
+  } catch (err) {
+    ctx.disposed = true;
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+    cleanup2(ctx.subscriber);
+    throw err;
   } finally {
     ctx.running = false;
     ctx.rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook) hook.emit("effect:create", { effectFn });
+  if (hook) emitDevtools(hook, "effect:create", { effectFn });
   return () => disposeEffect(ctx);
 }
 
@@ -3634,7 +4919,7 @@ function signal(initial, options) {
       state2.__v++;
       if (DEV) {
         const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+        if (hook) emitDevtools(hook, "signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       }
       if (!enqueueBatchedSignal(state2)) {
         notifySubscribers2(state2);
@@ -3648,7 +4933,7 @@ function signal(initial, options) {
       state2.value = newValue;
       state2.__v++;
       const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+      if (hook) emitDevtools(hook, "signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       if (!enqueueBatchedSignal(state2)) {
         notifySubscribers2(state2);
       }
@@ -3667,7 +4952,7 @@ function signal(initial, options) {
   }
   if (DEV) {
     const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) hook.emit("signal:create", { signal: state2, name: debugName, getter: get, initial });
+    if (hook) emitDevtools(hook, "signal:create", { signal: state2, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -4480,36 +5765,34 @@ function Loading(props = {}) {
   const { text: text2, variant = "spinner", size = "md" } = props;
   const sizeClass = size !== "md" ? ` sibu-loading-${size}` : "";
   if (variant === "dots") {
-    return div({
+    return div(
+      {
+        class: `sibu-loading${sizeClass}`,
+        role: "status",
+        "aria-live": "polite",
+        // When there's no visible text, give the live region an accessible name
+        // so it isn't announced as an empty status.
+        "aria-label": text2 ? void 0 : "Loading"
+      },
+      [
+        div({ class: "sibu-loading-dots" }, [
+          span({ class: "sibu-loading-dot" }),
+          span({ class: "sibu-loading-dot" }),
+          span({ class: "sibu-loading-dot" })
+        ]),
+        text2 ? span({ class: "sibu-loading-text" }, text2) : null
+      ]
+    );
+  }
+  return div(
+    {
       class: `sibu-loading${sizeClass}`,
       role: "status",
       "aria-live": "polite",
-      // When there's no visible text, give the live region an accessible name
-      // so it isn't announced as an empty status.
-      "aria-label": text2 ? void 0 : "Loading",
-      nodes: [
-        div({
-          class: "sibu-loading-dots",
-          nodes: [
-            span({ class: "sibu-loading-dot" }),
-            span({ class: "sibu-loading-dot" }),
-            span({ class: "sibu-loading-dot" })
-          ]
-        }),
-        text2 ? span({ class: "sibu-loading-text", nodes: text2 }) : null
-      ].filter(Boolean)
-    });
-  }
-  return div({
-    class: `sibu-loading${sizeClass}`,
-    role: "status",
-    "aria-live": "polite",
-    "aria-label": text2 ? void 0 : "Loading",
-    nodes: [
-      div({ class: "sibu-loading-spinner" }),
-      text2 ? span({ class: "sibu-loading-text", nodes: text2 }) : null
-    ].filter(Boolean)
-  });
+      "aria-label": text2 ? void 0 : "Loading"
+    },
+    [div({ class: "sibu-loading-spinner" }), text2 ? span({ class: "sibu-loading-text" }, text2) : null]
+  );
 }
 
 // src/core/rendering/action.ts
@@ -4615,13 +5898,35 @@ registerAction("copyOnClick", copyOnClick);
 registerAction("autoResize", autoResize);
 registerAction("trapFocus", trapFocus);
 
+// src/utils/adoptThenable.ts
+function adoptThenable(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (typeof then !== "function") return null;
+  return new Promise((resolve, reject) => {
+    queueMicrotask(() => {
+      try {
+        Reflect.apply(then, value, [resolve, reject]);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
 // src/core/rendering/catch.ts
 var globalErrorHandler = null;
 function catchError(fn, onError) {
   try {
     const result = fn();
-    if (result && typeof result.then === "function") {
-      result.catch((err) => {
+    const adopted = adoptThenable(result);
+    if (adopted) {
+      adopted.then(void 0, (err) => {
         if (onError) {
           onError(err, "async");
         } else if (globalErrorHandler) {
@@ -4748,6 +6053,10 @@ function attachBranch(parent, anchor, branch, attachedOnce, where) {
   parent.insertBefore(node, anchor.nextSibling);
   return { node, owned };
 }
+function releaseBranchNode(node, owned) {
+  if (owned) dispose(node);
+  node.parentNode?.removeChild(node);
+}
 function when(condition, thenBranch, elseBranch) {
   const anchor = document.createComment("when");
   let currentNode = null;
@@ -4761,16 +6070,15 @@ function when(condition, thenBranch, elseBranch) {
     const show2 = condition();
     const parent = anchor.parentNode;
     if (!parent) return;
-    if (initialized && show2 === lastCondition) return;
+    if (initialized && Object.is(show2, lastCondition)) return;
     lastCondition = show2;
     const focused = currentNode ? captureFocusWithin([currentNode]) : null;
     if (currentNode?.parentNode) {
-      if (currentNodeOwned) dispose(currentNode);
-      currentNode.parentNode.removeChild(currentNode);
+      releaseBranchNode(currentNode, currentNodeOwned);
       currentNode = null;
     }
     const branch = show2 ? thenBranch : elseBranch !== void 0 ? elseBranch : null;
-    const attached = attachBranch(parent, anchor, branch, attachedOnce, "when");
+    const attached = untracked2(() => attachBranch(parent, anchor, branch, attachedOnce, "when"));
     currentNode = attached.node;
     currentNodeOwned = attached.owned;
     restoreFocusWithin(focused, currentNode ? [currentNode] : [], "when");
@@ -4780,6 +6088,8 @@ function when(condition, thenBranch, elseBranch) {
   registerDisposer(anchor, () => {
     disposed = true;
     stopBinding();
+    if (currentNode) releaseBranchNode(currentNode, currentNodeOwned);
+    currentNode = null;
   });
   if (!initialized) {
     queueMicrotask(() => {
@@ -4805,12 +6115,11 @@ function match(value, cases, fallback) {
     lastKey = key;
     const focused = currentNode ? captureFocusWithin([currentNode]) : null;
     if (currentNode?.parentNode) {
-      if (currentNodeOwned) dispose(currentNode);
-      currentNode.parentNode.removeChild(currentNode);
+      releaseBranchNode(currentNode, currentNodeOwned);
       currentNode = null;
     }
     const branch = Object.hasOwn(cases, key) ? cases[key] : fallback;
-    const attached = attachBranch(parent, anchor, branch ?? null, attachedOnce, "match");
+    const attached = untracked2(() => attachBranch(parent, anchor, branch ?? null, attachedOnce, "match"));
     currentNode = attached.node;
     currentNodeOwned = attached.owned;
     restoreFocusWithin(focused, currentNode ? [currentNode] : [], "match");
@@ -4820,6 +6129,8 @@ function match(value, cases, fallback) {
   registerDisposer(anchor, () => {
     disposed = true;
     stopBinding();
+    if (currentNode) releaseBranchNode(currentNode, currentNodeOwned);
+    currentNode = null;
   });
   if (!initialized) {
     queueMicrotask(() => {
@@ -4840,11 +6151,17 @@ var componentRegistry = globalSingleton(
   /* @__PURE__ */ Symbol.for("sibujs.components.registry.v1"),
   () => /* @__PURE__ */ new Map()
 );
+var registryVersion = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.components.registryVersion.v1"), () => signal(0));
+function bumpRegistry() {
+  const [read, write] = registryVersion;
+  write(untracked2(read) + 1);
+}
 function registerComponent(name, component) {
   componentRegistry.set(name, component);
+  bumpRegistry();
 }
 function unregisterComponent(name) {
-  componentRegistry.delete(name);
+  if (componentRegistry.delete(name)) bumpRegistry();
 }
 function resolveComponent(name) {
   const component = componentRegistry.get(name);
@@ -4855,14 +6172,21 @@ function resolveComponent(name) {
 }
 function DynamicComponent(is) {
   const container = div({ class: "sibu-dynamic" });
+  const NONE = {};
+  let shown = NONE;
   function render() {
     const target = is();
-    let el;
+    let component;
     if (typeof target === "function") {
-      el = target();
+      component = target;
     } else {
-      el = resolveComponent(target);
+      registryVersion[0]();
+      component = componentRegistry.get(target);
     }
+    const next = component ?? `missing:${target}`;
+    if (next === shown) return;
+    const el = untracked2(() => component ? component() : div(`[Component "${target}" not found]`));
+    shown = next;
     replaceChildrenSafely(container, el);
   }
   const untrack = track2(render);
@@ -5126,31 +6450,29 @@ function Fragment(nodes) {
     if (Array.isArray(child)) {
       for (const nested of child) {
         if (nested == null || typeof nested === "boolean") continue;
-        frag.appendChild(resolveChild(nested));
+        appendChild(frag, nested);
       }
     } else {
-      frag.appendChild(resolveChild(child));
+      appendChild(frag, child);
     }
   }
   return frag;
 }
-function resolveChild(child) {
-  if (child == null) {
-    return document.createTextNode("");
-  }
+function appendChild(frag, child) {
   if (child instanceof Node) {
-    return child;
+    frag.appendChild(child);
+    return;
   }
   if (typeof child === "function") {
-    const result = child();
-    if (result instanceof Node) return result;
-    return document.createTextNode(String(result ?? ""));
+    const placeholder = document.createComment("");
+    frag.appendChild(placeholder);
+    registerDisposer(placeholder, bindChildNode(placeholder, child));
+    return;
   }
-  return document.createTextNode(String(child));
+  frag.appendChild(document.createTextNode(String(child)));
 }
 
 // src/core/rendering/htm.ts
-var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
 var VOID_ELEMENTS3 = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -5191,7 +6513,7 @@ var SVG_TAGS2 = /* @__PURE__ */ new Set([
   "marker"
 ]);
 var cache = /* @__PURE__ */ new WeakMap();
-function parseTemplate(strings) {
+function parseTemplate2(strings) {
   const exprCount = strings.length - 1;
   let template2 = strings[0];
   for (let i2 = 0; i2 < exprCount; i2++) {
@@ -5373,7 +6695,7 @@ function parseTemplate(strings) {
           children.push({ t: 0, el: { tag, svg: SVG_TAGS2.has(tag), attrs, children: [] } });
         } else {
           const inner = parseChildren();
-          if (RAW_TEXT_TAGS.has(tag.toLowerCase())) {
+          if (isCodeTextElement(tag)) {
             for (let i2 = 0; i2 < inner.length; i2++) {
               if (inner[i2].t === 2) {
                 throw new Error(
@@ -5399,12 +6721,12 @@ function parseTemplate(strings) {
   return parseChildren();
 }
 function executeElement(tmpl, values) {
-  const el = tmpl.svg ? document.createElementNS(SVG_NS2, tmpl.tag) : document.createElement(tmpl.tag);
+  const el = tmpl.svg ? document.createElementNS(SVG_NS4, tmpl.tag) : document.createElement(tmpl.tag);
   for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
     const attr = tmpl.attrs[i2];
     switch (attr.t) {
       case 0:
-        el.setAttribute(attr.name, attr.value);
+        setTrustedAttribute(el, attr.name, attr.value);
         break;
       case 1: {
         const name = attr.name;
@@ -5437,7 +6759,7 @@ function executeElement(tmpl, values) {
         break;
       }
       case 4:
-        el.setAttribute(attr.name, "");
+        setTrustedAttribute(el, attr.name, "");
         break;
     }
   }
@@ -5479,9 +6801,15 @@ function executeElement(tmpl, values) {
 function html2(strings, ...values) {
   let tmpl = cache.get(strings);
   if (!tmpl) {
-    tmpl = parseTemplate(strings);
+    tmpl = parseTemplate2(strings);
     cache.set(strings, tmpl);
   }
+  return renderTemplate(tmpl, values);
+}
+function __renderParsedTemplate(tree, values) {
+  return renderTemplate(tree, values);
+}
+function renderTemplate(tmpl, values) {
   if (tmpl.length === 1 && tmpl[0].t === 0) {
     return executeElement(tmpl[0].el, values);
   }
@@ -5616,25 +6944,77 @@ function mount(component, container) {
     typeof component === "function" || component instanceof Node,
     "mount: first argument must be a component function or a DOM Node."
   );
-  const startTime = typeof performance !== "undefined" ? performance.now() : 0;
-  const node = typeof component === "function" ? component() : component;
-  const duration = typeof performance !== "undefined" ? performance.now() - startTime : 0;
-  container.appendChild(node);
-  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook) {
-    hook.emit("app:init", { rootElement: node, container, duration });
+  const now = () => typeof performance !== "undefined" ? performance.now() : 0;
+  const startTime = now();
+  let range = null;
+  const attach = (built) => {
+    if (built instanceof DocumentFragment) {
+      const start = document.createComment("");
+      const end = document.createComment("");
+      built.insertBefore(start, built.firstChild);
+      built.appendChild(end);
+      range = { start, end };
+    }
+    container.appendChild(built);
+  };
+  let node;
+  if (typeof component === "function") {
+    node = withDisposerRollback(() => {
+      const built = component();
+      attach(built);
+      return built;
+    });
+  } else {
+    node = component;
+    attach(node);
   }
+  const duration = now() - startTime;
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) emitDevtools(hook, "app:init", { rootElement: node, container, duration });
+  const mounted = range;
   return {
     node,
     unmount() {
-      if (hook) hook.emit("app:unmount", { rootElement: node });
-      dispose(node);
-      if (node.parentNode) {
-        node.parentNode.removeChild(node);
+      if (hook) emitDevtools(hook, "app:unmount", { rootElement: node });
+      if (mounted) {
+        unmountRange(mounted.start, mounted.end);
+        return;
       }
+      dispose(node);
+      node.parentNode?.removeChild(node);
     }
   };
 }
+function unmountRange(start, end) {
+  const parent = start.parentNode;
+  if (!parent && !end.parentNode) return;
+  let budget = MAX_DRAIN_TEARDOWNS;
+  for (let n = start.nextSibling; n && n !== end; n = n.nextSibling) budget++;
+  let before = start;
+  let after = null;
+  let intact = true;
+  for (; ; ) {
+    if (start.parentNode !== parent || end.parentNode !== parent) intact = false;
+    else if (start.previousSibling !== before || end.nextSibling !== after) {
+      before = start.previousSibling;
+      after = end.nextSibling;
+      intact = !!(start.compareDocumentPosition(end) & 4);
+    }
+    const n = start.nextSibling;
+    if (!intact || n === end) break;
+    if (budget-- <= 0) {
+      reportDrainRunaway("mount", MAX_DRAIN_TEARDOWNS, 1);
+      return;
+    }
+    dispose(n);
+    if (n.parentNode === parent) parent.removeChild(n);
+  }
+  if (!intact) {
+    reportError(new Error("[SibuJS mount] fragment markers lost"), { phase: "cleanup", name: "mount" });
+  }
+  start.parentNode?.removeChild(start);
+  end.parentNode?.removeChild(end);
+}
 
 // src/core/rendering/portal.ts
 function Portal(nodes, target) {
@@ -6070,17 +7450,17 @@ function derived(getter, options) {
     cs._d = false;
     cs._init = true;
   };
-  track2(() => {
-    let threw = true;
-    try {
+  try {
+    track2(() => {
       cs._v = getter();
       cs._d = false;
       cs._init = true;
-      threw = false;
-    } finally {
-      if (threw) cs._d = true;
-    }
-  }, markDirty);
+    }, markDirty);
+  } catch (err) {
+    disposed = true;
+    cleanup2(markDirty);
+    throw err;
+  }
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   const validate = () => {
     if (!cs._d || disposed || pendingError !== void 0) return;
@@ -6099,7 +7479,7 @@ function derived(getter, options) {
       if (disposed) cleanup2(markDirty);
     }
     if (hook && !disposed && !Object.is(oldValue, cs._v)) {
-      hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      emitDevtools(hook, "computed:update", { signal: cs, oldValue, newValue: cs._v });
     }
   };
   cs._validate = validate;
@@ -6150,7 +7530,7 @@ function derived(getter, options) {
       }
     }
   };
-  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  if (hook) emitDevtools(hook, "computed:create", { signal: cs, name: debugName, getter: computedGetter });
   return computedGetter;
 }
 
@@ -6518,7 +7898,7 @@ function enhance(target, setup) {
           bindNode(el, () => {
             const v = value();
             const next = v == null ? null : String(v);
-            setSafeAttribute(el, name, next, { syncValueProperty: false, label: "enhance attr()" });
+            setSafeAttribute(el, name, next, { syncValueProperty: false, label: "enhance attr()", reactive: true });
           })
         );
       });
@@ -6790,27 +8170,6 @@ function trustHTML(html3) {
 }
 var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
 
-// src/utils/adoptThenable.ts
-function adoptThenable(value) {
-  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
-  let then;
-  try {
-    then = value.then;
-  } catch (error) {
-    return Promise.reject(error);
-  }
-  if (typeof then !== "function") return null;
-  return new Promise((resolve, reject) => {
-    queueMicrotask(() => {
-      try {
-        Reflect.apply(then, value, [resolve, reject]);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  });
-}
-
 // src/reactivity/concurrent.ts
 function defer(getter) {
   const [value, setValue] = signal(getter());
@@ -6901,7 +8260,23 @@ function nextTick() {
 }
 
 // src/build/cdn.ts
-var PACKAGE_NAME = "sibu";
+var PACKAGE_NAME = "sibujs";
+var SUBPATH_ENTRIES = [
+  "data",
+  "browser",
+  "patterns",
+  "motion",
+  "ui",
+  "widgets",
+  "ssr",
+  "devtools",
+  "performance",
+  "ecosystem",
+  "plugins",
+  "build",
+  "testing",
+  "extras"
+];
 function registerGlobal() {
   if (typeof window === "undefined") return;
   window.Sibu = { ...index_exports };
@@ -6947,7 +8322,7 @@ var cdnUrls = {
    * @example
    * ```ts
    * cdnUrls.scriptTag('jsdelivr', '1.0.0')
-   * // => '<script src="https://cdn.jsdelivr.net/npm/sibu@1.0.0/dist/cdn.global.js"></script>'
+   * // => '<script src="https://cdn.jsdelivr.net/npm/sibujs@1.0.0/dist/cdn.global.js"></script>'
    * ```
    */
   scriptTag: (provider = "jsdelivr", version) => {
@@ -6965,15 +8340,11 @@ function generateImportMap(baseUrl) {
   const base2 = baseUrl || `https://cdn.jsdelivr.net/npm/${PACKAGE_NAME}@latest`;
   const imports = {
     // Main package entry
-    [PACKAGE_NAME]: `${base2}/dist/index.js`,
-    // Sub-path imports for tree-shaking in browsers
-    [`${PACKAGE_NAME}/core`]: `${base2}/dist/core/index.js`,
-    [`${PACKAGE_NAME}/reactivity`]: `${base2}/dist/reactivity/index.js`,
-    [`${PACKAGE_NAME}/plugins`]: `${base2}/dist/plugins/index.js`,
-    [`${PACKAGE_NAME}/components`]: `${base2}/dist/components/index.js`,
-    [`${PACKAGE_NAME}/testing`]: `${base2}/dist/testing/index.js`,
-    [`${PACKAGE_NAME}/build`]: `${base2}/dist/build/index.js`
+    [PACKAGE_NAME]: `${base2}/dist/index.js`
   };
+  for (const entry of SUBPATH_ENTRIES) {
+    imports[`${PACKAGE_NAME}/${entry}`] = `${base2}/dist/${entry}.js`;
+  }
   return {
     imports,
     /**
@@ -7056,9 +8427,9 @@ function generateTsConfig(options) {
   if (paths && Object.keys(paths).length > 0) {
     compilerOptions.baseUrl = ".";
     compilerOptions.paths = {
-      // Default sibu alias
-      sibu: ["node_modules/sibu/dist/index.d.ts"],
-      "sibu/*": ["node_modules/sibu/dist/*"],
+      // Default sibujs alias
+      sibujs: ["node_modules/sibujs/dist/index.d.ts"],
+      "sibujs/*": ["node_modules/sibujs/dist/*"],
       // User-provided paths
       ...paths
     };
@@ -8172,6 +9543,19 @@ function generateTypeStubs() {
   };
 }
 
+// src/build/compileTemplates.ts
+function compileHtmlTemplates(code2) {
+  const plan = planHtmlTemplates(code2);
+  const edits = plan.compiledCount > 0 ? normalizeEdits(plan.edits) : null;
+  return {
+    code: edits ? applyEdits(code2, edits, plan.append) : null,
+    usedTags: plan.usedTags,
+    usesSvg: plan.usesSvg,
+    compiledCount: edits ? plan.compiledCount : 0,
+    skippedCount: plan.skippedCount
+  };
+}
+
 // src/build/routeSplitting.ts
 function fileToRoute(relativePath) {
   const basename = relativePath.split("/").pop() || "";
@@ -8227,7 +9611,7 @@ function generateRouteModule(entries, routesDir) {
     (e, i2) => `const route${i2} = () => import(/* webpackChunkName: "${e.chunkName}" */ "${routesDir}/${e.importPath}");`
   ).join("\n");
   const routes = entries.map((e, i2) => `  { path: "${e.path}", component: lazy(route${i2}) }`).join(",\n");
-  return `import { lazy } from "sibu";
+  return `import { lazy } from "sibujs";
 
 ${imports}