sibujs 4.5.0 → 4.7.0

package/dist/build.js

@@ -1,25 +1,938 @@
 import {
   index_exports
-} from "./chunk-S373NSMK.js";
-import "./chunk-PCT43HW3.js";
-import "./chunk-NIOYEGBQ.js";
-import "./chunk-7LN645I6.js";
-import "./chunk-CCSJMTRN.js";
-import "./chunk-VUF4ALSW.js";
-import "./chunk-KEISJXBU.js";
-import "./chunk-ONOHFDLG.js";
-import "./chunk-RBTPLM32.js";
-import "./chunk-IXKSNWV5.js";
+} from "./chunk-XYV3EDB7.js";
+import "./chunk-7LUJQAOJ.js";
+import "./chunk-HURREPU2.js";
+import "./chunk-SLM3IA34.js";
+import "./chunk-BC2SECJD.js";
+import "./chunk-UOL2ECCS.js";
+import "./chunk-FNJXNGYZ.js";
+import "./chunk-RUSSKG6G.js";
+import {
+  isEventHandlerAttr,
+  isHtmlContentAttribute,
+  isUrlAttribute
+} from "./chunk-2INLLLMZ.js";
 import "./chunk-7ZHH77QA.js";
-import "./chunk-RIXRAYIU.js";
-import "./chunk-5DXA2J44.js";
-import "./chunk-QKRPLZ2V.js";
-import "./chunk-XZZOBQAY.js";
-import "./chunk-UGRX3S57.js";
-import "./chunk-2WLZ6757.js";
+import "./chunk-WEQ3DMVL.js";
+import "./chunk-7XHATCIH.js";
+import "./chunk-5HZXGZ6T.js";
+import "./chunk-FQRUXCEE.js";
+import "./chunk-JWKYU5GV.js";
+import "./chunk-NYNYSPK7.js";
+
+// src/build/sourceEdit.ts
+function isLineBreak(c) {
+  return c === 10 || c === 13 || c === 8232 || c === 8233;
+}
+function lineBreaksIn(code, start, end) {
+  let out = "";
+  for (let i = start; i < end; i++) {
+    if (isLineBreak(code.charCodeAt(i))) out += code[i];
+  }
+  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(
+    (a, b) => a.edit.start - b.edit.start || a.edit.end - a.edit.start - (b.edit.end - b.edit.start) || a.order - b.order
+  ).map((x) => x.edit);
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].start < sorted[i - 1].end) return null;
+  }
+  return sorted;
+}
+function applyEdits(code, edits, append = "") {
+  let out = "";
+  let pos = 0;
+  for (const edit of edits) {
+    out += code.slice(pos, edit.start) + edit.text;
+    pos = edit.end;
+  }
+  return out + code.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(code, edits, append, source) {
+  const lineStarts = [0];
+  for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) lineStarts.push(i + 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 col = 0;
+  const mark = (offset) => {
+    const line = lines[lines.length - 1];
+    const last = line[line.length - 1];
+    if (last && last[0] === col) return;
+    const ol = origLine(offset);
+    line.push([col, ol, offset - lineStarts[ol]]);
+  };
+  const newline = () => {
+    lines.push([]);
+    col = 0;
+  };
+  const emitOriginal = (from, to) => {
+    for (let i = from; i < to; i++) {
+      const c = code.charCodeAt(i);
+      if (c === 10) {
+        newline();
+        continue;
+      }
+      if (i === from || col === 0 || isWordStart(c) && !isWordStart(code.charCodeAt(i - 1))) mark(i);
+      col++;
+    }
+  };
+  const emitReplacement = (edit) => {
+    let origOffset = edit.start;
+    let pending = true;
+    for (let i = 0; i < edit.text.length; i++) {
+      if (edit.text.charCodeAt(i) === 10) {
+        newline();
+        const nl = code.indexOf("\n", origOffset);
+        if (nl !== -1 && nl < edit.end) {
+          origOffset = nl + 1;
+          pending = true;
+        } else {
+          pending = false;
+        }
+        continue;
+      }
+      if (pending) {
+        mark(origOffset);
+        pending = false;
+      }
+      col++;
+    }
+  };
+  let pos = 0;
+  for (const edit of edits) {
+    emitOriginal(pos, edit.start);
+    emitReplacement(edit);
+    pos = edit.end;
+  }
+  emitOriginal(pos, code.length);
+  for (let i = 0; i < append.length; i++) {
+    if (append.charCodeAt(i) === 10) newline();
+  }
+  let prevLine = 0;
+  let prevCol = 0;
+  let prevSource = 0;
+  const mappings = lines.map((segments) => {
+    let prevGen = 0;
+    return segments.map(([gen, ol, oc]) => {
+      const s = vlq(gen - prevGen) + vlq(0 - prevSource) + vlq(ol - prevLine) + vlq(oc - prevCol);
+      prevGen = gen;
+      prevSource = 0;
+      prevLine = ol;
+      prevCol = oc;
+      return s;
+    }).join(",");
+  }).join(";");
+  return { version: 3, sources: [source], sourcesContent: [code], 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(code) {
+  scanStats.tokenize++;
+  let pos = 0;
+  const len = code.length;
+  if (code.startsWith("#!")) {
+    const nl = code.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 = code.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 && code.charCodeAt(pos + 1) === 47) {
+        pos += 2;
+        while (pos < len) {
+          const d = code.charCodeAt(pos);
+          if (d === 10 || d === 13 || d === 8232 || d === 8233) break;
+          pos++;
+        }
+      } else if (c === 47 && code.charCodeAt(pos + 1) === 42) {
+        const end = code.indexOf("*/", pos + 2);
+        if (end === -1) throw new ScanError("unterminated comment");
+        pos = end + 2;
+      } else {
+        break;
+      }
+    }
+  }
+  function readString() {
+    const start = pos;
+    const quote = code[pos];
+    pos++;
+    while (pos < len) {
+      const c = code[pos];
+      if (c === "\\") {
+        pos += 2;
+        continue;
+      }
+      if (c === quote) {
+        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 = code[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(code.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 = code[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 === "$" && code[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 = code.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 = code.charCodeAt(pos);
+          if (isIdentPart(d)) pos++;
+          else if (d === 92) pos += 2;
+          else break;
+        }
+        tokens.push({ type: "ident", start, end: pos, value: code.slice(start, pos) });
+      } else if (isDigit(c) || c === 46 && isDigit(code.charCodeAt(pos + 1))) {
+        const start = pos;
+        pos++;
+        while (pos < len) {
+          const d = code.charCodeAt(pos);
+          if (isIdentPart(d) || d === 46) pos++;
+          else break;
+        }
+        tokens.push({ type: "number", start, end: pos, value: code.slice(start, pos) });
+      } else if (c === 47 && regexAllowed(prev)) {
+        tokens.push(readRegex());
+      } else {
+        const start = pos;
+        let value = code[pos];
+        if (code.startsWith("...", pos)) value = "...";
+        else if (code.startsWith("?.", pos) && !isDigit(code.charCodeAt(pos + 2))) value = "?.";
+        else if (code.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 i = 0;
+  const n = raw.length;
+  while (i < n) {
+    const ch = raw[i];
+    if (ch === "\r") {
+      out += "\n";
+      i += raw[i + 1] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (ch !== "\\") {
+      out += ch;
+      i++;
+      continue;
+    }
+    const e = raw[i + 1];
+    i += 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 (i < n && isDigit(raw.charCodeAt(i))) return null;
+        out += "\0";
+        break;
+      case "x": {
+        const hex = raw.slice(i, i + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hex)) return null;
+        out += String.fromCharCode(Number.parseInt(hex, 16));
+        i += 2;
+        break;
+      }
+      case "u": {
+        if (raw[i] === "{") {
+          const close = raw.indexOf("}", i);
+          if (close === -1) return null;
+          const hex = raw.slice(i + 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);
+          i = close + 1;
+        } else {
+          const hex = raw.slice(i, i + 4);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+          out += String.fromCharCode(Number.parseInt(hex, 16));
+          i += 4;
+        }
+        break;
+      }
+      case "\r":
+        if (raw[i] === "\n") i++;
+        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(code, tok) {
+  if (tok.type !== "string") return null;
+  return cookEscapes(code.slice(tok.start + 1, tok.end - 1));
+}
+function collectImports(code, tokens) {
+  const decls = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok.type !== "ident" || tok.value !== "import") continue;
+    const prev = tokens[i - 1];
+    if (prev && prev.type === "punct" && (prev.value === "." || prev.value === "?.")) continue;
+    const next = tokens[i + 1];
+    if (!next) return null;
+    if (next.type === "punct" && (next.value === "(" || next.value === ".")) continue;
+    let j = i + 1;
+    const bindings = [];
+    let typeOnly = false;
+    if (next.type === "string") {
+      const source2 = stringTokenValue(code, next);
+      if (source2 === 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: source2, 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(code, 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 source = stringTokenValue(code, srcTok);
+    if (source === 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, bindings: typeOnly ? [] : bindings, start: tok.start, end });
+    i = j;
+  }
+  return decls;
+}
+var SCAN_CACHE_SIZE = 4;
+var scanCache = /* @__PURE__ */ new Map();
+function scanModule(code) {
+  const hit = scanCache.get(code);
+  if (hit !== void 0) return hit;
+  const tokens = tokenize(code);
+  const imports = tokens && collectImports(code, tokens);
+  const scan = tokens && imports ? { tokens, imports } : null;
+  if (scanCache.size >= SCAN_CACHE_SIZE) scanCache.delete(scanCache.keys().next().value);
+  scanCache.set(code, scan);
+  return scan;
+}
+function isSibuSource(source) {
+  return source === "sibujs" || source.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 b of decl.bindings) {
+      if (b.imported === "*" || b.imported === "default") continue;
+      out.set(b.local, b.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 i = 0; i < list.length; i++) {
+      const tok = list[i];
+      if (tok.type === "template") {
+        for (const e of tok.exprs) walk(e.tokens);
+        continue;
+      }
+      if (tok.type !== "ident") continue;
+      const prev = list[i - 1];
+      if (prev && prev.type === "punct" && (prev.value === "." || prev.value === "?." || prev.value === "#")) continue;
+      if (inImport(tok.start)) continue;
+      visit({ tok, list, index: i });
+    }
+  };
+  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(code, from, to) {
+  for (let i = from; i < to; i++) if (isLineTerminator(code.charCodeAt(i))) 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(code, 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(code, 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(code, scan, names) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const bound = /* @__PURE__ */ new Map();
+  for (const decl of scan.imports) {
+    for (const b of decl.bindings) bound.set(b.local, (bound.get(b.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, (ref) => {
+    const { tok, list, index } = ref;
+    if (!names.has(tok.value)) return;
+    const next = list[index + 1];
+    if (next && next.type === "punct" && next.value === "(") {
+      if (isDeclarationHead(code, list, index)) shadowed.add(tok.value);
+      else calls.push(ref);
+    } else if (next && next.type === "template") {
+      const prev = list[index - 1];
+      if (prev?.type === "punct" && prev.value === "@") shadowed.add(tok.value);
+      else tagged.push(ref);
+    } 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(code, base = "__sibujs") {
+  let prefix = `${base}$`;
+  for (let n = 1; code.includes(prefix); n++) prefix = `${base}${n}$`;
+  return prefix;
+}
+var PURE_FACTORIES = /* @__PURE__ */ new Set([
+  "tagFactory",
+  "context",
+  "defineComponent",
+  "withProps",
+  "withDefaults",
+  "pure",
+  "noSideEffect"
+]);
+var PURE_COMMENT = "/*#__PURE__*/ ";
+function pureAnnotationEdits(code) {
+  if (!code.includes("sibujs")) return [];
+  const scan = scanModule(code);
+  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(code, scan, candidates);
+  const unsafe = new Set(uses.shadowed);
+  for (const ref of uses.tagged) unsafe.add(ref.tok.value);
+  return uses.calls.filter(({ tok }) => {
+    if (unsafe.has(tok.value)) return false;
+    return !/\/\*\s*[#@]__PURE__\s*\*\/\s*$/.test(code.slice(Math.max(0, tok.start - 40), tok.start));
+  }).map(({ tok }) => ({ start: tok.start, end: tok.start, text: PURE_COMMENT }));
+}
+function injectPureAnnotations(code) {
+  const edits = normalizeEdits(pureAnnotationEdits(code));
+  return edits && edits.length > 0 ? applyEdits(code, edits) : code;
+}
+function importsSibu(code) {
+  if (!code.includes("sibujs")) return false;
+  const scan = scanModule(code);
+  return !!scan?.imports.some((d) => isSibuSource(d.source));
+}
+
+// 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(code, tok) {
+  if (!tok) return null;
+  if (tok.type === "string") {
+    const value = stringTokenValue(code, 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(s) {
+  return !s.includes("\r") && !s.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 on = lit.value === "true";
+    if (lower.startsWith("aria-")) return `${lower}="${on}"`;
+    if (NON_REFLECTING_BOOLEANS.has(lower)) return null;
+    return on ? `${lower}=""` : "";
+  }
+  if (!parserSafeText(lit.value)) return null;
+  return `${lower}="${escapeAttr(lit.value)}"`;
+}
+function parseCall(code, list, i) {
+  const at = (k2) => list[k2];
+  const isPunct = (k2, v) => {
+    const t = at(k2);
+    return !!t && t.type === "punct" && t.value === v;
+  };
+  let k = i + 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(code, keyTok);
+      if (key === null || !isPunct(k + 1, ":")) return null;
+      if (seen.has(key.toLowerCase())) return null;
+      seen.add(key.toLowerCase());
+      const lit = readLiteral(code, 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 html = attributeHtml(key, lit);
+        if (html === null) return null;
+        if (html) result.attrs.push(html);
+      }
+    }
+    k++;
+    if (isPunct(k, ",")) {
+      const second = readLiteral(code, 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(code, 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(code, 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(code) {
+  const none = { hasStaticPatterns: false, patterns: [] };
+  if (!code.includes("sibujs")) return none;
+  const scan = scanModule(code);
+  if (!scan) return none;
+  const factories = /* @__PURE__ */ new Map();
+  for (const decl of scan.imports) {
+    if (decl.source !== "sibujs") continue;
+    for (const b of decl.bindings) if (STATIC_TAGS.has(b.imported)) factories.set(b.local, b.imported);
+  }
+  if (factories.size === 0) return none;
+  const uses = bindingUses(code, scan, new Set(factories.keys()));
+  const unsafe = new Set(uses.shadowed);
+  for (const ref of uses.tagged) unsafe.add(ref.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(code, list, index + 1);
+    if (!call) continue;
+    const templateHtml = toHtml(tag, call);
+    if (templateHtml === null) continue;
+    const start = list[index].start;
+    patterns.push({ original: code.slice(start, call.end), tag, templateHtml, start, end: call.end });
+  }
+  return { hasStaticPatterns: patterns.length > 0, patterns };
+}
 
-// src/build/compileTemplates.ts
-var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+// src/build/templateCompiler.ts
+var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
+var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
   "area",
   "base",
   "br",
@@ -58,96 +971,10 @@ var SVG_TAGS = /* @__PURE__ */ new Set([
   "symbol",
   "marker"
 ]);
-function findHtmlTemplates(code) {
-  const results = [];
-  const tagRegex = /\bhtml\s*`/g;
-  let match;
-  while ((match = tagRegex.exec(code)) !== null) {
-    const start = match.index;
-    const backtickStart = code.indexOf("`", start + 4);
-    if (backtickStart === -1) continue;
-    const parsed = parseTemplateLiteral(code, backtickStart);
-    if (!parsed) continue;
-    results.push({
-      start,
-      end: parsed.end,
-      strings: parsed.strings,
-      exprCount: parsed.exprCount
-    });
-    tagRegex.lastIndex = parsed.end;
-  }
-  return results;
-}
-function parseTemplateLiteral(code, openBacktick) {
-  const strings = [];
-  let exprCount = 0;
-  let pos = openBacktick + 1;
-  let current = "";
-  while (pos < code.length) {
-    const ch = code[pos];
-    if (ch === "`") {
-      strings.push(current);
-      return { end: pos + 1, strings, exprCount };
-    }
-    if (ch === "$" && pos + 1 < code.length && code[pos + 1] === "{") {
-      strings.push(current);
-      current = "";
-      exprCount++;
-      pos += 2;
-      let depth = 1;
-      while (pos < code.length && depth > 0) {
-        const c = code[pos];
-        if (c === "{") depth++;
-        else if (c === "}") depth--;
-        else if (c === '"' || c === "'" || c === "`") {
-          pos = skipString(code, pos);
-          continue;
-        }
-        if (depth > 0) pos++;
-      }
-      if (depth !== 0) return null;
-      pos++;
-      continue;
-    }
-    if (ch === "\\") {
-      current += code[pos] + (code[pos + 1] || "");
-      pos += 2;
-      continue;
-    }
-    current += ch;
-    pos++;
-  }
-  return null;
-}
-function skipString(code, start) {
-  const quote = code[start];
-  let pos = start + 1;
-  while (pos < code.length) {
-    if (code[pos] === "\\") {
-      pos += 2;
-      continue;
-    }
-    if (code[pos] === quote) return pos + 1;
-    if (quote === "`" && code[pos] === "$" && code[pos + 1] === "{") {
-      pos += 2;
-      let depth = 1;
-      while (pos < code.length && depth > 0) {
-        if (code[pos] === "{") depth++;
-        else if (code[pos] === "}") depth--;
-        else if (code[pos] === '"' || code[pos] === "'" || code[pos] === "`") {
-          pos = skipString(code, pos);
-          continue;
-        }
-        if (depth > 0) pos++;
-      }
-      pos++;
-      continue;
-    }
-    pos++;
-  }
-  return pos;
-}
-function parseTemplateToAST(strings) {
+var SVG_NS = "http://www.w3.org/2000/svg";
+var RuntimeParseError = class extends Error {
+};
+function parseTemplate(strings) {
   const exprCount = strings.length - 1;
   let template = strings[0];
   for (let i = 0; i < exprCount; i++) {
@@ -156,26 +983,34 @@ function parseTemplateToAST(strings) {
   let pos = 0;
   const len = template.length;
   function skipWs() {
-    while (pos < len && /\s/.test(template[pos])) pos++;
+    while (pos < len && (template[pos] === " " || template[pos] === "	" || template[pos] === "\n" || template[pos] === "\r"))
+      pos++;
   }
   function tryExprIdx() {
-    if (template[pos] !== "\0") return -1;
+    if (template.charCodeAt(pos) !== 0) return -1;
     const start = pos;
     pos++;
-    let idxStr = "";
-    while (pos < len && template[pos] !== "\0") idxStr += template[pos++];
+    let idx = 0;
+    while (pos < len && template.charCodeAt(pos) !== 0) {
+      idx = idx * 10 + (template.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(template[pos])) name += template[pos++];
-    return name;
+    const start = pos;
+    while (pos < len) {
+      const c = template.charCodeAt(pos);
+      if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45) {
+        pos++;
+      } else break;
+    }
+    return template.slice(start, pos);
   }
   function parseAttrValue() {
     skipWs();
@@ -183,51 +1018,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 quote = template[pos];
     if (quote === '"' || quote === "'") {
       pos++;
-      const parts = [];
-      let current = "";
+      const statics2 = [];
+      const exprs2 = [];
+      let current2 = "";
       while (pos < len && template[pos] !== quote) {
         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 += template[pos++];
+          current2 += template[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((p) => p.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 = template.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 += template[pos++];
       }
-      return { kind: "static", value: parts.map((p) => p.value).join("") };
     }
-    let val = "";
-    while (pos < len && !/[\s>/]/.test(template[pos])) val += template[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 (template[pos] === ">" || template[pos] === "/") break;
-      let attrName = "";
-      while (pos < len && /[a-zA-Z0-9\-:_.]/.test(template[pos])) attrName += template[pos++];
+      const attrStart = pos;
+      while (pos < len) {
+        const c = template.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 = template.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;
@@ -241,40 +1097,67 @@ function parseTemplateToAST(strings) {
       const idx = tryExprIdx();
       if (idx >= 0) {
         const collapsed2 = collapseWs(text);
-        if (collapsed2) children.push({ kind: "text", value: collapsed2 });
+        if (collapsed2) children.push({ t: 1, value: collapsed2 });
         text = "";
-        children.push({ kind: "expr", index: idx });
+        children.push({ t: 2, idx });
       } else {
         text += template[pos++];
       }
     }
     const collapsed = collapseWs(text);
-    if (collapsed) children.push({ kind: "text", value: collapsed });
+    if (collapsed) children.push({ t: 1, value: collapsed });
   }
   function parseChildren() {
     const children = [];
     while (pos < len) {
       if (template[pos] === "<" && pos + 1 < len && template[pos + 1] === "/") break;
       if (template[pos] === "<") {
+        const next = template[pos + 1];
+        if (next === "!") {
+          if (template.startsWith("<!--", pos)) {
+            const end = template.indexOf("-->", pos + 4);
+            pos = end === -1 ? len : end + 3;
+          } else if (template.startsWith("<![CDATA[", pos)) {
+            const end = template.indexOf("]]>", pos + 9);
+            pos = end === -1 ? len : end + 3;
+          } else {
+            const end = template.indexOf(">", pos);
+            pos = end === -1 ? len : end + 1;
+          }
+          continue;
+        }
+        if (next === "?") {
+          const end = template.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 = template[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 (template[pos] === "<" && pos + 1 < len && template[pos + 1] === "/") {
             pos += 2;
             readTagName();
             skipWs();
             if (pos < len && template[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);
@@ -284,303 +1167,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((p) => p.kind === "static" ? JSON.stringify(p.value) : `String(${valuesVar}[${p.index}])`).join(" + ");
-        parts.push(`${JSON.stringify(attr.name)}: ${concat}`);
-        break;
+var IDL_SYNCED_ATTRS = /* @__PURE__ */ new Set(["value", "checked"]);
+function generateBody(roots, h) {
+  const lines = [];
+  let n = 0;
+  const q = 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(${q(SVG_NS)}, ${q(el.tag)});` : `const ${v} = document.createElement(${q(el.tag)});`
+    );
+    for (const attr of el.attrs) {
+      switch (attr.t) {
+        case 0:
+          lines.push(`${v}.setAttribute(${q(attr.name)}, ${q(attr.value)});`);
+          break;
+        case 4:
+          lines.push(`${v}.setAttribute(${q(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}, ${q(attr.name)}, v${attr.idx});`);
+          } else {
+            h.used.add("str");
+            let expr = q(attr.statics[0]);
+            for (let j = 0; j < attr.exprs.length; j++) {
+              expr += ` + ${P}str(v${attr.exprs[j]}) + ${q(attr.statics[j + 1])}`;
+            }
+            lines.push(`${P}attr(${v}, ${q(attr.name)}, ${expr});`);
+          }
+          break;
+        }
+        case 3:
+          h.used.add("on");
+          lines.push(`${P}on(${v}, ${q(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(${q(child.value)}));`);
+      } else {
+        h.used.add("child");
+        lines.push(`${P}child(${v}, v${child.idx});`);
       }
-      case "bool":
-        parts.push(`${JSON.stringify(attr.name)}: true`);
-        break;
-      case "event":
-        break;
     }
+    return v;
   }
-  const events = el.attrs.filter((a) => a.value.kind === "event");
-  if (events.length > 0) {
-    const eventEntries = events.map((a) => {
-      const v = a.value;
-      return `${JSON.stringify(a.name)}: ${valuesVar}[${v.index}]`;
-    });
-    parts.push(`on: { ${eventEntries.join(", ")} }`);
+  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  ");
   }
-  if (el.children.length > 0) {
-    const childExprs = el.children.map((c) => generateChild(c, valuesVar));
-    if (childExprs.length === 1) {
-      parts.push(`nodes: ${childExprs[0]}`);
+  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(${q(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(code) {
-  const templates = findHtmlTemplates(code);
-  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 = code;
-  for (let i = templates.length - 1; i >= 0; i--) {
-    const tmpl = templates[i];
-    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 body = rootExpr;
-      const exprSource = extractExpressions(code, tmpl.start, tmpl.end, tmpl.exprCount);
-      compiled = `((${valuesVar}) => ${body})([${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(code, templateStart, templateEnd, count) {
-  const exprs = [];
-  const backtickStart = code.indexOf("`", templateStart + 4);
-  let pos = backtickStart + 1;
-  for (let i = 0; i < count; i++) {
-    while (pos < templateEnd) {
-      if (code[pos] === "$" && code[pos + 1] === "{") {
-        pos += 2;
-        break;
-      }
-      if (code[pos] === "\\") {
-        pos += 2;
-        continue;
-      }
-      pos++;
-    }
-    const exprStart = pos;
-    let depth = 1;
-    while (pos < templateEnd && depth > 0) {
-      const c = code[pos];
-      if (c === "{") depth++;
-      else if (c === "}") {
-        depth--;
-        if (depth === 0) break;
-      } else if (c === '"' || c === "'" || c === "`") {
-        pos = skipString(code, pos);
-        continue;
-      }
-      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)));
     }
-    exprs.push(code.slice(exprStart, pos).trim());
-    pos++;
+  } else if (value != null && typeof value !== "boolean") {
+    el.appendChild(document.createTextNode(String(value)));
   }
-  return exprs;
-}
-
-// src/build/staticAnalysis.ts
-var HTML_TAGS = /* @__PURE__ */ new Set([
-  "div",
-  "span",
-  "section",
-  "article",
-  "header",
-  "footer",
-  "nav",
-  "main",
-  "aside",
-  "p",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "blockquote",
-  "li",
-  "ol",
-  "ul",
-  "pre",
-  "a",
-  "b",
-  "em",
-  "i",
-  "strong",
-  "small",
-  "code",
-  "mark",
-  "img",
-  "br",
-  "hr",
-  "input",
-  "button",
-  "form",
-  "label",
-  "select",
-  "textarea",
-  "option",
-  "table",
-  "tbody",
-  "thead",
-  "tfoot",
-  "tr",
-  "td",
-  "th",
-  "details",
-  "summary",
-  "dialog"
-]);
-var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
-  "br",
-  "hr",
-  "img",
-  "input",
-  "meta",
-  "link",
-  "area",
-  "base",
-  "col",
-  "embed",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-function analyzeStaticTemplates(code) {
-  const patterns = [];
-  const tagCallRegex = new RegExp(`\\b(${Array.from(HTML_TAGS).join("|")})\\s*\\(\\s*\\{([^}]*)\\}\\s*\\)`, "g");
-  let match;
-  while ((match = tagCallRegex.exec(code)) !== null) {
-    const [fullMatch, tag, propsContent] = match;
-    const start = match.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
-  };
+  return out.join("\n");
+}
+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;
+function planHtmlTemplates(code) {
+  const plan = {
+    edits: [],
+    append: "",
+    usedTags: /* @__PURE__ */ new Set(),
+    usesSvg: false,
+    compiledCount: 0,
+    skippedCount: 0
+  };
+  if (!code.includes("`") || !code.includes("sibujs")) return plan;
+  const scan = scanModule(code);
+  if (!scan) return plan;
+  const tagNames = /* @__PURE__ */ new Set();
+  for (const decl of scan.imports) {
+    if (!isSibuSource(decl.source)) continue;
+    for (const b of decl.bindings) if (b.imported === "html") tagNames.add(b.local);
   }
-  const props = propsContent.split(",").map((p) => p.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;
+  if (tagNames.size === 0) return plan;
+  const uses = bindingUses(code, scan, tagNames);
+  if (uses.shadowed.size > 0 || uses.calls.length > 0 || uses.tagged.length === 0) return plan;
+  const sites = new Set(uses.tagged.map((ref) => ref.tok));
+  const h = { prefix: uniquePrefix(code), 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(code.slice(qs.start, qs.end));
+      if (cooked === null) return null;
+      strings.push(cooked);
     }
-  }
-  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((p) => p.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))}"`);
+    let roots;
+    try {
+      roots = parseTemplate(strings);
+    } catch (err) {
+      if (err instanceof RuntimeParseError) return null;
+      throw err;
     }
-  }
-  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;");
+    const scratch = { prefix: h.prefix, used: /* @__PURE__ */ new Set(), tags: /* @__PURE__ */ new Set(), svg: false };
+    const body = generateBody(roots, scratch);
+    if (body === null) return null;
+    for (const u of scratch.used) h.used.add(u);
+    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((_, i) => `v${i}`).join(", ");
+    functions.push(`function ${name}(${params}) {
+  ${body}
+}`);
+    return name;
+  };
+  const replaceSite = (tag, tmpl, name) => {
+    const edit = (start, end, before, after) => plan.edits.push({ start, end, text: `${before}${lineBreaksIn(code, start, end)}${after}` });
+    const exprs = tmpl.exprs;
+    if (exprs.length === 0) {
+      edit(tag.start, tmpl.end, `${name}(`, ")");
+      return;
+    }
+    edit(tag.start, exprs[0].start, `${name}((`, "");
+    for (let i = 1; i < exprs.length; i++) edit(exprs[i - 1].end, exprs[i].start, ")", ", (");
+    edit(exprs[exprs.length - 1].end, tmpl.end, "", "))");
+  };
+  const visit = (list) => {
+    for (let i = 0; i < list.length; i++) {
+      const tok = list[i];
+      if (sites.has(tok)) {
+        const tmpl = list[i + 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++;
+        }
+        i++;
+      } else if (tok.type === "template") {
+        for (const e of tok.exprs) visit(e.tokens);
+      }
+    }
+  };
+  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) {
@@ -590,30 +1400,42 @@ function matchesPattern(filePath, patterns) {
     return new RegExp(regexStr).test(normalized);
   });
 }
-function injectPureAnnotations(code) {
-  const sibuFactories = [
-    "tagFactory",
-    "context",
-    "defineComponent",
-    "withProps",
-    "withDefaults",
-    "pure",
-    "noSideEffect"
-  ];
-  let result = code;
-  for (const factory of sibuFactories) {
-    const pattern = new RegExp(`(?<!/\\*#__PURE__\\*/\\s*)\\b(${factory})\\s*\\(`, "g");
-    result = result.replace(pattern, "/*#__PURE__*/ $1(");
+function devPrologueEdit(code) {
+  let at = 0;
+  if (code.startsWith("#!")) {
+    const nl = code.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(code) {
-  if (code.includes('from "sibu"') || code.includes("from 'sibu'") || code.includes('from "sibu/') || code.includes("from 'sibu/")) {
-    return `/* SibuJS Dev Mode */
-if (typeof globalThis !== 'undefined') { (globalThis as unknown as Record<string, unknown>).__SIBU_DEV__ = true; }
-${code}`;
-  }
-  return code;
+function staticOptimizationEdits(code) {
+  const analysis = analyzeStaticTemplates(code);
+  if (!analysis.hasStaticPatterns) return null;
+  const P = uniquePrefix(code);
+  const edits = analysis.patterns.map((pattern) => ({
+    start: pattern.start,
+    end: pattern.end,
+    // A call spanning several lines keeps its line breaks.
+    text: `${P}static(${jsStringLiteral(pattern.templateHtml)}${lineBreaksIn(code, pattern.start, pattern.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 {
@@ -622,22 +1444,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: {
@@ -650,69 +1473,47 @@ function sibuVitePlugin(options = {}) {
         }
       };
     },
+    configResolved(config) {
+      isDevMode = resolveDevMode(devMode, config);
+    },
     transform(code, id) {
       if (!matchesPattern(id, include) || matchesPattern(id, exclude)) {
         return null;
       }
-      let transformed = code;
-      let modified = false;
-      if (pureAnnotations) {
-        const annotated = injectPureAnnotations(transformed);
-        if (annotated !== transformed) {
-          transformed = annotated;
-          modified = true;
-        }
+      if (!code.includes("sibujs")) return null;
+      if (!scanModule(code)) return null;
+      const edits = [];
+      let append = "";
+      if (isDevMode && importsSibu(code)) {
+        const prologue = devPrologueEdit(code);
+        if (prologue) edits.push(prologue);
       }
-      if (isDevMode) {
-        const withDevHelpers = injectDevHelpers(transformed);
-        if (withDevHelpers !== transformed) {
-          transformed = withDevHelpers;
-          modified = true;
-        }
+      if (pureAnnotations) {
+        edits.push(...pureAnnotationEdits(code));
       }
       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(code);
+        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((a, b) => b.start - a.start);
-          for (const pattern of sorted) {
-            const replacement = `staticTemplate(${JSON.stringify(pattern.templateHtml)})`;
-            transformed = transformed.slice(0, pattern.start) + replacement + transformed.slice(pattern.end);
-          }
-          if (!transformed.includes("import") || !transformed.includes("staticTemplate")) {
-            transformed = `import { staticTemplate } from "sibu";
-${transformed}`;
-          }
-          modified = true;
+      if (staticOptimize) {
+        const optimized = staticOptimizationEdits(code);
+        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(code, sorted, append);
+      if (transformed === code) return null;
       return {
         code: transformed,
-        map: void 0
-        // Let Vite handle source maps
+        map: editsSourceMap(code, sorted, append, id)
       };
     },
     handleHotUpdate(ctx) {
@@ -771,7 +1572,7 @@ function createViteConfig(options = {}) {
     // SSR configuration
     ...ssr ? {
       ssr: {
-        noExternal: ["sibu"],
+        noExternal: ["sibujs"],
         target: "node"
       },
       build: {
@@ -788,8 +1589,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
@@ -812,26 +1613,11 @@ function deepMerge(target, source) {
 }
 
 // src/build/webpack.ts
-var PURE_FACTORIES = [
-  "tagFactory",
-  "context",
-  "defineComponent",
-  "withProps",
-  "withDefaults",
-  "pure",
-  "noSideEffect"
-];
 function addPureAnnotations(source) {
-  let result = source;
-  for (const factory of PURE_FACTORIES) {
-    const pattern = new RegExp(`(?<!/\\*#__PURE__\\*/\\s*)\\b(${factory})\\s*\\(`, "g");
-    result = result.replace(pattern, "/*#__PURE__*/ $1(");
-  }
-  return result;
+  return injectPureAnnotations(source);
 }
 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) {
@@ -842,31 +1628,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 = {};
@@ -878,20 +1639,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 = [];
         }
@@ -899,10 +1661,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(source) {
     return addPureAnnotations(source);
@@ -971,9 +1743,10 @@ function createWebpackConfig(options = {}) {
       splitChunks: isDev ? 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
@@ -1014,7 +1787,23 @@ function createWebpackConfig(options = {}) {
 }
 
 // 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 };
@@ -1060,7 +1849,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) => {
@@ -1078,15 +1867,11 @@ function generateImportMap(baseUrl) {
   const base = baseUrl || `https://cdn.jsdelivr.net/npm/${PACKAGE_NAME}@latest`;
   const imports = {
     // Main package entry
-    [PACKAGE_NAME]: `${base}/dist/index.js`,
-    // Sub-path imports for tree-shaking in browsers
-    [`${PACKAGE_NAME}/core`]: `${base}/dist/core/index.js`,
-    [`${PACKAGE_NAME}/reactivity`]: `${base}/dist/reactivity/index.js`,
-    [`${PACKAGE_NAME}/plugins`]: `${base}/dist/plugins/index.js`,
-    [`${PACKAGE_NAME}/components`]: `${base}/dist/components/index.js`,
-    [`${PACKAGE_NAME}/testing`]: `${base}/dist/testing/index.js`,
-    [`${PACKAGE_NAME}/build`]: `${base}/dist/build/index.js`
+    [PACKAGE_NAME]: `${base}/dist/index.js`
   };
+  for (const entry of SUBPATH_ENTRIES) {
+    imports[`${PACKAGE_NAME}/${entry}`] = `${base}/dist/${entry}.js`;
+  }
   return {
     imports,
     /**
@@ -1169,9 +1954,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
     };
@@ -2285,6 +3070,19 @@ function generateTypeStubs() {
   };
 }
 
+// src/build/compileTemplates.ts
+function compileHtmlTemplates(code) {
+  const plan = planHtmlTemplates(code);
+  const edits = plan.compiledCount > 0 ? normalizeEdits(plan.edits) : null;
+  return {
+    code: edits ? applyEdits(code, 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() || "";
@@ -2340,7 +3138,7 @@ function generateRouteModule(entries, routesDir) {
     (e, i) => `const route${i} = () => import(/* webpackChunkName: "${e.chunkName}" */ "${routesDir}/${e.importPath}");`
   ).join("\n");
   const routes = entries.map((e, i) => `  { path: "${e.path}", component: lazy(route${i}) }`).join(",\n");
-  return `import { lazy } from "sibu";
+  return `import { lazy } from "sibujs";
 
 ${imports}