sibujs 4.5.0 → 4.7.0

package/dist/build.cjs

@@ -59,8 +59,1162 @@ __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, "");
+}
+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;
+  }
+  return -1;
+}
+function sanitizeCSSValue(value, context2) {
+  const reason = blockedCssReason(value);
+  if (reason === -1) return value;
+  warnDroppedDeclaration(value, reason, context2);
+  return "";
+}
+function sanitizeStyleAttribute(cssText, context2) {
+  const input2 = String(cssText);
+  if (input2.trim() === "") return "";
+  if (typeof document === "undefined") {
+    return sanitizeCSSValue(input2, context2) === "" ? "" : input2;
+  }
+  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);
+    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}` : ""}`);
+  }
+  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 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;
+}
+
+// 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",
@@ -90,105 +1244,19 @@ var SVG_TAGS = /* @__PURE__ */ new Set([
   "tspan",
   "defs",
   "clipPath",
-  "mask",
-  "pattern",
-  "linearGradient",
-  "radialGradient",
-  "stop",
-  "use",
-  "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) {
+  "mask",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "use",
+  "symbol",
+  "marker"
+]);
+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 +1265,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 +1300,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 +1379,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 +1449,230 @@ 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;
-    }
-  }
-  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(", ")} }`);
-  }
-  if (el.children.length > 0) {
-    const childExprs = el.children.map((c) => generateChild(c, valuesVar));
-    if (childExprs.length === 1) {
-      parts.push(`nodes: ${childExprs[0]}`);
+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 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 {
-      parts.push(`nodes: [${childExprs.join(", ")}]`);
+      return null;
     }
   }
-  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)({})`;
-  }
-  return propsStr ? `${tag}(${propsStr})` : `${tag}({})`;
+  lines.push("return w;");
+  return lines.join("\n  ");
 }
-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 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);
+}`
+    );
   }
-}
-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("str")) {
+    out.push(`function ${P}str(value) {
+  return value == null ? "" : String(value);
+}`);
   }
-  return { code: result, usedTags, usesSvg, compiledCount: templates.length };
-}
-function collectTags(children, tags) {
-  for (const child of children) {
-    if (child.kind === "element") {
-      tags.add(child.el.tag);
-      collectTags(child.el.children, tags);
-    }
+  if (h.used.has("on")) {
+    out.push(
+      `function ${P}on(el, name, handler) {
+  if (typeof handler === "function") el.addEventListener(name, handler);
+}`
+    );
   }
-}
-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;
-        continue;
-      }
-      pos++;
-    }
-    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++;
-    }
-    exprs.push(code2.slice(exprStart, pos).trim());
-    pos++;
+  if (h.used.has("child")) {
+    out.push(
+      `function ${P}child(el, value) {
+  if (typeof value === "function") {
+    el.appendChild(${P}Fragment([value]));
+  } 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 exprs;
+  return out.join("\n");
 }
-
-// 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 });
-      }
-    }
-  }
-  return {
-    hasStaticPatterns: patterns.length > 0,
-    patterns
-  };
+function importSource(h) {
+  const P = h.prefix;
+  const core = [];
+  if (h.used.has("child")) core.push(`Fragment as ${P}Fragment`);
+  if (h.used.has("attr")) core.push(`registerDisposer as ${P}registerDisposer`);
+  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 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;
+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) return null;
+      strings.push(cooked);
+    }
+    let roots;
+    try {
+      roots = parseTemplate(strings);
+    } catch (err) {
+      if (err instanceof RuntimeParseError) return null;
+      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) return null;
+    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;
+    const name = `${h.prefix}t${functions.length}`;
+    const params = tmpl.exprs.map((_, i2) => `v${i2}`).join(", ");
+    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;
     }
-  }
-  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))}"`);
+    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);
+      }
     }
-  }
-  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 +1682,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 +1726,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 +1755,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 +1854,7 @@ function createViteConfig(options = {}) {
     // SSR configuration
     ...ssr ? {
       ssr: {
-        noExternal: ["sibu"],
+        noExternal: ["sibujs"],
         target: "node"
       },
       build: {
@@ -829,8 +1871,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
@@ -853,26 +1895,11 @@ function deepMerge(target, source2) {
 }
 
 // src/build/webpack.ts
-var PURE_FACTORIES = [
-  "tagFactory",
-  "context",
-  "defineComponent",
-  "withProps",
-  "withDefaults",
-  "pure",
-  "noSideEffect"
-];
 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) {
@@ -883,31 +1910,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 +1921,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 +1943,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 +2025,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,7 +2079,7 @@ __export(index_exports, {
   Loading: () => Loading,
   MAX_DRAIN_TEARDOWNS: () => MAX_DRAIN_TEARDOWNS,
   Portal: () => Portal,
-  SVG_NS: () => SVG_NS2,
+  SVG_NS: () => SVG_NS3,
   Suspense: () => Suspense,
   __resetIdCounter: () => __resetIdCounter,
   a: () => a,
@@ -1381,33 +2395,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;
@@ -1419,6 +2406,23 @@ function reportDrainRunaway(label2, executed, remaining) {
   );
 }
 var activeBindingCount = 0;
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
 function registerDisposer(node, teardown) {
   let disposers = elementDisposers.get(node);
   if (!disposers) {
@@ -1427,297 +2431,130 @@ function registerDisposer(node, teardown) {
   }
   disposers.push(teardown);
   if (DEV) activeBindingCount++;
-}
-function unregisterDisposer(node, teardown) {
-  const disposers = elementDisposers.get(node);
-  if (!disposers) return;
-  const index = disposers.indexOf(teardown);
-  if (index === -1) return;
-  disposers.splice(index, 1);
-  if (DEV) activeBindingCount--;
-  if (disposers.length === 0) elementDisposers.delete(node);
-}
-function dispose(node) {
-  const stack = [node];
-  const order = [];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    order.push(current);
-    const children = Array.from(current.childNodes);
-    for (let i2 = 0; i2 < children.length; i2++) {
-      stack.push(children[i2]);
-    }
-  }
-  for (let i2 = order.length - 1; i2 >= 0; i2--) {
-    const current = order[i2];
-    if (elementDisposers.has(current)) {
-      let executed = 0;
-      let runaway = false;
-      while (!runaway) {
-        const pending = elementDisposers.get(current);
-        if (!pending || pending.length === 0) break;
-        const snapshot = pending.slice();
-        elementDisposers.delete(current);
-        if (DEV) activeBindingCount -= snapshot.length;
-        for (let i3 = 0; i3 < snapshot.length; i3++) {
-          if (executed >= MAX_DRAIN_TEARDOWNS) {
-            const rest = snapshot.slice(i3);
-            const added = elementDisposers.get(current);
-            elementDisposers.set(current, added ? rest.concat(added) : rest);
-            if (DEV) activeBindingCount += rest.length;
-            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
-            runaway = true;
-            break;
-          }
-          executed++;
-          try {
-            snapshot[i3]();
-          } catch (err) {
-            reportError(err, { phase: "cleanup", name: "disposer" });
-          }
+  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;
         }
-      }
-    }
-  }
-}
-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.`;
+        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();
     }
-    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;
+    throw err;
   }
-  return -1;
+  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 sanitizeCSSValue(value, context2) {
-  const reason = blockedCssReason(value);
-  if (reason === -1) return value;
-  warnDroppedDeclaration(value, reason, context2);
-  return "";
+function unregisterDisposer(node, teardown) {
+  const disposers = elementDisposers.get(node);
+  if (!disposers) return false;
+  const index = disposers.indexOf(teardown);
+  if (index === -1) return false;
+  disposers.splice(index, 1);
+  if (DEV) activeBindingCount--;
+  if (disposers.length === 0) elementDisposers.delete(node);
+  return true;
 }
-function sanitizeStyleAttribute(cssText, context2) {
-  const input2 = String(cssText);
-  if (input2.trim() === "") return "";
-  if (typeof document === "undefined") {
-    return sanitizeCSSValue(input2, context2) === "" ? "" : input2;
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i2 = 0; i2 < children.length; i2++) {
+      stack.push(children[i2]);
+    }
   }
-  const probe = document.createElement("div");
-  try {
-    probe.style.cssText = input2;
-  } catch {
-    return "";
+  for (let i2 = order.length - 1; i2 >= 0; i2--) {
+    disposeNodeOwn(order[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;
+}
+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" });
+      }
     }
-    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 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 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 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/setSafeAttribute.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 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"]);
@@ -1728,7 +2565,7 @@ function setProp(el, key, val) {
   el[key] = val;
 }
 function namespaceFor(el, name) {
-  if (el.namespaceURI !== SVG_NS) return null;
+  if (el.namespaceURI !== SVG_NS2) return null;
   const lower = name.toLowerCase();
   if (lower.startsWith("xlink:")) return XLINK_NS;
   if (lower.startsWith("xml:")) return XML_NS;
@@ -1956,6 +2793,7 @@ function retrack(effectFn, subscriber) {
   }
   currentSubscriber = subscriber;
   const sub2 = subscriber;
+  if (sub2._cap === void 0) sub2._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub2._epoch = epoch;
   sub2._structDirty = false;
@@ -2147,7 +2985,12 @@ function drainQueue() {
       quarantined.add(sub2);
       continue;
     }
-    safeInvoke(sub2);
+    const pushed = beginDisposerCapture(sub2._cap ?? null);
+    try {
+      safeInvoke(sub2);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -2283,7 +3126,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.5.0" : "dev";
+var _runtimeVersion = true ? "4.7.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -2560,7 +3403,7 @@ function bindChildNode(placeholder, getter) {
 }
 
 // src/core/rendering/tagFactory.ts
-var SVG_NS2 = "http://www.w3.org/2000/svg";
+var SVG_NS3 = "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());
@@ -2591,8 +3434,34 @@ 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) {
+        const val = value[prop];
+        if (val == null) continue;
+        const name = toKebab(prop);
+        next.push(name);
+        decl.setProperty(name, sanitizeCSSValue(String(val), { property: name, 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;
@@ -2623,7 +3492,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;
@@ -2705,7 +3576,7 @@ function appendChildren(el, nodes) {
     }
   }
 }
-var tagFactory = (tag, ns) => {
+function tagFactory(tag, ns) {
   const blocked = isBlockedTag(tag);
   return (first, second) => {
     if (blocked) {
@@ -2754,7 +3625,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.`
@@ -2804,12 +3677,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");
@@ -2884,7 +3755,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_NS3);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -2925,26 +3796,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_NS3);
+var ellipse = tagFactory("ellipse", SVG_NS3);
+var g = tagFactory("g", SVG_NS3);
+var line = tagFactory("line", SVG_NS3);
+var path = tagFactory("path", SVG_NS3);
+var polygon = tagFactory("polygon", SVG_NS3);
+var polyline = tagFactory("polyline", SVG_NS3);
+var rect = tagFactory("rect", SVG_NS3);
+var text = tagFactory("text", SVG_NS3);
+var tspan = tagFactory("tspan", SVG_NS3);
+var defs = tagFactory("defs", SVG_NS3);
+var clipPath = tagFactory("clipPath", SVG_NS3);
+var mask = tagFactory("mask", SVG_NS3);
+var pattern = tagFactory("pattern", SVG_NS3);
+var linearGradient = tagFactory("linearGradient", SVG_NS3);
+var radialGradient = tagFactory("radialGradient", SVG_NS3);
+var stop = tagFactory("stop", SVG_NS3);
+var use = tagFactory("use", SVG_NS3);
+var symbol = tagFactory("symbol", SVG_NS3);
+var marker = tagFactory("marker", SVG_NS3);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -3058,10 +3929,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();
@@ -3223,25 +4097,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);
     });
@@ -3278,6 +4153,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() {
@@ -3324,6 +4207,10 @@ function getSSRStore() {
   }
   return fallbackStore;
 }
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
 function isSSR() {
   return getSSRStore().ssr;
 }
@@ -3345,16 +4232,18 @@ function disableSSR() {
   getSSRStore().ssr = false;
 }
 function runInSSRContext(fn) {
-  const store2 = { ssr: true, suspenseIdCounter: 0, locale: void 0 };
+  const store2 = { ssr: true, suspenseIdCounter: 0, idCounter: 0, locale: void 0 };
   if (als) {
     return als.run(store2, fn);
   }
   warnMissingAsyncLocalStorage();
   const prevSSR = fallbackStore.ssr;
   const prevCounter = fallbackStore.suspenseIdCounter;
+  const prevIdCounter = fallbackStore.idCounter;
   const prevLocale = fallbackStore.locale;
   fallbackStore.ssr = true;
   fallbackStore.suspenseIdCounter = 0;
+  fallbackStore.idCounter = 0;
   fallbackStore.locale = void 0;
   _shared.fallbackDepth++;
   try {
@@ -3363,6 +4252,7 @@ function runInSSRContext(fn) {
     _shared.fallbackDepth--;
     fallbackStore.ssr = prevSSR;
     fallbackStore.suspenseIdCounter = prevCounter;
+    fallbackStore.idCounter = prevIdCounter;
     fallbackStore.locale = prevLocale;
   }
 }
@@ -3508,12 +4398,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);
 }
 
@@ -3600,7 +4495,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);
@@ -3614,7 +4509,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);
       }
@@ -3633,7 +4528,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];
 }
@@ -4446,36 +5341,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
@@ -4534,9 +5427,14 @@ var longPress = (element, options) => {
   };
 };
 var copyOnClick = (element, getText) => {
+  const report = (error) => reportError(error, { phase: "async", name: "copyOnClick", node: element });
   const handler = () => {
-    const text2 = typeof getText === "function" ? getText() : element.textContent ?? "";
-    navigator.clipboard.writeText(text2);
+    try {
+      const text2 = typeof getText === "function" ? getText() : element.textContent ?? "";
+      Promise.resolve(navigator.clipboard.writeText(text2)).catch(report);
+    } catch (error) {
+      report(error);
+    }
   };
   element.addEventListener("click", handler);
   return () => element.removeEventListener("click", handler);
@@ -4576,13 +5474,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) {
@@ -4672,6 +5592,11 @@ function context(defaultValue) {
 var COUNTER_KEY = /* @__PURE__ */ Symbol.for("sibujs.createId.v1");
 var _counter = globalThis[COUNTER_KEY] ?? (globalThis[COUNTER_KEY] = { n: 0 });
 function createId(prefix = "sibu") {
+  const request = getRequestStore();
+  if (request) {
+    request.idCounter = (request.idCounter ?? 0) + 1;
+    return `${prefix}-${request.idCounter}`;
+  }
   _counter.n++;
   return `${prefix}-${_counter.n}`;
 }
@@ -4709,13 +5634,15 @@ function when(condition, thenBranch, elseBranch) {
   let currentNode = null;
   let lastCondition;
   let initialized = false;
+  let disposed = false;
   const attachedOnce = /* @__PURE__ */ new WeakSet();
   let currentNodeOwned = false;
   const update = () => {
+    if (disposed) return;
     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) {
@@ -4724,16 +5651,20 @@ function when(condition, thenBranch, elseBranch) {
       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");
     initialized = true;
   };
-  registerDisposer(anchor, reactiveBinding2(update, anchor));
+  const stopBinding = reactiveBinding2(update, anchor);
+  registerDisposer(anchor, () => {
+    disposed = true;
+    stopBinding();
+  });
   if (!initialized) {
     queueMicrotask(() => {
-      if (!initialized && anchor.parentNode) update();
+      if (!disposed && !initialized && anchor.parentNode) update();
     });
   }
   return anchor;
@@ -4743,9 +5674,11 @@ function match(value, cases, fallback) {
   let currentNode = null;
   let lastKey;
   let initialized = false;
+  let disposed = false;
   const attachedOnce = /* @__PURE__ */ new WeakSet();
   let currentNodeOwned = false;
   const update = () => {
+    if (disposed) return;
     const key = String(value());
     const parent = anchor.parentNode;
     if (!parent) return;
@@ -4758,46 +5691,72 @@ function match(value, cases, fallback) {
       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");
     initialized = true;
   };
-  registerDisposer(anchor, reactiveBinding2(update, anchor));
+  const stopBinding = reactiveBinding2(update, anchor);
+  registerDisposer(anchor, () => {
+    disposed = true;
+    stopBinding();
+  });
   if (!initialized) {
     queueMicrotask(() => {
-      if (!initialized && anchor.parentNode) update();
+      if (!disposed && !initialized && anchor.parentNode) update();
     });
   }
   return anchor;
 }
 
+// src/utils/globalSingleton.ts
+function globalSingleton(key, create) {
+  const g2 = globalThis;
+  return g2[key] ?? (g2[key] = create());
+}
+
 // src/core/rendering/dynamic.ts
-var componentRegistry = /* @__PURE__ */ new Map();
+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);
   if (component) {
     return component();
   }
-  return div({ nodes: `[Component "${name}" not found]` });
+  return div(`[Component "${name}" not found]`);
 }
 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);
@@ -5061,31 +6020,30 @@ 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 RAW_TEXT_TAGS2 = /* @__PURE__ */ new Set(["script", "style"]);
 var VOID_ELEMENTS3 = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -5126,7 +6084,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++) {
@@ -5308,7 +6266,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 (RAW_TEXT_TAGS2.has(tag.toLowerCase())) {
             for (let i2 = 0; i2 < inner.length; i2++) {
               if (inner[i2].t === 2) {
                 throw new Error(
@@ -5334,7 +6292,7 @@ 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_NS3, tmpl.tag) : document.createElement(tmpl.tag);
   for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
     const attr = tmpl.attrs[i2];
     switch (attr.t) {
@@ -5414,7 +6372,7 @@ 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);
   }
   if (tmpl.length === 1 && tmpl[0].t === 0) {
@@ -5551,25 +6509,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) {
@@ -5605,10 +6615,15 @@ function Portal(nodes, target) {
 
 // src/core/rendering/slots.ts
 function getSlot(slots, name = "default") {
-  return slots?.[name];
+  if (slots == null || !Object.hasOwn(slots, name)) return void 0;
+  const slot2 = slots[name];
+  return typeof slot2 === "function" ? slot2 : void 0;
 }
 
 // src/core/signals/array.ts
+function nativeSplice(target, start, rest) {
+  return rest.length === 0 ? target.splice(start) : target.splice(start, ...rest);
+}
 function array(initial = []) {
   const [arr, setArr] = signal([...initial]);
   const actions = {
@@ -5636,12 +6651,12 @@ function array(initial = []) {
     unshift(...items) {
       setArr((prev) => [...items, ...prev]);
     },
-    splice(start, deleteCount = 0, ...items) {
+    splice(start, ...rest) {
       let removed = [];
       setArr((prev) => {
         const copy = [...prev];
-        removed = copy.splice(start, deleteCount, ...items);
-        return copy;
+        removed = nativeSplice(copy, start, rest);
+        return removed.length === 0 && rest.length <= 1 ? prev : copy;
       });
       return removed;
     },
@@ -5724,9 +6739,9 @@ function reactiveArray(initial = []) {
       data2.unshift(...items);
       notify();
     },
-    splice(start, deleteCount = 0, ...items) {
-      const removed = data2.splice(start, deleteCount, ...items);
-      if (removed.length > 0 || items.length > 0) {
+    splice(start, ...rest) {
+      const removed = nativeSplice(data2, start, rest);
+      if (removed.length > 0 || rest.length > 1) {
         notify();
       }
       return removed;
@@ -5948,6 +6963,21 @@ function deepEqual(a2, b2, seen) {
     if (a2.length !== b2.length) return false;
     return a2.every((val, i2) => deepEqual(val, b2[i2], seen));
   }
+  if (a2 instanceof Number || a2 instanceof String || a2 instanceof Boolean) {
+    return Object.is(a2.valueOf(), b2.valueOf());
+  }
+  if (typeof URL !== "undefined" && a2 instanceof URL) {
+    return a2.href === b2.href;
+  }
+  if (a2 instanceof Error) {
+    const eb = b2;
+    return a2.name === eb.name && a2.message === eb.message && deepEqual(a2.cause, eb.cause, seen) && plainKeysEqual(objA, objB, seen);
+  }
+  const proto = Object.getPrototypeOf(objA);
+  if (proto !== Object.prototype && proto !== null) return false;
+  return plainKeysEqual(objA, objB, seen);
+}
+function plainKeysEqual(objA, objB, seen) {
   const keysA = Object.keys(objA);
   const keysB = Object.keys(objB);
   if (keysA.length !== keysB.length) return false;
@@ -5985,17 +7015,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;
@@ -6014,7 +7044,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;
@@ -6065,7 +7095,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;
 }
 
@@ -6083,15 +7113,18 @@ function ref(initial) {
 }
 
 // src/core/signals/store.ts
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
 function store(initialState) {
   devAssert(
     initialState !== null && typeof initialState === "object" && !Array.isArray(initialState),
     "store: argument must be a plain object. For arrays, use array() instead."
   );
-  const signals = {};
+  const signals = /* @__PURE__ */ Object.create(null);
   Object.keys(initialState).forEach((key) => {
     const [getter, setter] = signal(initialState[key]);
-    signals[key] = [getter, setter];
+    defineOwn(signals, key, [getter, setter]);
   });
   const store2 = new Proxy({}, {
     get(target, prop) {
@@ -6110,7 +7143,7 @@ function store(initialState) {
   const getSnapshot = () => {
     const snapshot = {};
     Object.keys(signals).forEach((key) => {
-      snapshot[key] = signals[key][0]();
+      defineOwn(snapshot, key, signals[key][0]());
     });
     return snapshot;
   };
@@ -6246,6 +7279,13 @@ function strictEffect(fn) {
   };
 }
 
+// src/reactivity/domBinding.ts
+function domBinding(commit, ownerNode) {
+  if (isSSR()) return () => {
+  };
+  return reactiveBinding2(commit, ownerNode);
+}
+
 // src/platform/enhance.ts
 var ENHANCED_ATTR = "data-sibu-enhanced";
 var enhancementOwner = /* @__PURE__ */ new WeakMap();
@@ -6281,9 +7321,7 @@ function resolveTarget(root, target) {
   }
 }
 function bindNode(el, commit) {
-  if (isSSR()) return () => {
-  };
-  return reactiveBinding2(commit, el);
+  return domBinding(commit, el);
 }
 function readControlValue(el) {
   if (el instanceof HTMLInputElement) {
@@ -6541,12 +7579,6 @@ function enhanceAll(selector, setup) {
   };
 }
 
-// src/utils/globalSingleton.ts
-function globalSingleton(key, create) {
-  const g2 = globalThis;
-  return g2[key] ?? (g2[key] = create());
-}
-
 // src/platform/islands.ts
 var SAFE_NAME = /^[A-Za-z0-9_-]+$/;
 var LAZY = /* @__PURE__ */ Symbol.for("sibujs.islands.lazy");
@@ -6752,23 +7784,27 @@ function scheduleIdle(fn) {
 }
 function transition() {
   const [pending, setPending] = signal(false);
+  let outstanding = 0;
   function start(fn) {
+    outstanding++;
     setPending(true);
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      outstanding--;
+      if (outstanding === 0) setPending(false);
+    };
+    const fail = (error) => {
+      finish();
+      reportError(error, { phase: "async", name: "transition" });
+    };
     scheduleIdle(() => {
-      let result;
       try {
-        result = fn();
-      } catch {
-        setPending(false);
-        return;
-      }
-      if (result && typeof result.then === "function") {
-        result.then(
-          () => setPending(false),
-          () => setPending(false)
-        );
-      } else {
-        setPending(false);
+        const adopted = adoptThenable(fn());
+        adopted ? adopted.then(finish, fail) : finish();
+      } catch (error) {
+        fail(error);
       }
     });
   }
@@ -6789,7 +7825,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 };
@@ -6835,7 +7887,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) => {
@@ -6853,15 +7905,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,
     /**
@@ -6944,9 +7992,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
     };
@@ -8060,6 +9108,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() || "";
@@ -8115,7 +9176,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}